VirtualBox

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

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

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