HostImpl.cpp revision 538ed51248ec8dbb4de3197f160656c43e88a5f1
/** @file
* VirtualBox COM class implementation
*/
/*
* Copyright (C) 2006 InnoTek Systemberatung GmbH
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License as published by the Free Software Foundation,
* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
* distribution. VirtualBox OSE is distributed in the hope that it will
* be useful, but WITHOUT ANY WARRANTY of any kind.
*
* If you received this file as part of a commercial VirtualBox
* distribution, then only the terms of your commercial VirtualBox
* license agreement apply instead of the previous paragraph.
*/
#ifdef __LINUX__
#include <unistd.h>
#include <fcntl.h>
#include <mntent.h>
/* bird: This is a hack to work around conflicts between these linux kernel headers
* and the GLIBC tcpip headers. They have different declarations of the 4
* standard byte order functions. */
#define _LINUX_BYTEORDER_GENERIC_H
#ifdef VBOX_USE_LIBHAL
# include <libhal.h>
/* These are defined by libhal.h and by VBox header files. */
#endif
#include <errno.h>
#endif /* __LINUX __ */
#ifdef __WIN__
#define _WIN32_DCOM
#include <windows.h>
#include <shellapi.h>
#define INITGUID
#include <guiddef.h>
#include <devguid.h>
#include <objbase.h>
#include <setupapi.h>
#include <shlobj.h>
#include <cfgmgr32.h>
#endif /* __WIN__ */
#include "HostImpl.h"
#include "HostDVDDriveImpl.h"
#include "HostFloppyDriveImpl.h"
#include "HostUSBDeviceImpl.h"
#include "USBControllerImpl.h"
#include "USBDeviceFilterImpl.h"
#include "USBProxyService.h"
#include "VirtualBoxImpl.h"
#include "MachineImpl.h"
#include "Logging.h"
#ifdef __DARWIN__
#endif
#ifdef __WIN__
#include "HostNetworkInterfaceImpl.h"
#endif
#include <stdio.h>
#include <algorithm>
// constructor / destructor
/////////////////////////////////////////////////////////////////////////////
{
return S_OK;
}
void Host::FinalRelease()
{
if (isReady())
uninit();
}
// public initializer/uninitializer for internal purposes only
/////////////////////////////////////////////////////////////////////////////
/**
* Initializes the host object.
*
* @returns COM result indicator
* @param parent handle of our parent object
*/
{
#if defined (__DARWIN__) && defined (VBOX_WITH_USB)
mUSBProxyService = new USBProxyServiceDarwin (this);
mUSBProxyService = new USBProxyServiceLinux (this);
mUSBProxyService = new USBProxyServiceWin32 (this);
#else
mUSBProxyService = new USBProxyService (this);
#endif
/** @todo handle !mUSBProxySerivce->isActive() and mUSBProxyService->getLastError()
* and somehow report or whatever that the proxy failed to startup.
* Also, there might be init order issues... */
setReady(true);
return S_OK;
}
/**
* Uninitializes the host object and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
{
AssertReturn (isReady(), (void) 0);
// uninit all USB device filters still referenced by clients
delete mUSBProxyService;
mUSBDevices.clear();
}
// IHost properties
/////////////////////////////////////////////////////////////////////////////
/**
* Returns a list of host DVD drives.
*
* @returns COM status code
* @param drives address of result pointer
*/
{
if (!drives)
return E_POINTER;
CHECK_READY();
#if defined(__WIN__)
TCHAR *p = hostDrives;
do
{
if (GetDriveType(p) == DRIVE_CDROM)
{
driveName[0] = *p;
}
p += _tcslen(p) + 1;
}
while (*p);
delete[] hostDrives;
#ifdef VBOX_USE_LIBHAL
#endif /* USE_LIBHAL defined */
// On Linux without hal, the situation is much more complex. We will take a
// heuristical approach and also allow the user to specify a list of host
// CDROMs using an environment variable.
// The general strategy is to try some known device names and see of they
// API to parse it) for CDROM devices. Ok, let's start!
{
if (getenv("VBOX_CDROM"))
{
char *cdromDrive;
while (cdromDrive)
{
if (validateDevice(cdromDrive, true))
{
}
}
}
else
{
// this is a good guess usually
if (validateDevice("/dev/cdrom", true))
{
}
// check the mounted drives
// check the drives that can be mounted
}
}
#elif defined(__DARWIN__)
while (cur)
{
/* next */
}
#else
/* PORTME */
#endif
return S_OK;
}
/**
* Returns a list of host floppy drives.
*
* @returns COM status code
* @param drives address of result pointer
*/
{
if (!drives)
return E_POINTER;
CHECK_READY();
#ifdef __WIN__
TCHAR *p = hostDrives;
do
{
if (GetDriveType(p) == DRIVE_REMOVABLE)
{
driveName[0] = *p;
}
p += _tcslen(p) + 1;
}
while (*p);
delete[] hostDrives;
// As with the CDROMs, on Linux we have to take a multi-level approach
// involving parsing the mount tables. As this is not bulletproof, we'll
// give the user the chance to override the detection by an environment
// variable and skip the detection.
if (getenv("VBOX_FLOPPY"))
{
char *floppyDrive;
while (floppyDrive)
{
// check if this is an acceptable device
if (validateDevice(floppyDrive, false))
{
}
}
}
else
{
char devName[10];
for (int i = 0; i <= 7; i++)
{
if (validateDevice(devName, false))
{
}
}
}
#else
/* PORTME */
#endif
return S_OK;
}
#ifdef __WIN__
static bool IsTAPDevice(const char *guid)
{
int i = 0;
bool ret = false;
status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}", 0, KEY_READ, &hNetcard);
if (status != ERROR_SUCCESS)
return false;
while(true)
{
char szEnumName[256];
char szNetCfgInstanceId[256];
len = sizeof(szEnumName);
if (status != ERROR_SUCCESS)
break;
if (status == ERROR_SUCCESS)
{
len = sizeof (szNetCfgInstanceId);
status = RegQueryValueExA(hNetCardGUID, "NetCfgInstanceId", NULL, &dwKeyType, (LPBYTE)szNetCfgInstanceId, &len);
{
char szNetProductName[256];
char szNetProviderName[256];
szNetProductName[0] = 0;
len = sizeof(szNetProductName);
status = RegQueryValueExA(hNetCardGUID, "ProductName", NULL, &dwKeyType, (LPBYTE)szNetProductName, &len);
szNetProviderName[0] = 0;
len = sizeof(szNetProviderName);
status = RegQueryValueExA(hNetCardGUID, "ProviderName", NULL, &dwKeyType, (LPBYTE)szNetProviderName, &len);
{
ret = true;
break;
}
}
}
++i;
}
return ret;
}
/**
* Returns a list of host network interfaces.
*
* @returns COM status code
* @param drives address of result pointer
*/
STDMETHODIMP Host::COMGETTER(NetworkInterfaces) (IHostNetworkInterfaceCollection **networkInterfaces)
{
if (!networkInterfaces)
return E_POINTER;
CHECK_READY();
static const char *NetworkKey = "SYSTEM\\CurrentControlSet\\Control\\Network\\"
"{4D36E972-E325-11CE-BFC1-08002BE10318}";
if (status != ERROR_SUCCESS)
for (int i = 0;; ++ i)
{
char szNetworkGUID [256];
char szNetworkConnection [256];
len = sizeof (szNetworkGUID);
if (status != ERROR_SUCCESS)
break;
if (!IsTAPDevice(szNetworkGUID))
continue;
"%s\\Connection", szNetworkGUID);
if (status == ERROR_SUCCESS)
{
{
if (status == ERROR_SUCCESS)
{
/* put a trailing zero, just in case (see MSDN) */
/* create a new object and add it to the list */
/* remove the curly bracket at the end */
}
}
}
}
return S_OK;
}
#endif /* __WIN__ */
{
#ifdef VBOX_WITH_USB
if (!aUSBDevices)
return E_POINTER;
CHECK_READY();
return S_OK;
#else
/* Note: The GUI depends on this method returning E_NOTIMPL with no
* extended error info to indicate that USB is simply not available
* (w/o treting it as a failure), for example, as in OSE */
return E_NOTIMPL;
#endif
}
STDMETHODIMP Host::COMGETTER(USBDeviceFilters) (IHostUSBDeviceFilterCollection ** aUSBDeviceFilters)
{
#ifdef VBOX_WITH_USB
if (!aUSBDeviceFilters)
return E_POINTER;
CHECK_READY();
return S_OK;
#else
/* Note: The GUI depends on this method returning E_NOTIMPL with no
* extended error info to indicate that USB is simply not available
* (w/o treting it as a failure), for example, as in OSE */
return E_NOTIMPL;
#endif
}
/**
* Returns the number of installed logical processors
*
* @returns COM status code
* @param count address of result variable
*/
{
if (!count)
return E_POINTER;
CHECK_READY();
return S_OK;
}
/**
* Returns the (approximate) speed of the host CPU in MHz
*
* @returns COM status code
* @param speed address of result variable
*/
{
if (!speed)
return E_POINTER;
CHECK_READY();
/** @todo Add a runtime function for this which uses GIP. */
return S_OK;
}
/**
* Returns a description string for the host CPU
*
* @returns COM status code
* @param description address of result variable
*/
{
if (!description)
return E_POINTER;
CHECK_READY();
/** @todo */
return S_OK;
}
/**
* Returns the amount of installed system memory in megabytes
*
* @returns COM status code
* @param size address of result variable
*/
{
if (!size)
return E_POINTER;
CHECK_READY();
/** @todo */
return S_OK;
}
/**
* Returns the current system memory free space in megabytes
*
* @returns COM status code
* @param available address of result variable
*/
{
if (!available)
return E_POINTER;
CHECK_READY();
/** @todo */
return S_OK;
}
/**
* Returns the name string of the host operating system
*
* @returns COM status code
* @param os address of result variable
*/
{
if (!os)
return E_POINTER;
CHECK_READY();
/** @todo */
return S_OK;
}
/**
* Returns the version string of the host operating system
*
* @returns COM status code
* @param os address of result variable
*/
{
if (!version)
return E_POINTER;
CHECK_READY();
/** @todo */
return S_OK;
}
/**
* Returns the current host time in milliseconds since 1970-01-01 UTC.
*
* @returns COM status code
* @param time address of result variable
*/
{
if (!aUTCTime)
return E_POINTER;
CHECK_READY();
return S_OK;
}
// IHost methods
////////////////////////////////////////////////////////////////////////////////
#ifdef __WIN__
/**
* Returns TRUE if the Windows version is 6.0 or greater (i.e. it's Vista and
* later OSes) and it has the UAC (User Account Control) feature enabled.
*/
static BOOL IsUACEnabled()
{
LogFlowFunc (("dwMajorVersion=%d, dwMinorVersion=%d\n",
/* we are interested only in Vista (and newer versions...). In all
* earlier versions UAC is not present. */
return FALSE;
/* the default EnableLUA value is 1 (Enabled) */
"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System",
0, KEY_QUERY_VALUE, &hKey);
if (rc == ERROR_SUCCESS)
{
RegCloseKey (hKey);
}
return dwEnableLUA == 1;
}
{
/* for SVCHlpMsg::CreateHostNetworkInterface */
/* for SVCHlpMsg::RemoveHostNetworkInterface */
};
{
if (!aName)
return E_INVALIDARG;
if (!aHostNetworkInterface)
return E_POINTER;
if (!aProgress)
return E_POINTER;
CHECK_READY();
/* first check whether an interface with the given name already exists */
{
}
/* create a progress object */
FALSE /* aCancelable */);
/* create a new uninitialized host interface object */
/* create the networkInterfaceHelperClient() argument */
d (new NetworkInterfaceHelperClientData());
static_cast <void *> (d.get()),
progress);
{
/* d is now owned by networkInterfaceHelperClient(), so release it */
d.release();
}
return rc;
}
{
if (!aHostNetworkInterface)
return E_POINTER;
if (!aProgress)
return E_POINTER;
CHECK_READY();
/* first check whether an interface with the given name already exists */
{
tr ("Host network interface with UUID {%Vuuid} does not exist"),
/* return the object to be removed to the caller */
}
/* create a progress object */
FALSE /* aCancelable */);
/* create the networkInterfaceHelperClient() argument */
d (new NetworkInterfaceHelperClientData());
static_cast <void *> (d.get()),
progress);
{
/* d is now owned by networkInterfaceHelperClient(), so release it */
d.release();
}
return rc;
}
#endif /* __WIN__ */
{
#ifdef VBOX_WITH_USB
if (!aFilter)
return E_POINTER;
return E_INVALIDARG;
CHECK_READY();
return S_OK;
#else
/* Note: The GUI depends on this method returning E_NOTIMPL with no
* extended error info to indicate that USB is simply not available
* (w/o treting it as a failure), for example, as in OSE */
return E_NOTIMPL;
#endif
}
{
#ifdef VBOX_WITH_USB
if (!aFilter)
return E_INVALIDARG;
CHECK_READY();
if (!filter)
return setError (E_INVALIDARG,
tr ("The given USB device filter is not created within "
"this VirtualBox instance"));
return setError (E_INVALIDARG,
tr ("The given USB device filter is already in the list"));
/* iterate to the position... */
/* ...and insert */
/* notify the proxy (only when the filter is active) */
{
}
/* save the global settings */
return mParent->saveSettings();
#else
/* Note: The GUI depends on this method returning E_NOTIMPL with no
* extended error info to indicate that USB is simply not available
* (w/o treting it as a failure), for example, as in OSE */
return E_NOTIMPL;
#endif
}
{
#ifdef VBOX_WITH_USB
if (!aFilter)
return E_POINTER;
CHECK_READY();
if (!mUSBDeviceFilters.size())
return setError (E_INVALIDARG,
tr ("The USB device filter list is empty"));
return setError (E_INVALIDARG,
tr ("Invalid position: %lu (must be in range [0, %lu])"),
{
/* iterate to the position... */
/* ...get an element from there... */
/* ...and remove */
}
/* notify the proxy (only when the filter is active) */
{
}
/* save the global settings */
return mParent->saveSettings();
#else
/* Note: The GUI depends on this method returning E_NOTIMPL with no
* extended error info to indicate that USB is simply not available
* (w/o treting it as a failure), for example, as in OSE */
return E_NOTIMPL;
#endif
}
// public methods only for internal purposes
////////////////////////////////////////////////////////////////////////////////
/**
* Called by setter methods of all USB device filters.
*/
{
CHECK_READY();
{
if (aActiveChanged)
{
{
}
else
{
}
}
else
{
{
// update the filter in the proxy
}
}
// save the global settings... yeah, on every single filter property change
return mParent->saveSettings();
}
return S_OK;
}
{
CHECK_READY();
unsigned filterCount = 0;
{
bool active;
if (actionStr == L"Ignore")
else
if (actionStr == L"Hold")
else
action);
// error info is set by init() when appropriate
{
// notify the proxy (only when the filter is active)
{
}
}
}
return rc;
}
{
CHECK_READY();
// first, delete the entry
if (VBOX_SUCCESS (vrc))
{
}
// then, recreate it
{
// all are optional
// action is mandatory
else
else
++ it;
}
return S_OK;
}
/**
* Marks the given host USB device as captured by the given machine and returns
* it as IUSBDevice to the caller.
*
* Called by Console from the VM process (throug IInternalMachineControl).
* Must return extended error info in case of errors.
*/
{
CHECK_READY();
{
++ it;
}
if (!device)
return setError (E_INVALIDARG,
tr ("USB device with UUID {%s} is not currently attached to the host"),
return setError (E_INVALIDARG,
tr ("USB device '%s' with UUID {%s} cannot be accessed by guest "
"computers"),
return setError (E_INVALIDARG,
tr ("USB device '%s' with UUID {%s} is being exclusively used by the "
"host computer"),
return setError (E_INVALIDARG,
tr ("USB device '%s' with UUID {%s} is already captured by the virtual "
"machine '%ls'"),
// try capture the device
if (!ok)
{
tr ("USB device with UUID {%s} is being accessed by the host "
"computer and cannot be attached to the virtual machine."
"Please try later"),
else
}
// return the device to the caller as IUSBDevice
return S_OK;
}
/**
* Replays all filters against the given USB device excluding filters of the
* machine the device is currently marked as captured by.
*
* Called by Console from the VM process (throug IInternalMachineControl).
*/
{
CHECK_READY();
{
++ it;
}
// reset the device and apply filters
ComAssertComRC (rc);
return rc;
}
/**
* Runs the filters of the given machine against all currently available USB
* devices, marks those that match as captured and returns them as the colection
* of IUSBDevice instances.
*
* Called by Console from the VM process (through IInternalMachineControl)
* upon VM startup.
*
* @note Locks this object for reading (@todo for writing now, until switched
* to the new locking scheme).
*/
{
CHECK_READY();
{
continue;
{
{
/* put the device to the return list */
ComPtr <IUSBDevice> d;
}
}
++ it;
}
coll.createObject();
return S_OK;
}
/**
* Replays all filters against all USB devices currently marked as captured
* by the given machine (excluding this machine's filters).
*
* Called by Console from the VM process (throug IInternalMachineControl)
* upon normal VM termination or by SessionMachine::uninit() upon abnormal
* VM termination (from under the Machine/SessionMachine lock).
*
* @note Locks this object for reading (@todo for writing now, until switched
* to the new locking scheme).
*/
{
CHECK_READY();
{
{
/* reset the device and apply filters */
ComAssertComRC (rc);
}
++ it;
}
return S_OK;
}
// private methods
////////////////////////////////////////////////////////////////////////////////
#ifdef __LINUX__
# ifdef VBOX_USE_LIBHAL
/**
* Helper function to query the hal subsystem for information about DVD drives attached to the
* system.
*
* @returns true if at least one drive was found, false otherwise
* @retval list drives found will be attached to this list
*/
{
bool halSuccess = false;
if (dbusConnection != 0)
{
if (halContext != 0)
{
{
{
int numDevices;
if (halDevices != 0)
{
for (int i = 0; i < numDevices; i++)
{
if (devNode != 0)
{
if (validateDevice(devNode, true))
{
char description[256];
/* We have at least one hit, so operation successful :) */
halSuccess = true;
if ((product != 0))
{
{
}
else
{
}
}
else
{
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to validate the block device %s as a DVD drive\n"));
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to get property \"block.device\" for device %s. dbus error: %s (%s)\n",
}
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to get devices with capability \"storage.cdrom\". dbus error: %s (%s)\n", dbusError.name, dbusError.message));
}
{
LogRel(("Host::COMGETTER(DVDDrives): failed to shutdown the libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to initialise libhal context. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to set libhal connection to dbus.\n"));
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to get a libhal context - out of memory?\n"));
}
}
else
{
LogRel(("Host::COMGETTER(DVDDrives): failed to connect to dbus. dbus error: %s (%s)\n", dbusError.name, dbusError.message));
}
return halSuccess;
}
# endif /* VBOX_USE_HAL defined */
/**
* Helper function to parse the given mount file and add found entries
*/
{
if (mtab)
{
char *mnt_type;
char *mnt_dev;
char *tmp;
{
// supermount fs case
{
if (tmp)
{
if (mnt_type)
{
if (tmp)
{
*tmp = '\0';
}
}
}
if (tmp)
{
if (mnt_dev)
{
if (tmp)
{
*tmp = '\0';
}
}
}
}
{
/** @todo check whether we've already got the drive in our list! */
if (validateDevice(mnt_dev, true))
{
}
}
}
}
}
/**
* Helper function to check whether the given device node is a valid drive
*/
{
bool retValue = false;
// sanity check
if (!deviceNode)
{
return false;
}
// first a simple stat() call
{
return false;
} else
{
if (isCDROM)
{
{
int fileHandle;
// now try to open the device
if (fileHandle >= 0)
{
// this call will finally reveal the whole truth
{
retValue = true;
}
}
}
} else
{
// floppy case
{
/// @todo do some more testing, maybe a nice IOCTL!
retValue = true;
}
}
}
return retValue;
}
#endif // __LINUX__
/**
* Runs through all global filters to determine the state of the given
* USB device, then unless ignored, runs trhough filters of all running machines
* (excluding the given one) to automatically capture the device when there is a
* match (the state of the device will be set to USBDeviceCaptured if so, and
* the machine's process will be informed about the auto-capture).
*
* @param aDevice USB device to set state for
* @param aMachine the machine whose filters are to be excluded (can be NULL)
*
* @note the method must be called from under this object's lock
*/
{
LogFlowMember (("Host::applyAllUSBFilters: \n"));
/* ignore unsupported devices */
return S_OK;
/* ignore unavailable devices as well */
return S_OK;
/* apply global filters */
{
{
return S_OK;
break;
}
++ it;
}
/* apply machine filters */
{
continue;
{
// inform the machine's process about the auto-capture
ComPtr <IUSBDevice> d;
return rc;
// the machine rejected it, continue applying filters.
}
}
/* no machine filters were matched.
* if no global filters were matched as well, release the device
* to make it available on the host */
aDevice->setHostDriven();
/** @todo dmik, what about USBDeviceFilterHold??? */
/**
* bird, everything's ok from what I see. if USBDeviceFilterHold filter was
* matched, setHostDevice() will not (and should not) be called
* (because it != mUSBDeviceFilters.end() in that case).
*/
return S_OK;
}
/**
* Runs through filters of the given machine in order to automatically capture
* the given USB device when there is a match (the state of the device will
* be set to USBDeviceCaptured if so, but the machine's process will *NOT* be)
* informed about the auto-capture).
*
* @param aMachine the machine whose filters are to be run
* @param aDevice USB device, a candidate for auto-attaching
*
* @note Locks aMachine for reading.
*/
{
LogFlowThisFunc (("\n"));
AssertReturn (aMachine, (void) 0);
if (!autoCaller.isOk())
{
/* silently return, the machine might be not running any more */
return;
}
/* enter the machine's lock because we want to access its USB controller */
{
/* try capture the device */
/*
* false is valid only when the state remains USBDeviceBusy meaning that
* the device is currently busy (being accessed by the host)
*/
}
}
/**
* Called by USB proxy service when a new device is physically attached
* to the host.
*
* @param aDevice Pointer to the device which has been attached.
*/
{
/// @todo (dmik) check locks
// add to the collecion
// apply all filters (no need to lock the device, nobody can access it yet)
AssertComRC (rc);
}
/**
* Called by USB proxy service (?) when the device is physically detached
* from the host.
*
* @param aDevice Pointer to the device which has been detached.
*/
{
/// @todo (dmik) check locks
{
{
break;
}
++ it;
}
AssertReturn (!!device, (void) 0);
// remove from the collecion
{
// the device is captured by a machine, instruct it to release
AssertComRC (rc);
}
}
/**
* Called by USB proxy service when the state of the host-driven device
* has changed because of non proxy interaction.
*
* @param aDevice The device in question.
*/
{
LogFlowMember (("Host::onUSBDeviceStateChanged: \n"));
/// @todo (dmik) check locks
/** @todo dmik, is there anything we should do here? For instance if the device now is available? */
}
/**
* Checks for the presense and status of the USB Proxy Service.
* Returns S_OK when the Proxy is present and OK, or E_FAIL and a
* corresponding error message otherwise. Intended to be used by methods
* that rely on the Proxy Service availability.
*
* @note Locks this object for reading.
*/
{
#ifdef VBOX_WITH_USB
CHECK_READY();
if (!mUSBProxyService->isActive())
{
/* disable the USB controller completely to avoid assertions if the
* USB proxy service could not start. */
tr ("Could not load the Host USB Proxy Service (%Vrc)."
"The service might be not installed on the host computer"),
else
tr ("Could not load the Host USB Proxy service (%Vrc)"),
}
return S_OK;
#else
return E_NOTIMPL;
#endif
}
#ifdef __WIN__
/* The original source of the VBoxTAP adapter creation/destruction code has the following copyright */
/*
Copyright 2004 by the Massachusetts Institute of Technology
All rights reserved.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of the Massachusetts
Institute of Technology (M.I.T.) not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.
M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
*/
/**
* Use the IShellFolder API to rename the connection.
*/
{
/* This is the GUID for the network connections folder. It is constant.
* {7007ACC7-3202-11D1-AAD2-00805FC1270E} */
const GUID CLSID_NetworkConnections = {
0x7007ACC7, 0x3202, 0x11D1, {
0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E
}
};
/* Build the display name in the form "::{GUID}". */
return E_INVALIDARG;
/* Create an instance of the network connections folder. */
reinterpret_cast <LPVOID *> (&pShellFolder));
/* Parse the display name. */
{
}
{
&pidl);
}
if (pShellFolder)
pShellFolder->Release();
return hr;
}
{
/* First try the IShellFolder interface, which was unimplemented
* for the network connections folder before XP. */
{
/** @todo that code doesn't seem to work! */
/* The IShellFolder interface is not implemented on this platform.
* Try the (undocumented) HrRenameConnection API in the netshell
* library. */
return E_FAIL;
return E_FAIL;
"HrRenameConnection");
if (RenameConnectionFunc == NULL)
{
return E_FAIL;
}
}
return status;
return S_OK;
}
#define SetErrBreak(strAndArgs) \
if (1) { \
} else do {} while (0)
/* static */
{
int vrc = VINF_SUCCESS;
do
{
/* for our purposes, 2k buffer is more
* than enough to obtain the hardware ID
* of the VBoxTAP driver. */
/* initialize the structure size */
/* copy the net class GUID */
/* create an empty device info set associated with the net class GUID */
if (hDeviceInfo == INVALID_HANDLE_VALUE)
SetErrBreak (("SetupDiCreateDeviceInfoList failed (0x%08X)",
GetLastError()));
/* get the class name from GUID */
if (!ok)
SetErrBreak (("SetupDiClassNameFromGuid failed (0x%08X)",
GetLastError()));
/* create a device info element and add the new device instance
* key to registry */
if (!ok)
SetErrBreak (("SetupDiCreateDeviceInfo failed (0x%08X)",
GetLastError()));
/* select the newly created device info to be the currently
selected member */
if (!ok)
SetErrBreak (("SetupDiSetSelectedDevice failed (0x%08X)",
GetLastError()));
/* build a list of class drivers */
if (!ok)
SetErrBreak (("SetupDiBuildDriverInfoList failed (0x%08X)",
GetLastError()));
destroyList = TRUE;
/* enumerate the driver info list */
while (TRUE)
{
/* if the function failed and GetLastError() returned
* ERROR_NO_MORE_ITEMS, then we have reached the end of the
* list. Othewise there was something wrong with this
* particular driver. */
if (!ret)
{
if(GetLastError() == ERROR_NO_MORE_ITEMS)
break;
else
{
index++;
continue;
}
}
/* if we successfully find the hardware ID and it turns out to
* be the one for the loopback driver, then we are done. */
sizeof (detailBuf),
NULL))
{
TCHAR * t;
/* pDriverInfoDetail->HardwareID is a MULTISZ string. Go through the
* whole list and see if there is a match somewhere. */
t = pDriverInfoDetail->HardwareID;
{
if (!_tcsicmp(t, DRIVERHWID))
break;
t += _tcslen(t) + 1;
}
{
break;
}
}
index ++;
}
if (!found)
"Please reinstall")));
/* set the loopback driver to be the currently selected */
if (!ok)
SetErrBreak (("SetupDiSetSelectedDriver failed (0x%08X)",
GetLastError()));
/* register the phantom device to prepare for install */
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller failed (0x%08X)",
GetLastError()));
/* registered, but remove if errors occur in the following code */
registered = TRUE;
/* ask the installer if we can install the device */
if (!ok)
{
if (GetLastError() != ERROR_DI_DO_DEFAULT)
SetErrBreak (("SetupDiCallClassInstaller (DIF_ALLOW_INSTALL) failed (0x%08X)",
GetLastError()));
/* that's fine */
}
/* install the files first */
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLDEVICEFILES) failed (0x%08X)",
GetLastError()));
/* get the device install parameters and disable filecopy */
if (ok)
{
if (!ok)
SetErrBreak (("SetupDiSetDeviceInstallParams failed (0x%08X)",
GetLastError()));
}
/*
* Register any device-specific co-installers for this device,
*/
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller (DIF_REGISTER_COINSTALLERS) failed (0x%08X)",
GetLastError()));
/*
* install any installer-specified interfaces.
* and then do the real install
*/
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLINTERFACES) failed (0x%08X)",
GetLastError()));
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller (DIF_INSTALLDEVICE) failed (0x%08X)",
GetLastError()));
/* Figure out NetCfgInstanceId */
0,
KEY_READ);
if (hkey == INVALID_HANDLE_VALUE)
SetErrBreak (("SetupDiOpenDevRegKey failed (0x%08X)",
GetLastError()));
cbSize = sizeof (pCfgGuidString);
RegCloseKey (hkey);
SetErrBreak (("Failed to set interface name (ret=0x%08X, "
"pCfgGuidString='%ls', cbSize=%d)",
}
while (0);
/*
* cleanup
*/
if (hDeviceInfo != INVALID_HANDLE_VALUE)
{
/* an error has occured, but the device is registered, we must remove it */
if (ret != 0 && registered)
/* destroy the driver info list */
if (destroyList)
/* clean up the device info set */
}
/* return the network connection GUID on success */
if (VBOX_SUCCESS (vrc))
{
/* remove the curly bracket at the end */
}
return vrc;
}
/* static */
{
int vrc = VINF_SUCCESS;
do
{
/* We have to find the device instance ID through a registry search */
HKEY hkeyNetwork = 0;
HKEY hkeyConnection = 0;
do
{
char strRegLocation [256];
"SYSTEM\\CurrentControlSet\\Control\\Network\\"
"{4D36E972-E325-11CE-BFC1-08002BE10318}\\{%s}",
KEY_READ, &hkeyNetwork);
SetErrBreak ((
tr ("Host interface network is not found in registry (%s) [1]"),
SetErrBreak ((
tr ("Host interface network is not found in registry (%s) [2]"),
SetErrBreak ((
tr ("Host interface network is not found in registry (%s) [3]"),
}
while (0);
if (hkeyConnection)
if (hkeyNetwork)
if (VBOX_FAILURE (vrc))
break;
/*
* Now we are going to enumerate all network devices and
* wait until we encounter the right device instance ID
*/
do
{
/* initialize the structure size */
/* copy the net class GUID */
/* return a device info set contains all installed devices of the Net class */
if (hDeviceInfo == INVALID_HANDLE_VALUE)
/* enumerate the driver info list */
while (TRUE)
{
if (!ok)
{
if (GetLastError() == ERROR_NO_MORE_ITEMS)
break;
else
{
index++;
continue;
}
}
/* try to get the hardware ID registry property */
NULL,
NULL,
0,
&size);
if (!ok)
{
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
index++;
continue;
}
NULL,
size,
NULL);
if (!ok)
{
free (deviceHwid);
deviceHwid = NULL;
index++;
continue;
}
}
else
{
/* something is wrong. This shouldn't have worked with a NULL buffer */
index++;
continue;
}
for (TCHAR *t = deviceHwid;
t += _tcslen (t) + 1)
{
if (!_tcsicmp (DRIVERHWID, t))
{
/* get the device instance ID */
{
/* compare to what we determined before */
{
break;
}
}
}
}
if (deviceHwid)
{
free (deviceHwid);
deviceHwid = NULL;
}
if (found)
break;
index++;
}
GetLastError()));
if (!ok)
SetErrBreak (("SetupDiSetSelectedDevice failed (0x%08X)",
GetLastError()));
if (!ok)
SetErrBreak (("SetupDiCallClassInstaller (DIF_REMOVE) failed (0x%08X)",
GetLastError()));
}
while (0);
/* clean up the device info set */
if (hDeviceInfo != INVALID_HANDLE_VALUE)
if (VBOX_FAILURE (vrc))
break;
}
while (0);
return vrc;
}
/* static */
{
LogFlowFunc (("aClient={%p}, aProgress={%p}, aUser={%p}\n",
d (static_cast <NetworkInterfaceHelperClientData *> (aUser));
{
/* "cleanup only" mode, just return (it will free aUser) */
return S_OK;
}
int vrc = VINF_SUCCESS;
switch (d->msgCode)
{
{
LogFlowFunc (("CreateHostNetworkInterface:\n"));
/* write message and parameters */
if (VBOX_FAILURE (vrc)) break;
if (VBOX_FAILURE (vrc)) break;
/* wait for a reply */
bool endLoop = false;
while (!endLoop)
{
if (VBOX_FAILURE (vrc)) break;
switch (reply)
{
{
/* read the GUID */
if (VBOX_FAILURE (vrc)) break;
/* initialize the object returned to the caller by
* CreateHostNetworkInterface() */
endLoop = true;
break;
}
{
/* read the error message */
if (VBOX_FAILURE (vrc)) break;
endLoop = true;
break;
}
default:
{
endLoop = true;
"Invalid message code %d (%08lX)\n",
}
}
}
break;
}
{
LogFlowFunc (("RemoveHostNetworkInterface:\n"));
/* write message and parameters */
if (VBOX_FAILURE (vrc)) break;
if (VBOX_FAILURE (vrc)) break;
/* wait for a reply */
bool endLoop = false;
while (!endLoop)
{
if (VBOX_FAILURE (vrc)) break;
switch (reply)
{
{
/* no parameters */
endLoop = true;
break;
}
{
/* read the error message */
if (VBOX_FAILURE (vrc)) break;
endLoop = true;
break;
}
default:
{
endLoop = true;
"Invalid message code %d (%08lX)\n",
}
}
}
break;
}
default:
"Invalid message code %d (%08lX)\n",
}
if (aVrc)
return rc;
}
/* static */
{
int vrc = VINF_SUCCESS;
switch (aMsgCode)
{
{
LogFlowFunc (("CreateHostNetworkInterface:\n"));
if (VBOX_FAILURE (vrc)) break;
if (VBOX_SUCCESS (vrc))
{
/* write success followed by GUID */
if (VBOX_FAILURE (vrc)) break;
if (VBOX_FAILURE (vrc)) break;
}
else
{
/* write failure followed by error message */
if (VBOX_FAILURE (vrc)) break;
if (VBOX_FAILURE (vrc)) break;
}
break;
}
{
LogFlowFunc (("RemoveHostNetworkInterface:\n"));
if (VBOX_FAILURE (vrc)) break;
if (VBOX_SUCCESS (vrc))
{
/* write parameter-less success */
if (VBOX_FAILURE (vrc)) break;
}
else
{
/* write failure followed by error message */
if (VBOX_FAILURE (vrc)) break;
if (VBOX_FAILURE (vrc)) break;
}
break;
}
default:
}
return vrc;
}
#endif /* __WIN__ */