VirtualBox

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

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

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