VirtualBox

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

Last change on this file since 9744 was 9335, checked in by vboxsync, 17 years ago

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