VirtualBox

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

Last change on this file since 14953 was 14953, checked in by vboxsync, 16 years ago

HostImpl: Fix for TAP driver recognition.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 123.5 KB
Line 
1/* $Id: HostImpl.cpp 14953 2008-12-03 15:47:50Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation: Host
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#define __STDC_LIMIT_MACROS
23#define __STDC_CONSTANT_MACROS
24
25#ifdef RT_OS_LINUX
26# include <sys/types.h>
27# include <sys/stat.h>
28# include <unistd.h>
29# include <sys/ioctl.h>
30# include <fcntl.h>
31# include <mntent.h>
32/* bird: This is a hack to work around conflicts between these linux kernel headers
33 * and the GLIBC tcpip headers. They have different declarations of the 4
34 * standard byte order functions. */
35# define _LINUX_BYTEORDER_GENERIC_H
36# include <linux/cdrom.h>
37# ifdef VBOX_WITH_LIBHAL
38# include <libhal.h>
39/* These are defined by libhal.h and by VBox header files. */
40# undef TRUE
41# undef FALSE
42# endif
43# include <errno.h>
44# include <net/if.h>
45# include <net/if_arp.h>
46#endif /* RT_OS_LINUX */
47
48#ifdef RT_OS_SOLARIS
49# include <fcntl.h>
50# include <unistd.h>
51# include <stropts.h>
52# include <errno.h>
53# include <limits.h>
54# include <stdio.h>
55# ifdef VBOX_SOLARIS_NSL_RESOLVED
56# include <libdevinfo.h>
57# endif
58# include <net/if.h>
59# include <sys/socket.h>
60# include <sys/sockio.h>
61# include <net/if_arp.h>
62# include <net/if.h>
63# include <sys/types.h>
64# include <sys/stat.h>
65# include <sys/cdio.h>
66# include <sys/dkio.h>
67# include <sys/mnttab.h>
68# include <sys/mntent.h>
69/* Dynamic loading of libhal on Solaris hosts */
70# ifdef VBOX_USE_LIBHAL
71# include "vbox-libhal.h"
72extern "C" char *getfullrawname(char *);
73# endif
74# include "solaris/DynLoadLibSolaris.h"
75#endif /* RT_OS_SOLARIS */
76
77#ifdef RT_OS_WINDOWS
78# define _WIN32_DCOM
79# include <windows.h>
80# include <shellapi.h>
81# define INITGUID
82# include <guiddef.h>
83# include <devguid.h>
84# include <objbase.h>
85# include <setupapi.h>
86# include <shlobj.h>
87# include <cfgmgr32.h>
88
89#endif /* RT_OS_WINDOWS */
90
91
92#include "HostImpl.h"
93#include "HostDVDDriveImpl.h"
94#include "HostFloppyDriveImpl.h"
95#include "HostNetworkInterfaceImpl.h"
96#ifdef VBOX_WITH_USB
97# include "HostUSBDeviceImpl.h"
98# include "USBDeviceFilterImpl.h"
99# include "USBProxyService.h"
100#endif
101#include "VirtualBoxImpl.h"
102#include "MachineImpl.h"
103#include "Logging.h"
104
105#ifdef RT_OS_DARWIN
106# include "darwin/iokit.h"
107#endif
108
109
110#include <VBox/usb.h>
111#include <VBox/x86.h>
112#include <VBox/err.h>
113#include <iprt/asm.h>
114#include <iprt/string.h>
115#include <iprt/mp.h>
116#include <iprt/time.h>
117#include <iprt/param.h>
118#include <iprt/env.h>
119#ifdef RT_OS_SOLARIS
120# include <iprt/path.h>
121# include <iprt/ctype.h>
122#endif
123
124#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
125# include <VBox/WinNetConfig.h>
126#endif /* #if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
127
128#include <stdio.h>
129
130#include <algorithm>
131
132
133
134// constructor / destructor
135/////////////////////////////////////////////////////////////////////////////
136
137HRESULT Host::FinalConstruct()
138{
139 return S_OK;
140}
141
142void Host::FinalRelease()
143{
144 if (isReady())
145 uninit();
146}
147
148// public initializer/uninitializer for internal purposes only
149/////////////////////////////////////////////////////////////////////////////
150
151/**
152 * Initializes the host object.
153 *
154 * @param aParent VirtualBox parent object.
155 */
156HRESULT Host::init (VirtualBox *aParent)
157{
158 LogFlowThisFunc (("isReady=%d\n", isReady()));
159
160 ComAssertRet (aParent, E_INVALIDARG);
161
162 AutoWriteLock alock (this);
163 ComAssertRet (!isReady(), E_FAIL);
164
165 mParent = aParent;
166
167#ifdef VBOX_WITH_USB
168 /*
169 * Create and initialize the USB Proxy Service.
170 */
171# if defined (RT_OS_DARWIN)
172 mUSBProxyService = new USBProxyServiceDarwin (this);
173# elif defined (RT_OS_LINUX)
174 mUSBProxyService = new USBProxyServiceLinux (this);
175# elif defined (RT_OS_OS2)
176 mUSBProxyService = new USBProxyServiceOs2 (this);
177# elif defined (RT_OS_SOLARIS)
178 mUSBProxyService = new USBProxyServiceSolaris (this);
179# elif defined (RT_OS_WINDOWS)
180 mUSBProxyService = new USBProxyServiceWindows (this);
181# else
182 mUSBProxyService = new USBProxyService (this);
183# endif
184 HRESULT hrc = mUSBProxyService->init();
185 AssertComRCReturn(hrc, hrc);
186#endif /* VBOX_WITH_USB */
187
188#ifdef VBOX_WITH_RESOURCE_USAGE_API
189 registerMetrics (aParent->performanceCollector());
190#endif /* VBOX_WITH_RESOURCE_USAGE_API */
191
192#if defined (RT_OS_WINDOWS)
193 mHostPowerService = new HostPowerServiceWin (mParent);
194#elif defined (RT_OS_DARWIN)
195 mHostPowerService = new HostPowerServiceDarwin (mParent);
196#else
197 mHostPowerService = new HostPowerService (mParent);
198#endif
199
200 /* Cache the features reported by GetProcessorFeature. */
201 fVTxAMDVSupported = false;
202 fLongModeSupported = false;
203 fPAESupported = false;
204
205 if (ASMHasCpuId())
206 {
207 uint32_t u32FeaturesECX;
208 uint32_t u32Dummy;
209 uint32_t u32FeaturesEDX;
210 uint32_t u32VendorEBX, u32VendorECX, u32VendorEDX, u32AMDFeatureEDX, u32AMDFeatureECX;
211
212 ASMCpuId (0, &u32Dummy, &u32VendorEBX, &u32VendorECX, &u32VendorEDX);
213 ASMCpuId (1, &u32Dummy, &u32Dummy, &u32FeaturesECX, &u32FeaturesEDX);
214 /* Query AMD features. */
215 ASMCpuId (0x80000001, &u32Dummy, &u32Dummy, &u32AMDFeatureECX, &u32AMDFeatureEDX);
216
217 fLongModeSupported = !!(u32AMDFeatureEDX & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE);
218 fPAESupported = !!(u32FeaturesEDX & X86_CPUID_FEATURE_EDX_PAE);
219
220 if ( u32VendorEBX == X86_CPUID_VENDOR_INTEL_EBX
221 && u32VendorECX == X86_CPUID_VENDOR_INTEL_ECX
222 && u32VendorEDX == X86_CPUID_VENDOR_INTEL_EDX
223 )
224 {
225 if ( (u32FeaturesECX & X86_CPUID_FEATURE_ECX_VMX)
226 && (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_MSR)
227 && (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_FXSR)
228 )
229 fVTxAMDVSupported = true;
230 }
231 else
232 if ( u32VendorEBX == X86_CPUID_VENDOR_AMD_EBX
233 && u32VendorECX == X86_CPUID_VENDOR_AMD_ECX
234 && u32VendorEDX == X86_CPUID_VENDOR_AMD_EDX
235 )
236 {
237 if ( (u32AMDFeatureECX & X86_CPUID_AMD_FEATURE_ECX_SVM)
238 && (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_MSR)
239 && (u32FeaturesEDX & X86_CPUID_FEATURE_EDX_FXSR)
240 )
241 fVTxAMDVSupported = true;
242 }
243 }
244
245 setReady(true);
246 return S_OK;
247}
248
249/**
250 * Uninitializes the host object and sets the ready flag to FALSE.
251 * Called either from FinalRelease() or by the parent when it gets destroyed.
252 */
253void Host::uninit()
254{
255 LogFlowThisFunc (("isReady=%d\n", isReady()));
256
257 AssertReturn (isReady(), (void) 0);
258
259#ifdef VBOX_WITH_RESOURCE_USAGE_API
260 unregisterMetrics (mParent->performanceCollector());
261#endif /* VBOX_WITH_RESOURCE_USAGE_API */
262
263#ifdef VBOX_WITH_USB
264 /* wait for USB proxy service to terminate before we uninit all USB
265 * devices */
266 LogFlowThisFunc (("Stopping USB proxy service...\n"));
267 delete mUSBProxyService;
268 mUSBProxyService = NULL;
269 LogFlowThisFunc (("Done stopping USB proxy service.\n"));
270#endif
271
272 delete mHostPowerService;
273
274 /* uninit all USB device filters still referenced by clients */
275 uninitDependentChildren();
276
277#ifdef VBOX_WITH_USB
278 mUSBDeviceFilters.clear();
279#endif
280
281 setReady (FALSE);
282}
283
284// IHost properties
285/////////////////////////////////////////////////////////////////////////////
286
287/**
288 * Returns a list of host DVD drives.
289 *
290 * @returns COM status code
291 * @param drives address of result pointer
292 */
293STDMETHODIMP Host::COMGETTER(DVDDrives) (IHostDVDDriveCollection **drives)
294{
295 if (!drives)
296 return E_POINTER;
297 AutoWriteLock alock (this);
298 CHECK_READY();
299 std::list <ComObjPtr <HostDVDDrive> > list;
300
301#if defined(RT_OS_WINDOWS)
302 int sz = GetLogicalDriveStrings(0, NULL);
303 TCHAR *hostDrives = new TCHAR[sz+1];
304 GetLogicalDriveStrings(sz, hostDrives);
305 wchar_t driveName[3] = { '?', ':', '\0' };
306 TCHAR *p = hostDrives;
307 do
308 {
309 if (GetDriveType(p) == DRIVE_CDROM)
310 {
311 driveName[0] = *p;
312 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
313 hostDVDDriveObj.createObject();
314 hostDVDDriveObj->init (Bstr (driveName));
315 list.push_back (hostDVDDriveObj);
316 }
317 p += _tcslen(p) + 1;
318 }
319 while (*p);
320 delete[] hostDrives;
321
322#elif defined(RT_OS_SOLARIS)
323# ifdef VBOX_USE_LIBHAL
324 if (!getDVDInfoFromHal(list))
325# endif
326 // Not all Solaris versions ship with libhal.
327 // So use a fallback approach similar to Linux.
328 {
329 if (RTEnvGet("VBOX_CDROM"))
330 {
331 char *cdromEnv = strdup(RTEnvGet("VBOX_CDROM"));
332 char *cdromDrive;
333 cdromDrive = strtok(cdromEnv, ":"); /** @todo use strtok_r. */
334 while (cdromDrive)
335 {
336 if (validateDevice(cdromDrive, true))
337 {
338 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
339 hostDVDDriveObj.createObject();
340 hostDVDDriveObj->init (Bstr (cdromDrive));
341 list.push_back (hostDVDDriveObj);
342 }
343 cdromDrive = strtok(NULL, ":");
344 }
345 free(cdromEnv);
346 }
347 else
348 {
349 // this might work on Solaris version older than Nevada.
350 if (validateDevice("/cdrom/cdrom0", true))
351 {
352 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
353 hostDVDDriveObj.createObject();
354 hostDVDDriveObj->init (Bstr ("cdrom/cdrom0"));
355 list.push_back (hostDVDDriveObj);
356 }
357
358 // check the mounted drives
359 parseMountTable(MNTTAB, list);
360 }
361 }
362
363#elif defined(RT_OS_LINUX)
364#ifdef VBOX_WITH_LIBHAL
365 if (!getDVDInfoFromHal(list)) /* Playing with #defines in this way is nasty, I know. */
366#endif /* VBOX_WITH_LIBHAL defined */
367 // On Linux without hal, the situation is much more complex. We will take a
368 // heuristical approach and also allow the user to specify a list of host
369 // CDROMs using an environment variable.
370 // The general strategy is to try some known device names and see of they
371 // exist. At last, we'll enumerate the /etc/fstab file (luckily there's an
372 // API to parse it) for CDROM devices. Ok, let's start!
373
374 {
375 if (RTEnvGet("VBOX_CDROM"))
376 {
377 char *cdromEnv = strdupa(RTEnvGet("VBOX_CDROM"));
378 char *cdromDrive;
379 cdromDrive = strtok(cdromEnv, ":"); /** @todo use strtok_r */
380 while (cdromDrive)
381 {
382 if (validateDevice(cdromDrive, true))
383 {
384 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
385 hostDVDDriveObj.createObject();
386 hostDVDDriveObj->init (Bstr (cdromDrive));
387 list.push_back (hostDVDDriveObj);
388 }
389 cdromDrive = strtok(NULL, ":");
390 }
391 }
392 else
393 {
394 // this is a good guess usually
395 if (validateDevice("/dev/cdrom", true))
396 {
397 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
398 hostDVDDriveObj.createObject();
399 hostDVDDriveObj->init (Bstr ("/dev/cdrom"));
400 list.push_back (hostDVDDriveObj);
401 }
402
403 // check the mounted drives
404 parseMountTable((char*)"/etc/mtab", list);
405
406 // check the drives that can be mounted
407 parseMountTable((char*)"/etc/fstab", list);
408 }
409 }
410#elif defined(RT_OS_DARWIN)
411 PDARWINDVD cur = DarwinGetDVDDrives();
412 while (cur)
413 {
414 ComObjPtr<HostDVDDrive> hostDVDDriveObj;
415 hostDVDDriveObj.createObject();
416 hostDVDDriveObj->init(Bstr(cur->szName));
417 list.push_back(hostDVDDriveObj);
418
419 /* next */
420 void *freeMe = cur;
421 cur = cur->pNext;
422 RTMemFree(freeMe);
423 }
424
425#else
426 /* PORTME */
427#endif
428
429 ComObjPtr<HostDVDDriveCollection> collection;
430 collection.createObject();
431 collection->init (list);
432 collection.queryInterfaceTo(drives);
433 return S_OK;
434}
435
436/**
437 * Returns a list of host floppy drives.
438 *
439 * @returns COM status code
440 * @param drives address of result pointer
441 */
442STDMETHODIMP Host::COMGETTER(FloppyDrives) (IHostFloppyDriveCollection **drives)
443{
444 if (!drives)
445 return E_POINTER;
446 AutoWriteLock alock (this);
447 CHECK_READY();
448
449 std::list <ComObjPtr <HostFloppyDrive> > list;
450
451#ifdef RT_OS_WINDOWS
452 int sz = GetLogicalDriveStrings(0, NULL);
453 TCHAR *hostDrives = new TCHAR[sz+1];
454 GetLogicalDriveStrings(sz, hostDrives);
455 wchar_t driveName[3] = { '?', ':', '\0' };
456 TCHAR *p = hostDrives;
457 do
458 {
459 if (GetDriveType(p) == DRIVE_REMOVABLE)
460 {
461 driveName[0] = *p;
462 ComObjPtr <HostFloppyDrive> hostFloppyDriveObj;
463 hostFloppyDriveObj.createObject();
464 hostFloppyDriveObj->init (Bstr (driveName));
465 list.push_back (hostFloppyDriveObj);
466 }
467 p += _tcslen(p) + 1;
468 }
469 while (*p);
470 delete[] hostDrives;
471#elif defined(RT_OS_LINUX)
472#ifdef VBOX_WITH_LIBHAL
473 if (!getFloppyInfoFromHal(list)) /* Playing with #defines in this way is nasty, I know. */
474#endif /* VBOX_WITH_LIBHAL defined */
475 // As with the CDROMs, on Linux we have to take a multi-level approach
476 // involving parsing the mount tables. As this is not bulletproof, we'll
477 // give the user the chance to override the detection by an environment
478 // variable and skip the detection.
479
480 {
481 if (RTEnvGet("VBOX_FLOPPY"))
482 {
483 char *floppyEnv = strdupa(RTEnvGet("VBOX_FLOPPY"));
484 char *floppyDrive;
485 floppyDrive = strtok(floppyEnv, ":");
486 while (floppyDrive)
487 {
488 // check if this is an acceptable device
489 if (validateDevice(floppyDrive, false))
490 {
491 ComObjPtr <HostFloppyDrive> hostFloppyDriveObj;
492 hostFloppyDriveObj.createObject();
493 hostFloppyDriveObj->init (Bstr (floppyDrive));
494 list.push_back (hostFloppyDriveObj);
495 }
496 floppyDrive = strtok(NULL, ":");
497 }
498 }
499 else
500 {
501 // we assume that a floppy is always /dev/fd[x] with x from 0 to 7
502 char devName[10];
503 for (int i = 0; i <= 7; i++)
504 {
505 sprintf(devName, "/dev/fd%d", i);
506 if (validateDevice(devName, false))
507 {
508 ComObjPtr <HostFloppyDrive> hostFloppyDriveObj;
509 hostFloppyDriveObj.createObject();
510 hostFloppyDriveObj->init (Bstr (devName));
511 list.push_back (hostFloppyDriveObj);
512 }
513 }
514 }
515 }
516#else
517 /* PORTME */
518#endif
519
520 ComObjPtr<HostFloppyDriveCollection> collection;
521 collection.createObject();
522 collection->init (list);
523 collection.queryInterfaceTo(drives);
524 return S_OK;
525}
526
527#ifdef RT_OS_WINDOWS
528/**
529 * Windows helper function for Host::COMGETTER(NetworkInterfaces).
530 *
531 * @returns true / false.
532 *
533 * @param guid The GUID.
534 */
535static bool IsTAPDevice(const char *guid)
536{
537 HKEY hNetcard;
538 LONG status;
539 DWORD len;
540 int i = 0;
541 bool ret = false;
542
543 status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}", 0, KEY_READ, &hNetcard);
544 if (status != ERROR_SUCCESS)
545 return false;
546
547 for (;;)
548 {
549 char szEnumName[256];
550 char szNetCfgInstanceId[256];
551 DWORD dwKeyType;
552 HKEY hNetCardGUID;
553
554 len = sizeof(szEnumName);
555 status = RegEnumKeyExA(hNetcard, i, szEnumName, &len, NULL, NULL, NULL, NULL);
556 if (status != ERROR_SUCCESS)
557 break;
558
559 status = RegOpenKeyExA(hNetcard, szEnumName, 0, KEY_READ, &hNetCardGUID);
560 if (status == ERROR_SUCCESS)
561 {
562 len = sizeof(szNetCfgInstanceId);
563 status = RegQueryValueExA(hNetCardGUID, "NetCfgInstanceId", NULL, &dwKeyType, (LPBYTE)szNetCfgInstanceId, &len);
564 if (status == ERROR_SUCCESS && dwKeyType == REG_SZ)
565 {
566 char szNetProductName[256];
567 char szNetProviderName[256];
568
569 szNetProductName[0] = 0;
570 len = sizeof(szNetProductName);
571 status = RegQueryValueExA(hNetCardGUID, "ProductName", NULL, &dwKeyType, (LPBYTE)szNetProductName, &len);
572
573 szNetProviderName[0] = 0;
574 len = sizeof(szNetProviderName);
575 status = RegQueryValueExA(hNetCardGUID, "ProviderName", NULL, &dwKeyType, (LPBYTE)szNetProviderName, &len);
576
577 if ( !strcmp(szNetCfgInstanceId, guid)
578 && !strcmp(szNetProductName, "VirtualBox TAP Adapter")
579 && ( (!strcmp(szNetProviderName, "innotek GmbH"))
580 || (!strcmp(szNetProviderName, "Sun Microsystems, Inc."))))
581 {
582 ret = true;
583 RegCloseKey(hNetCardGUID);
584 break;
585 }
586 }
587 RegCloseKey(hNetCardGUID);
588 }
589 ++i;
590 }
591
592 RegCloseKey(hNetcard);
593 return ret;
594}
595#endif /* RT_OS_WINDOWS */
596
597#ifdef RT_OS_SOLARIS
598static void vboxSolarisAddHostIface(char *pszIface, int Instance, PCRTMAC pMac, void *pvHostNetworkInterfaceList)
599{
600 std::list<ComObjPtr <HostNetworkInterface> > *pList = (std::list<ComObjPtr <HostNetworkInterface> > *)pvHostNetworkInterfaceList;
601 Assert(pList);
602
603 typedef std::map <std::string, std::string> NICMap;
604 typedef std::pair <std::string, std::string> NICPair;
605 static NICMap SolarisNICMap;
606 if (SolarisNICMap.empty())
607 {
608 SolarisNICMap.insert(NICPair("afe", "ADMtek Centaur/Comet Fast Ethernet"));
609 SolarisNICMap.insert(NICPair("aggr", "Link Aggregation Interface"));
610 SolarisNICMap.insert(NICPair("bge", "Broadcom BCM57xx Gigabit Ethernet"));
611 SolarisNICMap.insert(NICPair("ce", "Cassini Gigabit Ethernet"));
612 SolarisNICMap.insert(NICPair("chxge", "Chelsio Ethernet"));
613 SolarisNICMap.insert(NICPair("dmfe", "Davicom Fast Ethernet"));
614 SolarisNICMap.insert(NICPair("dnet", "DEC 21040/41 21140 Ethernet"));
615 SolarisNICMap.insert(NICPair("e1000", "Intel PRO/1000 Gigabit Ethernet"));
616 SolarisNICMap.insert(NICPair("e1000g", "Intel PRO/1000 Gigabit Ethernet"));
617 SolarisNICMap.insert(NICPair("elx", "3COM EtherLink III Ethernet"));
618 SolarisNICMap.insert(NICPair("elxl", "3COM Ethernet"));
619 SolarisNICMap.insert(NICPair("eri", "eri Fast Ethernet"));
620 SolarisNICMap.insert(NICPair("ge", "GEM Gigabit Ethernet"));
621 SolarisNICMap.insert(NICPair("hme", "SUNW,hme Fast-Ethernet"));
622 SolarisNICMap.insert(NICPair("ipge", "PCI-E Gigabit Ethernet"));
623 SolarisNICMap.insert(NICPair("iprb", "Intel 82557/58/59 Ethernet"));
624 SolarisNICMap.insert(NICPair("mxfe", "Macronix 98715 Fast Ethernet"));
625 SolarisNICMap.insert(NICPair("nge", "Nvidia Gigabit Ethernet"));
626 SolarisNICMap.insert(NICPair("pcelx", "3COM EtherLink III PCMCIA Ethernet"));
627 SolarisNICMap.insert(NICPair("pcn", "AMD PCnet Ethernet"));
628 SolarisNICMap.insert(NICPair("qfe", "SUNW,qfe Quad Fast-Ethernet"));
629 SolarisNICMap.insert(NICPair("rge", "Realtek Gigabit Ethernet"));
630 SolarisNICMap.insert(NICPair("rtls", "Realtek 8139 Fast Ethernet"));
631 SolarisNICMap.insert(NICPair("skge", "SksKonnect Gigabit Ethernet"));
632 SolarisNICMap.insert(NICPair("spwr", "SMC EtherPower II 10/100 (9432) Ethernet"));
633 SolarisNICMap.insert(NICPair("vnic", "Virtual Network Interface Ethernet"));
634 SolarisNICMap.insert(NICPair("xge", "Neterior Xframe Gigabit Ethernet"));
635 SolarisNICMap.insert(NICPair("xge", "Neterior Xframe 10Gigabit Ethernet"));
636 }
637
638 /*
639 * Try picking up description from our NIC map.
640 */
641 char szNICInstance[128];
642 RTStrPrintf(szNICInstance, sizeof(szNICInstance), "%s%d", pszIface, Instance);
643 char szNICDesc[256];
644 std::string Description = SolarisNICMap[pszIface];
645 if (Description != "")
646 RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - %s", szNICInstance, Description.c_str());
647 else
648 RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - Ethernet", szNICInstance);
649
650 /*
651 * Construct UUID with interface name and the MAC address if available.
652 */
653 RTUUID Uuid;
654 RTUuidClear(&Uuid);
655 memcpy(&Uuid, szNICInstance, RT_MIN(strlen(szNICInstance), sizeof(Uuid)));
656 Uuid.Gen.u8ClockSeqHiAndReserved = (Uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80;
657 Uuid.Gen.u16TimeHiAndVersion = (Uuid.Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000;
658 if (pMac)
659 {
660 Uuid.Gen.au8Node[0] = pMac->au8[0];
661 Uuid.Gen.au8Node[1] = pMac->au8[1];
662 Uuid.Gen.au8Node[2] = pMac->au8[2];
663 Uuid.Gen.au8Node[3] = pMac->au8[3];
664 Uuid.Gen.au8Node[4] = pMac->au8[4];
665 Uuid.Gen.au8Node[5] = pMac->au8[5];
666 }
667
668 ComObjPtr<HostNetworkInterface> IfObj;
669 IfObj.createObject();
670 if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), Guid(Uuid))))
671 pList->push_back(IfObj);
672}
673
674static boolean_t vboxSolarisAddLinkHostIface(const char *pszIface, void *pvHostNetworkInterfaceList)
675{
676 /*
677 * Clip off the zone instance number from the interface name (if any).
678 */
679 char szIfaceName[128];
680 strcpy(szIfaceName, pszIface);
681 char *pszColon = (char *)memchr(szIfaceName, ':', sizeof(szIfaceName));
682 if (pszColon)
683 *pszColon = '\0';
684
685 /*
686 * Get the instance number from the interface name, then clip it off.
687 */
688 int cbInstance = 0;
689 int cbIface = strlen(szIfaceName);
690 const char *pszEnd = pszIface + cbIface - 1;
691 for (int i = 0; i < cbIface - 1; i++)
692 {
693 if (!RT_C_IS_DIGIT(*pszEnd))
694 break;
695 cbInstance++;
696 pszEnd--;
697 }
698
699 int Instance = atoi(pszEnd + 1);
700 strncpy(szIfaceName, pszIface, cbIface - cbInstance);
701 szIfaceName[cbIface - cbInstance] = '\0';
702
703 /*
704 * Add the interface.
705 */
706 vboxSolarisAddHostIface(szIfaceName, Instance, NULL, pvHostNetworkInterfaceList);
707
708 /*
709 * Continue walking...
710 */
711 return _B_FALSE;
712}
713
714static bool vboxSolarisSortNICList(const ComObjPtr <HostNetworkInterface> Iface1, const ComObjPtr <HostNetworkInterface> Iface2)
715{
716 Bstr Iface1Str;
717 (*Iface1).COMGETTER(Name) (Iface1Str.asOutParam());
718
719 Bstr Iface2Str;
720 (*Iface2).COMGETTER(Name) (Iface2Str.asOutParam());
721
722 return Iface1Str < Iface2Str;
723}
724
725static bool vboxSolarisSameNIC(const ComObjPtr <HostNetworkInterface> Iface1, const ComObjPtr <HostNetworkInterface> Iface2)
726{
727 Bstr Iface1Str;
728 (*Iface1).COMGETTER(Name) (Iface1Str.asOutParam());
729
730 Bstr Iface2Str;
731 (*Iface2).COMGETTER(Name) (Iface2Str.asOutParam());
732
733 return (Iface1Str == Iface2Str);
734}
735
736# ifdef VBOX_SOLARIS_NSL_RESOLVED
737static int vboxSolarisAddPhysHostIface(di_node_t Node, di_minor_t Minor, void *pvHostNetworkInterfaceList)
738{
739 /*
740 * Skip aggregations.
741 */
742 if (!strcmp(di_driver_name(Node), "aggr"))
743 return DI_WALK_CONTINUE;
744
745 /*
746 * Skip softmacs.
747 */
748 if (!strcmp(di_driver_name(Node), "softmac"))
749 return DI_WALK_CONTINUE;
750
751 vboxSolarisAddHostIface(di_driver_name(Node), di_instance(Node), NULL, pvHostNetworkInterfaceList);
752 return DI_WALK_CONTINUE;
753}
754# endif /* VBOX_SOLARIS_NSL_RESOLVED */
755
756#endif
757
758#if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT)
759# define VBOX_APP_NAME L"VirtualBox"
760
761static int vboxNetWinAddComponent(std::list <ComObjPtr <HostNetworkInterface> > * pPist, INetCfgComponent * pncc)
762{
763 LPWSTR lpszName;
764 GUID IfGuid;
765 HRESULT hr;
766 int rc = VERR_GENERAL_FAILURE;
767
768 hr = pncc->GetDisplayName( &lpszName );
769 Assert(hr == S_OK);
770 if(hr == S_OK)
771 {
772 size_t cUnicodeName = wcslen(lpszName) + 1;
773 size_t uniLen = (cUnicodeName * 2 + sizeof (OLECHAR) - 1) / sizeof (OLECHAR);
774 Bstr name (uniLen + 1 /* extra zero */);
775 wcscpy((wchar_t *) name.mutableRaw(), lpszName);
776
777 hr = pncc->GetInstanceGuid(&IfGuid);
778 Assert(hr == S_OK);
779 if (hr == S_OK)
780 {
781 /* create a new object and add it to the list */
782 ComObjPtr <HostNetworkInterface> iface;
783 iface.createObject();
784 /* remove the curly bracket at the end */
785 if (SUCCEEDED (iface->init (name, Guid (IfGuid))))
786 {
787 pPist->push_back (iface);
788 rc = VINF_SUCCESS;
789 }
790 else
791 {
792 Assert(0);
793 }
794 }
795 CoTaskMemFree(lpszName);
796 }
797
798 return rc;
799}
800
801#endif /* #if defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT) */
802
803/**
804 * Returns a list of host network interfaces.
805 *
806 * @returns COM status code
807 * @param drives address of result pointer
808 */
809STDMETHODIMP Host::COMGETTER(NetworkInterfaces) (IHostNetworkInterfaceCollection **networkInterfaces)
810{
811#if defined(RT_OS_WINDOWS) || defined(VBOX_WITH_NETFLT) /*|| defined(RT_OS_OS2)*/
812 if (!networkInterfaces)
813 return E_POINTER;
814 AutoWriteLock alock (this);
815 CHECK_READY();
816
817 std::list <ComObjPtr <HostNetworkInterface> > list;
818
819# if defined(RT_OS_DARWIN)
820 PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
821 while (pEtherNICs)
822 {
823 ComObjPtr<HostNetworkInterface> IfObj;
824 IfObj.createObject();
825 if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), Guid(pEtherNICs->Uuid))))
826 list.push_back(IfObj);
827
828 /* next, free current */
829 void *pvFree = pEtherNICs;
830 pEtherNICs = pEtherNICs->pNext;
831 RTMemFree(pvFree);
832 }
833
834# elif defined(RT_OS_SOLARIS)
835
836# ifdef VBOX_SOLARIS_NSL_RESOLVED
837
838 /*
839 * Use libdevinfo for determining all physical interfaces.
840 */
841 di_node_t Root;
842 Root = di_init("/", DINFOCACHE);
843 if (Root != DI_NODE_NIL)
844 {
845 di_walk_minor(Root, DDI_NT_NET, 0, &list, vboxSolarisAddPhysHostIface);
846 di_fini(Root);
847 }
848
849 /*
850 * Use libdlpi for determining all DLPI interfaces.
851 */
852 if (VBoxSolarisLibDlpiFound())
853 g_pfnLibDlpiWalk(vboxSolarisAddLinkHostIface, &list, 0);
854
855# endif /* VBOX_SOLARIS_NSL_RESOLVED */
856
857 /*
858 * This gets only the list of all plumbed logical interfaces.
859 * This is needed for zones which cannot access the device tree
860 * and in this case we just let them use the list of plumbed interfaces
861 * on the zone.
862 */
863 int Sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
864 if (Sock > 0)
865 {
866 struct lifnum IfNum;
867 memset(&IfNum, 0, sizeof(IfNum));
868 IfNum.lifn_family = AF_INET;
869 int rc = ioctl(Sock, SIOCGLIFNUM, &IfNum);
870 if (!rc)
871 {
872 struct lifreq Ifaces[24];
873 struct lifconf IfConfig;
874 memset(&IfConfig, 0, sizeof(IfConfig));
875 IfConfig.lifc_family = AF_INET;
876 IfConfig.lifc_len = sizeof(Ifaces);
877 IfConfig.lifc_buf = (caddr_t)&(Ifaces[0]);
878 rc = ioctl(Sock, SIOCGLIFCONF, &IfConfig);
879 if (!rc)
880 {
881 for (int i = 0; i < IfNum.lifn_count; i++)
882 {
883 /*
884 * Skip loopback interfaces.
885 */
886 if (!strncmp(Ifaces[i].lifr_name, "lo", 2))
887 continue;
888
889#if 0
890 rc = ioctl(Sock, SIOCGLIFADDR, &(Ifaces[i]));
891 if (!rc)
892 {
893 RTMAC Mac;
894 struct arpreq ArpReq;
895 memcpy(&ArpReq.arp_pa, &Ifaces[i].lifr_addr, sizeof(struct sockaddr_in));
896
897 /*
898 * We might fail if the interface has not been assigned an IP address.
899 * That doesn't matter; as long as it's plumbed we can pick it up.
900 * But, if it has not acquired an IP address we cannot obtain it's MAC
901 * address this way, so we just use all zeros there.
902 */
903 rc = ioctl(Sock, SIOCGARP, &ArpReq);
904 if (!rc)
905 memcpy(&Mac, ArpReq.arp_ha.sa_data, sizeof(RTMAC));
906 else
907 memset(&Mac, 0, sizeof(Mac));
908
909 char szNICDesc[LIFNAMSIZ + 256];
910 char *pszIface = Ifaces[i].lifr_name;
911 strcpy(szNICDesc, pszIface);
912
913 vboxSolarisAddLinkHostIface(pszIface, &list);
914 }
915#endif
916
917 char *pszIface = Ifaces[i].lifr_name;
918 vboxSolarisAddLinkHostIface(pszIface, &list);
919 }
920 }
921 }
922 close(Sock);
923 }
924
925 /*
926 * Weed out duplicates caused by dlpi_walk inconsistencies across Nevadas.
927 */
928 list.sort(vboxSolarisSortNICList);
929 list.unique(vboxSolarisSameNIC);
930
931# elif defined RT_OS_WINDOWS
932# ifndef VBOX_WITH_NETFLT
933 static const char *NetworkKey = "SYSTEM\\CurrentControlSet\\Control\\Network\\"
934 "{4D36E972-E325-11CE-BFC1-08002BE10318}";
935 HKEY hCtrlNet;
936 LONG status;
937 DWORD len;
938 status = RegOpenKeyExA (HKEY_LOCAL_MACHINE, NetworkKey, 0, KEY_READ, &hCtrlNet);
939 if (status != ERROR_SUCCESS)
940 return setError (E_FAIL, tr("Could not open registry key \"%s\""), NetworkKey);
941
942 for (int i = 0;; ++ i)
943 {
944 char szNetworkGUID [256];
945 HKEY hConnection;
946 char szNetworkConnection [256];
947
948 len = sizeof (szNetworkGUID);
949 status = RegEnumKeyExA (hCtrlNet, i, szNetworkGUID, &len, NULL, NULL, NULL, NULL);
950 if (status != ERROR_SUCCESS)
951 break;
952
953 if (!IsTAPDevice(szNetworkGUID))
954 continue;
955
956 RTStrPrintf (szNetworkConnection, sizeof (szNetworkConnection),
957 "%s\\Connection", szNetworkGUID);
958 status = RegOpenKeyExA (hCtrlNet, szNetworkConnection, 0, KEY_READ, &hConnection);
959 if (status == ERROR_SUCCESS)
960 {
961 DWORD dwKeyType;
962 status = RegQueryValueExW (hConnection, TEXT("Name"), NULL,
963 &dwKeyType, NULL, &len);
964 if (status == ERROR_SUCCESS && dwKeyType == REG_SZ)
965 {
966 size_t uniLen = (len + sizeof (OLECHAR) - 1) / sizeof (OLECHAR);
967 Bstr name (uniLen + 1 /* extra zero */);
968 status = RegQueryValueExW (hConnection, TEXT("Name"), NULL,
969 &dwKeyType, (LPBYTE) name.mutableRaw(), &len);
970 if (status == ERROR_SUCCESS)
971 {
972 RTLogPrintf("Connection name %ls\n", name.mutableRaw());
973 /* put a trailing zero, just in case (see MSDN) */
974 name.mutableRaw() [uniLen] = 0;
975 /* create a new object and add it to the list */
976 ComObjPtr <HostNetworkInterface> iface;
977 iface.createObject();
978 /* remove the curly bracket at the end */
979 szNetworkGUID [strlen(szNetworkGUID) - 1] = '\0';
980 if (SUCCEEDED (iface->init (name, Guid (szNetworkGUID + 1))))
981 list.push_back (iface);
982 }
983 }
984 RegCloseKey (hConnection);
985 }
986 }
987 RegCloseKey (hCtrlNet);
988# else /* # if defined VBOX_WITH_NETFLT */
989 INetCfg *pNc;
990 INetCfgComponent *pMpNcc;
991 INetCfgComponent *pTcpIpNcc;
992 LPWSTR lpszApp;
993 HRESULT hr;
994 IEnumNetCfgBindingPath *pEnumBp;
995 INetCfgBindingPath *pBp;
996 IEnumNetCfgBindingInterface *pEnumBi;
997 INetCfgBindingInterface *pBi;
998
999 /* we are using the INetCfg API for getting the list of miniports */
1000 hr = VBoxNetCfgWinQueryINetCfg( FALSE,
1001 VBOX_APP_NAME,
1002 &pNc,
1003 &lpszApp );
1004 Assert(hr == S_OK);
1005 if(hr == S_OK)
1006 {
1007#ifdef VBOX_NETFLT_ONDEMAND_BIND
1008 /* for the protocol-based approach for now we just get all miniports the MS_TCPIP protocol binds to */
1009 hr = pNc->FindComponent(L"MS_TCPIP", &pTcpIpNcc);
1010#else
1011 /* for the filter-based approach we get all miniports our filter (sun_VBoxNetFlt)is bound to */
1012 hr = pNc->FindComponent(L"sun_VBoxNetFlt", &pTcpIpNcc);
1013# ifndef VBOX_WITH_HARDENING
1014 if(hr != S_OK)
1015 {
1016 /* TODO: try to install the netflt from here */
1017 }
1018# endif
1019
1020#endif
1021
1022 if(hr == S_OK)
1023 {
1024 hr = VBoxNetCfgWinGetBindingPathEnum(pTcpIpNcc, EBP_BELOW, &pEnumBp);
1025 Assert(hr == S_OK);
1026 if ( hr == S_OK )
1027 {
1028 hr = VBoxNetCfgWinGetFirstBindingPath(pEnumBp, &pBp);
1029 Assert(hr == S_OK || hr == S_FALSE);
1030 while( hr == S_OK )
1031 {
1032 /* S_OK == enabled, S_FALSE == disabled */
1033 if(pBp->IsEnabled() == S_OK)
1034 {
1035 hr = VBoxNetCfgWinGetBindingInterfaceEnum(pBp, &pEnumBi);
1036 Assert(hr == S_OK);
1037 if ( hr == S_OK )
1038 {
1039 hr = VBoxNetCfgWinGetFirstBindingInterface(pEnumBi, &pBi);
1040 Assert(hr == S_OK);
1041 while(hr == S_OK)
1042 {
1043 hr = pBi->GetLowerComponent( &pMpNcc );
1044 Assert(hr == S_OK);
1045 if(hr == S_OK)
1046 {
1047 vboxNetWinAddComponent(&list, pMpNcc);
1048 VBoxNetCfgWinReleaseRef( pMpNcc );
1049 }
1050 VBoxNetCfgWinReleaseRef(pBi);
1051
1052 hr = VBoxNetCfgWinGetNextBindingInterface(pEnumBi, &pBi);
1053 }
1054 VBoxNetCfgWinReleaseRef(pEnumBi);
1055 }
1056 }
1057 VBoxNetCfgWinReleaseRef(pBp);
1058
1059 hr = VBoxNetCfgWinGetNextBindingPath(pEnumBp, &pBp);
1060 }
1061 VBoxNetCfgWinReleaseRef(pEnumBp);
1062 }
1063 VBoxNetCfgWinReleaseRef(pTcpIpNcc);
1064 }
1065 else
1066 {
1067 LogRel(("failed to get the sun_VBoxNetFlt component, error (0x%x)", hr));
1068 }
1069
1070 VBoxNetCfgWinReleaseINetCfg(pNc, FALSE);
1071 }
1072# endif /* # if defined VBOX_WITH_NETFLT */
1073
1074
1075# elif defined RT_OS_LINUX
1076 int sock = socket(AF_INET, SOCK_DGRAM, 0);
1077 if (sock >= 0)
1078 {
1079 char pBuffer[2048];
1080 struct ifconf ifConf;
1081 ifConf.ifc_len = sizeof(pBuffer);
1082 ifConf.ifc_buf = pBuffer;
1083 if (ioctl(sock, SIOCGIFCONF, &ifConf) >= 0)
1084 {
1085 for (struct ifreq *pReq = ifConf.ifc_req; (char*)pReq < pBuffer + ifConf.ifc_len; pReq++)
1086 {
1087 if (ioctl(sock, SIOCGIFHWADDR, pReq) >= 0)
1088 {
1089 if (pReq->ifr_hwaddr.sa_family == ARPHRD_ETHER)
1090 {
1091 RTUUID uuid;
1092 Assert(sizeof(uuid) <= sizeof(*pReq));
1093 memcpy(&uuid, pReq, sizeof(uuid));
1094
1095 ComObjPtr<HostNetworkInterface> IfObj;
1096 IfObj.createObject();
1097 if (SUCCEEDED(IfObj->init(Bstr(pReq->ifr_name), Guid(uuid))))
1098 list.push_back(IfObj);
1099 }
1100 }
1101 }
1102 }
1103 close(sock);
1104 }
1105# endif /* RT_OS_LINUX */
1106
1107 ComObjPtr <HostNetworkInterfaceCollection> collection;
1108 collection.createObject();
1109 collection->init (list);
1110 collection.queryInterfaceTo (networkInterfaces);
1111 return S_OK;
1112
1113#else
1114 /* Not implemented / supported on this platform. */
1115 ReturnComNotImplemented();
1116#endif
1117}
1118
1119STDMETHODIMP Host::COMGETTER(USBDevices)(IHostUSBDeviceCollection **aUSBDevices)
1120{
1121#ifdef VBOX_WITH_USB
1122 if (!aUSBDevices)
1123 return E_POINTER;
1124
1125 AutoWriteLock alock (this);
1126 CHECK_READY();
1127
1128 MultiResult rc = checkUSBProxyService();
1129 CheckComRCReturnRC (rc);
1130
1131 return mUSBProxyService->getDeviceCollection (aUSBDevices);
1132
1133#else
1134 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1135 * extended error info to indicate that USB is simply not available
1136 * (w/o treting it as a failure), for example, as in OSE */
1137 ReturnComNotImplemented();
1138#endif
1139}
1140
1141STDMETHODIMP Host::COMGETTER(USBDeviceFilters) (IHostUSBDeviceFilterCollection **aUSBDeviceFilters)
1142{
1143#ifdef VBOX_WITH_USB
1144 if (!aUSBDeviceFilters)
1145 return E_POINTER;
1146
1147 AutoWriteLock alock (this);
1148 CHECK_READY();
1149
1150 MultiResult rc = checkUSBProxyService();
1151 CheckComRCReturnRC (rc);
1152
1153 ComObjPtr <HostUSBDeviceFilterCollection> collection;
1154 collection.createObject();
1155 collection->init (mUSBDeviceFilters);
1156 collection.queryInterfaceTo (aUSBDeviceFilters);
1157
1158 return rc;
1159#else
1160 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1161 * extended error info to indicate that USB is simply not available
1162 * (w/o treting it as a failure), for example, as in OSE */
1163 ReturnComNotImplemented();
1164#endif
1165}
1166
1167/**
1168 * Returns the number of installed logical processors
1169 *
1170 * @returns COM status code
1171 * @param count address of result variable
1172 */
1173STDMETHODIMP Host::COMGETTER(ProcessorCount)(ULONG *count)
1174{
1175 if (!count)
1176 return E_POINTER;
1177 AutoWriteLock alock (this);
1178 CHECK_READY();
1179 *count = RTMpGetPresentCount();
1180 return S_OK;
1181}
1182
1183/**
1184 * Returns the number of online logical processors
1185 *
1186 * @returns COM status code
1187 * @param count address of result variable
1188 */
1189STDMETHODIMP Host::COMGETTER(ProcessorOnlineCount)(ULONG *count)
1190{
1191 if (!count)
1192 return E_POINTER;
1193 AutoWriteLock alock (this);
1194 CHECK_READY();
1195 *count = RTMpGetOnlineCount();
1196 return S_OK;
1197}
1198
1199/**
1200 * Returns the (approximate) maximum speed of the given host CPU in MHz
1201 *
1202 * @returns COM status code
1203 * @param cpu id to get info for.
1204 * @param speed address of result variable, speed is 0 if unknown or cpuId is invalid.
1205 */
1206STDMETHODIMP Host::GetProcessorSpeed(ULONG aCpuId, ULONG *speed)
1207{
1208 if (!speed)
1209 return E_POINTER;
1210 AutoWriteLock alock (this);
1211 CHECK_READY();
1212 *speed = RTMpGetMaxFrequency(aCpuId);
1213 return S_OK;
1214}
1215/**
1216 * Returns a description string for the host CPU
1217 *
1218 * @returns COM status code
1219 * @param cpu id to get info for.
1220 * @param description address of result variable, NULL if known or cpuId is invalid.
1221 */
1222STDMETHODIMP Host::GetProcessorDescription(ULONG cpuId, BSTR *description)
1223{
1224 if (!description)
1225 return E_POINTER;
1226 AutoWriteLock alock (this);
1227 CHECK_READY();
1228 /** @todo */
1229 ReturnComNotImplemented();
1230}
1231
1232/**
1233 * Returns whether a host processor feature is supported or not
1234 *
1235 * @returns COM status code
1236 * @param Feature to query.
1237 * @param address of supported bool result variable
1238 */
1239STDMETHODIMP Host::GetProcessorFeature(ProcessorFeature_T feature, BOOL *supported)
1240{
1241 if (!supported)
1242 return E_POINTER;
1243 AutoWriteLock alock (this);
1244 CHECK_READY();
1245
1246 switch (feature)
1247 {
1248 case ProcessorFeature_HWVirtEx:
1249 *supported = fVTxAMDVSupported;
1250 break;
1251
1252 case ProcessorFeature_PAE:
1253 *supported = fPAESupported;
1254 break;
1255
1256 case ProcessorFeature_LongMode:
1257 *supported = fLongModeSupported;
1258 break;
1259
1260 default:
1261 ReturnComNotImplemented();
1262 }
1263 return S_OK;
1264}
1265
1266/**
1267 * Returns the amount of installed system memory in megabytes
1268 *
1269 * @returns COM status code
1270 * @param size address of result variable
1271 */
1272STDMETHODIMP Host::COMGETTER(MemorySize)(ULONG *size)
1273{
1274 if (!size)
1275 return E_POINTER;
1276 AutoWriteLock alock (this);
1277 CHECK_READY();
1278 /* @todo This is an ugly hack. There must be a function in IPRT for that. */
1279 pm::CollectorHAL *hal = pm::createHAL();
1280 if (!hal)
1281 return VERR_INTERNAL_ERROR;
1282 ULONG tmp;
1283 int rc = hal->getHostMemoryUsage(size, &tmp, &tmp);
1284 *size /= 1024;
1285 delete hal;
1286 return rc;
1287}
1288
1289/**
1290 * Returns the current system memory free space in megabytes
1291 *
1292 * @returns COM status code
1293 * @param available address of result variable
1294 */
1295STDMETHODIMP Host::COMGETTER(MemoryAvailable)(ULONG *available)
1296{
1297 if (!available)
1298 return E_POINTER;
1299 AutoWriteLock alock (this);
1300 CHECK_READY();
1301 /* @todo This is an ugly hack. There must be a function in IPRT for that. */
1302 pm::CollectorHAL *hal = pm::createHAL();
1303 if (!hal)
1304 return VERR_INTERNAL_ERROR;
1305 ULONG tmp;
1306 int rc = hal->getHostMemoryUsage(&tmp, &tmp, available);
1307 *available /= 1024;
1308 delete hal;
1309 return rc;
1310}
1311
1312/**
1313 * Returns the name string of the host operating system
1314 *
1315 * @returns COM status code
1316 * @param os address of result variable
1317 */
1318STDMETHODIMP Host::COMGETTER(OperatingSystem)(BSTR *os)
1319{
1320 if (!os)
1321 return E_POINTER;
1322 AutoWriteLock alock (this);
1323 CHECK_READY();
1324 /** @todo */
1325 ReturnComNotImplemented();
1326}
1327
1328/**
1329 * Returns the version string of the host operating system
1330 *
1331 * @returns COM status code
1332 * @param os address of result variable
1333 */
1334STDMETHODIMP Host::COMGETTER(OSVersion)(BSTR *version)
1335{
1336 if (!version)
1337 return E_POINTER;
1338 AutoWriteLock alock (this);
1339 CHECK_READY();
1340 /** @todo */
1341 ReturnComNotImplemented();
1342}
1343
1344/**
1345 * Returns the current host time in milliseconds since 1970-01-01 UTC.
1346 *
1347 * @returns COM status code
1348 * @param time address of result variable
1349 */
1350STDMETHODIMP Host::COMGETTER(UTCTime)(LONG64 *aUTCTime)
1351{
1352 if (!aUTCTime)
1353 return E_POINTER;
1354 AutoWriteLock alock (this);
1355 CHECK_READY();
1356 RTTIMESPEC now;
1357 *aUTCTime = RTTimeSpecGetMilli(RTTimeNow(&now));
1358 return S_OK;
1359}
1360
1361// IHost methods
1362////////////////////////////////////////////////////////////////////////////////
1363
1364#ifdef RT_OS_WINDOWS
1365
1366/**
1367 * Returns TRUE if the Windows version is 6.0 or greater (i.e. it's Vista and
1368 * later OSes) and it has the UAC (User Account Control) feature enabled.
1369 */
1370static BOOL IsUACEnabled()
1371{
1372 LONG rc = 0;
1373
1374 OSVERSIONINFOEX info;
1375 ZeroMemory (&info, sizeof (OSVERSIONINFOEX));
1376 info.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX);
1377 rc = GetVersionEx ((OSVERSIONINFO *) &info);
1378 AssertReturn (rc != 0, FALSE);
1379
1380 LogFlowFunc (("dwMajorVersion=%d, dwMinorVersion=%d\n",
1381 info.dwMajorVersion, info.dwMinorVersion));
1382
1383 /* we are interested only in Vista (and newer versions...). In all
1384 * earlier versions UAC is not present. */
1385 if (info.dwMajorVersion < 6)
1386 return FALSE;
1387
1388 /* the default EnableLUA value is 1 (Enabled) */
1389 DWORD dwEnableLUA = 1;
1390
1391 HKEY hKey;
1392 rc = RegOpenKeyExA (HKEY_LOCAL_MACHINE,
1393 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System",
1394 0, KEY_QUERY_VALUE, &hKey);
1395
1396 Assert (rc == ERROR_SUCCESS || rc == ERROR_PATH_NOT_FOUND);
1397 if (rc == ERROR_SUCCESS)
1398 {
1399
1400 DWORD cbEnableLUA = sizeof (dwEnableLUA);
1401 rc = RegQueryValueExA (hKey, "EnableLUA", NULL, NULL,
1402 (LPBYTE) &dwEnableLUA, &cbEnableLUA);
1403
1404 RegCloseKey (hKey);
1405
1406 Assert (rc == ERROR_SUCCESS || rc == ERROR_FILE_NOT_FOUND);
1407 }
1408
1409 LogFlowFunc (("rc=%d, dwEnableLUA=%d\n", rc, dwEnableLUA));
1410
1411 return dwEnableLUA == 1;
1412}
1413
1414struct NetworkInterfaceHelperClientData
1415{
1416 SVCHlpMsg::Code msgCode;
1417 /* for SVCHlpMsg::CreateHostNetworkInterface */
1418 Bstr name;
1419 ComObjPtr <HostNetworkInterface> iface;
1420 /* for SVCHlpMsg::RemoveHostNetworkInterface */
1421 Guid guid;
1422};
1423
1424STDMETHODIMP
1425Host::CreateHostNetworkInterface (INPTR BSTR aName,
1426 IHostNetworkInterface **aHostNetworkInterface,
1427 IProgress **aProgress)
1428{
1429 if (!aName)
1430 return E_INVALIDARG;
1431 if (!aHostNetworkInterface)
1432 return E_POINTER;
1433 if (!aProgress)
1434 return E_POINTER;
1435
1436 AutoWriteLock alock (this);
1437 CHECK_READY();
1438
1439 HRESULT rc = S_OK;
1440
1441 /* first check whether an interface with the given name already exists */
1442 {
1443 ComPtr <IHostNetworkInterfaceCollection> coll;
1444 rc = COMGETTER(NetworkInterfaces) (coll.asOutParam());
1445 CheckComRCReturnRC (rc);
1446 ComPtr <IHostNetworkInterface> iface;
1447 if (SUCCEEDED (coll->FindByName (aName, iface.asOutParam())))
1448 return setError (E_FAIL,
1449 tr ("Host network interface '%ls' already exists"), aName);
1450 }
1451
1452 /* create a progress object */
1453 ComObjPtr <Progress> progress;
1454 progress.createObject();
1455 rc = progress->init (mParent, static_cast <IHost *> (this),
1456 Bstr (tr ("Creating host network interface")),
1457 FALSE /* aCancelable */);
1458 CheckComRCReturnRC (rc);
1459 progress.queryInterfaceTo (aProgress);
1460
1461 /* create a new uninitialized host interface object */
1462 ComObjPtr <HostNetworkInterface> iface;
1463 iface.createObject();
1464 iface.queryInterfaceTo (aHostNetworkInterface);
1465
1466 /* create the networkInterfaceHelperClient() argument */
1467 std::auto_ptr <NetworkInterfaceHelperClientData>
1468 d (new NetworkInterfaceHelperClientData());
1469 AssertReturn (d.get(), E_OUTOFMEMORY);
1470
1471 d->msgCode = SVCHlpMsg::CreateHostNetworkInterface;
1472 d->name = aName;
1473 d->iface = iface;
1474
1475 rc = mParent->startSVCHelperClient (
1476 IsUACEnabled() == TRUE /* aPrivileged */,
1477 networkInterfaceHelperClient,
1478 static_cast <void *> (d.get()),
1479 progress);
1480
1481 if (SUCCEEDED (rc))
1482 {
1483 /* d is now owned by networkInterfaceHelperClient(), so release it */
1484 d.release();
1485 }
1486
1487 return rc;
1488}
1489
1490STDMETHODIMP
1491Host::RemoveHostNetworkInterface (INPTR GUIDPARAM aId,
1492 IHostNetworkInterface **aHostNetworkInterface,
1493 IProgress **aProgress)
1494{
1495 if (!aHostNetworkInterface)
1496 return E_POINTER;
1497 if (!aProgress)
1498 return E_POINTER;
1499
1500 AutoWriteLock alock (this);
1501 CHECK_READY();
1502
1503 HRESULT rc = S_OK;
1504
1505 /* first check whether an interface with the given name already exists */
1506 {
1507 ComPtr <IHostNetworkInterfaceCollection> coll;
1508 rc = COMGETTER(NetworkInterfaces) (coll.asOutParam());
1509 CheckComRCReturnRC (rc);
1510 ComPtr <IHostNetworkInterface> iface;
1511 if (FAILED (coll->FindById (aId, iface.asOutParam())))
1512 return setError (E_FAIL,
1513 tr ("Host network interface with UUID {%RTuuid} does not exist"),
1514 Guid (aId).raw());
1515
1516 /* return the object to be removed to the caller */
1517 iface.queryInterfaceTo (aHostNetworkInterface);
1518 }
1519
1520 /* create a progress object */
1521 ComObjPtr <Progress> progress;
1522 progress.createObject();
1523 rc = progress->init (mParent, static_cast <IHost *> (this),
1524 Bstr (tr ("Removing host network interface")),
1525 FALSE /* aCancelable */);
1526 CheckComRCReturnRC (rc);
1527 progress.queryInterfaceTo (aProgress);
1528
1529 /* create the networkInterfaceHelperClient() argument */
1530 std::auto_ptr <NetworkInterfaceHelperClientData>
1531 d (new NetworkInterfaceHelperClientData());
1532 AssertReturn (d.get(), E_OUTOFMEMORY);
1533
1534 d->msgCode = SVCHlpMsg::RemoveHostNetworkInterface;
1535 d->guid = aId;
1536
1537 rc = mParent->startSVCHelperClient (
1538 IsUACEnabled() == TRUE /* aPrivileged */,
1539 networkInterfaceHelperClient,
1540 static_cast <void *> (d.get()),
1541 progress);
1542
1543 if (SUCCEEDED (rc))
1544 {
1545 /* d is now owned by networkInterfaceHelperClient(), so release it */
1546 d.release();
1547 }
1548
1549 return rc;
1550}
1551
1552#endif /* RT_OS_WINDOWS */
1553
1554STDMETHODIMP Host::CreateUSBDeviceFilter (INPTR BSTR aName, IHostUSBDeviceFilter **aFilter)
1555{
1556#ifdef VBOX_WITH_USB
1557 if (!aFilter)
1558 return E_POINTER;
1559
1560 CheckComArgStrNotEmptyOrNull(aName);
1561
1562 AutoWriteLock alock (this);
1563 CHECK_READY();
1564
1565 ComObjPtr <HostUSBDeviceFilter> filter;
1566 filter.createObject();
1567 HRESULT rc = filter->init (this, aName);
1568 ComAssertComRCRet (rc, rc);
1569 rc = filter.queryInterfaceTo (aFilter);
1570 AssertComRCReturn (rc, rc);
1571 return S_OK;
1572#else
1573 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1574 * extended error info to indicate that USB is simply not available
1575 * (w/o treting it as a failure), for example, as in OSE */
1576 ReturnComNotImplemented();
1577#endif
1578}
1579
1580STDMETHODIMP Host::InsertUSBDeviceFilter (ULONG aPosition, IHostUSBDeviceFilter *aFilter)
1581{
1582#ifdef VBOX_WITH_USB
1583 if (!aFilter)
1584 return E_INVALIDARG;
1585
1586 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1587 AutoWriteLock alock (this);
1588 CHECK_READY();
1589
1590 MultiResult rc = checkUSBProxyService();
1591 CheckComRCReturnRC (rc);
1592
1593 ComObjPtr <HostUSBDeviceFilter> filter = getDependentChild (aFilter);
1594 if (!filter)
1595 return setError (E_INVALIDARG,
1596 tr ("The given USB device filter is not created within "
1597 "this VirtualBox instance"));
1598
1599 if (filter->mInList)
1600 return setError (E_INVALIDARG,
1601 tr ("The given USB device filter is already in the list"));
1602
1603 /* iterate to the position... */
1604 USBDeviceFilterList::iterator it = mUSBDeviceFilters.begin();
1605 std::advance (it, aPosition);
1606 /* ...and insert */
1607 mUSBDeviceFilters.insert (it, filter);
1608 filter->mInList = true;
1609
1610 /* notify the proxy (only when the filter is active) */
1611 if (mUSBProxyService->isActive() && filter->data().mActive)
1612 {
1613 ComAssertRet (filter->id() == NULL, E_FAIL);
1614 filter->id() = mUSBProxyService->insertFilter (&filter->data().mUSBFilter);
1615 }
1616
1617 /* save the global settings */
1618 alock.unlock();
1619 return rc = mParent->saveSettings();
1620#else
1621 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1622 * extended error info to indicate that USB is simply not available
1623 * (w/o treting it as a failure), for example, as in OSE */
1624 ReturnComNotImplemented();
1625#endif
1626}
1627
1628STDMETHODIMP Host::RemoveUSBDeviceFilter (ULONG aPosition, IHostUSBDeviceFilter **aFilter)
1629{
1630#ifdef VBOX_WITH_USB
1631 if (!aFilter)
1632 return E_POINTER;
1633
1634 /* Note: HostUSBDeviceFilter and USBProxyService also uses this lock. */
1635 AutoWriteLock alock (this);
1636 CHECK_READY();
1637
1638 MultiResult rc = checkUSBProxyService();
1639 CheckComRCReturnRC (rc);
1640
1641 if (!mUSBDeviceFilters.size())
1642 return setError (E_INVALIDARG,
1643 tr ("The USB device filter list is empty"));
1644
1645 if (aPosition >= mUSBDeviceFilters.size())
1646 return setError (E_INVALIDARG,
1647 tr ("Invalid position: %lu (must be in range [0, %lu])"),
1648 aPosition, mUSBDeviceFilters.size() - 1);
1649
1650 ComObjPtr <HostUSBDeviceFilter> filter;
1651 {
1652 /* iterate to the position... */
1653 USBDeviceFilterList::iterator it = mUSBDeviceFilters.begin();
1654 std::advance (it, aPosition);
1655 /* ...get an element from there... */
1656 filter = *it;
1657 /* ...and remove */
1658 filter->mInList = false;
1659 mUSBDeviceFilters.erase (it);
1660 }
1661
1662 filter.queryInterfaceTo (aFilter);
1663
1664 /* notify the proxy (only when the filter is active) */
1665 if (mUSBProxyService->isActive() && filter->data().mActive)
1666 {
1667 ComAssertRet (filter->id() != NULL, E_FAIL);
1668 mUSBProxyService->removeFilter (filter->id());
1669 filter->id() = NULL;
1670 }
1671
1672 /* save the global settings */
1673 alock.unlock();
1674 return rc = mParent->saveSettings();
1675#else
1676 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1677 * extended error info to indicate that USB is simply not available
1678 * (w/o treting it as a failure), for example, as in OSE */
1679 ReturnComNotImplemented();
1680#endif
1681}
1682
1683// public methods only for internal purposes
1684////////////////////////////////////////////////////////////////////////////////
1685
1686HRESULT Host::loadSettings (const settings::Key &aGlobal)
1687{
1688 using namespace settings;
1689
1690 AutoWriteLock alock (this);
1691 CHECK_READY();
1692
1693 AssertReturn (!aGlobal.isNull(), E_FAIL);
1694
1695 HRESULT rc = S_OK;
1696
1697#ifdef VBOX_WITH_USB
1698 Key::List filters = aGlobal.key ("USBDeviceFilters").keys ("DeviceFilter");
1699 for (Key::List::const_iterator it = filters.begin();
1700 it != filters.end(); ++ it)
1701 {
1702 Bstr name = (*it).stringValue ("name");
1703 bool active = (*it).value <bool> ("active");
1704
1705 Bstr vendorId = (*it).stringValue ("vendorId");
1706 Bstr productId = (*it).stringValue ("productId");
1707 Bstr revision = (*it).stringValue ("revision");
1708 Bstr manufacturer = (*it).stringValue ("manufacturer");
1709 Bstr product = (*it).stringValue ("product");
1710 Bstr serialNumber = (*it).stringValue ("serialNumber");
1711 Bstr port = (*it).stringValue ("port");
1712
1713 USBDeviceFilterAction_T action;
1714 action = USBDeviceFilterAction_Ignore;
1715 const char *actionStr = (*it).stringValue ("action");
1716 if (strcmp (actionStr, "Ignore") == 0)
1717 action = USBDeviceFilterAction_Ignore;
1718 else
1719 if (strcmp (actionStr, "Hold") == 0)
1720 action = USBDeviceFilterAction_Hold;
1721 else
1722 AssertMsgFailed (("Invalid action: '%s'\n", actionStr));
1723
1724 ComObjPtr <HostUSBDeviceFilter> filterObj;
1725 filterObj.createObject();
1726 rc = filterObj->init (this,
1727 name, active, vendorId, productId, revision,
1728 manufacturer, product, serialNumber, port,
1729 action);
1730 /* error info is set by init() when appropriate */
1731 CheckComRCBreakRC (rc);
1732
1733 mUSBDeviceFilters.push_back (filterObj);
1734 filterObj->mInList = true;
1735
1736 /* notify the proxy (only when the filter is active) */
1737 if (filterObj->data().mActive)
1738 {
1739 HostUSBDeviceFilter *flt = filterObj; /* resolve ambiguity */
1740 flt->id() = mUSBProxyService->insertFilter (&filterObj->data().mUSBFilter);
1741 }
1742 }
1743#endif /* VBOX_WITH_USB */
1744
1745 return rc;
1746}
1747
1748HRESULT Host::saveSettings (settings::Key &aGlobal)
1749{
1750 using namespace settings;
1751
1752 AutoWriteLock alock (this);
1753 CHECK_READY();
1754
1755 ComAssertRet (!aGlobal.isNull(), E_FAIL);
1756
1757#ifdef VBOX_WITH_USB
1758 /* first, delete the entry */
1759 Key filters = aGlobal.findKey ("USBDeviceFilters");
1760 if (!filters.isNull())
1761 filters.zap();
1762 /* then, recreate it */
1763 filters = aGlobal.createKey ("USBDeviceFilters");
1764
1765 USBDeviceFilterList::const_iterator it = mUSBDeviceFilters.begin();
1766 while (it != mUSBDeviceFilters.end())
1767 {
1768 AutoWriteLock filterLock (*it);
1769 const HostUSBDeviceFilter::Data &data = (*it)->data();
1770
1771 Key filter = filters.appendKey ("DeviceFilter");
1772
1773 filter.setValue <Bstr> ("name", data.mName);
1774 filter.setValue <bool> ("active", !!data.mActive);
1775
1776 /* all are optional */
1777 Bstr str;
1778 (*it)->COMGETTER (VendorId) (str.asOutParam());
1779 if (!str.isNull())
1780 filter.setValue <Bstr> ("vendorId", str);
1781
1782 (*it)->COMGETTER (ProductId) (str.asOutParam());
1783 if (!str.isNull())
1784 filter.setValue <Bstr> ("productId", str);
1785
1786 (*it)->COMGETTER (Revision) (str.asOutParam());
1787 if (!str.isNull())
1788 filter.setValue <Bstr> ("revision", str);
1789
1790 (*it)->COMGETTER (Manufacturer) (str.asOutParam());
1791 if (!str.isNull())
1792 filter.setValue <Bstr> ("manufacturer", str);
1793
1794 (*it)->COMGETTER (Product) (str.asOutParam());
1795 if (!str.isNull())
1796 filter.setValue <Bstr> ("product", str);
1797
1798 (*it)->COMGETTER (SerialNumber) (str.asOutParam());
1799 if (!str.isNull())
1800 filter.setValue <Bstr> ("serialNumber", str);
1801
1802 (*it)->COMGETTER (Port) (str.asOutParam());
1803 if (!str.isNull())
1804 filter.setValue <Bstr> ("port", str);
1805
1806 /* action is mandatory */
1807 USBDeviceFilterAction_T action = USBDeviceFilterAction_Null;
1808 (*it)->COMGETTER (Action) (&action);
1809 if (action == USBDeviceFilterAction_Ignore)
1810 filter.setStringValue ("action", "Ignore");
1811 else if (action == USBDeviceFilterAction_Hold)
1812 filter.setStringValue ("action", "Hold");
1813 else
1814 AssertMsgFailed (("Invalid action: %d\n", action));
1815
1816 ++ it;
1817 }
1818#endif /* VBOX_WITH_USB */
1819
1820 return S_OK;
1821}
1822
1823#ifdef VBOX_WITH_USB
1824/**
1825 * Called by setter methods of all USB device filters.
1826 */
1827HRESULT Host::onUSBDeviceFilterChange (HostUSBDeviceFilter *aFilter,
1828 BOOL aActiveChanged /* = FALSE */)
1829{
1830 AutoWriteLock alock (this);
1831 CHECK_READY();
1832
1833 if (aFilter->mInList)
1834 {
1835 if (aActiveChanged)
1836 {
1837 // insert/remove the filter from the proxy
1838 if (aFilter->data().mActive)
1839 {
1840 ComAssertRet (aFilter->id() == NULL, E_FAIL);
1841 aFilter->id() = mUSBProxyService->insertFilter (&aFilter->data().mUSBFilter);
1842 }
1843 else
1844 {
1845 ComAssertRet (aFilter->id() != NULL, E_FAIL);
1846 mUSBProxyService->removeFilter (aFilter->id());
1847 aFilter->id() = NULL;
1848 }
1849 }
1850 else
1851 {
1852 if (aFilter->data().mActive)
1853 {
1854 // update the filter in the proxy
1855 ComAssertRet (aFilter->id() != NULL, E_FAIL);
1856 mUSBProxyService->removeFilter (aFilter->id());
1857 aFilter->id() = mUSBProxyService->insertFilter (&aFilter->data().mUSBFilter);
1858 }
1859 }
1860
1861 // save the global settings... yeah, on every single filter property change
1862 alock.unlock();
1863 return mParent->saveSettings();
1864 }
1865
1866 return S_OK;
1867}
1868
1869
1870/**
1871 * Interface for obtaining a copy of the USBDeviceFilterList,
1872 * used by the USBProxyService.
1873 *
1874 * @param aGlobalFilters Where to put the global filter list copy.
1875 * @param aMachines Where to put the machine vector.
1876 */
1877void Host::getUSBFilters(Host::USBDeviceFilterList *aGlobalFilters, VirtualBox::SessionMachineVector *aMachines)
1878{
1879 AutoWriteLock alock (this);
1880
1881 mParent->getOpenedMachines (*aMachines);
1882 *aGlobalFilters = mUSBDeviceFilters;
1883}
1884
1885#endif /* VBOX_WITH_USB */
1886
1887// private methods
1888////////////////////////////////////////////////////////////////////////////////
1889
1890#if defined(RT_OS_LINUX) && defined(VBOX_WITH_LIBHAL)
1891/* Linux, load libhal statically */
1892
1893/** Helper function for setting up a libhal context */
1894bool hostInitLibHal(DBusConnection **pDBusConnection,
1895 LibHalContext **pLibHalContext)
1896{
1897 bool halSuccess = true;
1898 DBusError dbusError;
1899
1900 dbus_error_init (&dbusError);
1901 DBusConnection *dbusConnection;
1902 LibHalContext *libhalContext;
1903 dbusConnection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbusError);
1904 if (dbusConnection == NULL)
1905 halSuccess = false;
1906 if (dbusConnection == NULL && !dbus_error_is_set (&dbusError))
1907 LogRelFunc (("Unresolved error getting DBus connection.\n"));
1908 if (halSuccess)
1909 {
1910 libhalContext = libhal_ctx_new();
1911 if (libhalContext == NULL)
1912 halSuccess = false;
1913 }
1914 if ( halSuccess
1915 && !libhal_ctx_set_dbus_connection (libhalContext, dbusConnection))
1916 halSuccess = false;
1917 if ( halSuccess
1918 && !libhal_ctx_init (libhalContext, &dbusError))
1919 {
1920 halSuccess = false;
1921 if (!dbus_error_is_set (&dbusError))
1922 LogRelFunc (("Unresolved error initialising the libhal context.\n"));
1923 }
1924 if (halSuccess)
1925 {
1926 *pDBusConnection = dbusConnection;
1927 *pLibHalContext = libhalContext;
1928 }
1929 return halSuccess;
1930}
1931
1932/**
1933 * Helper function to query the hal subsystem for information about DVD drives attached to the
1934 * system.
1935 *
1936 * @returns true if information was successfully obtained, false otherwise
1937 * @retval list drives found will be attached to this list
1938 */
1939bool Host::getDVDInfoFromHal(std::list <ComObjPtr <HostDVDDrive> > &list)
1940{
1941 DBusConnection *dbusConnection;
1942 LibHalContext *libhalContext;
1943 int numDevices = 0;
1944 char **halDevices = NULL;
1945 bool halSuccess = hostInitLibHal (&dbusConnection, &libhalContext);
1946 if (halSuccess)
1947 halDevices = libhal_manager_find_device_string_match(libhalContext,
1948 "storage.drive_type", "cdrom",
1949 &numDevices, NULL);
1950 /* Hal is installed and working, so if no devices are reported, assume
1951 that there are none. */
1952 for (int i = 0; halSuccess && i < numDevices; ++i)
1953 {
1954 char *devNode = libhal_device_get_property_string(libhalContext,
1955 halDevices[i], "block.device", NULL);
1956 Utf8Str description;
1957 char *vendor = NULL, *product = NULL;
1958 if (devNode != NULL)
1959 {
1960 vendor = libhal_device_get_property_string(libhalContext,
1961 halDevices[i], "info.vendor", NULL);
1962 product = libhal_device_get_property_string(libhalContext,
1963 halDevices[i], "info.product", NULL);
1964 if ((product != 0 && product[0] != 0))
1965 {
1966 if ((vendor != 0) && (vendor[0] != 0))
1967 description = Utf8StrFmt ("%s %s",
1968 vendor, product);
1969 else
1970 description = product;
1971 }
1972 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
1973 hostDVDDriveObj.createObject();
1974 if (!description.isNull ())
1975 hostDVDDriveObj->init (Bstr (devNode),
1976 Bstr (halDevices[i]),
1977 Bstr (description));
1978 else
1979 hostDVDDriveObj->init (Bstr (devNode),
1980 Bstr (halDevices[i]));
1981 list.push_back (hostDVDDriveObj);
1982 if (vendor != NULL)
1983 libhal_free_string(vendor);
1984 if (product != NULL)
1985 libhal_free_string(product);
1986 libhal_free_string(devNode);
1987 }
1988 }
1989 if (halDevices != NULL)
1990 libhal_free_string_array(halDevices);
1991 if (halSuccess)
1992 libhal_ctx_shutdown (libhalContext, NULL);
1993 if (libhalContext != NULL)
1994 libhal_ctx_free (libhalContext);
1995 if (dbusConnection != NULL)
1996 dbus_connection_unref (dbusConnection);
1997 return halSuccess;
1998}
1999
2000/**
2001 * Helper function to query the hal subsystem for information about floppy drives attached to the
2002 * system.
2003 *
2004 * @returns true if information was successfully obtained, false otherwise
2005 * @retval list drives found will be attached to this list
2006 */
2007bool Host::getFloppyInfoFromHal(std::list <ComObjPtr <HostFloppyDrive> > &list)
2008{
2009 DBusConnection *dbusConnection;
2010 LibHalContext *libhalContext;
2011 int numDevices = 0;
2012 char **halDevices = NULL;
2013 bool halSuccess = hostInitLibHal (&dbusConnection, &libhalContext);
2014 if (halSuccess)
2015 halDevices = libhal_manager_find_device_string_match(libhalContext,
2016 "storage.drive_type", "floppy",
2017 &numDevices, NULL);
2018 /* Hal is installed and working, so if no devices are reported, assume
2019 that there are none. */
2020 for (int i = 0; halSuccess && i < numDevices; ++i)
2021 {
2022 char *devNode = libhal_device_get_property_string(libhalContext,
2023 halDevices[i], "block.device", NULL);
2024 Utf8Str description;
2025 char *vendor = NULL, *product = NULL;
2026 if (devNode != NULL)
2027 {
2028 vendor = libhal_device_get_property_string(libhalContext,
2029 halDevices[i], "info.vendor", NULL);
2030 product = libhal_device_get_property_string(libhalContext,
2031 halDevices[i], "info.product", NULL);
2032 if ((product != 0 && product[0] != 0))
2033 {
2034 if ((vendor != 0) && (vendor[0] != 0))
2035 description = Utf8StrFmt ("%s %s",
2036 vendor, product);
2037 else
2038 description = product;
2039 }
2040 ComObjPtr <HostFloppyDrive> hostFloppyDriveObj;
2041 hostFloppyDriveObj.createObject();
2042 if (!description.isNull ())
2043 hostFloppyDriveObj->init (Bstr (devNode),
2044 Bstr (halDevices[i]),
2045 Bstr (description));
2046 else
2047 hostFloppyDriveObj->init (Bstr (devNode),
2048 Bstr (halDevices[i]));
2049 list.push_back (hostFloppyDriveObj);
2050 if (vendor != NULL)
2051 libhal_free_string(vendor);
2052 if (product != NULL)
2053 libhal_free_string(product);
2054 libhal_free_string(devNode);
2055 }
2056 }
2057 if (halDevices != NULL)
2058 libhal_free_string_array(halDevices);
2059 if (halSuccess)
2060 libhal_ctx_shutdown (libhalContext, NULL);
2061 if (libhalContext != NULL)
2062 libhal_ctx_free (libhalContext);
2063 if (dbusConnection != NULL)
2064 dbus_connection_unref (dbusConnection);
2065 return halSuccess;
2066}
2067
2068# elif defined(RT_OS_SOLARIS) && defined(VBOX_USE_LIBHAL)
2069/* Solaris hosts, loading libhal at runtime */
2070
2071/**
2072 * Helper function to query the hal subsystem for information about DVD drives attached to the
2073 * system.
2074 *
2075 * @returns true if information was successfully obtained, false otherwise
2076 * @retval list drives found will be attached to this list
2077 */
2078bool Host::getDVDInfoFromHal(std::list <ComObjPtr <HostDVDDrive> > &list)
2079{
2080 bool halSuccess = false;
2081 DBusError dbusError;
2082 if (!gLibHalCheckPresence())
2083 return false;
2084 gDBusErrorInit (&dbusError);
2085 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2086 if (dbusConnection != 0)
2087 {
2088 LibHalContext *halContext = gLibHalCtxNew();
2089 if (halContext != 0)
2090 {
2091 if (gLibHalCtxSetDBusConnection (halContext, dbusConnection))
2092 {
2093 if (gLibHalCtxInit(halContext, &dbusError))
2094 {
2095 int numDevices;
2096 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2097 "storage.drive_type", "cdrom",
2098 &numDevices, &dbusError);
2099 if (halDevices != 0)
2100 {
2101 /* Hal is installed and working, so if no devices are reported, assume
2102 that there are none. */
2103 halSuccess = true;
2104 for (int i = 0; i < numDevices; i++)
2105 {
2106 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2107 halDevices[i], "block.device", &dbusError);
2108#ifdef RT_OS_SOLARIS
2109 /* The CD/DVD ioctls work only for raw device nodes. */
2110 char *tmp = getfullrawname(devNode);
2111 gLibHalFreeString(devNode);
2112 devNode = tmp;
2113#endif
2114 if (devNode != 0)
2115 {
2116// if (validateDevice(devNode, true))
2117// {
2118 Utf8Str description;
2119 char *vendor, *product;
2120 /* We do not check the error here, as this field may
2121 not even exist. */
2122 vendor = gLibHalDeviceGetPropertyString(halContext,
2123 halDevices[i], "info.vendor", 0);
2124 product = gLibHalDeviceGetPropertyString(halContext,
2125 halDevices[i], "info.product", &dbusError);
2126 if ((product != 0 && product[0] != 0))
2127 {
2128 if ((vendor != 0) && (vendor[0] != 0))
2129 {
2130 description = Utf8StrFmt ("%s %s",
2131 vendor, product);
2132 }
2133 else
2134 {
2135 description = product;
2136 }
2137 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
2138 hostDVDDriveObj.createObject();
2139 hostDVDDriveObj->init (Bstr (devNode),
2140 Bstr (halDevices[i]),
2141 Bstr (description));
2142 list.push_back (hostDVDDriveObj);
2143 }
2144 else
2145 {
2146 if (product == 0)
2147 {
2148 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2149 halDevices[i], dbusError.name, dbusError.message));
2150 gDBusErrorFree(&dbusError);
2151 }
2152 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
2153 hostDVDDriveObj.createObject();
2154 hostDVDDriveObj->init (Bstr (devNode),
2155 Bstr (halDevices[i]));
2156 list.push_back (hostDVDDriveObj);
2157 }
2158 if (vendor != 0)
2159 {
2160 gLibHalFreeString(vendor);
2161 }
2162 if (product != 0)
2163 {
2164 gLibHalFreeString(product);
2165 }
2166// }
2167// else
2168// {
2169// LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
2170// }
2171#ifndef RT_OS_SOLARIS
2172 gLibHalFreeString(devNode);
2173#else
2174 free(devNode);
2175#endif
2176 }
2177 else
2178 {
2179 LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2180 halDevices[i], dbusError.name, dbusError.message));
2181 gDBusErrorFree(&dbusError);
2182 }
2183 }
2184 gLibHalFreeStringArray(halDevices);
2185 }
2186 else
2187 {
2188 LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2189 gDBusErrorFree(&dbusError);
2190 }
2191 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2192 {
2193 LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2194 gDBusErrorFree(&dbusError);
2195 }
2196 }
2197 else
2198 {
2199 LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2200 gDBusErrorFree(&dbusError);
2201 }
2202 gLibHalCtxFree(halContext);
2203 }
2204 else
2205 {
2206 LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
2207 }
2208 }
2209 else
2210 {
2211 LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
2212 }
2213 gDBusConnectionUnref(dbusConnection);
2214 }
2215 else
2216 {
2217 LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2218 gDBusErrorFree(&dbusError);
2219 }
2220 return halSuccess;
2221}
2222
2223
2224/**
2225 * Helper function to query the hal subsystem for information about floppy drives attached to the
2226 * system.
2227 *
2228 * @returns true if information was successfully obtained, false otherwise
2229 * @retval list drives found will be attached to this list
2230 */
2231bool Host::getFloppyInfoFromHal(std::list <ComObjPtr <HostFloppyDrive> > &list)
2232{
2233 bool halSuccess = false;
2234 DBusError dbusError;
2235 if (!gLibHalCheckPresence())
2236 return false;
2237 gDBusErrorInit (&dbusError);
2238 DBusConnection *dbusConnection = gDBusBusGet(DBUS_BUS_SYSTEM, &dbusError);
2239 if (dbusConnection != 0)
2240 {
2241 LibHalContext *halContext = gLibHalCtxNew();
2242 if (halContext != 0)
2243 {
2244 if (gLibHalCtxSetDBusConnection (halContext, dbusConnection))
2245 {
2246 if (gLibHalCtxInit(halContext, &dbusError))
2247 {
2248 int numDevices;
2249 char **halDevices = gLibHalFindDeviceStringMatch(halContext,
2250 "storage.drive_type", "floppy",
2251 &numDevices, &dbusError);
2252 if (halDevices != 0)
2253 {
2254 /* Hal is installed and working, so if no devices are reported, assume
2255 that there are none. */
2256 halSuccess = true;
2257 for (int i = 0; i < numDevices; i++)
2258 {
2259 char *driveType = gLibHalDeviceGetPropertyString(halContext,
2260 halDevices[i], "storage.drive_type", 0);
2261 if (driveType != 0)
2262 {
2263 if (strcmp(driveType, "floppy") != 0)
2264 {
2265 gLibHalFreeString(driveType);
2266 continue;
2267 }
2268 gLibHalFreeString(driveType);
2269 }
2270 else
2271 {
2272 /* An error occurred. The attribute "storage.drive_type"
2273 probably didn't exist. */
2274 continue;
2275 }
2276 char *devNode = gLibHalDeviceGetPropertyString(halContext,
2277 halDevices[i], "block.device", &dbusError);
2278 if (devNode != 0)
2279 {
2280// if (validateDevice(devNode, false))
2281// {
2282 Utf8Str description;
2283 char *vendor, *product;
2284 /* We do not check the error here, as this field may
2285 not even exist. */
2286 vendor = gLibHalDeviceGetPropertyString(halContext,
2287 halDevices[i], "info.vendor", 0);
2288 product = gLibHalDeviceGetPropertyString(halContext,
2289 halDevices[i], "info.product", &dbusError);
2290 if ((product != 0) && (product[0] != 0))
2291 {
2292 if ((vendor != 0) && (vendor[0] != 0))
2293 {
2294 description = Utf8StrFmt ("%s %s",
2295 vendor, product);
2296 }
2297 else
2298 {
2299 description = product;
2300 }
2301 ComObjPtr <HostFloppyDrive> hostFloppyDrive;
2302 hostFloppyDrive.createObject();
2303 hostFloppyDrive->init (Bstr (devNode),
2304 Bstr (halDevices[i]),
2305 Bstr (description));
2306 list.push_back (hostFloppyDrive);
2307 }
2308 else
2309 {
2310 if (product == 0)
2311 {
2312 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"info.product\" for device %s. dbus error: %s (%s)\n",
2313 halDevices[i], dbusError.name, dbusError.message));
2314 gDBusErrorFree(&dbusError);
2315 }
2316 ComObjPtr <HostFloppyDrive> hostFloppyDrive;
2317 hostFloppyDrive.createObject();
2318 hostFloppyDrive->init (Bstr (devNode),
2319 Bstr (halDevices[i]));
2320 list.push_back (hostFloppyDrive);
2321 }
2322 if (vendor != 0)
2323 {
2324 gLibHalFreeString(vendor);
2325 }
2326 if (product != 0)
2327 {
2328 gLibHalFreeString(product);
2329 }
2330// }
2331// else
2332// {
2333// LogRel(("Host::COMGETTER(FloppyDrives): failed to validate the block device %s as a floppy drive\n"));
2334// }
2335 gLibHalFreeString(devNode);
2336 }
2337 else
2338 {
2339 LogRel(("Host::COMGETTER(FloppyDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
2340 halDevices[i], dbusError.name, dbusError.message));
2341 gDBusErrorFree(&dbusError);
2342 }
2343 }
2344 gLibHalFreeStringArray(halDevices);
2345 }
2346 else
2347 {
2348 LogRel(("Host::COMGETTER(FloppyDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2349 gDBusErrorFree(&dbusError);
2350 }
2351 if (!gLibHalCtxShutdown(halContext, &dbusError)) /* what now? */
2352 {
2353 LogRel(("Host::COMGETTER(FloppyDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2354 gDBusErrorFree(&dbusError);
2355 }
2356 }
2357 else
2358 {
2359 LogRel(("Host::COMGETTER(FloppyDrives): failed to initialise libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2360 gDBusErrorFree(&dbusError);
2361 }
2362 gLibHalCtxFree(halContext);
2363 }
2364 else
2365 {
2366 LogRel(("Host::COMGETTER(FloppyDrives): failed to set libhal connection to dbus.\n"));
2367 }
2368 }
2369 else
2370 {
2371 LogRel(("Host::COMGETTER(FloppyDrives): failed to get a libhal context - out of memory?\n"));
2372 }
2373 gDBusConnectionUnref(dbusConnection);
2374 }
2375 else
2376 {
2377 LogRel(("Host::COMGETTER(FloppyDrives): failed to connect to dbus. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
2378 gDBusErrorFree(&dbusError);
2379 }
2380 return halSuccess;
2381}
2382#endif /* VBOX_WITH_HAL and VBOX_USE_HAL */
2383
2384#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)
2385
2386/**
2387 * Helper function to parse the given mount file and add found entries
2388 */
2389void Host::parseMountTable(char *mountTable, std::list <ComObjPtr <HostDVDDrive> > &list)
2390{
2391#ifdef RT_OS_LINUX
2392 FILE *mtab = setmntent(mountTable, "r");
2393 if (mtab)
2394 {
2395 struct mntent *mntent;
2396 char *mnt_type;
2397 char *mnt_dev;
2398 char *tmp;
2399 while ((mntent = getmntent(mtab)))
2400 {
2401 mnt_type = (char*)malloc(strlen(mntent->mnt_type) + 1);
2402 mnt_dev = (char*)malloc(strlen(mntent->mnt_fsname) + 1);
2403 strcpy(mnt_type, mntent->mnt_type);
2404 strcpy(mnt_dev, mntent->mnt_fsname);
2405 // supermount fs case
2406 if (strcmp(mnt_type, "supermount") == 0)
2407 {
2408 tmp = strstr(mntent->mnt_opts, "fs=");
2409 if (tmp)
2410 {
2411 free(mnt_type);
2412 mnt_type = strdup(tmp + strlen("fs="));
2413 if (mnt_type)
2414 {
2415 tmp = strchr(mnt_type, ',');
2416 if (tmp)
2417 *tmp = '\0';
2418 }
2419 }
2420 tmp = strstr(mntent->mnt_opts, "dev=");
2421 if (tmp)
2422 {
2423 free(mnt_dev);
2424 mnt_dev = strdup(tmp + strlen("dev="));
2425 if (mnt_dev)
2426 {
2427 tmp = strchr(mnt_dev, ',');
2428 if (tmp)
2429 *tmp = '\0';
2430 }
2431 }
2432 }
2433 // use strstr here to cover things fs types like "udf,iso9660"
2434 if (strstr(mnt_type, "iso9660") == 0)
2435 {
2436 /** @todo check whether we've already got the drive in our list! */
2437 if (validateDevice(mnt_dev, true))
2438 {
2439 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
2440 hostDVDDriveObj.createObject();
2441 hostDVDDriveObj->init (Bstr (mnt_dev));
2442 list.push_back (hostDVDDriveObj);
2443 }
2444 }
2445 free(mnt_dev);
2446 free(mnt_type);
2447 }
2448 endmntent(mtab);
2449 }
2450#else // RT_OS_SOLARIS
2451 FILE *mntFile = fopen(mountTable, "r");
2452 if (mntFile)
2453 {
2454 struct mnttab mntTab;
2455 while (getmntent(mntFile, &mntTab) == 0)
2456 {
2457 char *mountName = strdup(mntTab.mnt_special);
2458 char *mountPoint = strdup(mntTab.mnt_mountp);
2459 char *mountFSType = strdup(mntTab.mnt_fstype);
2460
2461 // skip devices we are not interested in
2462 if ((*mountName && mountName[0] == '/') && // skip 'fake' devices (like -hosts, proc, fd, swap)
2463 (*mountFSType && (strcmp(mountFSType, "devfs") != 0 && // skip devfs (i.e. /devices)
2464 strcmp(mountFSType, "dev") != 0 && // skip dev (i.e. /dev)
2465 strcmp(mountFSType, "lofs") != 0)) && // skip loop-back file-system (lofs)
2466 (*mountPoint && strcmp(mountPoint, "/") != 0)) // skip point '/' (Can CD/DVD be mounted at '/' ???)
2467 {
2468 char *rawDevName = getfullrawname(mountName);
2469 if (validateDevice(rawDevName, true))
2470 {
2471 ComObjPtr <HostDVDDrive> hostDVDDriveObj;
2472 hostDVDDriveObj.createObject();
2473 hostDVDDriveObj->init (Bstr (rawDevName));
2474 list.push_back (hostDVDDriveObj);
2475 }
2476 free(rawDevName);
2477 }
2478
2479 free(mountName);
2480 free(mountPoint);
2481 free(mountFSType);
2482 }
2483
2484 fclose(mntFile);
2485 }
2486#endif
2487}
2488
2489/**
2490 * Helper function to check whether the given device node is a valid drive
2491 */
2492bool Host::validateDevice(const char *deviceNode, bool isCDROM)
2493{
2494 struct stat statInfo;
2495 bool retValue = false;
2496
2497 // sanity check
2498 if (!deviceNode)
2499 {
2500 return false;
2501 }
2502
2503 // first a simple stat() call
2504 if (stat(deviceNode, &statInfo) < 0)
2505 {
2506 return false;
2507 } else
2508 {
2509 if (isCDROM)
2510 {
2511 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2512 {
2513 int fileHandle;
2514 // now try to open the device
2515 fileHandle = open(deviceNode, O_RDONLY | O_NONBLOCK, 0);
2516 if (fileHandle >= 0)
2517 {
2518 cdrom_subchnl cdChannelInfo;
2519 cdChannelInfo.cdsc_format = CDROM_MSF;
2520 // this call will finally reveal the whole truth
2521#ifdef RT_OS_LINUX
2522 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2523 (errno == EIO) || (errno == ENOENT) ||
2524 (errno == EINVAL) || (errno == ENOMEDIUM))
2525#else
2526 if ((ioctl(fileHandle, CDROMSUBCHNL, &cdChannelInfo) == 0) ||
2527 (errno == EIO) || (errno == ENOENT) ||
2528 (errno == EINVAL))
2529#endif
2530 {
2531 retValue = true;
2532 }
2533 close(fileHandle);
2534 }
2535 }
2536 } else
2537 {
2538 // floppy case
2539 if (S_ISCHR(statInfo.st_mode) || S_ISBLK(statInfo.st_mode))
2540 {
2541 /// @todo do some more testing, maybe a nice IOCTL!
2542 retValue = true;
2543 }
2544 }
2545 }
2546 return retValue;
2547}
2548#endif // RT_OS_LINUX || RT_OS_SOLARIS
2549
2550#ifdef VBOX_WITH_USB
2551/**
2552 * Checks for the presense and status of the USB Proxy Service.
2553 * Returns S_OK when the Proxy is present and OK, or E_FAIL and a
2554 * corresponding error message otherwise. Intended to be used by methods
2555 * that rely on the Proxy Service availability.
2556 *
2557 * @note This method may return a warning result code. It is recommended to use
2558 * MultiError to store the return value.
2559 *
2560 * @note Locks this object for reading.
2561 */
2562HRESULT Host::checkUSBProxyService()
2563{
2564 AutoWriteLock alock (this);
2565 CHECK_READY();
2566
2567 AssertReturn (mUSBProxyService, E_FAIL);
2568 if (!mUSBProxyService->isActive())
2569 {
2570 /* disable the USB controller completely to avoid assertions if the
2571 * USB proxy service could not start. */
2572
2573 if (mUSBProxyService->getLastError() == VERR_FILE_NOT_FOUND)
2574 return setWarning (E_FAIL,
2575 tr ("Could not load the Host USB Proxy Service (%Rrc). "
2576 "The service might be not installed on the host computer"),
2577 mUSBProxyService->getLastError());
2578 if (mUSBProxyService->getLastError() == VINF_SUCCESS)
2579 return setWarning (E_FAIL,
2580 tr ("The USB Proxy Service has not yet been ported to this host"));
2581 return setWarning (E_FAIL,
2582 tr ("Could not load the Host USB Proxy service (%Rrc)"),
2583 mUSBProxyService->getLastError());
2584 }
2585
2586 return S_OK;
2587}
2588#endif /* VBOX_WITH_USB */
2589
2590#ifdef RT_OS_WINDOWS
2591
2592/* The original source of the VBoxTAP adapter creation/destruction code has the following copyright */
2593/*
2594 Copyright 2004 by the Massachusetts Institute of Technology
2595
2596 All rights reserved.
2597
2598 Permission to use, copy, modify, and distribute this software and its
2599 documentation for any purpose and without fee is hereby granted,
2600 provided that the above copyright notice appear in all copies and that
2601 both that copyright notice and this permission notice appear in
2602 supporting documentation, and that the name of the Massachusetts
2603 Institute of Technology (M.I.T.) not be used in advertising or publicity
2604 pertaining to distribution of the software without specific, written
2605 prior permission.
2606
2607 M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
2608 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
2609 M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
2610 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
2611 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
2612 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
2613 SOFTWARE.
2614*/
2615
2616
2617#define NETSHELL_LIBRARY _T("netshell.dll")
2618
2619/**
2620 * Use the IShellFolder API to rename the connection.
2621 */
2622static HRESULT rename_shellfolder (PCWSTR wGuid, PCWSTR wNewName)
2623{
2624 /* This is the GUID for the network connections folder. It is constant.
2625 * {7007ACC7-3202-11D1-AAD2-00805FC1270E} */
2626 const GUID CLSID_NetworkConnections = {
2627 0x7007ACC7, 0x3202, 0x11D1, {
2628 0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E
2629 }
2630 };
2631
2632 LPITEMIDLIST pidl = NULL;
2633 IShellFolder *pShellFolder = NULL;
2634 HRESULT hr;
2635
2636 /* Build the display name in the form "::{GUID}". */
2637 if (wcslen (wGuid) >= MAX_PATH)
2638 return E_INVALIDARG;
2639 WCHAR szAdapterGuid[MAX_PATH + 2] = {0};
2640 swprintf (szAdapterGuid, L"::%ls", wGuid);
2641
2642 /* Create an instance of the network connections folder. */
2643 hr = CoCreateInstance (CLSID_NetworkConnections, NULL,
2644 CLSCTX_INPROC_SERVER, IID_IShellFolder,
2645 reinterpret_cast <LPVOID *> (&pShellFolder));
2646 /* Parse the display name. */
2647 if (SUCCEEDED (hr))
2648 {
2649 hr = pShellFolder->ParseDisplayName (NULL, NULL, szAdapterGuid, NULL,
2650 &pidl, NULL);
2651 }
2652 if (SUCCEEDED (hr))
2653 {
2654 hr = pShellFolder->SetNameOf (NULL, pidl, wNewName, SHGDN_NORMAL,
2655 &pidl);
2656 }
2657
2658 CoTaskMemFree (pidl);
2659
2660 if (pShellFolder)
2661 pShellFolder->Release();
2662
2663 return hr;
2664}
2665
2666extern "C" HRESULT RenameConnection (PCWSTR GuidString, PCWSTR NewName)
2667{
2668 typedef HRESULT (WINAPI *lpHrRenameConnection) (const GUID *, PCWSTR);
2669 lpHrRenameConnection RenameConnectionFunc = NULL;
2670 HRESULT status;
2671
2672 /* First try the IShellFolder interface, which was unimplemented
2673 * for the network connections folder before XP. */
2674 status = rename_shellfolder (GuidString, NewName);
2675 if (status == E_NOTIMPL)
2676 {
2677/** @todo that code doesn't seem to work! */
2678 /* The IShellFolder interface is not implemented on this platform.
2679 * Try the (undocumented) HrRenameConnection API in the netshell
2680 * library. */
2681 CLSID clsid;
2682 HINSTANCE hNetShell;
2683 status = CLSIDFromString ((LPOLESTR) GuidString, &clsid);
2684 if (FAILED(status))
2685 return E_FAIL;
2686 hNetShell = LoadLibrary (NETSHELL_LIBRARY);
2687 if (hNetShell == NULL)
2688 return E_FAIL;
2689 RenameConnectionFunc =
2690 (lpHrRenameConnection) GetProcAddress (hNetShell,
2691 "HrRenameConnection");
2692 if (RenameConnectionFunc == NULL)
2693 {
2694 FreeLibrary (hNetShell);
2695 return E_FAIL;
2696 }
2697 status = RenameConnectionFunc (&clsid, NewName);
2698 FreeLibrary (hNetShell);
2699 }
2700 if (FAILED (status))
2701 return status;
2702
2703 return S_OK;
2704}
2705
2706#define DRIVERHWID _T("vboxtap")
2707
2708#define SetErrBreak(strAndArgs) \
2709 if (1) { \
2710 aErrMsg = Utf8StrFmt strAndArgs; vrc = VERR_GENERAL_FAILURE; break; \
2711 } else do {} while (0)
2712
2713/* static */
2714int Host::createNetworkInterface (SVCHlpClient *aClient,
2715 const Utf8Str &aName,
2716 Guid &aGUID, Utf8Str &aErrMsg)
2717{
2718 LogFlowFuncEnter();
2719 LogFlowFunc (("Network connection name = '%s'\n", aName.raw()));
2720
2721 AssertReturn (aClient, VERR_INVALID_POINTER);
2722 AssertReturn (!aName.isNull(), VERR_INVALID_PARAMETER);
2723
2724 int vrc = VINF_SUCCESS;
2725
2726 HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
2727 SP_DEVINFO_DATA DeviceInfoData;
2728 DWORD ret = 0;
2729 BOOL found = FALSE;
2730 BOOL registered = FALSE;
2731 BOOL destroyList = FALSE;
2732 TCHAR pCfgGuidString [50];
2733
2734 do
2735 {
2736 BOOL ok;
2737 GUID netGuid;
2738 SP_DRVINFO_DATA DriverInfoData;
2739 SP_DEVINSTALL_PARAMS DeviceInstallParams;
2740 TCHAR className [MAX_PATH];
2741 DWORD index = 0;
2742 PSP_DRVINFO_DETAIL_DATA pDriverInfoDetail;
2743 /* for our purposes, 2k buffer is more
2744 * than enough to obtain the hardware ID
2745 * of the VBoxTAP driver. */
2746 DWORD detailBuf [2048];
2747
2748 HKEY hkey = NULL;
2749 DWORD cbSize;
2750 DWORD dwValueType;
2751
2752 /* initialize the structure size */
2753 DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2754 DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
2755
2756 /* copy the net class GUID */
2757 memcpy(&netGuid, &GUID_DEVCLASS_NET, sizeof(GUID_DEVCLASS_NET));
2758
2759 /* create an empty device info set associated with the net class GUID */
2760 hDeviceInfo = SetupDiCreateDeviceInfoList (&netGuid, NULL);
2761 if (hDeviceInfo == INVALID_HANDLE_VALUE)
2762 SetErrBreak (("SetupDiCreateDeviceInfoList failed (0x%08X)",
2763 GetLastError()));
2764
2765 /* get the class name from GUID */
2766 ok = SetupDiClassNameFromGuid (&netGuid, className, MAX_PATH, NULL);
2767 if (!ok)
2768 SetErrBreak (("SetupDiClassNameFromGuid failed (0x%08X)",
2769 GetLastError()));
2770
2771 /* create a device info element and add the new device instance
2772 * key to registry */
2773 ok = SetupDiCreateDeviceInfo (hDeviceInfo, className, &netGuid, NULL, NULL,
2774 DICD_GENERATE_ID, &DeviceInfoData);
2775 if (!ok)
2776 SetErrBreak (("SetupDiCreateDeviceInfo failed (0x%08X)",
2777 GetLastError()));
2778
2779 /* select the newly created device info to be the currently
2780 selected member */
2781 ok = SetupDiSetSelectedDevice (hDeviceInfo, &DeviceInfoData);
2782 if (!ok)
2783 SetErrBreak (("SetupDiSetSelectedDevice failed (0x%08X)",
2784 GetLastError()));
2785
2786 /* build a list of class drivers */
2787 ok = SetupDiBuildDriverInfoList (hDeviceInfo, &DeviceInfoData,
2788 SPDIT_CLASSDRIVER);
2789 if (!ok)
2790 SetErrBreak (("SetupDiBuildDriverInfoList failed (0x%08X)",
2791 GetLastError()));
2792
2793 destroyList = TRUE;
2794
2795 /* enumerate the driver info list */
2796 while (TRUE)
2797 {
2798 BOOL ret;
2799
2800 ret = SetupDiEnumDriverInfo (hDeviceInfo, &DeviceInfoData,
2801 SPDIT_CLASSDRIVER, index, &DriverInfoData);
2802
2803 /* if the function failed and GetLastError() returned
2804 * ERROR_NO_MORE_ITEMS, then we have reached the end of the
2805 * list. Othewise there was something wrong with this
2806 * particular driver. */
2807 if (!ret)
2808 {
2809 if(GetLastError() == ERROR_NO_MORE_ITEMS)
2810 break;
2811 else
2812 {
2813 index++;
2814 continue;
2815 }
2816 }
2817
2818 pDriverInfoDetail = (PSP_DRVINFO_DETAIL_DATA) detailBuf;
2819 pDriverInfoDetail->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
2820
2821 /* if we successfully find the hardware ID and it turns out to
2822 * be the one for the loopback driver, then we are done. */
2823 if (SetupDiGetDriverInfoDetail (hDeviceInfo,
2824 &DeviceInfoData,
2825 &DriverInfoData,
2826 pDriverInfoDetail,
2827 sizeof (detailBuf),
2828 NULL))
2829 {
2830 TCHAR * t;
2831
2832 /* pDriverInfoDetail->HardwareID is a MULTISZ string. Go through the
2833 * whole list and see if there is a match somewhere. */
2834 t = pDriverInfoDetail->HardwareID;
2835 while (t && *t && t < (TCHAR *) &detailBuf [sizeof(detailBuf) / sizeof (detailBuf[0])])
2836 {
2837 if (!_tcsicmp(t, DRIVERHWID))
2838 break;
2839
2840 t += _tcslen(t) + 1;
2841 }
2842
2843 if (t && *t && t < (TCHAR *) &detailBuf [sizeof(detailBuf) / sizeof (detailBuf[0])])
2844 {
2845 found = TRUE;
2846 break;
2847 }
2848 }
2849
2850 index ++;
2851 }
2852
2853 if (!found)
2854 SetErrBreak ((tr ("Could not find Host Interface Networking driver! "
2855 "Please reinstall")));
2856
2857 /* set the loopback driver to be the currently selected */
2858 ok = SetupDiSetSelectedDriver (hDeviceInfo, &DeviceInfoData,
2859 &DriverInfoData);
2860 if (!ok)
2861 SetErrBreak (("SetupDiSetSelectedDriver failed (0x%08X)",
2862 GetLastError()));
2863
2864 /* register the phantom device to prepare for install */
2865 ok = SetupDiCallClassInstaller (DIF_REGISTERDEVICE, hDeviceInfo,
2866 &DeviceInfoData);
2867 if (!ok)
2868 SetErrBreak (("SetupDiCallClassInstaller failed (0x%08X)",
2869 GetLastError()));
2870
2871 /* registered, but remove if errors occur in the following code */
2872 registered = TRUE;
2873
2874 /* ask the installer if we can install the device */
2875 ok = SetupDiCallClassInstaller (DIF_ALLOW_INSTALL, hDeviceInfo,
2876 &DeviceInfoData);
2877 if (!ok)
2878 {
2879 if (GetLastError() != ERROR_DI_DO_DEFAULT)
2880 SetErrBreak (("SetupDiCallClassInstaller (DIF_ALLOW_INSTALL) failed (0x%08X)",
2881 GetLastError()));
2882 /* that's fine */
2883 }
2884
2885 /* install the files first */
2886 ok = SetupDiCallClassInstaller (DIF_INSTALLDEVICEFILES, hDeviceInfo,
2887 &DeviceInfoData);
2888 if (!ok)
2889 SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLDEVICEFILES) failed (0x%08X)",
2890 GetLastError()));
2891
2892 /* get the device install parameters and disable filecopy */
2893 DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
2894 ok = SetupDiGetDeviceInstallParams (hDeviceInfo, &DeviceInfoData,
2895 &DeviceInstallParams);
2896 if (ok)
2897 {
2898 DeviceInstallParams.Flags |= DI_NOFILECOPY;
2899 ok = SetupDiSetDeviceInstallParams (hDeviceInfo, &DeviceInfoData,
2900 &DeviceInstallParams);
2901 if (!ok)
2902 SetErrBreak (("SetupDiSetDeviceInstallParams failed (0x%08X)",
2903 GetLastError()));
2904 }
2905
2906 /*
2907 * Register any device-specific co-installers for this device,
2908 */
2909
2910 ok = SetupDiCallClassInstaller (DIF_REGISTER_COINSTALLERS,
2911 hDeviceInfo,
2912 &DeviceInfoData);
2913 if (!ok)
2914 SetErrBreak (("SetupDiCallClassInstaller (DIF_REGISTER_COINSTALLERS) failed (0x%08X)",
2915 GetLastError()));
2916
2917 /*
2918 * install any installer-specified interfaces.
2919 * and then do the real install
2920 */
2921 ok = SetupDiCallClassInstaller (DIF_INSTALLINTERFACES,
2922 hDeviceInfo,
2923 &DeviceInfoData);
2924 if (!ok)
2925 SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLINTERFACES) failed (0x%08X)",
2926 GetLastError()));
2927
2928 ok = SetupDiCallClassInstaller (DIF_INSTALLDEVICE,
2929 hDeviceInfo,
2930 &DeviceInfoData);
2931 if (!ok)
2932 SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLDEVICE) failed (0x%08X)",
2933 GetLastError()));
2934
2935 /* Figure out NetCfgInstanceId */
2936 hkey = SetupDiOpenDevRegKey (hDeviceInfo,
2937 &DeviceInfoData,
2938 DICS_FLAG_GLOBAL,
2939 0,
2940 DIREG_DRV,
2941 KEY_READ);
2942 if (hkey == INVALID_HANDLE_VALUE)
2943 SetErrBreak (("SetupDiOpenDevRegKey failed (0x%08X)",
2944 GetLastError()));
2945
2946 cbSize = sizeof (pCfgGuidString);
2947 DWORD ret;
2948 ret = RegQueryValueEx (hkey, _T ("NetCfgInstanceId"), NULL,
2949 &dwValueType, (LPBYTE) pCfgGuidString, &cbSize);
2950 RegCloseKey (hkey);
2951
2952 ret = RenameConnection (pCfgGuidString, Bstr (aName));
2953 if (FAILED (ret))
2954 SetErrBreak (("Failed to set interface name (ret=0x%08X, "
2955 "pCfgGuidString='%ls', cbSize=%d)",
2956 ret, pCfgGuidString, cbSize));
2957 }
2958 while (0);
2959
2960 /*
2961 * cleanup
2962 */
2963
2964 if (hDeviceInfo != INVALID_HANDLE_VALUE)
2965 {
2966 /* an error has occured, but the device is registered, we must remove it */
2967 if (ret != 0 && registered)
2968 SetupDiCallClassInstaller (DIF_REMOVE, hDeviceInfo, &DeviceInfoData);
2969
2970 found = SetupDiDeleteDeviceInfo (hDeviceInfo, &DeviceInfoData);
2971
2972 /* destroy the driver info list */
2973 if (destroyList)
2974 SetupDiDestroyDriverInfoList (hDeviceInfo, &DeviceInfoData,
2975 SPDIT_CLASSDRIVER);
2976 /* clean up the device info set */
2977 SetupDiDestroyDeviceInfoList (hDeviceInfo);
2978 }
2979
2980 /* return the network connection GUID on success */
2981 if (RT_SUCCESS (vrc))
2982 {
2983 /* remove the curly bracket at the end */
2984 pCfgGuidString [_tcslen (pCfgGuidString) - 1] = '\0';
2985 LogFlowFunc (("Network connection GUID string = {%ls}\n", pCfgGuidString + 1));
2986
2987 aGUID = Guid (Utf8Str (pCfgGuidString + 1));
2988 LogFlowFunc (("Network connection GUID = {%RTuuid}\n", aGUID.raw()));
2989 Assert (!aGUID.isEmpty());
2990 }
2991
2992 LogFlowFunc (("vrc=%Rrc\n", vrc));
2993 LogFlowFuncLeave();
2994 return vrc;
2995}
2996
2997/* static */
2998int Host::removeNetworkInterface (SVCHlpClient *aClient,
2999 const Guid &aGUID,
3000 Utf8Str &aErrMsg)
3001{
3002 LogFlowFuncEnter();
3003 LogFlowFunc (("Network connection GUID = {%RTuuid}\n", aGUID.raw()));
3004
3005 AssertReturn (aClient, VERR_INVALID_POINTER);
3006 AssertReturn (!aGUID.isEmpty(), VERR_INVALID_PARAMETER);
3007
3008 int vrc = VINF_SUCCESS;
3009
3010 do
3011 {
3012 TCHAR lszPnPInstanceId [512] = {0};
3013
3014 /* We have to find the device instance ID through a registry search */
3015
3016 HKEY hkeyNetwork = 0;
3017 HKEY hkeyConnection = 0;
3018
3019 do
3020 {
3021 char strRegLocation [256];
3022 sprintf (strRegLocation,
3023 "SYSTEM\\CurrentControlSet\\Control\\Network\\"
3024 "{4D36E972-E325-11CE-BFC1-08002BE10318}\\{%s}",
3025 aGUID.toString().raw());
3026 LONG status;
3027 status = RegOpenKeyExA (HKEY_LOCAL_MACHINE, strRegLocation, 0,
3028 KEY_READ, &hkeyNetwork);
3029 if ((status != ERROR_SUCCESS) || !hkeyNetwork)
3030 SetErrBreak ((
3031 tr ("Host interface network is not found in registry (%s) [1]"),
3032 strRegLocation));
3033
3034 status = RegOpenKeyExA (hkeyNetwork, "Connection", 0,
3035 KEY_READ, &hkeyConnection);
3036 if ((status != ERROR_SUCCESS) || !hkeyConnection)
3037 SetErrBreak ((
3038 tr ("Host interface network is not found in registry (%s) [2]"),
3039 strRegLocation));
3040
3041 DWORD len = sizeof (lszPnPInstanceId);
3042 DWORD dwKeyType;
3043 status = RegQueryValueExW (hkeyConnection, L"PnPInstanceID", NULL,
3044 &dwKeyType, (LPBYTE) lszPnPInstanceId, &len);
3045 if ((status != ERROR_SUCCESS) || (dwKeyType != REG_SZ))
3046 SetErrBreak ((
3047 tr ("Host interface network is not found in registry (%s) [3]"),
3048 strRegLocation));
3049 }
3050 while (0);
3051
3052 if (hkeyConnection)
3053 RegCloseKey (hkeyConnection);
3054 if (hkeyNetwork)
3055 RegCloseKey (hkeyNetwork);
3056
3057 if (RT_FAILURE (vrc))
3058 break;
3059
3060 /*
3061 * Now we are going to enumerate all network devices and
3062 * wait until we encounter the right device instance ID
3063 */
3064
3065 HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
3066
3067 do
3068 {
3069 BOOL ok;
3070 DWORD ret = 0;
3071 GUID netGuid;
3072 SP_DEVINFO_DATA DeviceInfoData;
3073 DWORD index = 0;
3074 BOOL found = FALSE;
3075 DWORD size = 0;
3076
3077 /* initialize the structure size */
3078 DeviceInfoData.cbSize = sizeof (SP_DEVINFO_DATA);
3079
3080 /* copy the net class GUID */
3081 memcpy (&netGuid, &GUID_DEVCLASS_NET, sizeof (GUID_DEVCLASS_NET));
3082
3083 /* return a device info set contains all installed devices of the Net class */
3084 hDeviceInfo = SetupDiGetClassDevs (&netGuid, NULL, NULL, DIGCF_PRESENT);
3085
3086 if (hDeviceInfo == INVALID_HANDLE_VALUE)
3087 SetErrBreak (("SetupDiGetClassDevs failed (0x%08X)", GetLastError()));
3088
3089 /* enumerate the driver info list */
3090 while (TRUE)
3091 {
3092 TCHAR *deviceHwid;
3093
3094 ok = SetupDiEnumDeviceInfo (hDeviceInfo, index, &DeviceInfoData);
3095
3096 if (!ok)
3097 {
3098 if (GetLastError() == ERROR_NO_MORE_ITEMS)
3099 break;
3100 else
3101 {
3102 index++;
3103 continue;
3104 }
3105 }
3106
3107 /* try to get the hardware ID registry property */
3108 ok = SetupDiGetDeviceRegistryProperty (hDeviceInfo,
3109 &DeviceInfoData,
3110 SPDRP_HARDWAREID,
3111 NULL,
3112 NULL,
3113 0,
3114 &size);
3115 if (!ok)
3116 {
3117 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
3118 {
3119 index++;
3120 continue;
3121 }
3122
3123 deviceHwid = (TCHAR *) malloc (size);
3124 ok = SetupDiGetDeviceRegistryProperty (hDeviceInfo,
3125 &DeviceInfoData,
3126 SPDRP_HARDWAREID,
3127 NULL,
3128 (PBYTE)deviceHwid,
3129 size,
3130 NULL);
3131 if (!ok)
3132 {
3133 free (deviceHwid);
3134 deviceHwid = NULL;
3135 index++;
3136 continue;
3137 }
3138 }
3139 else
3140 {
3141 /* something is wrong. This shouldn't have worked with a NULL buffer */
3142 index++;
3143 continue;
3144 }
3145
3146 for (TCHAR *t = deviceHwid;
3147 t && *t && t < &deviceHwid[size / sizeof(TCHAR)];
3148 t += _tcslen (t) + 1)
3149 {
3150 if (!_tcsicmp (DRIVERHWID, t))
3151 {
3152 /* get the device instance ID */
3153 TCHAR devID [MAX_DEVICE_ID_LEN];
3154 if (CM_Get_Device_ID(DeviceInfoData.DevInst,
3155 devID, MAX_DEVICE_ID_LEN, 0) == CR_SUCCESS)
3156 {
3157 /* compare to what we determined before */
3158 if (wcscmp(devID, lszPnPInstanceId) == 0)
3159 {
3160 found = TRUE;
3161 break;
3162 }
3163 }
3164 }
3165 }
3166
3167 if (deviceHwid)
3168 {
3169 free (deviceHwid);
3170 deviceHwid = NULL;
3171 }
3172
3173 if (found)
3174 break;
3175
3176 index++;
3177 }
3178
3179 if (found == FALSE)
3180 SetErrBreak ((tr ("Host Interface Network driver not found (0x%08X)"),
3181 GetLastError()));
3182
3183 ok = SetupDiSetSelectedDevice (hDeviceInfo, &DeviceInfoData);
3184 if (!ok)
3185 SetErrBreak (("SetupDiSetSelectedDevice failed (0x%08X)",
3186 GetLastError()));
3187
3188 ok = SetupDiCallClassInstaller (DIF_REMOVE, hDeviceInfo, &DeviceInfoData);
3189 if (!ok)
3190 SetErrBreak (("SetupDiCallClassInstaller (DIF_REMOVE) failed (0x%08X)",
3191 GetLastError()));
3192 }
3193 while (0);
3194
3195 /* clean up the device info set */
3196 if (hDeviceInfo != INVALID_HANDLE_VALUE)
3197 SetupDiDestroyDeviceInfoList (hDeviceInfo);
3198
3199 if (RT_FAILURE (vrc))
3200 break;
3201 }
3202 while (0);
3203
3204 LogFlowFunc (("vrc=%Rrc\n", vrc));
3205 LogFlowFuncLeave();
3206 return vrc;
3207}
3208
3209#undef SetErrBreak
3210
3211/* static */
3212HRESULT Host::networkInterfaceHelperClient (SVCHlpClient *aClient,
3213 Progress *aProgress,
3214 void *aUser, int *aVrc)
3215{
3216 LogFlowFuncEnter();
3217 LogFlowFunc (("aClient={%p}, aProgress={%p}, aUser={%p}\n",
3218 aClient, aProgress, aUser));
3219
3220 AssertReturn ((aClient == NULL && aProgress == NULL && aVrc == NULL) ||
3221 (aClient != NULL && aProgress != NULL && aVrc != NULL),
3222 E_POINTER);
3223 AssertReturn (aUser, E_POINTER);
3224
3225 std::auto_ptr <NetworkInterfaceHelperClientData>
3226 d (static_cast <NetworkInterfaceHelperClientData *> (aUser));
3227
3228 if (aClient == NULL)
3229 {
3230 /* "cleanup only" mode, just return (it will free aUser) */
3231 return S_OK;
3232 }
3233
3234 HRESULT rc = S_OK;
3235 int vrc = VINF_SUCCESS;
3236
3237 switch (d->msgCode)
3238 {
3239 case SVCHlpMsg::CreateHostNetworkInterface:
3240 {
3241 LogFlowFunc (("CreateHostNetworkInterface:\n"));
3242 LogFlowFunc (("Network connection name = '%ls'\n", d->name.raw()));
3243
3244 /* write message and parameters */
3245 vrc = aClient->write (d->msgCode);
3246 if (RT_FAILURE (vrc)) break;
3247 vrc = aClient->write (Utf8Str (d->name));
3248 if (RT_FAILURE (vrc)) break;
3249
3250 /* wait for a reply */
3251 bool endLoop = false;
3252 while (!endLoop)
3253 {
3254 SVCHlpMsg::Code reply = SVCHlpMsg::Null;
3255
3256 vrc = aClient->read (reply);
3257 if (RT_FAILURE (vrc)) break;
3258
3259 switch (reply)
3260 {
3261 case SVCHlpMsg::CreateHostNetworkInterface_OK:
3262 {
3263 /* read the GUID */
3264 Guid guid;
3265 vrc = aClient->read (guid);
3266 if (RT_FAILURE (vrc)) break;
3267
3268 LogFlowFunc (("Network connection GUID = {%RTuuid}\n", guid.raw()));
3269
3270 /* initialize the object returned to the caller by
3271 * CreateHostNetworkInterface() */
3272 rc = d->iface->init (d->name, guid);
3273 endLoop = true;
3274 break;
3275 }
3276 case SVCHlpMsg::Error:
3277 {
3278 /* read the error message */
3279 Utf8Str errMsg;
3280 vrc = aClient->read (errMsg);
3281 if (RT_FAILURE (vrc)) break;
3282
3283 rc = setError (E_FAIL, errMsg);
3284 endLoop = true;
3285 break;
3286 }
3287 default:
3288 {
3289 endLoop = true;
3290 ComAssertMsgFailedBreak ((
3291 "Invalid message code %d (%08lX)\n",
3292 reply, reply),
3293 rc = E_FAIL);
3294 }
3295 }
3296 }
3297
3298 break;
3299 }
3300 case SVCHlpMsg::RemoveHostNetworkInterface:
3301 {
3302 LogFlowFunc (("RemoveHostNetworkInterface:\n"));
3303 LogFlowFunc (("Network connection GUID = {%RTuuid}\n", d->guid.raw()));
3304
3305 /* write message and parameters */
3306 vrc = aClient->write (d->msgCode);
3307 if (RT_FAILURE (vrc)) break;
3308 vrc = aClient->write (d->guid);
3309 if (RT_FAILURE (vrc)) break;
3310
3311 /* wait for a reply */
3312 bool endLoop = false;
3313 while (!endLoop)
3314 {
3315 SVCHlpMsg::Code reply = SVCHlpMsg::Null;
3316
3317 vrc = aClient->read (reply);
3318 if (RT_FAILURE (vrc)) break;
3319
3320 switch (reply)
3321 {
3322 case SVCHlpMsg::OK:
3323 {
3324 /* no parameters */
3325 rc = S_OK;
3326 endLoop = true;
3327 break;
3328 }
3329 case SVCHlpMsg::Error:
3330 {
3331 /* read the error message */
3332 Utf8Str errMsg;
3333 vrc = aClient->read (errMsg);
3334 if (RT_FAILURE (vrc)) break;
3335
3336 rc = setError (E_FAIL, errMsg);
3337 endLoop = true;
3338 break;
3339 }
3340 default:
3341 {
3342 endLoop = true;
3343 ComAssertMsgFailedBreak ((
3344 "Invalid message code %d (%08lX)\n",
3345 reply, reply),
3346 rc = E_FAIL);
3347 }
3348 }
3349 }
3350
3351 break;
3352 }
3353 default:
3354 ComAssertMsgFailedBreak ((
3355 "Invalid message code %d (%08lX)\n",
3356 d->msgCode, d->msgCode),
3357 rc = E_FAIL);
3358 }
3359
3360 if (aVrc)
3361 *aVrc = vrc;
3362
3363 LogFlowFunc (("rc=0x%08X, vrc=%Rrc\n", rc, vrc));
3364 LogFlowFuncLeave();
3365 return rc;
3366}
3367
3368/* static */
3369int Host::networkInterfaceHelperServer (SVCHlpClient *aClient,
3370 SVCHlpMsg::Code aMsgCode)
3371{
3372 LogFlowFuncEnter();
3373 LogFlowFunc (("aClient={%p}, aMsgCode=%d\n", aClient, aMsgCode));
3374
3375 AssertReturn (aClient, VERR_INVALID_POINTER);
3376
3377 int vrc = VINF_SUCCESS;
3378
3379 switch (aMsgCode)
3380 {
3381 case SVCHlpMsg::CreateHostNetworkInterface:
3382 {
3383 LogFlowFunc (("CreateHostNetworkInterface:\n"));
3384
3385 Utf8Str name;
3386 vrc = aClient->read (name);
3387 if (RT_FAILURE (vrc)) break;
3388
3389 Guid guid;
3390 Utf8Str errMsg;
3391 vrc = createNetworkInterface (aClient, name, guid, errMsg);
3392
3393 if (RT_SUCCESS (vrc))
3394 {
3395 /* write success followed by GUID */
3396 vrc = aClient->write (SVCHlpMsg::CreateHostNetworkInterface_OK);
3397 if (RT_FAILURE (vrc)) break;
3398 vrc = aClient->write (guid);
3399 if (RT_FAILURE (vrc)) break;
3400 }
3401 else
3402 {
3403 /* write failure followed by error message */
3404 if (errMsg.isEmpty())
3405 errMsg = Utf8StrFmt ("Unspecified error (%Rrc)", vrc);
3406 vrc = aClient->write (SVCHlpMsg::Error);
3407 if (RT_FAILURE (vrc)) break;
3408 vrc = aClient->write (errMsg);
3409 if (RT_FAILURE (vrc)) break;
3410 }
3411
3412 break;
3413 }
3414 case SVCHlpMsg::RemoveHostNetworkInterface:
3415 {
3416 LogFlowFunc (("RemoveHostNetworkInterface:\n"));
3417
3418 Guid guid;
3419 vrc = aClient->read (guid);
3420 if (RT_FAILURE (vrc)) break;
3421
3422 Utf8Str errMsg;
3423 vrc = removeNetworkInterface (aClient, guid, errMsg);
3424
3425 if (RT_SUCCESS (vrc))
3426 {
3427 /* write parameter-less success */
3428 vrc = aClient->write (SVCHlpMsg::OK);
3429 if (RT_FAILURE (vrc)) break;
3430 }
3431 else
3432 {
3433 /* write failure followed by error message */
3434 if (errMsg.isEmpty())
3435 errMsg = Utf8StrFmt ("Unspecified error (%Rrc)", vrc);
3436 vrc = aClient->write (SVCHlpMsg::Error);
3437 if (RT_FAILURE (vrc)) break;
3438 vrc = aClient->write (errMsg);
3439 if (RT_FAILURE (vrc)) break;
3440 }
3441
3442 break;
3443 }
3444 default:
3445 AssertMsgFailedBreakStmt (
3446 ("Invalid message code %d (%08lX)\n", aMsgCode, aMsgCode),
3447 VERR_GENERAL_FAILURE);
3448 }
3449
3450 LogFlowFunc (("vrc=%Rrc\n", vrc));
3451 LogFlowFuncLeave();
3452 return vrc;
3453}
3454
3455#endif /* RT_OS_WINDOWS */
3456
3457#ifdef VBOX_WITH_RESOURCE_USAGE_API
3458void Host::registerMetrics (PerformanceCollector *aCollector)
3459{
3460 pm::CollectorHAL *hal = aCollector->getHAL();
3461 /* Create sub metrics */
3462 pm::SubMetric *cpuLoadUser = new pm::SubMetric ("CPU/Load/User",
3463 "Percentage of processor time spent in user mode.");
3464 pm::SubMetric *cpuLoadKernel = new pm::SubMetric ("CPU/Load/Kernel",
3465 "Percentage of processor time spent in kernel mode.");
3466 pm::SubMetric *cpuLoadIdle = new pm::SubMetric ("CPU/Load/Idle",
3467 "Percentage of processor time spent idling.");
3468 pm::SubMetric *cpuMhzSM = new pm::SubMetric ("CPU/MHz",
3469 "Average of current frequency of all processors.");
3470 pm::SubMetric *ramUsageTotal = new pm::SubMetric ("RAM/Usage/Total",
3471 "Total physical memory installed.");
3472 pm::SubMetric *ramUsageUsed = new pm::SubMetric ("RAM/Usage/Used",
3473 "Physical memory currently occupied.");
3474 pm::SubMetric *ramUsageFree = new pm::SubMetric ("RAM/Usage/Free",
3475 "Physical memory currently available to applications.");
3476 /* Create and register base metrics */
3477 IUnknown *objptr;
3478 ComObjPtr <Host> tmp = this;
3479 tmp.queryInterfaceTo (&objptr);
3480 pm::BaseMetric *cpuLoad = new pm::HostCpuLoadRaw (hal, objptr, cpuLoadUser, cpuLoadKernel,
3481 cpuLoadIdle);
3482 aCollector->registerBaseMetric (cpuLoad);
3483 pm::BaseMetric *cpuMhz = new pm::HostCpuMhz (hal, objptr, cpuMhzSM);
3484 aCollector->registerBaseMetric (cpuMhz);
3485 pm::BaseMetric *ramUsage = new pm::HostRamUsage (hal, objptr, ramUsageTotal, ramUsageUsed,
3486 ramUsageFree);
3487 aCollector->registerBaseMetric (ramUsage);
3488
3489 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadUser, 0));
3490 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadUser,
3491 new pm::AggregateAvg()));
3492 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadUser,
3493 new pm::AggregateMin()));
3494 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadUser,
3495 new pm::AggregateMax()));
3496
3497 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadKernel, 0));
3498 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadKernel,
3499 new pm::AggregateAvg()));
3500 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadKernel,
3501 new pm::AggregateMin()));
3502 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadKernel,
3503 new pm::AggregateMax()));
3504
3505 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadIdle, 0));
3506 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadIdle,
3507 new pm::AggregateAvg()));
3508 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadIdle,
3509 new pm::AggregateMin()));
3510 aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadIdle,
3511 new pm::AggregateMax()));
3512
3513 aCollector->registerMetric (new pm::Metric(cpuMhz, cpuMhzSM, 0));
3514 aCollector->registerMetric (new pm::Metric(cpuMhz, cpuMhzSM,
3515 new pm::AggregateAvg()));
3516 aCollector->registerMetric (new pm::Metric(cpuMhz, cpuMhzSM,
3517 new pm::AggregateMin()));
3518 aCollector->registerMetric (new pm::Metric(cpuMhz, cpuMhzSM,
3519 new pm::AggregateMax()));
3520
3521 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageTotal, 0));
3522 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageTotal,
3523 new pm::AggregateAvg()));
3524 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageTotal,
3525 new pm::AggregateMin()));
3526 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageTotal,
3527 new pm::AggregateMax()));
3528
3529 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed, 0));
3530 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
3531 new pm::AggregateAvg()));
3532 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
3533 new pm::AggregateMin()));
3534 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
3535 new pm::AggregateMax()));
3536
3537 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageFree, 0));
3538 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageFree,
3539 new pm::AggregateAvg()));
3540 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageFree,
3541 new pm::AggregateMin()));
3542 aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageFree,
3543 new pm::AggregateMax()));
3544};
3545
3546void Host::unregisterMetrics (PerformanceCollector *aCollector)
3547{
3548 aCollector->unregisterMetricsFor (this);
3549 aCollector->unregisterBaseMetricsFor (this);
3550};
3551#endif /* VBOX_WITH_RESOURCE_USAGE_API */
3552/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette