VirtualBox

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

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

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