VirtualBox

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

Last change on this file since 25310 was 25310, checked in by vboxsync, 14 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use