VirtualBox

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

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

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