HostImpl.cpp@ 99771

Last change on this file since 99771 was 98294, checked in by vboxsync, 23 months ago
Main/src-server: hr -> hrc. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 150.0 KB

Line
1	/* $Id: HostImpl.cpp 98294 2023-01-25 01:24:09Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation: Host
4	*/
5
6	/*
7	* Copyright (C) 2004-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	#define LOG_GROUP LOG_GROUP_MAIN_HOST
29
30	#define __STDC_LIMIT_MACROS
31	#define __STDC_CONSTANT_MACROS
32
33	// VBoxNetCfg-win.h needs winsock2.h and thus MUST be included before any other
34	// header file includes Windows.h.
35	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
36	# include <VBox/VBoxNetCfg-win.h>
37	#endif
38
39	// for some reason Windows burns in sdk\...\winsock.h if this isn't included first
40	#include "VBox/com/ptr.h"
41
42	#include "HostImpl.h"
43
44	#ifdef VBOX_WITH_USB
45	# include "HostUSBDeviceImpl.h"
46	# include "USBDeviceFilterImpl.h"
47	# include "USBProxyService.h"
48	#else
49	# include "VirtualBoxImpl.h"
50	#endif // VBOX_WITH_USB
51
52	#include "HostNetworkInterfaceImpl.h"
53	#include "HostVideoInputDeviceImpl.h"
54	#include "AutoCaller.h"
55	#include "LoggingNew.h"
56	#include "Performance.h"
57	#ifdef VBOX_WITH_UPDATE_AGENT
58	# include "UpdateAgentImpl.h"
59	#endif
60
61	#include "MediumImpl.h"
62	#include "HostPower.h"
63
64	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
65	# include <HostHardwareLinux.h>
66	#endif
67
68	#include <set>
69
70	#ifdef VBOX_WITH_RESOURCE_USAGE_API
71	# include "PerformanceImpl.h"
72	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
73
74	#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
75	# include <sys/types.h>
76	# include <sys/sysctl.h>
77	#endif
78
79	#ifdef RT_OS_LINUX
80	# include <sys/ioctl.h>
81	# include <errno.h>
82	# include <net/if.h>
83	# include <net/if_arp.h>
84	#endif /* RT_OS_LINUX */
85
86	#ifdef RT_OS_SOLARIS
87	# include <fcntl.h>
88	# include <unistd.h>
89	# include <stropts.h>
90	# include <errno.h>
91	# include <limits.h>
92	# include <stdio.h>
93	# include <libdevinfo.h>
94	# include <sys/mkdev.h>
95	# include <sys/scsi/generic/inquiry.h>
96	# include <net/if.h>
97	# include <sys/socket.h>
98	# include <sys/sockio.h>
99	# include <net/if_arp.h>
100	# include <net/if.h>
101	# include <sys/types.h>
102	# include <sys/stat.h>
103	# include <sys/cdio.h>
104	# include <sys/dkio.h>
105	# include <sys/mnttab.h>
106	# include <sys/mntent.h>
107	/* Dynamic loading of libhal on Solaris hosts */
108	# ifdef VBOX_USE_LIBHAL
109	# include "vbox-libhal.h"
110	extern "C" char getfullrawname(char );
111	# endif
112	# include "solaris/DynLoadLibSolaris.h"
113
114	/**
115	* Solaris DVD drive list as returned by getDVDInfoFromDevTree().
116	*/
117	typedef struct SOLARISDVD
118	{
119	struct SOLARISDVD *pNext;
120	char szDescription[512];
121	char szRawDiskPath[PATH_MAX];
122	} SOLARISDVD;
123	/** Pointer to a Solaris DVD descriptor. */
124	typedef SOLARISDVD *PSOLARISDVD;
125
126	/** Solaris fixed drive (SSD, HDD, ++) descriptor list entry as returned by the
127	* solarisWalkDeviceNodeForFixedDrive callback. */
128	typedef SOLARISDVD SOLARISFIXEDDISK;
129	/** Pointer to a Solaris fixed drive (SSD, HDD, ++) descriptor. */
130	typedef SOLARISFIXEDDISK *PSOLARISFIXEDDISK;
131
132
133	#endif /* RT_OS_SOLARIS */
134
135	#ifdef RT_OS_WINDOWS
136	# define _WIN32_DCOM
137	# include <iprt/win/windows.h>
138	# include <shellapi.h>
139	# define INITGUID
140	# include <guiddef.h>
141	# include <devguid.h>
142	# include <iprt/win/objbase.h>
143	# include <iprt/win/shlobj.h>
144	# include <cfgmgr32.h>
145	# include <tchar.h>
146	#endif /* RT_OS_WINDOWS */
147
148	#ifdef RT_OS_DARWIN
149	# include "darwin/iokit.h"
150	#endif
151
152	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
153	# include <iprt/asm-amd64-x86.h>
154	#endif
155	#ifdef RT_OS_SOLARIS
156	# include <iprt/ctype.h>
157	#endif
158	#if defined(RT_OS_SOLARIS) \|\| defined(RT_OS_WINDOWS)
159	# include <iprt/file.h>
160	#endif
161	#include <iprt/mp.h>
162	#include <iprt/env.h>
163	#include <iprt/mem.h>
164	#include <iprt/param.h>
165	#include <iprt/string.h>
166	#include <iprt/system.h>
167	#ifndef RT_OS_WINDOWS
168	# include <iprt/path.h>
169	#endif
170	#include <iprt/time.h>
171	#ifdef RT_OS_WINDOWS
172	# include <iprt/dir.h>
173	# include <iprt/vfs.h>
174	#endif
175
176	#ifdef VBOX_WITH_HOSTNETIF_API
177	# include "netif.h"
178	#endif
179
180	#include <VBox/usb.h>
181	#include <VBox/err.h>
182	#include <VBox/settings.h>
183	#include <VBox/sup.h>
184	#ifdef VBOX_WITH_3D_ACCELERATION
185	# include <VBox/VBoxOGL.h>
186	#endif
187	#include <iprt/x86.h>
188
189	#include "VBox/com/MultiResult.h"
190	#include "VBox/com/array.h"
191
192	#include <stdio.h>
193
194	#include <algorithm>
195	#include <iprt/sanitized/string>
196	#include <vector>
197
198	#include "HostDnsService.h"
199	#include "HostDriveImpl.h"
200	#include "HostDrivePartitionImpl.h"
201
202	////////////////////////////////////////////////////////////////////////////////
203	//
204	// Host private data definition
205	//
206	////////////////////////////////////////////////////////////////////////////////
207
208	struct Host::Data
209	{
210	Data()
211	:
212	fDVDDrivesListBuilt(false),
213	fFloppyDrivesListBuilt(false),
214	fPersistentConfigUpToDate(false)
215	{};
216
217	VirtualBox *pParent;
218
219	HostNetworkInterfaceList llNetIfs; // list of network interfaces
220
221	#ifdef VBOX_WITH_USB
222	USBDeviceFilterList llChildren; // all USB device filters
223	USBDeviceFilterList llUSBDeviceFilters; // USB device filters in use by the USB proxy service
224
225	/** Pointer to the USBProxyService object. */
226	USBProxyService *pUSBProxyService;
227	#endif /* VBOX_WITH_USB */
228
229	// list of host drives; lazily created by getDVDDrives() and getFloppyDrives(),
230	// and protected by the medium tree lock handle (including the bools).
231	MediaList llDVDDrives,
232	llFloppyDrives;
233	bool fDVDDrivesListBuilt,
234	fFloppyDrivesListBuilt;
235
236	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
237	/** Object with information about host drives */
238	VBoxMainDriveInfo hostDrives;
239	#endif
240
241	/** @name Features that can be queried with GetProcessorFeature.
242	* @{ */
243	bool fVTSupported,
244	fLongModeSupported,
245	fPAESupported,
246	fNestedPagingSupported,
247	fUnrestrictedGuestSupported,
248	fNestedHWVirtSupported,
249	fVirtVmsaveVmload,
250	fRecheckVTSupported;
251
252	/** @} */
253
254	/** 3D hardware acceleration supported? Tristate, -1 meaning not probed. */
255	int f3DAccelerationSupported;
256
257	HostPowerService *pHostPowerService;
258	/** Host's DNS information fetching */
259	HostDnsMonitorProxy hostDnsMonitorProxy;
260
261	/** Startup syncing of persistent config in extra data */
262	bool fPersistentConfigUpToDate;
263
264	#ifdef VBOX_WITH_UPDATE_AGENT
265	/** Reference to the host update agent. */
266	const ComObjPtr<HostUpdateAgent> pUpdateHost;
267	#endif
268	};
269
270
271	////////////////////////////////////////////////////////////////////////////////
272	//
273	// Constructor / destructor
274	//
275	////////////////////////////////////////////////////////////////////////////////
276	DEFINE_EMPTY_CTOR_DTOR(Host)
277
278	HRESULT Host::FinalConstruct()
279	{
280	return BaseFinalConstruct();
281	}
282
283	void Host::FinalRelease()
284	{
285	uninit();
286	BaseFinalRelease();
287	}
288
289	/**
290	* Initializes the host object.
291	*
292	* @param aParent VirtualBox parent object.
293	*/
294	HRESULT Host::init(VirtualBox *aParent)
295	{
296	HRESULT hrc;
297	LogFlowThisFunc(("aParent=%p\n", aParent));
298
299	/* Enclose the state transition NotReady->InInit->Ready */
300	AutoInitSpan autoInitSpan(this);
301	AssertReturn(autoInitSpan.isOk(), E_FAIL);
302
303	m = new Data();
304
305	m->pParent = aParent;
306
307	#ifdef VBOX_WITH_USB
308	/*
309	* Create and initialize the USB Proxy Service.
310	*/
311	m->pUSBProxyService = new USBProxyService(this);
312	hrc = m->pUSBProxyService->init();
313	AssertComRCReturn(hrc, hrc);
314	#endif /* VBOX_WITH_USB */
315
316	#ifdef VBOX_WITH_RESOURCE_USAGE_API
317	i_registerMetrics(aParent->i_performanceCollector());
318	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
319	/* Create the list of network interfaces so their metrics get registered. */
320	i_updateNetIfList();
321
322	m->hostDnsMonitorProxy.init(m->pParent);
323
324	#ifdef VBOX_WITH_UPDATE_AGENT
325	hrc = unconst(m->pUpdateHost).createObject();
326	if (SUCCEEDED(hrc))
327	hrc = m->pUpdateHost->init(m->pParent);
328	AssertComRCReturn(hrc, hrc);
329	#endif
330
331	#if defined(RT_OS_WINDOWS)
332	m->pHostPowerService = new HostPowerServiceWin(m->pParent);
333	#elif defined(RT_OS_LINUX) && defined(VBOX_WITH_DBUS)
334	m->pHostPowerService = new HostPowerServiceLinux(m->pParent);
335	#elif defined(RT_OS_DARWIN)
336	m->pHostPowerService = new HostPowerServiceDarwin(m->pParent);
337	#else
338	m->pHostPowerService = new HostPowerService(m->pParent);
339	#endif
340
341	/* Cache the features reported by GetProcessorFeature. */
342	m->fVTSupported = false;
343	m->fLongModeSupported = false;
344	m->fPAESupported = false;
345	m->fNestedPagingSupported = false;
346	m->fUnrestrictedGuestSupported = false;
347	m->fNestedHWVirtSupported = false;
348	m->fVirtVmsaveVmload = false;
349	m->fRecheckVTSupported = false;
350
351	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
352	if (ASMHasCpuId())
353	{
354	/* Note! This code is duplicated in SUPDrv.c and other places! */
355	uint32_t uMaxId, uVendorEBX, uVendorECX, uVendorEDX;
356	ASMCpuId(0, &uMaxId, &uVendorEBX, &uVendorECX, &uVendorEDX);
357	if (RTX86IsValidStdRange(uMaxId))
358	{
359	/* PAE? */
360	uint32_t uDummy, fFeaturesEcx, fFeaturesEdx;
361	ASMCpuId(1, &uDummy, &uDummy, &fFeaturesEcx, &fFeaturesEdx);
362	m->fPAESupported = RT_BOOL(fFeaturesEdx & X86_CPUID_FEATURE_EDX_PAE);
363
364	/* Long Mode? */
365	uint32_t uExtMaxId, fExtFeaturesEcx, fExtFeaturesEdx;
366	ASMCpuId(0x80000000, &uExtMaxId, &uDummy, &uDummy, &uDummy);
367	ASMCpuId(0x80000001, &uDummy, &uDummy, &fExtFeaturesEcx, &fExtFeaturesEdx);
368	m->fLongModeSupported = RTX86IsValidExtRange(uExtMaxId)
369	&& (fExtFeaturesEdx & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE);
370
371	# if defined(RT_OS_DARWIN) && ARCH_BITS == 32 /* darwin.x86 has some optimizations of 64-bit on 32-bit. */
372	int f64bitCapable = 0;
373	size_t cbParameter = sizeof(f64bitCapable);
374	if (sysctlbyname("hw.cpu64bit_capable", &f64bitCapable, &cbParameter, NULL, NULL) != -1)
375	m->fLongModeSupported = f64bitCapable != 0;
376	# endif
377
378	/* VT-x? */
379	if ( RTX86IsIntelCpu(uVendorEBX, uVendorECX, uVendorEDX)
380	\|\| RTX86IsViaCentaurCpu(uVendorEBX, uVendorECX, uVendorEDX)
381	\|\| RTX86IsShanghaiCpu(uVendorEBX, uVendorECX, uVendorEDX))
382	{
383	if ( (fFeaturesEcx & X86_CPUID_FEATURE_ECX_VMX)
384	&& (fFeaturesEdx & X86_CPUID_FEATURE_EDX_MSR)
385	&& (fFeaturesEdx & X86_CPUID_FEATURE_EDX_FXSR)
386	)
387	{
388	const char *pszIgn;
389	int vrc = SUPR3QueryVTxSupported(&pszIgn);
390	if (RT_SUCCESS(vrc))
391	m->fVTSupported = true;
392	}
393	}
394	/* AMD-V */
395	else if ( RTX86IsAmdCpu(uVendorEBX, uVendorECX, uVendorEDX)
396	\|\| RTX86IsHygonCpu(uVendorEBX, uVendorECX, uVendorEDX))
397	{
398	if ( (fExtFeaturesEcx & X86_CPUID_AMD_FEATURE_ECX_SVM)
399	&& (fFeaturesEdx & X86_CPUID_FEATURE_EDX_MSR)
400	&& (fFeaturesEdx & X86_CPUID_FEATURE_EDX_FXSR)
401	&& RTX86IsValidExtRange(uExtMaxId)
402	)
403	{
404	m->fVTSupported = true;
405	m->fUnrestrictedGuestSupported = true;
406
407	/* Query AMD features. */
408	if (uExtMaxId >= 0x8000000a)
409	{
410	uint32_t fSVMFeaturesEdx;
411	ASMCpuId(0x8000000a, &uDummy, &uDummy, &uDummy, &fSVMFeaturesEdx);
412	if (fSVMFeaturesEdx & X86_CPUID_SVM_FEATURE_EDX_NESTED_PAGING)
413	m->fNestedPagingSupported = true;
414	if (fSVMFeaturesEdx & X86_CPUID_SVM_FEATURE_EDX_VIRT_VMSAVE_VMLOAD)
415	m->fVirtVmsaveVmload = true;
416	}
417	}
418	}
419	}
420	}
421	#endif /* defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86) */
422
423
424	/* Check with SUPDrv if VT-x and AMD-V are really supported (may fail). */
425	if (m->fVTSupported)
426	{
427	m->fRecheckVTSupported = true; /* Try again later when the driver is loaded; cleared by i_updateProcessorFeatures on success. */
428	i_updateProcessorFeatures();
429	}
430
431	/* Check for NEM in root paritition (hyper-V / windows). */
432	if (!m->fVTSupported && SUPR3IsNemSupportedWhenNoVtxOrAmdV())
433	{
434	m->fVTSupported = m->fNestedPagingSupported = true;
435	m->fRecheckVTSupported = false;
436	}
437
438	#ifdef VBOX_WITH_3D_ACCELERATION
439	/* Test for 3D hardware acceleration support later when (if ever) need. */
440	m->f3DAccelerationSupported = -1;
441	#else
442	m->f3DAccelerationSupported = false;
443	#endif
444
445	#if defined(VBOX_WITH_HOSTNETIF_API) && (defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_FREEBSD))
446	/* Extract the list of configured host-only interfaces */
447	std::set<Utf8Str> aConfiguredNames;
448	SafeArray<BSTR> aGlobalExtraDataKeys;
449	hrc = aParent->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
450	AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
451	for (size_t i = 0; i < aGlobalExtraDataKeys.size(); ++i)
452	{
453	Utf8Str strKey = aGlobalExtraDataKeys[i];
454
455	if (!strKey.startsWith("HostOnly/vboxnet"))
456	continue;
457
458	size_t pos = strKey.find("/", sizeof("HostOnly/vboxnet"));
459	if (pos != Utf8Str::npos)
460	aConfiguredNames.insert(strKey.substr(sizeof("HostOnly"),
461	pos - sizeof("HostOnly")));
462	}
463
464	for (std::set<Utf8Str>::const_iterator it = aConfiguredNames.begin();
465	it != aConfiguredNames.end();
466	++it)
467	{
468	ComPtr<IHostNetworkInterface> hif;
469	ComPtr<IProgress> progress;
470
471	int vrc = NetIfCreateHostOnlyNetworkInterface(m->pParent,
472	hif.asOutParam(),
473	progress.asOutParam(),
474	it->c_str());
475	if (RT_FAILURE(vrc))
476	LogRel(("failed to create %s, error (%Rrc)\n", it->c_str(), vrc));
477	}
478
479	#endif /* defined(VBOX_WITH_HOSTNETIF_API) && (defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_FREEBSD)) */
480
481	/* Confirm a successful initialization */
482	autoInitSpan.setSucceeded();
483
484	return S_OK;
485	}
486
487	/**
488	* Uninitializes the host object and sets the ready flag to FALSE.
489	* Called either from FinalRelease() or by the parent when it gets destroyed.
490	*/
491	void Host::uninit()
492	{
493	LogFlowThisFunc(("\n"));
494
495	/* Enclose the state transition Ready->InUninit->NotReady */
496	AutoUninitSpan autoUninitSpan(this);
497	if (autoUninitSpan.uninitDone())
498	return;
499
500	#ifdef VBOX_WITH_RESOURCE_USAGE_API
501	PerformanceCollector *aCollector = m->pParent->i_performanceCollector();
502	i_unregisterMetrics(aCollector);
503	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
504	/*
505	* Note that unregisterMetrics() has unregistered all metrics associated
506	* with Host including network interface ones. We can destroy network
507	* interface objects now. Don't forget the uninit call, otherwise this
508	* causes a race with crashing API clients getting their stale references
509	* cleaned up and VirtualBox shutting down.
510	*/
511	while (!m->llNetIfs.empty())
512	{
513	ComObjPtr<HostNetworkInterface> &pNet = m->llNetIfs.front();
514	pNet->uninit();
515	m->llNetIfs.pop_front();
516	}
517
518	m->hostDnsMonitorProxy.uninit();
519
520	#ifdef VBOX_WITH_UPDATE_AGENT
521	if (m->pUpdateHost)
522	{
523	m->pUpdateHost->uninit();
524	unconst(m->pUpdateHost).setNull();
525	}
526	#endif
527
528	#ifdef VBOX_WITH_USB
529	/* wait for USB proxy service to terminate before we uninit all USB
530	* devices */
531	LogFlowThisFunc(("Stopping USB proxy service...\n"));
532	delete m->pUSBProxyService;
533	m->pUSBProxyService = NULL;
534	LogFlowThisFunc(("Done stopping USB proxy service.\n"));
535	#endif
536
537	delete m->pHostPowerService;
538
539	#ifdef VBOX_WITH_USB
540	/* uninit all USB device filters still referenced by clients
541	* Note! HostUSBDeviceFilter::uninit() will modify llChildren.
542	* This list should be already empty, but better be safe than sorry. */
543	while (!m->llChildren.empty())
544	{
545	ComObjPtr<HostUSBDeviceFilter> &pChild = m->llChildren.front();
546	pChild->uninit();
547	m->llChildren.pop_front();
548	}
549
550	/* No need to uninit these, as either Machine::uninit() or the above loop
551	* already covered them all. Subset of llChildren. */
552	m->llUSBDeviceFilters.clear();
553	#endif
554
555	/* uninit all host DVD medium objects */
556	while (!m->llDVDDrives.empty())
557	{
558	ComObjPtr<Medium> &pMedium = m->llDVDDrives.front();
559	pMedium->uninit();
560	m->llDVDDrives.pop_front();
561	}
562	/* uninit all host floppy medium objects */
563	while (!m->llFloppyDrives.empty())
564	{
565	ComObjPtr<Medium> &pMedium = m->llFloppyDrives.front();
566	pMedium->uninit();
567	m->llFloppyDrives.pop_front();
568	}
569
570	delete m;
571	m = NULL;
572	}
573
574	////////////////////////////////////////////////////////////////////////////////
575	//
576	// IHost public methods
577	//
578	////////////////////////////////////////////////////////////////////////////////
579
580	/**
581	* Returns a list of host DVD drives.
582	*
583	* @returns COM status code
584	* @param aDVDDrives address of result pointer
585	*/
586
587	HRESULT Host::getDVDDrives(std::vector<ComPtr<IMedium> > &aDVDDrives)
588	{
589	AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
590
591	MediaList *pList;
592	HRESULT hrc = i_getDrives(DeviceType_DVD, true /* fRefresh */, pList, treeLock);
593	if (FAILED(hrc))
594	return hrc;
595
596	aDVDDrives.resize(pList->size());
597	size_t i = 0;
598	for (MediaList::const_iterator it = pList->begin(); it != pList->end(); ++it, ++i)
599	(*it).queryInterfaceTo(aDVDDrives[i].asOutParam());
600
601	return S_OK;
602	}
603
604	/**
605	* Returns a list of host floppy drives.
606	*
607	* @returns COM status code
608	* @param aFloppyDrives address of result pointer
609	*/
610	HRESULT Host::getFloppyDrives(std::vector<ComPtr<IMedium> > &aFloppyDrives)
611	{
612	AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
613
614	MediaList *pList;
615	HRESULT hrc = i_getDrives(DeviceType_Floppy, true /* fRefresh */, pList, treeLock);
616	if (FAILED(hrc))
617	return hrc;
618
619	aFloppyDrives.resize(pList->size());
620	size_t i = 0;
621	for (MediaList::const_iterator it = pList->begin(); it != pList->end(); ++it, ++i)
622	(*it).queryInterfaceTo(aFloppyDrives[i].asOutParam());
623
624	return S_OK;
625	}
626
627
628	#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
629	# define VBOX_APP_NAME L"VirtualBox"
630
631	static int vboxNetWinAddComponent(std::list< ComObjPtr<HostNetworkInterface> > *pPist,
632	INetCfgComponent *pncc)
633	{
634	int vrc = VERR_GENERAL_FAILURE;
635
636	LPWSTR lpszName = NULL;
637	HRESULT hrc = pncc->GetDisplayName(&lpszName);
638	Assert(hrc == S_OK);
639	if (hrc == S_OK)
640	{
641	Bstr name((CBSTR)lpszName);
642
643	GUID IfGuid;
644	hrc = pncc->GetInstanceGuid(&IfGuid);
645	Assert(hrc == S_OK);
646	if (hrc == S_OK)
647	{
648	/* create a new object and add it to the list */
649	ComObjPtr<HostNetworkInterface> iface;
650	iface.createObject();
651	/* remove the curly bracket at the end */
652	if (SUCCEEDED(iface->init(name, name, Guid(IfGuid), HostNetworkInterfaceType_Bridged)))
653	{
654	// iface->setVirtualBox(m->pParent);
655	pPist->push_back(iface);
656	vrc = VINF_SUCCESS;
657	}
658	else
659	{
660	Assert(0);
661	}
662	}
663	CoTaskMemFree(lpszName);
664	}
665
666	return vrc;
667	}
668	#endif /* defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
669
670	#if defined(RT_OS_WINDOWS)
671	struct HostOnlyInfo
672	{
673	HostOnlyInfo() : fDhcpEnabled(false), uIPv6PrefixLength(0) {};
674
675	Bstr bstrName;
676	bool fDhcpEnabled;
677	Bstr strIPv4Address;
678	Bstr strIPv4NetMask;
679	Bstr strIPv6Address;
680	ULONG uIPv6PrefixLength;
681	};
682
683	typedef std::map<Utf8Str, HostOnlyInfo*> GUID_TO_HOST_ONLY_INFO;
684
685	HRESULT Host::i_updatePersistentConfigForHostOnlyAdapters(void)
686	{
687	/* No need to do the sync twice */
688	if (m->fPersistentConfigUpToDate)
689	return S_OK;
690	m->fPersistentConfigUpToDate = true;
691	bool fChangesMade = false;
692
693	/* Extract the list of configured host-only interfaces */
694	GUID_TO_HOST_ONLY_INFO aSavedAdapters;
695	SafeArray<BSTR> aGlobalExtraDataKeys;
696	HRESULT hrc = m->pParent->GetExtraDataKeys(ComSafeArrayAsOutParam(aGlobalExtraDataKeys));
697	AssertMsg(SUCCEEDED(hrc), ("VirtualBox::GetExtraDataKeys failed with %Rhrc\n", hrc));
698	for (size_t i = 0; i < aGlobalExtraDataKeys.size(); ++i)
699	{
700	Utf8Str strKey = aGlobalExtraDataKeys[i];
701
702	if (strKey.startsWith("HostOnly/{"))
703	{
704	Bstr bstrValue;
705	hrc = m->pParent->GetExtraData(aGlobalExtraDataKeys[i], bstrValue.asOutParam());
706	if (hrc != S_OK)
707	continue;
708
709	Utf8Str strGuid = strKey.substr(10, 36); /* Skip "HostOnly/{" */
710	if (aSavedAdapters.find(strGuid) == aSavedAdapters.end())
711	aSavedAdapters[strGuid] = new HostOnlyInfo();
712
713	if (strKey.endsWith("}/Name"))
714	aSavedAdapters[strGuid]->bstrName = bstrValue;
715	else if (strKey.endsWith("}/IPAddress"))
716	{
717	if (bstrValue == "DHCP")
718	aSavedAdapters[strGuid]->fDhcpEnabled = true;
719	else
720	aSavedAdapters[strGuid]->strIPv4Address = bstrValue;
721	}
722	else if (strKey.endsWith("}/IPNetMask"))
723	aSavedAdapters[strGuid]->strIPv4NetMask = bstrValue;
724	else if (strKey.endsWith("}/IPV6Address"))
725	aSavedAdapters[strGuid]->strIPv6Address = bstrValue;
726	else if (strKey.endsWith("}/IPV6PrefixLen"))
727	aSavedAdapters[strGuid]->uIPv6PrefixLength = Utf8Str(bstrValue).toUInt32();
728	}
729	}
730
731	/* Go over the list of existing adapters and update configs saved in extra data */
732	std::set<Bstr> aKnownNames;
733	for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
734	{
735	/* Get type */
736	HostNetworkInterfaceType_T t;
737	hrc = (*it)->COMGETTER(InterfaceType)(&t);
738	if (FAILED(hrc) \|\| t != HostNetworkInterfaceType_HostOnly)
739	continue;
740	/* Get id */
741	Bstr bstrGuid;
742	hrc = (*it)->COMGETTER(Id)(bstrGuid.asOutParam());
743	if (FAILED(hrc))
744	continue;
745	/* Get name */
746	Bstr bstrName;
747	hrc = (*it)->COMGETTER(Name)(bstrName.asOutParam());
748	if (FAILED(hrc))
749	continue;
750
751	/* Remove adapter from map as it does not need any further processing */
752	aSavedAdapters.erase(Utf8Str(bstrGuid));
753	/* Add adapter name to the list of known names, so we won't attempt to create adapters with the same name */
754	aKnownNames.insert(bstrName);
755	/* Make sure our extra data contains the latest config */
756	hrc = (*it)->i_updatePersistentConfig();
757	if (hrc != S_OK)
758	break;
759	}
760
761	/* The following loop not only creates missing adapters, it destroys HostOnlyInfo objects contained in the map as well */
762	for (GUID_TO_HOST_ONLY_INFO::iterator it = aSavedAdapters.begin(); it != aSavedAdapters.end(); ++it)
763	{
764	Utf8Str strGuid = (*it).first;
765	HostOnlyInfo pInfo = (it).second;
766	/* We create adapters only if we haven't seen one with the same name */
767	if (aKnownNames.find(pInfo->bstrName) == aKnownNames.end())
768	{
769	/* There is no adapter with such name yet, create it */
770	ComPtr<IHostNetworkInterface> hif;
771	ComPtr<IProgress> progress;
772
773	int vrc = NetIfCreateHostOnlyNetworkInterface(m->pParent, hif.asOutParam(), progress.asOutParam(),
774	pInfo->bstrName.raw());
775	if (RT_FAILURE(vrc))
776	{
777	LogRel(("Failed to create host-only adapter (%Rrc)\n", vrc));
778	hrc = E_UNEXPECTED;
779	break;
780	}
781
782	/* Wait for the adapter to get configured completely, before we modify IP addresses. */
783	progress->WaitForCompletion(-1);
784	fChangesMade = true;
785	if (pInfo->fDhcpEnabled)
786	{
787	hrc = hif->EnableDynamicIPConfig();
788	if (FAILED(hrc))
789	LogRel(("EnableDynamicIPConfig failed with 0x%x\n", hrc));
790	}
791	else
792	{
793	hrc = hif->EnableStaticIPConfig(pInfo->strIPv4Address.raw(), pInfo->strIPv4NetMask.raw());
794	if (FAILED(hrc))
795	LogRel(("EnableStaticIpConfig failed with 0x%x\n", hrc));
796	}
797	# if 0
798	/* Somehow HostNetworkInterface::EnableStaticIPConfigV6 is not implemented yet. */
799	if (SUCCEEDED(hrc))
800	{
801	hrc = hif->EnableStaticIPConfigV6(pInfo->strIPv6Address.raw(), pInfo->uIPv6PrefixLength);
802	if (FAILED(hrc))
803	LogRel(("EnableStaticIPConfigV6 failed with 0x%x\n", hrc));
804	}
805	# endif
806	/* Now we have seen this name */
807	aKnownNames.insert(pInfo->bstrName);
808	/* Drop the old config as the newly created adapter has different GUID */
809	i_removePersistentConfig(strGuid);
810	}
811	delete pInfo;
812	}
813	/* Update the list again if we have created some adapters */
814	if (SUCCEEDED(hrc) && fChangesMade)
815	hrc = i_updateNetIfList();
816
817	return hrc;
818	}
819	#endif /* defined(RT_OS_WINDOWS) */
820
821	/**
822	* Returns a list of host network interfaces.
823	*
824	* @returns COM status code
825	* @param aNetworkInterfaces address of result pointer
826	*/
827	HRESULT Host::getNetworkInterfaces(std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces)
828	{
829	#if defined(RT_OS_WINDOWS) \|\| defined(VBOX_WITH_NETFLT) /\|\| defined(RT_OS_OS2)/
830	# ifdef VBOX_WITH_HOSTNETIF_API
831	HRESULT hrc = i_updateNetIfList();
832	if (FAILED(hrc))
833	{
834	Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
835	return hrc;
836	}
837	#if defined(RT_OS_WINDOWS)
838	hrc = i_updatePersistentConfigForHostOnlyAdapters();
839	if (FAILED(hrc))
840	{
841	LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
842	return hrc;
843	}
844	#endif /* defined(RT_OS_WINDOWS) */
845
846	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
847
848	aNetworkInterfaces.resize(m->llNetIfs.size());
849	size_t i = 0;
850	for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it, ++i)
851	(*it).queryInterfaceTo(aNetworkInterfaces[i].asOutParam());
852
853	return S_OK;
854	# else
855	std::list<ComObjPtr<HostNetworkInterface> > list;
856
857	# if defined(RT_OS_DARWIN)
858	PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
859	while (pEtherNICs)
860	{
861	ComObjPtr<HostNetworkInterface> IfObj;
862	IfObj.createObject();
863	if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid), HostNetworkInterfaceType_Bridged)))
864	list.push_back(IfObj);
865
866	/* next, free current */
867	void *pvFree = pEtherNICs;
868	pEtherNICs = pEtherNICs->pNext;
869	RTMemFree(pvFree);
870	}
871
872	# elif defined RT_OS_WINDOWS
873	# ifndef VBOX_WITH_NETFLT
874	hrc = E_NOTIMPL;
875	# else /* # if defined VBOX_WITH_NETFLT */
876	INetCfg *pNc;
877	INetCfgComponent *pMpNcc;
878	INetCfgComponent *pTcpIpNcc;
879	LPWSTR lpszApp;
880	HRESULT hrc;
881	IEnumNetCfgBindingPath *pEnumBp;
882	INetCfgBindingPath *pBp;
883	IEnumNetCfgBindingInterface *pEnumBi;
884	INetCfgBindingInterface *pBi;
885
886	/* we are using the INetCfg API for getting the list of miniports */
887	hrc = VBoxNetCfgWinQueryINetCfg(FALSE, VBOX_APP_NAME, &pNc, &lpszApp);
888	Assert(hrc == S_OK);
889	if (hrc == S_OK)
890	{
891	# ifdef VBOX_NETFLT_ONDEMAND_BIND
892	/* for the protocol-based approach for now we just get all miniports the MS_TCPIP protocol binds to */
893	hrc = pNc->FindComponent(L"MS_TCPIP", &pTcpIpNcc);
894	# else
895	/* for the filter-based approach we get all miniports our filter (oracle_VBoxNetLwf)is bound to */
896	hrc = pNc->FindComponent(L"oracle_VBoxNetLwf", &pTcpIpNcc);
897	if (hrc != S_OK)
898	{
899	/* fall back to NDIS5 miniport lookup (sun_VBoxNetFlt) */
900	hrc = pNc->FindComponent(L"sun_VBoxNetFlt", &pTcpIpNcc);
901	}
902	# ifndef VBOX_WITH_HARDENING
903	if (hrc != S_OK)
904	{
905	/** @todo try to install the netflt from here */
906	}
907	# endif
908
909	# endif
910
911	if (hrc == S_OK)
912	{
913	hrc = VBoxNetCfgWinGetBindingPathEnum(pTcpIpNcc, EBP_BELOW, &pEnumBp);
914	Assert(hrc == S_OK);
915	if (hrc == S_OK)
916	{
917	hrc = VBoxNetCfgWinGetFirstBindingPath(pEnumBp, &pBp);
918	Assert(hrc == S_OK \|\| hrc == S_FALSE);
919	while (hrc == S_OK)
920	{
921	/* S_OK == enabled, S_FALSE == disabled */
922	if (pBp->IsEnabled() == S_OK)
923	{
924	hrc = VBoxNetCfgWinGetBindingInterfaceEnum(pBp, &pEnumBi);
925	Assert(hrc == S_OK);
926	if (hrc == S_OK)
927	{
928	hrc = VBoxNetCfgWinGetFirstBindingInterface(pEnumBi, &pBi);
929	Assert(hrc == S_OK);
930	while (hrc == S_OK)
931	{
932	hrc = pBi->GetLowerComponent(&pMpNcc);
933	Assert(hrc == S_OK);
934	if (hrc == S_OK)
935	{
936	ULONG uComponentStatus;
937	hrc = pMpNcc->GetDeviceStatus(&uComponentStatus);
938	Assert(hrc == S_OK);
939	if (hrc == S_OK)
940	{
941	if (uComponentStatus == 0)
942	vboxNetWinAddComponent(&list, pMpNcc);
943	}
944	VBoxNetCfgWinReleaseRef(pMpNcc);
945	}
946	VBoxNetCfgWinReleaseRef(pBi);
947
948	hrc = VBoxNetCfgWinGetNextBindingInterface(pEnumBi, &pBi);
949	}
950	VBoxNetCfgWinReleaseRef(pEnumBi);
951	}
952	}
953	VBoxNetCfgWinReleaseRef(pBp);
954
955	hrc = VBoxNetCfgWinGetNextBindingPath(pEnumBp, &pBp);
956	}
957	VBoxNetCfgWinReleaseRef(pEnumBp);
958	}
959	VBoxNetCfgWinReleaseRef(pTcpIpNcc);
960	}
961	else
962	{
963	LogRel(("failed to get the oracle_VBoxNetLwf(sun_VBoxNetFlt) component, error (0x%x)\n", hrc));
964	}
965
966	VBoxNetCfgWinReleaseINetCfg(pNc, FALSE);
967	}
968	# endif /* # if defined VBOX_WITH_NETFLT */
969
970
971	# elif defined RT_OS_LINUX
972	int sock = socket(AF_INET, SOCK_DGRAM, 0);
973	if (sock >= 0)
974	{
975	char pBuffer[2048];
976	struct ifconf ifConf;
977	ifConf.ifc_len = sizeof(pBuffer);
978	ifConf.ifc_buf = pBuffer;
979	if (ioctl(sock, SIOCGIFCONF, &ifConf) >= 0)
980	{
981	for (struct ifreq pReq = ifConf.ifc_req; (char)pReq < pBuffer + ifConf.ifc_len; pReq++)
982	{
983	if (ioctl(sock, SIOCGIFHWADDR, pReq) >= 0)
984	{
985	if (pReq->ifr_hwaddr.sa_family == ARPHRD_ETHER)
986	{
987	RTUUID uuid;
988	Assert(sizeof(uuid) <= sizeof(*pReq));
989	memcpy(&uuid, pReq, sizeof(uuid));
990
991	ComObjPtr<HostNetworkInterface> IfObj;
992	IfObj.createObject();
993	if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid), HostNetworkInterfaceType_Bridged)))
994	list.push_back(IfObj);
995	}
996	}
997	}
998	}
999	close(sock);
1000	}
1001	# endif /* RT_OS_LINUX */
1002
1003	aNetworkInterfaces.resize(list.size());
1004	size_t i = 0;
1005	for (std::list<ComObjPtr<HostNetworkInterface> >::const_iterator it = list.begin(); it != list.end(); ++it, ++i)
1006	aNetworkInterfaces[i] = *it;
1007
1008	return S_OK;
1009	# endif
1010	#else
1011	/* Not implemented / supported on this platform. */
1012	RT_NOREF(aNetworkInterfaces);
1013	ReturnComNotImplemented();
1014	#endif
1015	}
1016
1017	HRESULT Host::getAudioDevices(std::vector<ComPtr<IHostAudioDevice> > &aAudioDevices)
1018	{
1019	RT_NOREF(aAudioDevices);
1020	ReturnComNotImplemented();
1021	}
1022
1023	HRESULT Host::getUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices)
1024	{
1025	#ifdef VBOX_WITH_USB
1026	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1027
1028	MultiResult mrc = i_checkUSBProxyService();
1029	if (FAILED(mrc) \|\| SUCCEEDED_WARNING(mrc))
1030	return mrc;
1031
1032	return m->pUSBProxyService->getDeviceCollection(aUSBDevices);
1033	#else
1034	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1035	* extended error info to indicate that USB is simply not available
1036	* (w/o treating it as a failure), for example, as in OSE. */
1037	RT_NOREF(aUSBDevices);
1038	ReturnComNotImplemented();
1039	#endif
1040	}
1041
1042	/**
1043	* This method return the list of registered name servers
1044	*/
1045	HRESULT Host::getNameServers(std::vector<com::Utf8Str> &aNameServers)
1046	{
1047	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1048	return m->hostDnsMonitorProxy.GetNameServers(aNameServers);
1049	}
1050
1051
1052	/**
1053	* This method returns the domain name of the host
1054	*/
1055	HRESULT Host::getDomainName(com::Utf8Str &aDomainName)
1056	{
1057	/** @todo XXX: note here should be synchronization with thread polling state
1058	* changes in name resolving system on host */
1059	return m->hostDnsMonitorProxy.GetDomainName(&aDomainName);
1060	}
1061
1062
1063	/**
1064	* This method returns the search string.
1065	*/
1066	HRESULT Host::getSearchStrings(std::vector<com::Utf8Str> &aSearchStrings)
1067	{
1068	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1069	return m->hostDnsMonitorProxy.GetSearchStrings(aSearchStrings);
1070	}
1071
1072	HRESULT Host::getUSBDeviceFilters(std::vector<ComPtr<IHostUSBDeviceFilter> > &aUSBDeviceFilters)
1073	{
1074	#ifdef VBOX_WITH_USB
1075	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1076
1077	MultiResult mrc = i_checkUSBProxyService();
1078	if (FAILED(mrc))
1079	return mrc;
1080
1081	aUSBDeviceFilters.resize(m->llUSBDeviceFilters.size());
1082	size_t i = 0;
1083	for (USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin(); it != m->llUSBDeviceFilters.end(); ++it, ++i)
1084	(*it).queryInterfaceTo(aUSBDeviceFilters[i].asOutParam());
1085
1086	return mrc;
1087	#else
1088	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1089	* extended error info to indicate that USB is simply not available
1090	* (w/o treating it as a failure), for example, as in OSE. */
1091	RT_NOREF(aUSBDeviceFilters);
1092	ReturnComNotImplemented();
1093	#endif
1094	}
1095
1096	/**
1097	* Returns the number of installed logical processors
1098	*
1099	* @returns COM status code
1100	* @param aCount address of result variable
1101	*/
1102
1103	HRESULT Host::getProcessorCount(ULONG *aCount)
1104	{
1105	// no locking required
1106
1107	*aCount = RTMpGetPresentCount();
1108	return S_OK;
1109	}
1110
1111	/**
1112	* Returns the number of online logical processors
1113	*
1114	* @returns COM status code
1115	* @param aCount address of result variable
1116	*/
1117	HRESULT Host::getProcessorOnlineCount(ULONG *aCount)
1118	{
1119	// no locking required
1120
1121	*aCount = RTMpGetOnlineCount();
1122	return S_OK;
1123	}
1124
1125	/**
1126	* Returns the number of installed physical processor cores.
1127	*
1128	* @returns COM status code
1129	* @param aCount address of result variable
1130	*/
1131	HRESULT Host::getProcessorCoreCount(ULONG *aCount)
1132	{
1133	// no locking required
1134
1135	*aCount = RTMpGetPresentCoreCount();
1136	return S_OK;
1137	}
1138
1139	/**
1140	* Returns the number of installed physical processor cores.
1141	*
1142	* @returns COM status code
1143	* @param aCount address of result variable
1144	*/
1145	HRESULT Host::getProcessorOnlineCoreCount(ULONG *aCount)
1146	{
1147	// no locking required
1148
1149	*aCount = RTMpGetOnlineCoreCount();
1150	return S_OK;
1151	}
1152
1153	/**
1154	* Returns the (approximate) maximum speed of the given host CPU in MHz
1155	*
1156	* @returns COM status code
1157	* @param aCpuId id to get info for.
1158	* @param aSpeed address of result variable, speed is 0 if unknown or aCpuId
1159	* is invalid.
1160	*/
1161	HRESULT Host::getProcessorSpeed(ULONG aCpuId,
1162	ULONG *aSpeed)
1163	{
1164	// no locking required
1165
1166	*aSpeed = RTMpGetMaxFrequency(aCpuId);
1167	return S_OK;
1168	}
1169
1170	/**
1171	* Returns a description string for the host CPU
1172	*
1173	* @returns COM status code
1174	* @param aCpuId id to get info for.
1175	* @param aDescription address of result variable, empty string if not known
1176	* or aCpuId is invalid.
1177	*/
1178	HRESULT Host::getProcessorDescription(ULONG aCpuId, com::Utf8Str &aDescription)
1179	{
1180	// no locking required
1181
1182	int vrc = aDescription.reserveNoThrow(80);
1183	if (RT_SUCCESS(vrc))
1184	{
1185	vrc = RTMpGetDescription(aCpuId, aDescription.mutableRaw(), aDescription.capacity());
1186	if (RT_SUCCESS(vrc))
1187	{
1188	aDescription.jolt();
1189	return S_OK;
1190	}
1191	}
1192	return setErrorVrc(vrc);
1193	}
1194
1195	/**
1196	* Updates fVTSupported, fNestedPagingSupported, fUnrestrictedGuestSupported,
1197	* fVirtVmsaveVmload and fNestedHWVirtSupported with info from SUPR3QueryVTCaps().
1198	*
1199	* This is repeated till we successfully open the support driver, in case it
1200	* is loaded after VBoxSVC starts.
1201	*/
1202	void Host::i_updateProcessorFeatures()
1203	{
1204	/* Perhaps the driver is available now... */
1205	int vrc = SUPR3InitEx(SUPR3INIT_F_LIMITED, NULL);
1206	if (RT_SUCCESS(vrc))
1207	{
1208	uint32_t fVTCaps;
1209	vrc = SUPR3QueryVTCaps(&fVTCaps);
1210	AssertMsg(RT_SUCCESS(vrc) \|\| vrc == VERR_SUP_DRIVERLESS, ("SUPR3QueryVTCaps failed vrc=%Rrc\n", vrc));
1211
1212	SUPR3Term(false);
1213
1214	AutoWriteLock wlock(this COMMA_LOCKVAL_SRC_POS);
1215	if (RT_FAILURE(vrc))
1216	{
1217	fVTCaps = 0;
1218	if (vrc != VERR_SUP_DRIVERLESS)
1219	LogRel(("SUPR0QueryVTCaps -> %Rrc\n", vrc));
1220	# if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86) /* Preserve detected VT-x/AMD-V support for show. */
1221	else
1222	fVTCaps = m->fVTSupported ? SUPVTCAPS_AMD_V \| SUPVTCAPS_VT_X : 0;
1223	# endif
1224	}
1225	m->fVTSupported = (fVTCaps & (SUPVTCAPS_AMD_V \| SUPVTCAPS_VT_X)) != 0;
1226	m->fNestedPagingSupported = (fVTCaps & SUPVTCAPS_NESTED_PAGING) != 0;
1227	m->fUnrestrictedGuestSupported = (fVTCaps & (SUPVTCAPS_AMD_V \| SUPVTCAPS_VTX_UNRESTRICTED_GUEST)) != 0;
1228	m->fNestedHWVirtSupported = (fVTCaps & (SUPVTCAPS_AMD_V \| SUPVTCAPS_NESTED_PAGING))
1229	== (SUPVTCAPS_AMD_V \| SUPVTCAPS_NESTED_PAGING)
1230	\|\| (fVTCaps & ( SUPVTCAPS_VT_X \| SUPVTCAPS_NESTED_PAGING
1231	\| SUPVTCAPS_VTX_UNRESTRICTED_GUEST \| SUPVTCAPS_VTX_VMCS_SHADOWING))
1232	== ( SUPVTCAPS_VT_X \| SUPVTCAPS_NESTED_PAGING
1233	\| SUPVTCAPS_VTX_UNRESTRICTED_GUEST \| SUPVTCAPS_VTX_VMCS_SHADOWING);
1234	m->fVirtVmsaveVmload = (fVTCaps & SUPVTCAPS_AMDV_VIRT_VMSAVE_VMLOAD) != 0;
1235	m->fRecheckVTSupported = false; /* No need to try again, we cached everything. */
1236	}
1237	}
1238
1239	/**
1240	* Returns whether a host processor feature is supported or not
1241	*
1242	* @returns COM status code
1243	* @param aFeature to query.
1244	* @param aSupported supported bool result variable
1245	*/
1246	HRESULT Host::getProcessorFeature(ProcessorFeature_T aFeature, BOOL *aSupported)
1247	{
1248	/* Validate input. */
1249	switch (aFeature)
1250	{
1251	case ProcessorFeature_HWVirtEx:
1252	case ProcessorFeature_PAE:
1253	case ProcessorFeature_LongMode:
1254	case ProcessorFeature_NestedPaging:
1255	case ProcessorFeature_UnrestrictedGuest:
1256	case ProcessorFeature_NestedHWVirt:
1257	case ProcessorFeature_VirtVmsaveVmload:
1258	break;
1259	default:
1260	return setError(E_INVALIDARG, tr("The aFeature value %d (%#x) is out of range."), (int)aFeature, (int)aFeature);
1261	}
1262
1263	/* Do the job. */
1264	AutoCaller autoCaller(this);
1265	HRESULT hrc = autoCaller.hrc();
1266	if (SUCCEEDED(hrc))
1267	{
1268	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1269
1270	if ( m->fRecheckVTSupported
1271	&& ( aFeature == ProcessorFeature_HWVirtEx
1272	\|\| aFeature == ProcessorFeature_NestedPaging
1273	\|\| aFeature == ProcessorFeature_UnrestrictedGuest
1274	\|\| aFeature == ProcessorFeature_NestedHWVirt
1275	\|\| aFeature == ProcessorFeature_VirtVmsaveVmload)
1276	)
1277	{
1278	alock.release();
1279	i_updateProcessorFeatures();
1280	alock.acquire();
1281	}
1282
1283	switch (aFeature)
1284	{
1285	case ProcessorFeature_HWVirtEx:
1286	*aSupported = m->fVTSupported;
1287	break;
1288
1289	case ProcessorFeature_PAE:
1290	*aSupported = m->fPAESupported;
1291	break;
1292
1293	case ProcessorFeature_LongMode:
1294	*aSupported = m->fLongModeSupported;
1295	break;
1296
1297	case ProcessorFeature_NestedPaging:
1298	*aSupported = m->fNestedPagingSupported;
1299	break;
1300
1301	case ProcessorFeature_UnrestrictedGuest:
1302	*aSupported = m->fUnrestrictedGuestSupported;
1303	break;
1304
1305	case ProcessorFeature_NestedHWVirt:
1306	*aSupported = m->fNestedHWVirtSupported;
1307	break;
1308
1309	case ProcessorFeature_VirtVmsaveVmload:
1310	*aSupported = m->fVirtVmsaveVmload;
1311	break;
1312
1313	default:
1314	AssertFailed();
1315	}
1316	}
1317	return hrc;
1318	}
1319
1320	/**
1321	* Returns the specific CPUID leaf.
1322	*
1323	* @returns COM status code
1324	* @param aCpuId The CPU number. Mostly ignored.
1325	* @param aLeaf The leaf number.
1326	* @param aSubLeaf The sub-leaf number.
1327	* @param aValEAX Where to return EAX.
1328	* @param aValEBX Where to return EBX.
1329	* @param aValECX Where to return ECX.
1330	* @param aValEDX Where to return EDX.
1331	*/
1332	HRESULT Host::getProcessorCPUIDLeaf(ULONG aCpuId, ULONG aLeaf, ULONG aSubLeaf,
1333	ULONG aValEAX, ULONG aValEBX, ULONG aValECX, ULONG aValEDX)
1334	{
1335	// no locking required
1336
1337	/* Check that the CPU is online. */
1338	/** @todo later use RTMpOnSpecific. */
1339	if (!RTMpIsCpuOnline(aCpuId))
1340	return RTMpIsCpuPresent(aCpuId)
1341	? setError(E_FAIL, tr("CPU no.%u is not present"), aCpuId)
1342	: setError(E_FAIL, tr("CPU no.%u is not online"), aCpuId);
1343
1344	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
1345	uint32_t uEAX, uEBX, uECX, uEDX;
1346	ASMCpuId_Idx_ECX(aLeaf, aSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
1347	*aValEAX = uEAX;
1348	*aValEBX = uEBX;
1349	*aValECX = uECX;
1350	*aValEDX = uEDX;
1351	#else
1352	*aValEAX = 0;
1353	*aValEBX = 0;
1354	*aValECX = 0;
1355	*aValEDX = 0;
1356	#endif
1357
1358	return S_OK;
1359	}
1360
1361	/**
1362	* Returns the amount of installed system memory in megabytes
1363	*
1364	* @returns COM status code
1365	* @param aSize address of result variable
1366	*/
1367	HRESULT Host::getMemorySize(ULONG *aSize)
1368	{
1369	// no locking required
1370
1371	uint64_t cb;
1372	int vrc = RTSystemQueryTotalRam(&cb);
1373	if (RT_FAILURE(vrc))
1374	return E_FAIL;
1375	*aSize = (ULONG)(cb / _1M);
1376	return S_OK;
1377	}
1378
1379	/**
1380	* Returns the current system memory free space in megabytes
1381	*
1382	* @returns COM status code
1383	* @param aAvailable address of result variable
1384	*/
1385	HRESULT Host::getMemoryAvailable(ULONG *aAvailable)
1386	{
1387	// no locking required
1388
1389	uint64_t cb;
1390	int vrc = RTSystemQueryAvailableRam(&cb);
1391	if (RT_FAILURE(vrc))
1392	return E_FAIL;
1393	*aAvailable = (ULONG)(cb / _1M);
1394	return S_OK;
1395	}
1396
1397	/**
1398	* Returns the name string of the host operating system
1399	*
1400	* @returns COM status code
1401	* @param aOperatingSystem result variable
1402	*/
1403	HRESULT Host::getOperatingSystem(com::Utf8Str &aOperatingSystem)
1404	{
1405	// no locking required
1406
1407	char szOSName[80];
1408	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szOSName, sizeof(szOSName));
1409	if (RT_FAILURE(vrc))
1410	return E_FAIL; /** @todo error reporting? */
1411	aOperatingSystem = Utf8Str(szOSName);
1412	return S_OK;
1413	}
1414
1415	/**
1416	* Returns the version string of the host operating system
1417	*
1418	* @returns COM status code
1419	* @param aVersion address of result variable
1420	*/
1421	HRESULT Host::getOSVersion(com::Utf8Str &aVersion)
1422	{
1423	// no locking required
1424
1425	/* Get the OS release. Reserve some buffer space for the service pack. */
1426	char szOSRelease[128];
1427	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSRelease, sizeof(szOSRelease) - 32);
1428	if (RT_FAILURE(vrc))
1429	return E_FAIL; /** @todo error reporting? */
1430
1431	/* Append the service pack if present. */
1432	char szOSServicePack[80];
1433	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szOSServicePack, sizeof(szOSServicePack));
1434	if (RT_FAILURE(vrc))
1435	{
1436	if (vrc != VERR_NOT_SUPPORTED)
1437	return E_FAIL; /** @todo error reporting? */
1438	szOSServicePack[0] = '\0';
1439	}
1440	if (szOSServicePack[0] != '\0')
1441	{
1442	char *psz = strchr(szOSRelease, '\0');
1443	RTStrPrintf(psz, (size_t)(&szOSRelease[sizeof(szOSRelease)] - psz), "sp%s", szOSServicePack);
1444	}
1445
1446	aVersion = szOSRelease;
1447	return S_OK;
1448	}
1449
1450	/**
1451	* Returns the current host time in milliseconds since 1970-01-01 UTC.
1452	*
1453	* @returns COM status code
1454	* @param aUTCTime address of result variable
1455	*/
1456	HRESULT Host::getUTCTime(LONG64 *aUTCTime)
1457	{
1458	// no locking required
1459
1460	RTTIMESPEC now;
1461	*aUTCTime = RTTimeSpecGetMilli(RTTimeNow(&now));
1462
1463	return S_OK;
1464	}
1465
1466
1467	HRESULT Host::getAcceleration3DAvailable(BOOL *aSupported)
1468	{
1469	HRESULT hrc = S_OK;
1470	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1471	if (m->f3DAccelerationSupported != -1)
1472	*aSupported = m->f3DAccelerationSupported;
1473	else
1474	{
1475	alock.release();
1476
1477	#ifdef VBOX_WITH_3D_ACCELERATION
1478	bool fSupported = VBoxOglIs3DAccelerationSupported();
1479	#else
1480	bool fSupported = false; /* shouldn't get here, but just in case. */
1481	#endif
1482	AutoWriteLock alock2(this COMMA_LOCKVAL_SRC_POS);
1483
1484	m->f3DAccelerationSupported = fSupported;
1485	alock2.release();
1486	*aSupported = fSupported;
1487	}
1488
1489	#ifdef DEBUG_misha
1490	AssertMsgFailed(("should not be here any more!\n"));
1491	#endif
1492
1493	return hrc;
1494	}
1495
1496	HRESULT Host::createHostOnlyNetworkInterface(ComPtr<IHostNetworkInterface> &aHostInterface,
1497	ComPtr<IProgress> &aProgress)
1498
1499	{
1500	#ifdef VBOX_WITH_HOSTNETIF_API
1501	/* No need to lock anything. If there ever will - watch out, the function
1502	* called below grabs the VirtualBox lock. */
1503
1504	int vrc = NetIfCreateHostOnlyNetworkInterface(m->pParent, aHostInterface.asOutParam(), aProgress.asOutParam());
1505	if (RT_SUCCESS(vrc))
1506	{
1507	if (aHostInterface.isNull())
1508	return setError(E_FAIL,
1509	tr("Unable to create a host network interface"));
1510
1511	# if !defined(RT_OS_WINDOWS)
1512	Bstr tmpAddr, tmpMask, tmpName;
1513	HRESULT hrc;
1514	hrc = aHostInterface->COMGETTER(Name)(tmpName.asOutParam());
1515	ComAssertComRCRet(hrc, hrc);
1516	hrc = aHostInterface->COMGETTER(IPAddress)(tmpAddr.asOutParam());
1517	ComAssertComRCRet(hrc, hrc);
1518	hrc = aHostInterface->COMGETTER(NetworkMask)(tmpMask.asOutParam());
1519	ComAssertComRCRet(hrc, hrc);
1520
1521	/*
1522	* We need to write the default IP address and mask to extra data now,
1523	* so the interface gets re-created after vboxnetadp.ko reload.
1524	* Note that we avoid calling EnableStaticIpConfig since it would
1525	* change the address on host's interface as well and we want to
1526	* postpone the change until VM actually starts.
1527	*/
1528	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", tmpName.raw()).raw(),
1529	tmpAddr.raw());
1530	ComAssertComRCRet(hrc, hrc);
1531
1532	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", tmpName.raw()).raw(),
1533	tmpMask.raw());
1534	ComAssertComRCRet(hrc, hrc);
1535	# endif /* !defined(RT_OS_WINDOWS) */
1536	}
1537
1538	return S_OK;
1539	#else
1540	RT_NOREF(aHostInterface, aProgress);
1541	return E_NOTIMPL;
1542	#endif
1543	}
1544
1545
1546	#ifdef RT_OS_WINDOWS
1547	HRESULT Host::i_removePersistentConfig(const Bstr &bstrGuid)
1548	{
1549	HRESULT hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/{%ls}/Name", bstrGuid.raw()).raw(), NULL);
1550	if (SUCCEEDED(hrc)) hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/{%ls}/IPAddress", bstrGuid.raw()).raw(), NULL);
1551	if (SUCCEEDED(hrc)) hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/{%ls}/IPNetMask", bstrGuid.raw()).raw(), NULL);
1552	if (SUCCEEDED(hrc)) hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/{%ls}/IPV6Address", bstrGuid.raw()).raw(), NULL);
1553	if (SUCCEEDED(hrc)) hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/{%ls}/IPV6PrefixLen", bstrGuid.raw()).raw(), NULL);
1554	return hrc;
1555	}
1556	#endif /* RT_OS_WINDOWS */
1557
1558	HRESULT Host::removeHostOnlyNetworkInterface(const com::Guid &aId,
1559	ComPtr<IProgress> &aProgress)
1560
1561	{
1562	#ifdef VBOX_WITH_HOSTNETIF_API
1563	/* No need to lock anything, the code below does not touch the state
1564	* of the host object. If that ever changes then check for lock order
1565	* violations with the called functions. */
1566
1567	Bstr name;
1568	HRESULT hrc;
1569
1570	/* first check whether an interface with the given name already exists */
1571	{
1572	ComPtr<IHostNetworkInterface> iface;
1573	hrc = findHostNetworkInterfaceById(aId, iface);
1574	if (FAILED(hrc))
1575	return setError(VBOX_E_OBJECT_NOT_FOUND,
1576	tr("Host network interface with UUID {%RTuuid} does not exist"),
1577	Guid(aId).raw());
1578	hrc = iface->COMGETTER(Name)(name.asOutParam());
1579	ComAssertComRCRet(hrc, hrc);
1580	}
1581
1582	int vrc = NetIfRemoveHostOnlyNetworkInterface(m->pParent, aId, aProgress.asOutParam());
1583	if (RT_SUCCESS(vrc))
1584	{
1585	/* Drop configuration parameters for removed interface */
1586	#ifdef RT_OS_WINDOWS
1587	hrc = i_removePersistentConfig(Utf8StrFmt("%RTuuid", &aId));
1588	if (FAILED(hrc))
1589	LogRel(("i_removePersistentConfig(%RTuuid) failed with 0x%x\n", &aId, hrc));
1590	#else /* !RT_OS_WINDOWS */
1591	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", name.raw()).raw(), NULL);
1592	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", name.raw()).raw(), NULL);
1593	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", name.raw()).raw(), NULL);
1594	hrc = m->pParent->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", name.raw()).raw(), NULL);
1595	#endif /* !RT_OS_WINDOWS */
1596
1597	return S_OK;
1598	}
1599
1600	return vrc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
1601	#else
1602	RT_NOREF(aId, aProgress);
1603	return E_NOTIMPL;
1604	#endif
1605	}
1606
1607	HRESULT Host::createUSBDeviceFilter(const com::Utf8Str &aName,
1608	ComPtr<IHostUSBDeviceFilter> &aFilter)
1609	{
1610	#ifdef VBOX_WITH_USB
1611
1612	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1613
1614	ComObjPtr<HostUSBDeviceFilter> filter;
1615	filter.createObject();
1616	HRESULT hrc = filter->init(this, Bstr(aName).raw());
1617	ComAssertComRCRet(hrc, hrc);
1618	hrc = filter.queryInterfaceTo(aFilter.asOutParam());
1619	AssertComRCReturn(hrc, hrc);
1620	return S_OK;
1621	#else
1622	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1623	* extended error info to indicate that USB is simply not available
1624	* (w/o treating it as a failure), for example, as in OSE. */
1625	RT_NOREF(aName, aFilter);
1626	ReturnComNotImplemented();
1627	#endif
1628	}
1629
1630	HRESULT Host::insertUSBDeviceFilter(ULONG aPosition,
1631	const ComPtr<IHostUSBDeviceFilter> &aFilter)
1632	{
1633	#ifdef VBOX_WITH_USB
1634	/* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1635
1636	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1637
1638	MultiResult hrcMult = i_checkUSBProxyService();
1639	if (FAILED(hrcMult))
1640	return hrcMult;
1641
1642	ComObjPtr<HostUSBDeviceFilter> pFilter;
1643	for (USBDeviceFilterList::iterator it = m->llChildren.begin();
1644	it != m->llChildren.end();
1645	++it)
1646	{
1647	if (*it == aFilter)
1648	{
1649	pFilter = *it;
1650	break;
1651	}
1652	}
1653	if (pFilter.isNull())
1654	return setError(VBOX_E_INVALID_OBJECT_STATE,
1655	tr("The given USB device filter is not created within this VirtualBox instance"));
1656
1657	if (pFilter->mInList)
1658	return setError(E_INVALIDARG,
1659	tr("The given USB device filter is already in the list"));
1660
1661	/* iterate to the position... */
1662	USBDeviceFilterList::iterator itPos = m->llUSBDeviceFilters.begin();
1663	std::advance(itPos, aPosition);
1664	/* ...and insert */
1665	m->llUSBDeviceFilters.insert(itPos, pFilter);
1666	pFilter->mInList = true;
1667
1668	/* notify the proxy (only when the filter is active) */
1669	if ( m->pUSBProxyService->isActive()
1670	&& pFilter->i_getData().mData.fActive)
1671	{
1672	ComAssertRet(pFilter->i_getId() == NULL, E_FAIL);
1673	pFilter->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
1674	}
1675
1676	// save the global settings; for that we should hold only the VirtualBox lock
1677	alock.release();
1678	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1679	return hrcMult = m->pParent->i_saveSettings();
1680	#else
1681
1682	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1683	* extended error info to indicate that USB is simply not available
1684	* (w/o treating it as a failure), for example, as in OSE. */
1685	RT_NOREF(aPosition, aFilter);
1686	ReturnComNotImplemented();
1687	#endif
1688	}
1689
1690	HRESULT Host::removeUSBDeviceFilter(ULONG aPosition)
1691	{
1692	#ifdef VBOX_WITH_USB
1693
1694	/* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1695	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1696
1697	MultiResult hrcMult = i_checkUSBProxyService();
1698	if (FAILED(hrcMult))
1699	return hrcMult;
1700
1701	if (!m->llUSBDeviceFilters.size())
1702	return setError(E_INVALIDARG,
1703	tr("The USB device filter list is empty"));
1704
1705	if (aPosition >= m->llUSBDeviceFilters.size())
1706	return setError(E_INVALIDARG,
1707	tr("Invalid position: %lu (must be in range [0, %lu])"),
1708	aPosition, m->llUSBDeviceFilters.size() - 1);
1709
1710	ComObjPtr<HostUSBDeviceFilter> filter;
1711	{
1712	/* iterate to the position... */
1713	USBDeviceFilterList::iterator it = m->llUSBDeviceFilters.begin();
1714	std::advance(it, aPosition);
1715	/* ...get an element from there... */
1716	filter = *it;
1717	/* ...and remove */
1718	filter->mInList = false;
1719	m->llUSBDeviceFilters.erase(it);
1720	}
1721
1722	/* notify the proxy (only when the filter is active) */
1723	if (m->pUSBProxyService->isActive() && filter->i_getData().mData.fActive)
1724	{
1725	ComAssertRet(filter->i_getId() != NULL, E_FAIL);
1726	m->pUSBProxyService->removeFilter(filter->i_getId());
1727	filter->i_getId() = NULL;
1728	}
1729
1730	// save the global settings; for that we should hold only the VirtualBox lock
1731	alock.release();
1732	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
1733	return hrcMult = m->pParent->i_saveSettings();
1734	#else
1735	/* Note: The GUI depends on this method returning E_NOTIMPL with no
1736	* extended error info to indicate that USB is simply not available
1737	* (w/o treating it as a failure), for example, as in OSE. */
1738	RT_NOREF(aPosition);
1739	ReturnComNotImplemented();
1740	#endif
1741	}
1742
1743	HRESULT Host::findHostDVDDrive(const com::Utf8Str &aName,
1744	ComPtr<IMedium> &aDrive)
1745	{
1746	ComObjPtr<Medium> medium;
1747	HRESULT hrc = i_findHostDriveByNameOrId(DeviceType_DVD, aName, medium);
1748	if (SUCCEEDED(hrc))
1749	hrc = medium.queryInterfaceTo(aDrive.asOutParam());
1750	else
1751	hrc = setError(hrc, tr("The host DVD drive named '%s' could not be found"), aName.c_str());
1752	return hrc;
1753	}
1754
1755	HRESULT Host::findHostFloppyDrive(const com::Utf8Str &aName, ComPtr<IMedium> &aDrive)
1756	{
1757	aDrive = NULL;
1758
1759	ComObjPtr<Medium>medium;
1760
1761	HRESULT hrc = i_findHostDriveByNameOrId(DeviceType_Floppy, aName, medium);
1762	if (SUCCEEDED(hrc))
1763	return medium.queryInterfaceTo(aDrive.asOutParam());
1764	return setError(hrc, tr("The host floppy drive named '%s' could not be found"), aName.c_str());
1765	}
1766
1767	HRESULT Host::findHostNetworkInterfaceByName(const com::Utf8Str &aName,
1768	ComPtr<IHostNetworkInterface> &aNetworkInterface)
1769	{
1770	#ifndef VBOX_WITH_HOSTNETIF_API
1771	RT_NOREF(aName, aNetworkInterface);
1772	return E_NOTIMPL;
1773	#else
1774	if (!aName.length())
1775	return E_INVALIDARG;
1776
1777	HRESULT hrc = i_updateNetIfList();
1778	if (FAILED(hrc))
1779	{
1780	Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
1781	return hrc;
1782	}
1783	#if defined(RT_OS_WINDOWS)
1784	hrc = i_updatePersistentConfigForHostOnlyAdapters();
1785	if (FAILED(hrc))
1786	{
1787	LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
1788	return hrc;
1789	}
1790	#endif /* defined(RT_OS_WINDOWS) */
1791
1792	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1793
1794	ComObjPtr<HostNetworkInterface> found;
1795	for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1796	{
1797	Bstr n;
1798	(*it)->COMGETTER(Name)(n.asOutParam());
1799	if (n == aName)
1800	found = *it;
1801	}
1802
1803	if (!found)
1804	return setError(E_INVALIDARG,
1805	tr("The host network interface named '%s' could not be found"), aName.c_str());
1806
1807	return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1808	#endif
1809	}
1810
1811	HRESULT Host::findHostNetworkInterfaceById(const com::Guid &aId,
1812	ComPtr<IHostNetworkInterface> &aNetworkInterface)
1813	{
1814	#ifndef VBOX_WITH_HOSTNETIF_API
1815	RT_NOREF(aId, aNetworkInterface);
1816	return E_NOTIMPL;
1817	#else
1818	if (!aId.isValid())
1819	return E_INVALIDARG;
1820
1821	HRESULT hrc = i_updateNetIfList();
1822	if (FAILED(hrc))
1823	{
1824	Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
1825	return hrc;
1826	}
1827	#if defined(RT_OS_WINDOWS)
1828	hrc = i_updatePersistentConfigForHostOnlyAdapters();
1829	if (FAILED(hrc))
1830	{
1831	LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
1832	return hrc;
1833	}
1834	#endif /* defined(RT_OS_WINDOWS) */
1835
1836	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1837
1838	ComObjPtr<HostNetworkInterface> found;
1839	for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1840	{
1841	Bstr g;
1842	(*it)->COMGETTER(Id)(g.asOutParam());
1843	if (Guid(g) == aId)
1844	found = *it;
1845	}
1846
1847	if (!found)
1848	return setError(E_INVALIDARG,
1849	tr("The host network interface with the given GUID could not be found"));
1850	return found.queryInterfaceTo(aNetworkInterface.asOutParam());
1851
1852	#endif
1853	}
1854
1855	HRESULT Host::findHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
1856	std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces)
1857	{
1858	#ifdef VBOX_WITH_HOSTNETIF_API
1859	HRESULT hrc = i_updateNetIfList();
1860	if (FAILED(hrc))
1861	{
1862	Log(("Failed to update host network interface list with hrc=%Rhrc\n", hrc));
1863	return hrc;
1864	}
1865	#if defined(RT_OS_WINDOWS)
1866	hrc = i_updatePersistentConfigForHostOnlyAdapters();
1867	if (FAILED(hrc))
1868	{
1869	LogRel(("Failed to update persistent config for host-only adapters with hrc=%Rhrc\n", hrc));
1870	return hrc;
1871	}
1872	#endif /* defined(RT_OS_WINDOWS) */
1873
1874	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1875
1876	HostNetworkInterfaceList resultList;
1877	for (HostNetworkInterfaceList::iterator it = m->llNetIfs.begin(); it != m->llNetIfs.end(); ++it)
1878	{
1879	HostNetworkInterfaceType_T t;
1880	hrc = (*it)->COMGETTER(InterfaceType)(&t);
1881	if (FAILED(hrc))
1882	return hrc;
1883
1884	if (t == aType)
1885	resultList.push_back(*it);
1886	}
1887	aNetworkInterfaces.resize(resultList.size());
1888	size_t i = 0;
1889	for (HostNetworkInterfaceList::iterator it = resultList.begin(); it != resultList.end(); ++it, ++i)
1890	{
1891	(*it).queryInterfaceTo(aNetworkInterfaces[i].asOutParam());
1892	}
1893
1894	return S_OK;
1895	#else
1896	RT_NOREF(aType, aNetworkInterfaces);
1897	return E_NOTIMPL;
1898	#endif
1899	}
1900
1901	HRESULT Host::findUSBDeviceByAddress(const com::Utf8Str &aName,
1902	ComPtr<IHostUSBDevice> &aDevice)
1903	{
1904	#ifdef VBOX_WITH_USB
1905
1906	aDevice = NULL;
1907	SafeIfaceArray<IHostUSBDevice> devsvec;
1908	HRESULT hrc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1909	if (FAILED(hrc))
1910	return hrc;
1911
1912	for (size_t i = 0; i < devsvec.size(); ++i)
1913	{
1914	Bstr address;
1915	hrc = devsvec[i]->COMGETTER(Address)(address.asOutParam());
1916	if (FAILED(hrc))
1917	return hrc;
1918	if (address == aName)
1919	{
1920	return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1921	}
1922	}
1923
1924	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1925	tr("Could not find a USB device with address '%s'"),
1926	aName.c_str());
1927
1928	#else /* !VBOX_WITH_USB */
1929	RT_NOREF(aName, aDevice);
1930	return E_NOTIMPL;
1931	#endif /* !VBOX_WITH_USB */
1932	}
1933	HRESULT Host::findUSBDeviceById(const com::Guid &aId,
1934	ComPtr<IHostUSBDevice> &aDevice)
1935	{
1936	#ifdef VBOX_WITH_USB
1937	if (!aId.isValid())
1938	return E_INVALIDARG;
1939
1940	aDevice = NULL;
1941
1942	SafeIfaceArray<IHostUSBDevice> devsvec;
1943	HRESULT hrc = COMGETTER(USBDevices)(ComSafeArrayAsOutParam(devsvec));
1944	if (FAILED(hrc))
1945	return hrc;
1946
1947	for (size_t i = 0; i < devsvec.size(); ++i)
1948	{
1949	Bstr id;
1950	hrc = devsvec[i]->COMGETTER(Id)(id.asOutParam());
1951	if (FAILED(hrc))
1952	return hrc;
1953	if (Guid(id) == aId)
1954	{
1955	return (ComPtr<IHostUSBDevice>(devsvec[i]).queryInterfaceTo(aDevice.asOutParam()));
1956	}
1957	}
1958	return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
1959	tr("Could not find a USB device with uuid {%RTuuid}"),
1960	aId.raw());
1961
1962	#else /* !VBOX_WITH_USB */
1963	RT_NOREF(aId, aDevice);
1964	return E_NOTIMPL;
1965	#endif /* !VBOX_WITH_USB */
1966	}
1967
1968	HRESULT Host::generateMACAddress(com::Utf8Str &aAddress)
1969	{
1970	// no locking required
1971	i_generateMACAddress(aAddress);
1972	return S_OK;
1973	}
1974
1975	/**
1976	* Returns a list of host video capture devices (webcams, etc).
1977	*
1978	* @returns COM status code
1979	* @param aVideoInputDevices Array of interface pointers to be filled.
1980	*/
1981	HRESULT Host::getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices)
1982	{
1983	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1984	HostVideoInputDeviceList list;
1985
1986	HRESULT hrc = HostVideoInputDevice::queryHostDevices(m->pParent, &list);
1987	if (FAILED(hrc))
1988	return hrc;
1989
1990	aVideoInputDevices.resize(list.size());
1991	size_t i = 0;
1992	for (HostVideoInputDeviceList::const_iterator it = list.begin(); it != list.end(); ++it, ++i)
1993	(*it).queryInterfaceTo(aVideoInputDevices[i].asOutParam());
1994
1995	return S_OK;
1996	}
1997
1998	HRESULT Host::addUSBDeviceSource(const com::Utf8Str &aBackend, const com::Utf8Str &aId, const com::Utf8Str &aAddress,
1999	const std::vector<com::Utf8Str> &aPropertyNames, const std::vector<com::Utf8Str> &aPropertyValues)
2000	{
2001	#ifdef VBOX_WITH_USB
2002	/* The USB proxy service will do the locking. */
2003	return m->pUSBProxyService->addUSBDeviceSource(aBackend, aId, aAddress, aPropertyNames, aPropertyValues);
2004	#else
2005	RT_NOREF(aBackend, aId, aAddress, aPropertyNames, aPropertyValues);
2006	ReturnComNotImplemented();
2007	#endif
2008	}
2009
2010	HRESULT Host::removeUSBDeviceSource(const com::Utf8Str &aId)
2011	{
2012	#ifdef VBOX_WITH_USB
2013	/* The USB proxy service will do the locking. */
2014	return m->pUSBProxyService->removeUSBDeviceSource(aId);
2015	#else
2016	RT_NOREF(aId);
2017	ReturnComNotImplemented();
2018	#endif
2019	}
2020
2021	HRESULT Host::getUpdateHost(ComPtr<IUpdateAgent> &aUpdate)
2022	{
2023	#ifdef VBOX_WITH_UPDATE_AGENT
2024	HRESULT hrc = m->pUpdateHost.queryInterfaceTo(aUpdate.asOutParam());
2025	return hrc;
2026	#else
2027	RT_NOREF(aUpdate);
2028	ReturnComNotImplemented();
2029	#endif
2030	}
2031
2032	HRESULT Host::getUpdateExtPack(ComPtr<IUpdateAgent> &aUpdate)
2033	{
2034	RT_NOREF(aUpdate);
2035	ReturnComNotImplemented();
2036	}
2037
2038	HRESULT Host::getUpdateGuestAdditions(ComPtr<IUpdateAgent> &aUpdate)
2039	{
2040	RT_NOREF(aUpdate);
2041	ReturnComNotImplemented();
2042	}
2043
2044	HRESULT Host::getHostDrives(std::vector<ComPtr<IHostDrive> > &aHostDrives)
2045	{
2046	std::list<std::pair<com::Utf8Str, com::Utf8Str> > llDrivesPathsList;
2047	HRESULT hrc = i_getDrivesPathsList(llDrivesPathsList);
2048	if (SUCCEEDED(hrc))
2049	{
2050	for (std::list<std::pair<com::Utf8Str, com::Utf8Str> >::const_iterator it = llDrivesPathsList.begin();
2051	it != llDrivesPathsList.end();
2052	++it)
2053	{
2054	ComObjPtr<HostDrive> pHostDrive;
2055	hrc = pHostDrive.createObject();
2056	if (SUCCEEDED(hrc))
2057	hrc = pHostDrive->initFromPathAndModel(it->first, it->second);
2058	if (FAILED(hrc))
2059	break;
2060	aHostDrives.push_back(pHostDrive);
2061	}
2062	}
2063	return hrc;
2064	}
2065
2066
2067	// public methods only for internal purposes
2068	////////////////////////////////////////////////////////////////////////////////
2069
2070	HRESULT Host::i_loadSettings(const settings::Host &data)
2071	{
2072	HRESULT hrc = S_OK;
2073	#ifdef VBOX_WITH_USB
2074	AutoCaller autoCaller(this);
2075	if (FAILED(autoCaller.hrc()))
2076	return autoCaller.hrc();
2077
2078	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2079
2080	for (settings::USBDeviceFiltersList::const_iterator it = data.llUSBDeviceFilters.begin();
2081	it != data.llUSBDeviceFilters.end();
2082	++it)
2083	{
2084	const settings::USBDeviceFilter &f = *it;
2085	ComObjPtr<HostUSBDeviceFilter> pFilter;
2086	pFilter.createObject();
2087	hrc = pFilter->init(this, f);
2088	if (FAILED(hrc))
2089	break;
2090
2091	m->llUSBDeviceFilters.push_back(pFilter);
2092	pFilter->mInList = true;
2093
2094	/* notify the proxy (only when the filter is active) */
2095	if (pFilter->i_getData().mData.fActive)
2096	{
2097	HostUSBDeviceFilter flt = pFilter; / resolve ambiguity */
2098	flt->i_getId() = m->pUSBProxyService->insertFilter(&pFilter->i_getData().mUSBFilter);
2099	}
2100	}
2101
2102	hrc = m->pUSBProxyService->i_loadSettings(data.llUSBDeviceSources);
2103	#else
2104	RT_NOREF(data);
2105	#endif /* VBOX_WITH_USB */
2106
2107	#ifdef VBOX_WITH_UPDATE_AGENT
2108	hrc = m->pUpdateHost->i_loadSettings(data.updateHost);
2109	ComAssertComRCRet(hrc, hrc);
2110	/** @todo Add handling for ExtPack and Guest Additions updates here later. See @bugref{7983}. */
2111	#endif
2112
2113	return hrc;
2114	}
2115
2116	HRESULT Host::i_saveSettings(settings::Host &data)
2117	{
2118	AutoCaller autoCaller(this);
2119	if (FAILED(autoCaller.hrc()))
2120	return autoCaller.hrc();
2121
2122	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2123
2124	HRESULT hrc;
2125
2126	#ifdef VBOX_WITH_USB
2127	data.llUSBDeviceFilters.clear();
2128	data.llUSBDeviceSources.clear();
2129
2130	for (USBDeviceFilterList::const_iterator it = m->llUSBDeviceFilters.begin();
2131	it != m->llUSBDeviceFilters.end();
2132	++it)
2133	{
2134	ComObjPtr<HostUSBDeviceFilter> pFilter = *it;
2135	settings::USBDeviceFilter f;
2136	pFilter->i_saveSettings(f);
2137	data.llUSBDeviceFilters.push_back(f);
2138	}
2139
2140	hrc = m->pUSBProxyService->i_saveSettings(data.llUSBDeviceSources);
2141	ComAssertComRCRet(hrc, hrc);
2142	#else
2143	RT_NOREF(data);
2144	#endif /* VBOX_WITH_USB */
2145
2146	#ifdef VBOX_WITH_UPDATE_AGENT
2147	hrc = m->pUpdateHost->i_saveSettings(data.updateHost);
2148	ComAssertComRCRet(hrc, hrc);
2149	/** @todo Add handling for ExtPack and Guest Additions updates here later. See @bugref{7983}. */
2150	#endif
2151
2152	return S_OK;
2153	}
2154
2155	/**
2156	* Sets the given pointer to point to the static list of DVD or floppy
2157	* drives in the Host instance data, depending on the @a mediumType
2158	* parameter.
2159	*
2160	* This builds the list on the first call; it adds or removes host drives
2161	* that may have changed if fRefresh == true.
2162	*
2163	* The caller must hold the medium tree write lock before calling this.
2164	* To protect the list to which the caller's pointer points, the caller
2165	* must also hold that lock.
2166	*
2167	* @param mediumType Must be DeviceType_Floppy or DeviceType_DVD.
2168	* @param fRefresh Whether to refresh the host drives list even if this is not the first call.
2169	* @param pll Caller's pointer which gets set to the static list of host drives.
2170	* @param treeLock Reference to media tree lock, need to drop it temporarily.
2171	* @returns COM status code
2172	*/
2173	HRESULT Host::i_getDrives(DeviceType_T mediumType,
2174	bool fRefresh,
2175	MediaList *&pll,
2176	AutoWriteLock &treeLock)
2177	{
2178	HRESULT hrc = S_OK;
2179	Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2180
2181	MediaList llNew;
2182	MediaList *pllCached;
2183	bool *pfListBuilt = NULL;
2184
2185	switch (mediumType)
2186	{
2187	case DeviceType_DVD:
2188	if (!m->fDVDDrivesListBuilt \|\| fRefresh)
2189	{
2190	hrc = i_buildDVDDrivesList(llNew);
2191	if (FAILED(hrc))
2192	return hrc;
2193	pfListBuilt = &m->fDVDDrivesListBuilt;
2194	}
2195	pllCached = &m->llDVDDrives;
2196	break;
2197
2198	case DeviceType_Floppy:
2199	if (!m->fFloppyDrivesListBuilt \|\| fRefresh)
2200	{
2201	hrc = i_buildFloppyDrivesList(llNew);
2202	if (FAILED(hrc))
2203	return hrc;
2204	pfListBuilt = &m->fFloppyDrivesListBuilt;
2205	}
2206	pllCached = &m->llFloppyDrives;
2207	break;
2208
2209	default:
2210	return E_INVALIDARG;
2211	}
2212
2213	if (pfListBuilt)
2214	{
2215	// a list was built in llNew above:
2216	if (!*pfListBuilt)
2217	{
2218	// this was the first call (instance bool is still false): then just copy the whole list and return
2219	*pllCached = llNew;
2220	// and mark the instance data as "built"
2221	*pfListBuilt = true;
2222	}
2223	else
2224	{
2225	// list was built, and this was a subsequent call: then compare the old and the new lists
2226
2227	// remove drives from the cached list which are no longer present
2228	for (MediaList::iterator itCached = pllCached->begin();
2229	itCached != pllCached->end();
2230	/nothing /)
2231	{
2232	Medium pCached = itCached;
2233	const Utf8Str strLocationCached = pCached->i_getLocationFull();
2234	bool fFound = false;
2235	for (MediaList::iterator itNew = llNew.begin();
2236	itNew != llNew.end();
2237	++itNew)
2238	{
2239	Medium pNew = itNew;
2240	const Utf8Str strLocationNew = pNew->i_getLocationFull();
2241	if (strLocationNew == strLocationCached)
2242	{
2243	fFound = true;
2244	break;
2245	}
2246	}
2247	if (!fFound)
2248	{
2249	pCached->uninit();
2250	itCached = pllCached->erase(itCached);
2251	}
2252	else
2253	++itCached;
2254	}
2255
2256	// add drives to the cached list that are not on there yet
2257	for (MediaList::iterator itNew = llNew.begin();
2258	itNew != llNew.end();
2259	++itNew)
2260	{
2261	Medium pNew = itNew;
2262	const Utf8Str strLocationNew = pNew->i_getLocationFull();
2263	bool fFound = false;
2264	for (MediaList::iterator itCached = pllCached->begin();
2265	itCached != pllCached->end();
2266	++itCached)
2267	{
2268	Medium pCached = itCached;
2269	const Utf8Str strLocationCached = pCached->i_getLocationFull();
2270	if (strLocationNew == strLocationCached)
2271	{
2272	fFound = true;
2273	break;
2274	}
2275	}
2276
2277	if (!fFound)
2278	pllCached->push_back(pNew);
2279	}
2280	}
2281	}
2282
2283	// return cached list to caller
2284	pll = pllCached;
2285
2286	// Make sure the media tree lock is released before llNew is cleared,
2287	// as this usually triggers calls to uninit().
2288	treeLock.release();
2289
2290	llNew.clear();
2291
2292	treeLock.acquire();
2293
2294	return hrc;
2295	}
2296
2297	/**
2298	* Goes through the list of host drives that would be returned by getDrives()
2299	* and looks for a host drive with the given UUID. If found, it sets pMedium
2300	* to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
2301	*
2302	* @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
2303	* @param uuid Medium UUID of host drive to look for.
2304	* @param fRefresh Whether to refresh the host drives list (see getDrives())
2305	* @param pMedium Medium object, if found...
2306	* @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
2307	*/
2308	HRESULT Host::i_findHostDriveById(DeviceType_T mediumType,
2309	const Guid &uuid,
2310	bool fRefresh,
2311	ComObjPtr<Medium> &pMedium)
2312	{
2313	MediaList *pllMedia;
2314
2315	AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2316	HRESULT hrc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
2317	if (SUCCEEDED(hrc))
2318	{
2319	for (MediaList::iterator it = pllMedia->begin();
2320	it != pllMedia->end();
2321	++it)
2322	{
2323	Medium pThis = it;
2324	AutoCaller mediumCaller(pThis);
2325	AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
2326	if (pThis->i_getId() == uuid)
2327	{
2328	pMedium = pThis;
2329	return S_OK;
2330	}
2331	}
2332	}
2333
2334	return VBOX_E_OBJECT_NOT_FOUND;
2335	}
2336
2337	/**
2338	* Goes through the list of host drives that would be returned by getDrives()
2339	* and looks for a host drive with the given name. If found, it sets pMedium
2340	* to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
2341	*
2342	* @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
2343	* @param strLocationFull Name (path) of host drive to look for.
2344	* @param fRefresh Whether to refresh the host drives list (see getDrives())
2345	* @param pMedium Medium object, if found
2346	* @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
2347	*/
2348	HRESULT Host::i_findHostDriveByName(DeviceType_T mediumType,
2349	const Utf8Str &strLocationFull,
2350	bool fRefresh,
2351	ComObjPtr<Medium> &pMedium)
2352	{
2353	MediaList *pllMedia;
2354
2355	AutoWriteLock treeLock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2356	HRESULT hrc = i_getDrives(mediumType, fRefresh, pllMedia, treeLock);
2357	if (SUCCEEDED(hrc))
2358	{
2359	for (MediaList::iterator it = pllMedia->begin();
2360	it != pllMedia->end();
2361	++it)
2362	{
2363	Medium pThis = it;
2364	AutoCaller mediumCaller(pThis);
2365	AutoReadLock mediumLock(pThis COMMA_LOCKVAL_SRC_POS);
2366	if (pThis->i_getLocationFull() == strLocationFull)
2367	{
2368	pMedium = pThis;
2369	return S_OK;
2370	}
2371	}
2372	}
2373
2374	return VBOX_E_OBJECT_NOT_FOUND;
2375	}
2376
2377	/**
2378	* Goes through the list of host drives that would be returned by getDrives()
2379	* and looks for a host drive with the given name, location or ID. If found,
2380	* it sets pMedium to that drive; otherwise returns VBOX_E_OBJECT_NOT_FOUND.
2381	*
2382	* @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
2383	* @param strNameOrId Name or full location or UUID of host drive to look for.
2384	* @param pMedium Medium object, if found...
2385	* @return VBOX_E_OBJECT_NOT_FOUND if not found, or S_OK if found, or errors from getDrives().
2386	*/
2387	HRESULT Host::i_findHostDriveByNameOrId(DeviceType_T mediumType,
2388	const Utf8Str &strNameOrId,
2389	ComObjPtr<Medium> &pMedium)
2390	{
2391	AutoWriteLock wlock(m->pParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
2392
2393	Guid uuid(strNameOrId);
2394	if (uuid.isValid() && !uuid.isZero())
2395	return i_findHostDriveById(mediumType, uuid, true /* fRefresh */, pMedium);
2396
2397	// string is not a syntactically valid UUID: try a name then
2398	return i_findHostDriveByName(mediumType, strNameOrId, true /* fRefresh */, pMedium);
2399	}
2400
2401	/**
2402	* Called from getDrives() to build the DVD drives list.
2403	* @param list Media list
2404	* @return
2405	*/
2406	HRESULT Host::i_buildDVDDrivesList(MediaList &list)
2407	{
2408	HRESULT hrc = S_OK;
2409
2410	Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2411
2412	try
2413	{
2414	#if defined(RT_OS_WINDOWS)
2415	int sz = GetLogicalDriveStrings(0, NULL);
2416	TCHAR *hostDrives = new TCHAR[sz+1];
2417	GetLogicalDriveStrings(sz, hostDrives);
2418	wchar_t driveName[3] = { '?', ':', '\0' };
2419	TCHAR *p = hostDrives;
2420	do
2421	{
2422	if (GetDriveType(p) == DRIVE_CDROM)
2423	{
2424	driveName[0] = *p;
2425	ComObjPtr<Medium> hostDVDDriveObj;
2426	hostDVDDriveObj.createObject();
2427	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(driveName));
2428	list.push_back(hostDVDDriveObj);
2429	}
2430	p += _tcslen(p) + 1;
2431	}
2432	while (*p);
2433	delete[] hostDrives;
2434
2435	#elif defined(RT_OS_SOLARIS)
2436	# ifdef VBOX_USE_LIBHAL
2437	if (!i_getDVDInfoFromHal(list))
2438	# endif
2439	{
2440	i_getDVDInfoFromDevTree(list);
2441	}
2442
2443	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
2444	if (RT_SUCCESS(m->hostDrives.updateDVDs()))
2445	for (DriveInfoList::const_iterator it = m->hostDrives.DVDBegin();
2446	SUCCEEDED(hrc) && it != m->hostDrives.DVDEnd(); ++it)
2447	{
2448	ComObjPtr<Medium> hostDVDDriveObj;
2449	Utf8Str location(it->mDevice);
2450	Utf8Str description(it->mDescription);
2451	if (SUCCEEDED(hrc))
2452	hrc = hostDVDDriveObj.createObject();
2453	if (SUCCEEDED(hrc))
2454	hrc = hostDVDDriveObj->init(m->pParent, DeviceType_DVD, location, description);
2455	if (SUCCEEDED(hrc))
2456	list.push_back(hostDVDDriveObj);
2457	}
2458	#elif defined(RT_OS_DARWIN)
2459	PDARWINDVD cur = DarwinGetDVDDrives();
2460	while (cur)
2461	{
2462	ComObjPtr<Medium> hostDVDDriveObj;
2463	hostDVDDriveObj.createObject();
2464	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(cur->szName));
2465	list.push_back(hostDVDDriveObj);
2466
2467	/* next */
2468	void *freeMe = cur;
2469	cur = cur->pNext;
2470	RTMemFree(freeMe);
2471	}
2472	#else
2473	/* PORTME */
2474	#endif
2475	}
2476	catch (std::bad_alloc &)
2477	{
2478	hrc = E_OUTOFMEMORY;
2479	}
2480	return hrc;
2481	}
2482
2483	/**
2484	* Called from getDrives() to build the floppy drives list.
2485	* @param list
2486	* @return
2487	*/
2488	HRESULT Host::i_buildFloppyDrivesList(MediaList &list)
2489	{
2490	HRESULT hrc = S_OK;
2491
2492	Assert(m->pParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
2493
2494	try
2495	{
2496	#ifdef RT_OS_WINDOWS
2497	int sz = GetLogicalDriveStrings(0, NULL);
2498	TCHAR *hostDrives = new TCHAR[sz+1];
2499	GetLogicalDriveStrings(sz, hostDrives);
2500	wchar_t driveName[3] = { '?', ':', '\0' };
2501	TCHAR *p = hostDrives;
2502	do
2503	{
2504	if (GetDriveType(p) == DRIVE_REMOVABLE)
2505	{
2506	driveName[0] = *p;
2507	ComObjPtr<Medium> hostFloppyDriveObj;
2508	hostFloppyDriveObj.createObject();
2509	hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, Bstr(driveName));
2510	list.push_back(hostFloppyDriveObj);
2511	}
2512	p += _tcslen(p) + 1;
2513	}
2514	while (*p);
2515	delete[] hostDrives;
2516	#elif defined(RT_OS_LINUX)
2517	if (RT_SUCCESS(m->hostDrives.updateFloppies()))
2518	for (DriveInfoList::const_iterator it = m->hostDrives.FloppyBegin();
2519	SUCCEEDED(hrc) && it != m->hostDrives.FloppyEnd(); ++it)
2520	{
2521	ComObjPtr<Medium> hostFloppyDriveObj;
2522	Utf8Str location(it->mDevice);
2523	Utf8Str description(it->mDescription);
2524	if (SUCCEEDED(hrc))
2525	hrc = hostFloppyDriveObj.createObject();
2526	if (SUCCEEDED(hrc))
2527	hrc = hostFloppyDriveObj->init(m->pParent, DeviceType_Floppy, location, description);
2528	if (SUCCEEDED(hrc))
2529	list.push_back(hostFloppyDriveObj);
2530	}
2531	#else
2532	RT_NOREF(list);
2533	/* PORTME */
2534	#endif
2535	}
2536	catch(std::bad_alloc &)
2537	{
2538	hrc = E_OUTOFMEMORY;
2539	}
2540
2541	return hrc;
2542	}
2543
2544	#ifdef VBOX_WITH_USB
2545	USBProxyService* Host::i_usbProxyService()
2546	{
2547	return m->pUSBProxyService;
2548	}
2549
2550	HRESULT Host::i_addChild(HostUSBDeviceFilter *pChild)
2551	{
2552	AutoCaller autoCaller(this);
2553	if (FAILED(autoCaller.hrc()))
2554	return autoCaller.hrc();
2555
2556	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2557
2558	m->llChildren.push_back(pChild);
2559
2560	return S_OK;
2561	}
2562
2563	HRESULT Host::i_removeChild(HostUSBDeviceFilter *pChild)
2564	{
2565	AutoCaller autoCaller(this);
2566	if (FAILED(autoCaller.hrc()))
2567	return autoCaller.hrc();
2568
2569	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2570
2571	for (USBDeviceFilterList::iterator it = m->llChildren.begin();
2572	it != m->llChildren.end();
2573	++it)
2574	{
2575	if (*it == pChild)
2576	{
2577	m->llChildren.erase(it);
2578	break;
2579	}
2580	}
2581
2582	return S_OK;
2583	}
2584
2585	VirtualBox* Host::i_parent()
2586	{
2587	return m->pParent;
2588	}
2589
2590	/**
2591	* Called by setter methods of all USB device filters.
2592	*/
2593	HRESULT Host::i_onUSBDeviceFilterChange(HostUSBDeviceFilter *aFilter,
2594	BOOL aActiveChanged /* = FALSE */)
2595	{
2596	AutoCaller autoCaller(this);
2597	if (FAILED(autoCaller.hrc()))
2598	return autoCaller.hrc();
2599
2600	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2601
2602	if (aFilter->mInList)
2603	{
2604	if (aActiveChanged)
2605	{
2606	// insert/remove the filter from the proxy
2607	if (aFilter->i_getData().mData.fActive)
2608	{
2609	ComAssertRet(aFilter->i_getId() == NULL, E_FAIL);
2610	aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2611	}
2612	else
2613	{
2614	ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2615	m->pUSBProxyService->removeFilter(aFilter->i_getId());
2616	aFilter->i_getId() = NULL;
2617	}
2618	}
2619	else
2620	{
2621	if (aFilter->i_getData().mData.fActive)
2622	{
2623	// update the filter in the proxy
2624	ComAssertRet(aFilter->i_getId() != NULL, E_FAIL);
2625	m->pUSBProxyService->removeFilter(aFilter->i_getId());
2626	aFilter->i_getId() = m->pUSBProxyService->insertFilter(&aFilter->i_getData().mUSBFilter);
2627	}
2628	}
2629
2630	// save the global settings... yeah, on every single filter property change
2631	// for that we should hold only the VirtualBox lock
2632	alock.release();
2633	AutoWriteLock vboxLock(m->pParent COMMA_LOCKVAL_SRC_POS);
2634	return m->pParent->i_saveSettings();
2635	}
2636
2637	return S_OK;
2638	}
2639
2640
2641	/**
2642	* Interface for obtaining a copy of the USBDeviceFilterList,
2643	* used by the USBProxyService.
2644	*
2645	* @param aGlobalFilters Where to put the global filter list copy.
2646	* @param aMachines Where to put the machine vector.
2647	*/
2648	void Host::i_getUSBFilters(Host::USBDeviceFilterList *aGlobalFilters)
2649	{
2650	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
2651
2652	*aGlobalFilters = m->llUSBDeviceFilters;
2653	}
2654
2655	#endif /* VBOX_WITH_USB */
2656
2657	// private methods
2658	////////////////////////////////////////////////////////////////////////////////
2659
2660	#if defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
2661
2662	/**
2663	* Helper function to get the slice number from a device path
2664	*
2665	* @param pszDevLinkPath Pointer to a device path (/dev/(r)dsk/c7d1t0d0s3 etc.)
2666	* @returns Pointer to the slice portion of the given path.
2667	*/
2668	static char solarisGetSliceFromPath(const char pszDevLinkPath)
2669	{
2670	char pszSlice = (char )strrchr(pszDevLinkPath, 's');
2671	char pszDisk = (char )strrchr(pszDevLinkPath, 'd');
2672	char *pszFound;
2673	if (pszSlice && (uintptr_t)pszSlice > (uintptr_t)pszDisk)
2674	pszFound = pszSlice;
2675	else
2676	pszFound = pszDisk;
2677
2678	if (pszFound && RT_C_IS_DIGIT(pszFound[1]))
2679	return pszFound;
2680
2681	return NULL;
2682	}
2683
2684	/**
2685	* Walk device links and returns an allocated path for the first one in the snapshot.
2686	*
2687	* @param DevLink Handle to the device link being walked.
2688	* @param pvArg Opaque pointer that we use to point to the return
2689	* variable (char *). Caller must call RTStrFree on it.
2690	* @returns DI_WALK_TERMINATE to stop the walk.
2691	*/
2692	static int solarisWalkDevLink(di_devlink_t DevLink, void *pvArg)
2693	{
2694	char ppszPath = (char )pvArg;
2695	*ppszPath = RTStrDup(di_devlink_path(DevLink));
2696	return DI_WALK_TERMINATE;
2697	}
2698
2699	/**
2700	* Walk all devices in the system and enumerate CD/DVD drives.
2701	* @param Node Handle to the current node.
2702	* @param pvArg Opaque data (holds list pointer).
2703	* @returns Solaris specific code whether to continue walking or not.
2704	*/
2705	static int solarisWalkDeviceNodeForDVD(di_node_t Node, void *pvArg)
2706	{
2707	PSOLARISDVD ppDrives = (PSOLARISDVD )pvArg;
2708
2709	/*
2710	* Check for "removable-media" or "hotpluggable" instead of "SCSI" so that we also include USB CD-ROMs.
2711	* As unfortunately the Solaris drivers only export these common properties.
2712	*/
2713	int *pInt = NULL;
2714	if ( di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "removable-media", &pInt) >= 0
2715	\|\| di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "hotpluggable", &pInt) >= 0)
2716	{
2717	if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "inquiry-device-type", &pInt) > 0
2718	&& ( pInt == DTYPE_RODIRECT / CDROM */
2719	\|\| pInt == DTYPE_OPTICAL)) / Optical Drive */
2720	{
2721	char *pszProduct = NULL;
2722	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-product-id", &pszProduct) > 0)
2723	{
2724	char *pszVendor = NULL;
2725	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-vendor-id", &pszVendor) > 0)
2726	{
2727	/*
2728	* Found a DVD drive, we need to scan the minor nodes to find the correct
2729	* slice that represents the whole drive. "s2" is always the whole drive for CD/DVDs.
2730	*/
2731	int Major = di_driver_major(Node);
2732	di_minor_t Minor = DI_MINOR_NIL;
2733	di_devlink_handle_t DevLink = di_devlink_init(NULL /* name /, 0 / flags */);
2734	if (DevLink)
2735	{
2736	while ((Minor = di_minor_next(Node, Minor)) != DI_MINOR_NIL)
2737	{
2738	dev_t Dev = di_minor_devt(Minor);
2739	if ( Major != (int)major(Dev)
2740	\|\| di_minor_spectype(Minor) == S_IFBLK
2741	\|\| di_minor_type(Minor) != DDM_MINOR)
2742	{
2743	continue;
2744	}
2745
2746	char *pszMinorPath = di_devfs_minor_path(Minor);
2747	if (!pszMinorPath)
2748	continue;
2749
2750	char *pszDevLinkPath = NULL;
2751	di_devlink_walk(DevLink, NULL, pszMinorPath, DI_PRIMARY_LINK, &pszDevLinkPath, solarisWalkDevLink);
2752	di_devfs_path_free(pszMinorPath);
2753
2754	if (pszDevLinkPath)
2755	{
2756	char *pszSlice = solarisGetSliceFromPath(pszDevLinkPath);
2757	if ( pszSlice && !strcmp(pszSlice, "s2")
2758	&& !strncmp(pszDevLinkPath, RT_STR_TUPLE("/dev/rdsk"))) /* We want only raw disks */
2759	{
2760	/*
2761	* We've got a fully qualified DVD drive. Add it to the list.
2762	*/
2763	PSOLARISDVD pDrive = (PSOLARISDVD)RTMemAllocZ(sizeof(SOLARISDVD));
2764	if (RT_LIKELY(pDrive))
2765	{
2766	RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription),
2767	"%s %s", pszVendor, pszProduct);
2768	RTStrPurgeEncoding(pDrive->szDescription);
2769	RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevLinkPath);
2770	if (*ppDrives)
2771	pDrive->pNext = *ppDrives;
2772	*ppDrives = pDrive;
2773
2774	/* We're not interested in any of the other slices, stop minor nodes traversal. */
2775	RTStrFree(pszDevLinkPath);
2776	break;
2777	}
2778	}
2779	RTStrFree(pszDevLinkPath);
2780	}
2781	}
2782	di_devlink_fini(&DevLink);
2783	}
2784	}
2785	}
2786	}
2787	}
2788	return DI_WALK_CONTINUE;
2789	}
2790
2791	/**
2792	* Solaris specific function to enumerate CD/DVD drives via the device tree.
2793	* Works on Solaris 10 as well as OpenSolaris without depending on libhal.
2794	*/
2795	void Host::i_getDVDInfoFromDevTree(std::list<ComObjPtr<Medium> > &list)
2796	{
2797	PSOLARISDVD pDrives = NULL;
2798	di_node_t RootNode = di_init("/", DINFOCPYALL);
2799	if (RootNode != DI_NODE_NIL)
2800	di_walk_node(RootNode, DI_WALK_CLDFIRST, &pDrives, solarisWalkDeviceNodeForDVD);
2801
2802	di_fini(RootNode);
2803
2804	while (pDrives)
2805	{
2806	ComObjPtr<Medium> hostDVDDriveObj;
2807	hostDVDDriveObj.createObject();
2808	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(pDrives->szRawDiskPath), Bstr(pDrives->szDescription));
2809	list.push_back(hostDVDDriveObj);
2810
2811	void *pvDrive = pDrives;
2812	pDrives = pDrives->pNext;
2813	RTMemFree(pvDrive);
2814	}
2815	}
2816
2817
2818	/**
2819	* Walk all devices in the system and enumerate fixed drives.
2820	* @param Node Handle to the current node.
2821	* @param pvArg Opaque data (holds list pointer).
2822	* @returns Solaris specific code whether to continue walking or not.
2823	*/
2824	static int solarisWalkDeviceNodeForFixedDrive(di_node_t Node, void *pvArg) RT_NOEXCEPT
2825	{
2826	PSOLARISFIXEDDISK ppDrives = (PSOLARISFIXEDDISK )pvArg;
2827
2828	int *pInt = NULL;
2829	if ( di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "inquiry-device-type", &pInt) > 0
2830	&& pInt == DTYPE_DIRECT) / Fixed drive */
2831	{
2832	char *pszProduct = NULL;
2833	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-product-id", &pszProduct) > 0)
2834	{
2835	char *pszVendor = NULL;
2836	if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "inquiry-vendor-id", &pszVendor) > 0)
2837	{
2838	/*
2839	* Found a fixed drive, we need to scan the minor nodes to find the correct
2840	* slice that represents the whole drive.
2841	*/
2842	int Major = di_driver_major(Node);
2843	di_minor_t Minor = DI_MINOR_NIL;
2844	di_devlink_handle_t DevLink = di_devlink_init(NULL /* name /, 0 / flags */);
2845	if (DevLink)
2846	{
2847	/*
2848	* The device name we have to select depends on drive type. For fixed drives, the
2849	* name without slice or partition should be selected, for USB flash drive the
2850	* partition 0 should be selected and slice 0 for other cases.
2851	*/
2852	char *pszDisk = NULL;
2853	char *pszPartition0 = NULL;
2854	char *pszSlice0 = NULL;
2855	while ((Minor = di_minor_next(Node, Minor)) != DI_MINOR_NIL)
2856	{
2857	dev_t Dev = di_minor_devt(Minor);
2858	if ( Major != (int)major(Dev)
2859	\|\| di_minor_spectype(Minor) == S_IFBLK
2860	\|\| di_minor_type(Minor) != DDM_MINOR)
2861	continue;
2862
2863	char *pszMinorPath = di_devfs_minor_path(Minor);
2864	if (!pszMinorPath)
2865	continue;
2866
2867	char *pszDevLinkPath = NULL;
2868	di_devlink_walk(DevLink, NULL, pszMinorPath, DI_PRIMARY_LINK, &pszDevLinkPath, solarisWalkDevLink);
2869	di_devfs_path_free(pszMinorPath);
2870
2871	if (pszDevLinkPath)
2872	{
2873	char const *pszCurSlice = strrchr(pszDevLinkPath, 's');
2874	char const *pszCurDisk = strrchr(pszDevLinkPath, 'd');
2875	char const *pszCurPart = strrchr(pszDevLinkPath, 'p');
2876	char **ppszDst = NULL;
2877	if (pszCurSlice && (uintptr_t)pszCurSlice > (uintptr_t)pszCurDisk && !strcmp(pszCurSlice, "s0"))
2878	ppszDst = &pszSlice0;
2879	else if (pszCurPart && (uintptr_t)pszCurPart > (uintptr_t)pszCurDisk && !strcmp(pszCurPart, "p0"))
2880	ppszDst = &pszPartition0;
2881	else if ( (!pszCurSlice \|\| (uintptr_t)pszCurSlice < (uintptr_t)pszCurDisk)
2882	&& (!pszCurPart \|\| (uintptr_t)pszCurPart < (uintptr_t)pszCurDisk)
2883	&& *pszDevLinkPath != '\0')
2884	ppszDst = &pszDisk;
2885	else
2886	RTStrFree(pszDevLinkPath);
2887	if (ppszDst)
2888	{
2889	if (*ppszDst != NULL)
2890	RTStrFree(*ppszDst);
2891	*ppszDst = pszDevLinkPath;
2892	}
2893	}
2894	}
2895	di_devlink_fini(&DevLink);
2896	if (pszDisk \|\| pszPartition0 \|\| pszSlice0)
2897	{
2898	PSOLARISFIXEDDISK pDrive = (PSOLARISFIXEDDISK)RTMemAllocZ(sizeof(*pDrive));
2899	if (RT_LIKELY(pDrive))
2900	{
2901	RTStrPrintf(pDrive->szDescription, sizeof(pDrive->szDescription), "%s %s", pszVendor, pszProduct);
2902	RTStrPurgeEncoding(pDrive->szDescription);
2903
2904	const char *pszDevPath = pszDisk ? pszDisk : pszPartition0 ? pszPartition0 : pszSlice0;
2905	int vrc = RTStrCopy(pDrive->szRawDiskPath, sizeof(pDrive->szRawDiskPath), pszDevPath);
2906	AssertRC(vrc);
2907
2908	if (*ppDrives)
2909	pDrive->pNext = *ppDrives;
2910	*ppDrives = pDrive;
2911	}
2912	RTStrFree(pszDisk);
2913	RTStrFree(pszPartition0);
2914	RTStrFree(pszSlice0);
2915	}
2916	}
2917	}
2918	}
2919	}
2920	return DI_WALK_CONTINUE;
2921	}
2922
2923
2924	/**
2925	* Solaris specific function to enumerate fixed drives via the device tree.
2926	* Works on Solaris 10 as well as OpenSolaris without depending on libhal.
2927	*
2928	* @returns COM status, either S_OK or E_OUTOFMEMORY.
2929	* @param list Reference to list where the the path/model pairs are to
2930	* be returned.
2931	*/
2932	HRESULT Host::i_getFixedDrivesFromDevTree(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &list) RT_NOEXCEPT
2933	{
2934	PSOLARISFIXEDDISK pDrives = NULL;
2935	di_node_t RootNode = di_init("/", DINFOCPYALL);
2936	if (RootNode != DI_NODE_NIL)
2937	di_walk_node(RootNode, DI_WALK_CLDFIRST, &pDrives, solarisWalkDeviceNodeForFixedDrive);
2938	di_fini(RootNode);
2939
2940	HRESULT hrc = S_OK;
2941	try
2942	{
2943	for (PSOLARISFIXEDDISK pCurDrv = pDrives; pCurDrv; pCurDrv = pCurDrv->pNext)
2944	list.push_back(std::pair<com::Utf8Str, com::Utf8Str>(pCurDrv->szRawDiskPath, pCurDrv->szDescription));
2945	}
2946	catch (std::bad_alloc &)
2947	{
2948	LogRelFunc(("Out of memory!\n"));
2949	list.clear();
2950	hrc = E_OUTOFMEMORY;
2951	}
2952
2953	while (pDrives)
2954	{
2955	PSOLARISFIXEDDISK pFreeMe = pDrives;
2956	pDrives = pDrives->pNext;
2957	ASMCompilerBarrier();
2958	RTMemFree(pFreeMe);
2959	}
2960
2961	return hrc;
2962	}
2963
2964
2965	/* Solaris hosts, loading libhal at runtime */
2966
2967	/**
2968	* Helper function to query the hal subsystem for information about DVD drives attached to the
2969	* system.
2970	*
2971	* @returns true if information was successfully obtained, false otherwise
2972	* @param list Reference to list where the DVDs drives are to be returned.
2973	*/
2974	bool Host::i_getDVDInfoFromHal(std::list<ComObjPtr<Medium> > &list)
2975	{
2976	bool halSuccess = false;
2977	DBusError dbusError;
2978	if (!gLibHalCheckPresence())
2979	return false;
2980	gDBusErrorInit(&dbusError);
2981	DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2982	if (dbusConnection != 0)
2983	{
2984	LibHalContext *halContext = gLibHalCtxNew();
2985	if (halContext != 0)
2986	{
2987	if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
2988	{
2989	if (gLibHalCtxInit(halContext, &dbusError))
2990	{
2991	int numDevices;
2992	char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2993	"storage.drive_type", "cdrom",
2994	&numDevices, &dbusError);
2995	if (halDevices != 0)
2996	{
2997	/* Hal is installed and working, so if no devices are reported, assume
2998	that there are none. */
2999	halSuccess = true;
3000	for (int i = 0; i < numDevices; i++)
3001	{
3002	char *devNode = gLibHalDeviceGetPropertyString(halContext,
3003	halDevices[i], "block.device", &dbusError);
3004	#ifdef RT_OS_SOLARIS
3005	/* The CD/DVD ioctls work only for raw device nodes. */
3006	char *tmp = getfullrawname(devNode);
3007	gLibHalFreeString(devNode);
3008	devNode = tmp;
3009	#endif
3010
3011	if (devNode != 0)
3012	{
3013	// if (validateDevice(devNode, true))
3014	// {
3015	Utf8Str description;
3016	char vendor, product;
3017	/* We do not check the error here, as this field may
3018	not even exist. */
3019	vendor = gLibHalDeviceGetPropertyString(halContext,
3020	halDevices[i], "info.vendor", 0);
3021	product = gLibHalDeviceGetPropertyString(halContext,
3022	halDevices[i], "info.product", &dbusError);
3023	if ((product != 0 && product[0] != 0))
3024	{
3025	if ((vendor != 0) && (vendor[0] != 0))
3026	{
3027	description = Utf8StrFmt("%s %s",
3028	vendor, product);
3029	}
3030	else
3031	{
3032	description = product;
3033	}
3034	ComObjPtr<Medium> hostDVDDriveObj;
3035	hostDVDDriveObj.createObject();
3036	hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
3037	Bstr(devNode), Bstr(description));
3038	list.push_back(hostDVDDriveObj);
3039	}
3040	else
3041	{
3042	if (product == 0)
3043	{
3044	LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
3045	halDevices[i], dbusError.name, dbusError.message));
3046	gDBusErrorFree(&dbusError);
3047	}
3048	ComObjPtr<Medium> hostDVDDriveObj;
3049	hostDVDDriveObj.createObject();
3050	hostDVDDriveObj->init(m->pParent, DeviceType_DVD,
3051	Bstr(devNode));
3052	list.push_back(hostDVDDriveObj);
3053	}
3054	if (vendor != 0)
3055	{
3056	gLibHalFreeString(vendor);
3057	}
3058	if (product != 0)
3059	{
3060	gLibHalFreeString(product);
3061	}
3062	// }
3063	// else
3064	// {
3065	// LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
3066	// }
3067	#ifndef RT_OS_SOLARIS
3068	gLibHalFreeString(devNode);
3069	#else
3070	free(devNode);
3071	#endif
3072	}
3073	else
3074	{
3075	LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
3076	halDevices[i], dbusError.name, dbusError.message));
3077	gDBusErrorFree(&dbusError);
3078	}
3079	}
3080	gLibHalFreeStringArray(halDevices);
3081	}
3082	else
3083	{
3084	LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
3085	gDBusErrorFree(&dbusError);
3086	}
3087	if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
3088	{
3089	LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
3090	dbusError.name, dbusError.message));
3091	gDBusErrorFree(&dbusError);
3092	}
3093	}
3094	else
3095	{
3096	LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
3097	dbusError.name, dbusError.message));
3098	gDBusErrorFree(&dbusError);
3099	}
3100	gLibHalCtxFree(halContext);
3101	}
3102	else
3103	{
3104	LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
3105	}
3106	}
3107	else
3108	{
3109	LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
3110	}
3111	gDBusConnectionUnref(dbusConnection);
3112	}
3113	else
3114	{
3115	LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n",
3116	dbusError.name, dbusError.message));
3117	gDBusErrorFree(&dbusError);
3118	}
3119	return halSuccess;
3120	}
3121
3122
3123	/**
3124	* Helper function to query the hal subsystem for information about floppy drives attached to the
3125	* system.
3126	*
3127	* @returns true if information was successfully obtained, false otherwise
3128	* @retval list drives found will be attached to this list
3129	*/
3130	bool Host::i_getFloppyInfoFromHal(std::list< ComObjPtr<Medium> > &list)
3131	{
3132	bool halSuccess = false;
3133	DBusError dbusError;
3134	if (!gLibHalCheckPresence())
3135	return false;
3136	gDBusErrorInit(&dbusError);
3137	DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
3138	if (dbusConnection != 0)
3139	{
3140	LibHalContext *halContext = gLibHalCtxNew();
3141	if (halContext != 0)
3142	{
3143	if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
3144	{
3145	if (gLibHalCtxInit(halContext, &dbusError))
3146	{
3147	int numDevices;
3148	char **halDevices = gLibHalFindDeviceStringMatch(halContext,
3149	"storage.drive_type", "floppy",
3150	&numDevices, &dbusError);
3151	if (halDevices != 0)
3152	{
3153	/* Hal is installed and working, so if no devices are reported, assume
3154	that there are none. */
3155	halSuccess = true;
3156	for (int i = 0; i < numDevices; i++)
3157	{
3158	char *driveType = gLibHalDeviceGetPropertyString(halContext,
3159	halDevices[i], "storage.drive_type", 0);
3160	if (driveType != 0)
3161	{
3162	if (strcmp(driveType, "floppy") != 0)
3163	{
3164	gLibHalFreeString(driveType);
3165	continue;
3166	}
3167	gLibHalFreeString(driveType);
3168	}
3169	else
3170	{
3171	/* An error occurred. The attribute "storage.drive_type"
3172	probably didn't exist. */
3173	continue;
3174	}
3175	char *devNode = gLibHalDeviceGetPropertyString(halContext,
3176	halDevices[i], "block.device", &dbusError);
3177	if (devNode != 0)
3178	{
3179	// if (validateDevice(devNode, false))
3180	// {
3181	Utf8Str description;
3182	char vendor, product;
3183	/* We do not check the error here, as this field may
3184	not even exist. */
3185	vendor = gLibHalDeviceGetPropertyString(halContext,
3186	halDevices[i], "info.vendor", 0);
3187	product = gLibHalDeviceGetPropertyString(halContext,
3188	halDevices[i], "info.product", &dbusError);
3189	if ((product != 0) && (product[0] != 0))
3190	{
3191	if ((vendor != 0) && (vendor[0] != 0))
3192	{
3193	description = Utf8StrFmt("%s %s",
3194	vendor, product);
3195	}
3196	else
3197	{
3198	description = product;
3199	}
3200	ComObjPtr<Medium> hostFloppyDrive;
3201	hostFloppyDrive.createObject();
3202	hostFloppyDrive->init(m->pParent, DeviceType_DVD,
3203	Bstr(devNode), Bstr(description));
3204	list.push_back(hostFloppyDrive);
3205	}
3206	else
3207	{
3208	if (product == 0)
3209	{
3210	LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
3211	halDevices[i], dbusError.name, dbusError.message));
3212	gDBusErrorFree(&dbusError);
3213	}
3214	ComObjPtr<Medium> hostFloppyDrive;
3215	hostFloppyDrive.createObject();
3216	hostFloppyDrive->init(m->pParent, DeviceType_DVD,
3217	Bstr(devNode));
3218	list.push_back(hostFloppyDrive);
3219	}
3220	if (vendor != 0)
3221	{
3222	gLibHalFreeString(vendor);
3223	}
3224	if (product != 0)
3225	{
3226	gLibHalFreeString(product);
3227	}
3228	// }
3229	// else
3230	// {
3231	// LogRel(("Host::COMGETTER(FloppyDrives): failed to validate the block device %s as a floppy drive\n"));
3232	// }
3233	gLibHalFreeString(devNode);
3234	}
3235	else
3236	{
3237	LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
3238	halDevices[i], dbusError.name, dbusError.message));
3239	gDBusErrorFree(&dbusError);
3240	}
3241	}
3242	gLibHalFreeStringArray(halDevices);
3243	}
3244	else
3245	{
3246	LogRel(("Host::COMGETTER(FloppyDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
3247	gDBusErrorFree(&dbusError);
3248	}
3249	if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
3250	{
3251	LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
3252	dbusError.name, dbusError.message));
3253	gDBusErrorFree(&dbusError);
3254	}
3255	}
3256	else
3257	{
3258	LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
3259	dbusError.name, dbusError.message));
3260	gDBusErrorFree(&dbusError);
3261	}
3262	gLibHalCtxFree(halContext);
3263	}
3264	else
3265	{
3266	LogRel(("Host::COMGETTER(FloppyDrives): failed to set libhal connection to dbus.\n"));
3267	}
3268	}
3269	else
3270	{
3271	LogRel(("Host::COMGETTER(FloppyDrives): failed to get a libhal context - out of memory?\n"));
3272	}
3273	gDBusConnectionUnref(dbusConnection);
3274	}
3275	else
3276	{
3277	LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus. dbus error: %s (%s)\n",
3278	dbusError.name, dbusError.message));
3279	gDBusErrorFree(&dbusError);
3280	}
3281	return halSuccess;
3282	}
3283
3284
3285	/**
3286	* Helper function to query the hal subsystem for information about fixed drives attached to the
3287	* system.
3288	*
3289	* @returns COM status code. (setError is not called on failure as we only fail
3290	* with E_OUTOFMEMORY.)
3291	* @retval S_OK on success.
3292	* @retval S_FALSE if HAL cannot be used.
3293	* @param list Reference to list to return the path/model string pairs.
3294	*/
3295	HRESULT Host::i_getFixedDrivesFromHal(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &list) RT_NOEXCEPT
3296	{
3297	HRESULT hrc = S_FALSE;
3298	if (!gLibHalCheckPresence())
3299	return hrc;
3300
3301	DBusError dbusError;
3302	gDBusErrorInit(&dbusError);
3303	DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
3304	if (dbusConnection != 0)
3305	{
3306	LibHalContext *halContext = gLibHalCtxNew();
3307	if (halContext != 0)
3308	{
3309	if (gLibHalCtxSetDBusConnection(halContext, dbusConnection))
3310	{
3311	if (gLibHalCtxInit(halContext, &dbusError))
3312	{
3313	int cDevices;
3314	char **halDevices = gLibHalFindDeviceStringMatch(halContext, "storage.drive_type", "disk",
3315	&cDevices, &dbusError);
3316	if (halDevices != 0)
3317	{
3318	/* Hal is installed and working, so if no devices are reported, assume
3319	that there are none. */
3320	hrc = S_OK;
3321	for (int i = 0; i < cDevices && hrc == S_OK; i++)
3322	{
3323	char *pszDevNode = gLibHalDeviceGetPropertyString(halContext, halDevices[i], "block.device",
3324	&dbusError);
3325	/* The fixed drive ioctls work only for raw device nodes. */
3326	char *pszTmp = getfullrawname(pszDevNode);
3327	gLibHalFreeString(pszDevNode);
3328	pszDevNode = pszTmp;
3329	if (pszDevNode != 0)
3330	{
3331	/* We do not check the error here, as this field may
3332	not even exist. */
3333	char *pszVendor = gLibHalDeviceGetPropertyString(halContext, halDevices[i], "info.vendor", 0);
3334	char *pszProduct = gLibHalDeviceGetPropertyString(halContext, halDevices[i], "info.product",
3335	&dbusError);
3336	Utf8Str strDescription;
3337	if (pszProduct != NULL && pszProduct[0] != '\0')
3338	{
3339	int vrc;
3340	if (pszVendor != NULL && pszVendor[0] != '\0')
3341	vrc = strDescription.printfNoThrow("%s %s", pszVendor, pszProduct);
3342	else
3343	vrc = strDescription.assignNoThrow(pszProduct);
3344	AssertRCStmt(vrc, hrc = E_OUTOFMEMORY);
3345	}
3346	if (pszVendor != NULL)
3347	gLibHalFreeString(pszVendor);
3348	if (pszProduct != NULL)
3349	gLibHalFreeString(pszProduct);
3350
3351	/* Correct device/partition/slice already choosen. Just add it to the return list */
3352	if (hrc == S_OK)
3353	try
3354	{
3355	list.push_back(std::pair<com::Utf8Str, com::Utf8Str>(pszDevNode, strDescription));
3356	}
3357	catch (std::bad_alloc &)
3358	{
3359	AssertFailedStmt(hrc = E_OUTOFMEMORY);
3360	}
3361	gLibHalFreeString(pszDevNode);
3362	}
3363	else
3364	{
3365	LogRel(("Host::COMGETTER(HostDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
3366	halDevices[i], dbusError.name, dbusError.message));
3367	gDBusErrorFree(&dbusError);
3368	}
3369	}
3370	gLibHalFreeStringArray(halDevices);
3371	}
3372	else
3373	{
3374	LogRel(("Host::COMGETTER(HostDrives): failed to get devices with capability \"storage.disk\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
3375	gDBusErrorFree(&dbusError);
3376	}
3377	if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
3378	{
3379	LogRel(("Host::COMGETTER(HostDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n",
3380	dbusError.name, dbusError.message));
3381	gDBusErrorFree(&dbusError);
3382	}
3383	}
3384	else
3385	{
3386	LogRel(("Host::COMGETTER(HostDrives): failed to initialise libhal context. dbus error: %s (%s)\n",
3387	dbusError.name, dbusError.message));
3388	gDBusErrorFree(&dbusError);
3389	}
3390	gLibHalCtxFree(halContext);
3391	}
3392	else
3393	LogRel(("Host::COMGETTER(HostDrives): failed to set libhal connection to dbus.\n"));
3394	}
3395	else
3396	LogRel(("Host::COMGETTER(HostDrives): failed to get a libhal context - out of memory?\n"));
3397	gDBusConnectionUnref(dbusConnection);
3398	}
3399	else
3400	{
3401	LogRel(("Host::COMGETTER(HostDrives): failed to connect to dbus. dbus error: %s (%s)\n",
3402	dbusError.name, dbusError.message));
3403	gDBusErrorFree(&dbusError);
3404	}
3405	return hrc;
3406	}
3407
3408	#endif /* RT_OS_SOLARIS and VBOX_USE_HAL */
3409
3410	/** @todo get rid of dead code below - RT_OS_SOLARIS and RT_OS_LINUX are never both set */
3411	#if defined(RT_OS_SOLARIS)
3412
3413	/**
3414	* Helper function to parse the given mount file and add found entries
3415	*/
3416	void Host::i_parseMountTable(char *mountTable, std::list< ComObjPtr<Medium> > &list)
3417	{
3418	#ifdef RT_OS_LINUX
3419	FILE *mtab = setmntent(mountTable, "r");
3420	if (mtab)
3421	{
3422	struct mntent *mntent;
3423	char *mnt_type;
3424	char *mnt_dev;
3425	char *tmp;
3426	while ((mntent = getmntent(mtab)))
3427	{
3428	mnt_type = (char*)malloc(strlen(mntent->mnt_type) + 1);
3429	mnt_dev = (char*)malloc(strlen(mntent->mnt_fsname) + 1);
3430	strcpy(mnt_type, mntent->mnt_type);
3431	strcpy(mnt_dev, mntent->mnt_fsname);
3432	// supermount fs case
3433	if (strcmp(mnt_type, "supermount") == 0)
3434	{
3435	tmp = strstr(mntent->mnt_opts, "fs=");
3436	if (tmp)
3437	{
3438	free(mnt_type);
3439	mnt_type = strdup(tmp + strlen("fs="));
3440	if (mnt_type)
3441	{
3442	tmp = strchr(mnt_type, ',');
3443	if (tmp)
3444	*tmp = '\0';
3445	}
3446	}
3447	tmp = strstr(mntent->mnt_opts, "dev=");
3448	if (tmp)
3449	{
3450	free(mnt_dev);
3451	mnt_dev = strdup(tmp + strlen("dev="));
3452	if (mnt_dev)
3453	{
3454	tmp = strchr(mnt_dev, ',');
3455	if (tmp)
3456	*tmp = '\0';
3457	}
3458	}
3459	}
3460	// use strstr here to cover things fs types like "udf,iso9660"
3461	if (strstr(mnt_type, "iso9660") == 0)
3462	{
3463	/** @todo check whether we've already got the drive in our list! */
3464	if (i_validateDevice(mnt_dev, true))
3465	{
3466	ComObjPtr<Medium> hostDVDDriveObj;
3467	hostDVDDriveObj.createObject();
3468	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(mnt_dev));
3469	list.push_back (hostDVDDriveObj);
3470	}
3471	}
3472	free(mnt_dev);
3473	free(mnt_type);
3474	}
3475	endmntent(mtab);
3476	}
3477	#else // RT_OS_SOLARIS
3478	FILE *mntFile = fopen(mountTable, "r");
3479	if (mntFile)
3480	{
3481	struct mnttab mntTab;
3482	while (getmntent(mntFile, &mntTab) == 0)
3483	{
3484	const char *mountName = mntTab.mnt_special;
3485	const char *mountPoint = mntTab.mnt_mountp;
3486	const char *mountFSType = mntTab.mnt_fstype;
3487	if (mountName && mountPoint && mountFSType)
3488	{
3489	// skip devices we are not interested in
3490	if ((*mountName && mountName[0] == '/') && // skip 'fake' devices (like -hosts,
3491	// proc, fd, swap)
3492	(*mountFSType && (strncmp(mountFSType, RT_STR_TUPLE("devfs")) != 0 && // skip devfs
3493	// (i.e. /devices)
3494	strncmp(mountFSType, RT_STR_TUPLE("dev")) != 0 && // skip dev (i.e. /dev)
3495	strncmp(mountFSType, RT_STR_TUPLE("lofs")) != 0))) // skip loop-back file-system (lofs)
3496	{
3497	char rawDevName = getfullrawname((char )mountName);
3498	if (i_validateDevice(rawDevName, true))
3499	{
3500	ComObjPtr<Medium> hostDVDDriveObj;
3501	hostDVDDriveObj.createObject();
3502	hostDVDDriveObj->init(m->pParent, DeviceType_DVD, Bstr(rawDevName));
3503	list.push_back(hostDVDDriveObj);
3504	}
3505	free(rawDevName);
3506	}
3507	}
3508	}
3509
3510	fclose(mntFile);
3511	}
3512	#endif
3513	}
3514
3515	/**
3516	* Helper function to check whether the given device node is a valid drive
3517	*/
3518	bool Host::i_validateDevice(const char *deviceNode, bool isCDROM)
3519	{
3520	struct stat statInfo;
3521	bool retValue = false;
3522
3523	// sanity check
3524	if (!deviceNode)
3525	{
3526	return false;
3527	}
3528
3529	// first a simple stat() call
3530	if (stat(deviceNode, &statInfo) < 0)
3531	{
3532	return false;
3533	}
3534	else
3535	{
3536	if (isCDROM)
3537	{
3538	if (S_ISCHR(statInfo.st_mode) \|\| S_ISBLK(statInfo.st_mode))
3539	{
3540	int fileHandle;
3541	// now try to open the device
3542	fileHandle = open(deviceNode, O_RDONLY \| O_NONBLOCK, 0);
3543	if (fileHandle >= 0)
3544	{
3545	cdrom_subchnl cdChannelInfo;
3546	cdChannelInfo.cdsc_format = CDROM_MSF;
3547	// this call will finally reveal the whole truth
3548	#ifdef RT_OS_LINUX
3549	if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) \|\|
3550	(errno == EIO) \|\| (errno == ENOENT) \|\|
3551	(errno == EINVAL) \|\| (errno == ENOMEDIUM))
3552	#else
3553	if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) \|\|
3554	(errno == EIO) \|\| (errno == ENOENT) \|\|
3555	(errno == EINVAL))
3556	#endif
3557	{
3558	retValue = true;
3559	}
3560	close(fileHandle);
3561	}
3562	}
3563	} else
3564	{
3565	// floppy case
3566	if (S_ISCHR(statInfo.st_mode) \|\| S_ISBLK(statInfo.st_mode))
3567	{
3568	/// @todo do some more testing, maybe a nice IOCTL!
3569	retValue = true;
3570	}
3571	}
3572	}
3573	return retValue;
3574	}
3575	#endif // RT_OS_SOLARIS
3576
3577	#ifdef VBOX_WITH_USB
3578	/**
3579	* Checks for the presence and status of the USB Proxy Service.
3580	* Returns S_OK when the Proxy is present and OK, VBOX_E_HOST_ERROR (as a
3581	* warning) if the proxy service is not available due to the way the host is
3582	* configured (at present, that means that usbfs and hal/DBus are not
3583	* available on a Linux host) or E_FAIL and a corresponding error message
3584	* otherwise. Intended to be used by methods that rely on the Proxy Service
3585	* availability.
3586	*
3587	* @note This method may return a warning result code. It is recommended to use
3588	* MultiError to store the return value.
3589	*
3590	* @note Locks this object for reading.
3591	*/
3592	HRESULT Host::i_checkUSBProxyService()
3593	{
3594	AutoCaller autoCaller(this);
3595	if (FAILED(autoCaller.hrc()))
3596	return autoCaller.hrc();
3597
3598	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3599
3600	AssertReturn(m->pUSBProxyService, E_FAIL);
3601	if (!m->pUSBProxyService->isActive())
3602	{
3603	/* disable the USB controller completely to avoid assertions if the
3604	* USB proxy service could not start. */
3605
3606	switch (m->pUSBProxyService->getLastError())
3607	{
3608	case VERR_FILE_NOT_FOUND: /** @todo what does this mean? */
3609	return setWarning(E_FAIL,
3610	tr("Could not load the Host USB Proxy Service (VERR_FILE_NOT_FOUND). The service might not be installed on the host computer"));
3611	case VERR_VUSB_USB_DEVICE_PERMISSION:
3612	return setWarning(E_FAIL,
3613	tr("VirtualBox is not currently allowed to access USB devices. You can change this by adding your user to the 'vboxusers' group. Please see the user manual for a more detailed explanation"));
3614	case VERR_VUSB_USBFS_PERMISSION:
3615	return setWarning(E_FAIL,
3616	tr("VirtualBox is not currently allowed to access USB devices. You can change this by allowing your user to access the 'usbfs' folder and files. Please see the user manual for a more detailed explanation"));
3617	case VINF_SUCCESS:
3618	return setWarning(E_FAIL,
3619	tr("The USB Proxy Service has not yet been ported to this host"));
3620	default:
3621	return setWarning(E_FAIL, "%s: %Rrc",
3622	tr("Could not load the Host USB Proxy service"),
3623	m->pUSBProxyService->getLastError());
3624	}
3625	}
3626
3627	return S_OK;
3628	}
3629	#endif /* VBOX_WITH_USB */
3630
3631	HRESULT Host::i_updateNetIfList()
3632	{
3633	#ifdef VBOX_WITH_HOSTNETIF_API
3634	AssertReturn(!isWriteLockOnCurrentThread(), E_FAIL);
3635
3636	/** @todo r=klaus it would save lots of clock cycles if for concurrent
3637	* threads executing this code we'd only do one interface enumeration
3638	* and update, and let the other threads use the result as is. However
3639	* if there's a constant hammering of this method, we don't want this
3640	* to cause update starvation. */
3641	HostNetworkInterfaceList list;
3642	int vrc = NetIfList(list);
3643	if (RT_FAILURE(vrc))
3644	{
3645	Log(("Failed to get host network interface list with vrc=%Rrc\n", vrc));
3646	return E_FAIL;
3647	}
3648
3649	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
3650
3651	AssertReturn(m->pParent, E_FAIL);
3652	/* Make a copy as the original may be partially destroyed later. */
3653	HostNetworkInterfaceList listCopy(list);
3654	HostNetworkInterfaceList::iterator itOld, itNew;
3655	# ifdef VBOX_WITH_RESOURCE_USAGE_API
3656	PerformanceCollector *aCollector = m->pParent->i_performanceCollector();
3657	# endif
3658	for (itOld = m->llNetIfs.begin(); itOld != m->llNetIfs.end(); ++itOld)
3659	{
3660	bool fGone = true;
3661	Bstr nameOld;
3662	(*itOld)->COMGETTER(Name)(nameOld.asOutParam());
3663	for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3664	{
3665	Bstr nameNew;
3666	(*itNew)->COMGETTER(Name)(nameNew.asOutParam());
3667	if (nameNew == nameOld)
3668	{
3669	fGone = false;
3670	(*itNew)->uninit();
3671	listCopy.erase(itNew);
3672	break;
3673	}
3674	}
3675	if (fGone)
3676	{
3677	# ifdef VBOX_WITH_RESOURCE_USAGE_API
3678	(*itOld)->i_unregisterMetrics(aCollector, this);
3679	(*itOld)->uninit();
3680	# endif
3681	}
3682	}
3683	/*
3684	* Need to set the references to VirtualBox object in all interface objects
3685	* (see @bugref{6439}).
3686	*/
3687	for (itNew = list.begin(); itNew != list.end(); ++itNew)
3688	(*itNew)->i_setVirtualBox(m->pParent);
3689	/* At this point listCopy will contain newly discovered interfaces only. */
3690	for (itNew = listCopy.begin(); itNew != listCopy.end(); ++itNew)
3691	{
3692	HostNetworkInterfaceType_T t;
3693	HRESULT hrc = (*itNew)->COMGETTER(InterfaceType)(&t);
3694	if (FAILED(hrc))
3695	{
3696	Bstr n;
3697	(*itNew)->COMGETTER(Name)(n.asOutParam());
3698	LogRel(("Host::updateNetIfList: failed to get interface type for %ls\n", n.raw()));
3699	}
3700	else if (t == HostNetworkInterfaceType_Bridged)
3701	{
3702	# ifdef VBOX_WITH_RESOURCE_USAGE_API
3703	(*itNew)->i_registerMetrics(aCollector, this);
3704	# endif
3705	}
3706	}
3707	m->llNetIfs = list;
3708	return S_OK;
3709	#else
3710	return E_NOTIMPL;
3711	#endif
3712	}
3713
3714	#ifdef VBOX_WITH_RESOURCE_USAGE_API
3715
3716	void Host::i_registerDiskMetrics(PerformanceCollector *aCollector)
3717	{
3718	pm::CollectorHAL *hal = aCollector->getHAL();
3719	/* Create sub metrics */
3720	Utf8StrFmt fsNameBase("FS/{%s}/Usage", "/");
3721	//Utf8StrFmt fsNameBase("Filesystem/[root]/Usage");
3722	pm::SubMetric *fsRootUsageTotal = new pm::SubMetric(fsNameBase + "/Total",
3723	"Root file system size.");
3724	pm::SubMetric *fsRootUsageUsed = new pm::SubMetric(fsNameBase + "/Used",
3725	"Root file system space currently occupied.");
3726	pm::SubMetric *fsRootUsageFree = new pm::SubMetric(fsNameBase + "/Free",
3727	"Root file system space currently empty.");
3728
3729	pm::BaseMetric *fsRootUsage = new pm::HostFilesystemUsage(hal, this,
3730	fsNameBase, "/",
3731	fsRootUsageTotal,
3732	fsRootUsageUsed,
3733	fsRootUsageFree);
3734	aCollector->registerBaseMetric(fsRootUsage);
3735
3736	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal, 0));
3737	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3738	new pm::AggregateAvg()));
3739	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3740	new pm::AggregateMin()));
3741	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageTotal,
3742	new pm::AggregateMax()));
3743
3744	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed, 0));
3745	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3746	new pm::AggregateAvg()));
3747	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3748	new pm::AggregateMin()));
3749	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageUsed,
3750	new pm::AggregateMax()));
3751
3752	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree, 0));
3753	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3754	new pm::AggregateAvg()));
3755	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3756	new pm::AggregateMin()));
3757	aCollector->registerMetric(new pm::Metric(fsRootUsage, fsRootUsageFree,
3758	new pm::AggregateMax()));
3759
3760	/* For now we are concerned with the root file system only. */
3761	pm::DiskList disksUsage, disksLoad;
3762	int vrc = hal->getDiskListByFs("/", disksUsage, disksLoad);
3763	if (RT_FAILURE(vrc))
3764	return;
3765	pm::DiskList::iterator it;
3766	for (it = disksLoad.begin(); it != disksLoad.end(); ++it)
3767	{
3768	Utf8StrFmt strName("Disk/%s", it->c_str());
3769	pm::SubMetric *fsLoadUtil = new pm::SubMetric(strName + "/Load/Util",
3770	"Percentage of time disk was busy serving I/O requests.");
3771	pm::BaseMetric *fsLoad = new pm::HostDiskLoadRaw(hal, this, strName + "/Load",
3772	*it, fsLoadUtil);
3773	aCollector->registerBaseMetric(fsLoad);
3774
3775	aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil, 0));
3776	aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3777	new pm::AggregateAvg()));
3778	aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3779	new pm::AggregateMin()));
3780	aCollector->registerMetric(new pm::Metric(fsLoad, fsLoadUtil,
3781	new pm::AggregateMax()));
3782	}
3783	for (it = disksUsage.begin(); it != disksUsage.end(); ++it)
3784	{
3785	Utf8StrFmt strName("Disk/%s", it->c_str());
3786	pm::SubMetric *fsUsageTotal = new pm::SubMetric(strName + "/Usage/Total",
3787	"Disk size.");
3788	pm::BaseMetric *fsUsage = new pm::HostDiskUsage(hal, this, strName + "/Usage",
3789	*it, fsUsageTotal);
3790	aCollector->registerBaseMetric(fsUsage);
3791
3792	aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal, 0));
3793	aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3794	new pm::AggregateAvg()));
3795	aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3796	new pm::AggregateMin()));
3797	aCollector->registerMetric(new pm::Metric(fsUsage, fsUsageTotal,
3798	new pm::AggregateMax()));
3799	}
3800	}
3801
3802	void Host::i_registerMetrics(PerformanceCollector *aCollector)
3803	{
3804	pm::CollectorHAL *hal = aCollector->getHAL();
3805	/* Create sub metrics */
3806	pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
3807	"Percentage of processor time spent in user mode.");
3808	pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
3809	"Percentage of processor time spent in kernel mode.");
3810	pm::SubMetric *cpuLoadIdle = new pm::SubMetric("CPU/Load/Idle",
3811	"Percentage of processor time spent idling.");
3812	pm::SubMetric *cpuMhzSM = new pm::SubMetric("CPU/MHz",
3813	"Average of current frequency of all processors.");
3814	pm::SubMetric *ramUsageTotal = new pm::SubMetric("RAM/Usage/Total",
3815	"Total physical memory installed.");
3816	pm::SubMetric *ramUsageUsed = new pm::SubMetric("RAM/Usage/Used",
3817	"Physical memory currently occupied.");
3818	pm::SubMetric *ramUsageFree = new pm::SubMetric("RAM/Usage/Free",
3819	"Physical memory currently available to applications.");
3820	pm::SubMetric *ramVMMUsed = new pm::SubMetric("RAM/VMM/Used",
3821	"Total physical memory used by the hypervisor.");
3822	pm::SubMetric *ramVMMFree = new pm::SubMetric("RAM/VMM/Free",
3823	"Total physical memory free inside the hypervisor.");
3824	pm::SubMetric *ramVMMBallooned = new pm::SubMetric("RAM/VMM/Ballooned",
3825	"Total physical memory ballooned by the hypervisor.");
3826	pm::SubMetric *ramVMMShared = new pm::SubMetric("RAM/VMM/Shared",
3827	"Total physical memory shared between VMs.");
3828
3829
3830	/* Create and register base metrics */
3831	pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw(hal, this, cpuLoadUser, cpuLoadKernel,
3832	cpuLoadIdle);
3833	aCollector->registerBaseMetric(cpuLoad);
3834	pm::BaseMetric *cpuMhz = new pm::HostCpuMhz(hal, this, cpuMhzSM);
3835	aCollector->registerBaseMetric(cpuMhz);
3836	pm::BaseMetric *ramUsage = new pm::HostRamUsage(hal, this,
3837	ramUsageTotal,
3838	ramUsageUsed,
3839	ramUsageFree);
3840	aCollector->registerBaseMetric(ramUsage);
3841	pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), this,
3842	ramVMMUsed,
3843	ramVMMFree,
3844	ramVMMBallooned,
3845	ramVMMShared);
3846	aCollector->registerBaseMetric(ramVmm);
3847
3848	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
3849	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3850	new pm::AggregateAvg()));
3851	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3852	new pm::AggregateMin()));
3853	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
3854	new pm::AggregateMax()));
3855
3856	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
3857	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3858	new pm::AggregateAvg()));
3859	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3860	new pm::AggregateMin()));
3861	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
3862	new pm::AggregateMax()));
3863
3864	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle, 0));
3865	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3866	new pm::AggregateAvg()));
3867	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3868	new pm::AggregateMin()));
3869	aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadIdle,
3870	new pm::AggregateMax()));
3871
3872	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM, 0));
3873	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3874	new pm::AggregateAvg()));
3875	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3876	new pm::AggregateMin()));
3877	aCollector->registerMetric(new pm::Metric(cpuMhz, cpuMhzSM,
3878	new pm::AggregateMax()));
3879
3880	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal, 0));
3881	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3882	new pm::AggregateAvg()));
3883	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3884	new pm::AggregateMin()));
3885	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageTotal,
3886	new pm::AggregateMax()));
3887
3888	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
3889	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3890	new pm::AggregateAvg()));
3891	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3892	new pm::AggregateMin()));
3893	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
3894	new pm::AggregateMax()));
3895
3896	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree, 0));
3897	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3898	new pm::AggregateAvg()));
3899	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3900	new pm::AggregateMin()));
3901	aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageFree,
3902	new pm::AggregateMax()));
3903
3904	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed, 0));
3905	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3906	new pm::AggregateAvg()));
3907	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3908	new pm::AggregateMin()));
3909	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMUsed,
3910	new pm::AggregateMax()));
3911
3912	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree, 0));
3913	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3914	new pm::AggregateAvg()));
3915	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3916	new pm::AggregateMin()));
3917	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMFree,
3918	new pm::AggregateMax()));
3919
3920	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned, 0));
3921	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3922	new pm::AggregateAvg()));
3923	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3924	new pm::AggregateMin()));
3925	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMBallooned,
3926	new pm::AggregateMax()));
3927
3928	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared, 0));
3929	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3930	new pm::AggregateAvg()));
3931	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3932	new pm::AggregateMin()));
3933	aCollector->registerMetric(new pm::Metric(ramVmm, ramVMMShared,
3934	new pm::AggregateMax()));
3935	i_registerDiskMetrics(aCollector);
3936	}
3937
3938	void Host::i_unregisterMetrics(PerformanceCollector *aCollector)
3939	{
3940	aCollector->unregisterMetricsFor(this);
3941	aCollector->unregisterBaseMetricsFor(this);
3942	}
3943
3944	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
3945
3946
3947	/* static */
3948	void Host::i_generateMACAddress(Utf8Str &mac)
3949	{
3950	/*
3951	* Our strategy is as follows: the first three bytes are our fixed
3952	* vendor ID (080027). The remaining 3 bytes will be taken from the
3953	* start of a GUID. This is a fairly safe algorithm.
3954	*/
3955	Guid guid;
3956	guid.create();
3957	mac = Utf8StrFmt("080027%02X%02X%02X",
3958	guid.raw()->au8[0], guid.raw()->au8[1], guid.raw()->au8[2]);
3959	}
3960
3961	#ifdef RT_OS_WINDOWS
3962	HRESULT Host::i_getFixedDrivesFromGlobalNamespace(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &aDriveList) RT_NOEXCEPT
3963	{
3964	RTERRINFOSTATIC ErrInfo;
3965	uint32_t offError;
3966	RTVFSDIR hVfsDir;
3967	int vrc = RTVfsChainOpenDir("\\\\:iprtnt:\\GLOBAL??", 0 /fFlags/, &hVfsDir, &offError, RTErrInfoInitStatic(&ErrInfo));
3968	if (RT_FAILURE(vrc))
3969	return setError(E_FAIL, tr("Failed to open NT\\GLOBAL?? (error %Rrc)"), vrc);
3970
3971	/*
3972	* Scan whole directory and find any 'PhysicalDiskX' entries. Next, combine with '\\.\'
3973	* to obtain the harddisk dev path.
3974	*/
3975	size_t cbDirEntryAlloced = sizeof(RTDIRENTRYEX);
3976	PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
3977	if (!pDirEntry)
3978	{
3979	RTVfsDirRelease(hVfsDir);
3980	return setError(E_OUTOFMEMORY, tr("Out of memory! (direntry buffer)"));
3981	}
3982
3983	HRESULT hrc = S_OK;
3984	for (;;)
3985	{
3986	size_t cbDirEntry = cbDirEntryAlloced;
3987	vrc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING);
3988	if (RT_FAILURE(vrc))
3989	{
3990	if (vrc == VERR_BUFFER_OVERFLOW)
3991	{
3992	RTMemTmpFree(pDirEntry);
3993	cbDirEntryAlloced = RT_ALIGN_Z(RT_MIN(cbDirEntry, cbDirEntryAlloced) + 64, 64);
3994	pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
3995	if (pDirEntry)
3996	continue;
3997	hrc = setError(E_OUTOFMEMORY, tr("Out of memory! (direntry buffer)"));
3998	}
3999	else if (vrc != VERR_NO_MORE_FILES)
4000	hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsDirReadEx failed: %Rrc"), vrc);
4001	break;
4002	}
4003	if (RTStrStartsWith(pDirEntry->szName, "PhysicalDrive"))
4004	{
4005	char szPhysicalDrive[64];
4006	RTStrPrintf(szPhysicalDrive, sizeof(szPhysicalDrive), "\\\\.\\%s", pDirEntry->szName);
4007
4008	RTFILE hRawFile = NIL_RTFILE;
4009	vrc = RTFileOpen(&hRawFile, szPhysicalDrive, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
4010	if (RT_FAILURE(vrc))
4011	{
4012	try
4013	{
4014	aDriveList.push_back(std::pair<com::Utf8Str, com::Utf8Str>(szPhysicalDrive, tr("Unknown (Access denied)")));
4015	}
4016	catch (std::bad_alloc &)
4017	{
4018	hrc = setError(E_OUTOFMEMORY, tr("Out of memory"));
4019	break;
4020	}
4021	continue;
4022	}
4023
4024	DWORD cbBytesReturned = 0;
4025	uint8_t abBuffer[1024];
4026	RT_ZERO(abBuffer);
4027
4028	STORAGE_PROPERTY_QUERY query;
4029	RT_ZERO(query);
4030	query.PropertyId = StorageDeviceProperty;
4031	query.QueryType = PropertyStandardQuery;
4032
4033	BOOL fRc = DeviceIoControl((HANDLE)RTFileToNative(hRawFile),
4034	IOCTL_STORAGE_QUERY_PROPERTY, &query, sizeof(query),
4035	abBuffer, sizeof(abBuffer), &cbBytesReturned, NULL);
4036	RTFileClose(hRawFile);
4037	char szModel[1024];
4038	if (fRc)
4039	{
4040	PSTORAGE_DEVICE_DESCRIPTOR pDevDescriptor = (PSTORAGE_DEVICE_DESCRIPTOR)abBuffer;
4041	char pszProduct = pDevDescriptor->ProductIdOffset ? (char )&abBuffer[pDevDescriptor->ProductIdOffset] : NULL;
4042	if (pszProduct)
4043	{
4044	RTStrPurgeEncoding(pszProduct);
4045	if (*pszProduct != '\0')
4046	{
4047	char pszVendor = pDevDescriptor->VendorIdOffset ? (char )&abBuffer[pDevDescriptor->VendorIdOffset] : NULL;
4048	if (pszVendor)
4049	RTStrPurgeEncoding(pszVendor);
4050	if (pszVendor && *pszVendor)
4051	RTStrPrintf(szModel, sizeof(szModel), "%s %s", pszVendor, pszProduct);
4052	else
4053	RTStrCopy(szModel, sizeof(szModel), pszProduct);
4054	}
4055	}
4056	}
4057	try
4058	{
4059	aDriveList.push_back(std::pair<com::Utf8Str, com::Utf8Str>(szPhysicalDrive, szModel));
4060	}
4061	catch (std::bad_alloc &)
4062	{
4063	hrc = setError(E_OUTOFMEMORY, tr("Out of memory"));
4064	break;
4065	}
4066	}
4067	}
4068	if (FAILED(hrc))
4069	aDriveList.clear();
4070	RTMemTmpFree(pDirEntry);
4071	RTVfsDirRelease(hVfsDir);
4072	return hrc;
4073	}
4074	#endif
4075
4076	/**
4077	* @throws nothing
4078	*/
4079	HRESULT Host::i_getDrivesPathsList(std::list<std::pair<com::Utf8Str, com::Utf8Str> > &aDriveList) RT_NOEXCEPT
4080	{
4081	#ifdef RT_OS_WINDOWS
4082	return i_getFixedDrivesFromGlobalNamespace(aDriveList);
4083
4084	#elif defined(RT_OS_DARWIN)
4085	/*
4086	* Get the list of fixed drives from iokit.cpp and transfer it to aDriveList.
4087	*/
4088	PDARWINFIXEDDRIVE pDrives = DarwinGetFixedDrives();
4089	HRESULT hrc;
4090	try
4091	{
4092	for (PDARWINFIXEDDRIVE pCurDrv = pDrives; pCurDrv; pCurDrv = pCurDrv->pNext)
4093	aDriveList.push_back(std::pair<com::Utf8Str, com::Utf8Str>(pCurDrv->szName, pCurDrv->pszModel));
4094	hrc = S_OK;
4095	}
4096	catch (std::bad_alloc &)
4097	{
4098	aDriveList.clear();
4099	hrc = E_OUTOFMEMORY;
4100	}
4101
4102	while (pDrives)
4103	{
4104	PDARWINFIXEDDRIVE pFreeMe = pDrives;
4105	pDrives = pDrives->pNext;
4106	ASMCompilerBarrier();
4107	RTMemFree(pFreeMe);
4108	}
4109	return hrc;
4110
4111	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
4112	/*
4113	* The list of fixed drives is kept in the VBoxMainDriveInfo instance, so
4114	* update it and tranfer the info to aDriveList.
4115	*
4116	* This obviously requires us to write lock the object!
4117	*/
4118	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
4119	int vrc = m->hostDrives.updateFixedDrives(); /* nothrow */
4120	if (RT_FAILURE(vrc))
4121	return setErrorBoth(E_FAIL, vrc, tr("Failed to update fixed drive list (%Rrc)"), vrc);
4122
4123	try
4124	{
4125	for (DriveInfoList::const_iterator it = m->hostDrives.FixedDriveBegin(); it != m->hostDrives.FixedDriveEnd(); ++it)
4126	aDriveList.push_back(std::pair<com::Utf8Str, com::Utf8Str>(it->mDevice, it->mDescription));
4127	}
4128	catch (std::bad_alloc &)
4129	{
4130	aDriveList.clear();
4131	return E_OUTOFMEMORY;
4132	}
4133	return S_OK;
4134
4135	#elif defined(RT_OS_SOLARIS)
4136	/*
4137	* We can get the info from HAL, if not present/working we'll get by
4138	* walking the device tree.
4139	*/
4140	# ifdef VBOX_USE_LIBHAL
4141	HRESULT hrc = i_getFixedDrivesFromHal(aDriveList);
4142	if (hrc != S_FALSE)
4143	return hrc;
4144	aDriveList.clear(); /* just in case */
4145	# endif
4146	return i_getFixedDrivesFromDevTree(aDriveList);
4147
4148	#else
4149	/* PORTME */
4150	RT_NOREF(aDriveList);
4151	return E_NOTIMPL;
4152	#endif
4153	}
4154
4155	/* 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@ 99771

Download in other formats: