Status getDeviceDriverInfo(const device_infoset_t& infoset,
SP_DEVINFO_DATA& device,
SP_DRVINFO_DATA& rDriverInfo,
SP_DRVINFO_DETAIL_DATA& rDriverInfoDetail) {
rDriverInfo.cbSize = sizeof(SP_DRVINFO_DATA);
rDriverInfoDetail.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
auto ret =
SetupDiBuildDriverInfoList(infoset.get(), &device, SPDIT_CLASSDRIVER);
if (ret == FALSE) {
return Status(GetLastError(), "Error building driver info list");
}
ret = SetupDiEnumDriverInfo(
infoset.get(), &device, SPDIT_CLASSDRIVER, 0, &rDriverInfo);
if (ret == FALSE) {
return Status(GetLastError(), "Error enumerating driver info");
}
ret = SetupDiGetDriverInfoDetail(infoset.get(),
&device,
&rDriverInfo,
&rDriverInfoDetail,
sizeof(SP_DRVINFO_DETAIL_DATA),
nullptr);
if (ret == FALSE) {
auto err = GetLastError();
// It's common to get INSUFFICIENT_BUFFER for some variable length fields in
// SP_DRVINFO_DETAIL_DATA, but we don't care about this info so ignore it
if (err != ERROR_INSUFFICIENT_BUFFER) {
return Status(err, "Error getting detailed driver info");
}
}
return Status();
}
VOID
EnumerateDrivers(PVOID Context, HDEVINFO hList, PSP_DEVINFO_DATA pInfoData)
{
HSPFILEQ hQueue;
SP_DEVINSTALL_PARAMS DeviceInstallParams = {0};
SP_DRVINFO_DATA DriverInfoData;
DWORD Result;
DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
if (!SetupDiGetDeviceInstallParamsW(hList, pInfoData, &DeviceInstallParams))
return;
DeviceInstallParams.FlagsEx |= (DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
if (!SetupDiSetDeviceInstallParams(hList, pInfoData, &DeviceInstallParams))
return;
if (!SetupDiBuildDriverInfoList(hList, pInfoData, SPDIT_CLASSDRIVER))
return;
DriverInfoData.cbSize = sizeof(DriverInfoData);
if (!SetupDiEnumDriverInfoW(hList, pInfoData, SPDIT_CLASSDRIVER, 0, &DriverInfoData))
return;
DriverInfoData.cbSize = sizeof(DriverInfoData);
if (!SetupDiSetSelectedDriverW(hList, pInfoData, &DriverInfoData))
return;
hQueue = SetupOpenFileQueue();
if (hQueue == (HSPFILEQ)INVALID_HANDLE_VALUE)
return;
DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
if (!SetupDiGetDeviceInstallParamsW(hList, pInfoData, &DeviceInstallParams))
{
SetupCloseFileQueue(hQueue);
return;
}
DeviceInstallParams.FileQueue = hQueue;
DeviceInstallParams.Flags |= DI_NOVCP;
if (!SetupDiSetDeviceInstallParamsW(hList, pInfoData, &DeviceInstallParams))
{
SetupCloseFileQueue(hQueue);
return;
}
if(!SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES, hList, pInfoData))
{
SetupCloseFileQueue(hQueue);
return;
}
/* enumerate the driver files */
SetupScanFileQueueW(hQueue, SPQ_SCAN_USE_CALLBACK, NULL, DriverFilesCallback, Context, &Result);
SetupCloseFileQueue(hQueue);
}
DWORD
InstallInfOnDevice(
IN HWND hWnd,
HDEVINFO DeviceInfoSet,
PSP_DEVINFO_DATA DeviceInfoData,
PTSTR Inf,
BOOL DelayInstall
)
{
DWORD Err = NO_ERROR;
SP_DEVINSTALL_PARAMS DeviceInstallParams;
BOOL Reboot = FALSE;
if (!SetupDiSetSelectedDevice(DeviceInfoSet, DeviceInfoData)) {
Err = GetLastError();
goto exit;
}
DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
if (!SetupDiGetDeviceInstallParams(DeviceInfoSet,
DeviceInfoData,
&DeviceInstallParams)) {
Err = GetLastError();
goto exit;
}
//
// Set DriverPath to the path of the INF that we want to install from.
// Set the DI_ENUMSINGLEINFO so setupapi builds up a driver list just from
// this specific INF.
// Set DI_DONOTCALLCONFIGMG so that we won't call kernel PnP when installing
// the driver. This will do all the install actions except stop/start the
// device so it won't start using the new driver until a reboot.
//
StringCchCopy(DeviceInstallParams.DriverPath,
SIZECHARS(DeviceInstallParams.DriverPath),
Inf);
DeviceInstallParams.hwndParent = hWnd;
DeviceInstallParams.Flags |= (DI_ENUMSINGLEINF | DI_QUIETINSTALL);
if (DelayInstall) {
DeviceInstallParams.Flags |= DI_DONOTCALLCONFIGMG;
}
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_ALLOWEXCLUDEDDRVS;
if (!SetupDiSetDeviceInstallParams(DeviceInfoSet,
DeviceInfoData,
&DeviceInstallParams)) {
Err = GetLastError();
goto exit;
}
//
// Build up a list of drivers from the specified INFs
//
if (!SetupDiBuildDriverInfoList(DeviceInfoSet, DeviceInfoData, SPDIT_COMPATDRIVER)) {
Err = GetLastError();
goto exit;
}
//
// Tell setupapi and the class installers to select the best driver from the
// list built from the specified INF.
//
if (!SetupDiCallClassInstaller(DIF_SELECTBESTCOMPATDRV,
DeviceInfoSet,
DeviceInfoData)) {
Err = GetLastError();
goto exit;
}
//
// Install the selected driver on the selected device without calling kernel mode
//
if (!InstallSelectedDriver(hWnd,
DeviceInfoSet,
NULL,
FALSE,
&Reboot)) {
Err = GetLastError();
goto exit;
}
exit:
return Err;
}
/**
* Install the VBox video driver.
*
* @returns TRUE on success.
* @returns FALSE on failure.
* @param szDriverDir The base directory where we find the INF.
*/
BOOL installVideoDriver(TCHAR* szDriverDir)
{
HDEVINFO hDevInfo;
SP_DEVINSTALL_PARAMS DeviceInstallParams={0};
SP_DRVINFO_DATA drvInfoData={0};
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData={0};
DWORD cbReqSize;
/* Vars used for reading the INF */
HINF hInf;
TCHAR szServiceSection[LINE_LEN];
INFCONTEXT serviceContext;
TCHAR szServiceData[LINE_LEN];
TCHAR deviceRegStr[1000];//I'm lazy here. 1000 ought to be enough for everybody...
SP_DEVINFO_DATA deviceInfoData;
DWORD configFlags;
HKEY hkey;
DWORD disp;
TCHAR regKeyName[LINE_LEN];
BOOL rc;
/* Create an empty list */
hDevInfo = SetupDiCreateDeviceInfoList((LPGUID) &GUID_DEVCLASS_DISPLAY,
NULL);
if (hDevInfo == INVALID_HANDLE_VALUE)
return FALSE;
memset(&DeviceInstallParams, 0, sizeof(SP_DEVINSTALL_PARAMS));
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
rc=SetupDiGetDeviceInstallParams(hDevInfo,
NULL,
&DeviceInstallParams);
if(!rc)
return FALSE;
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
DeviceInstallParams.Flags |= DI_NOFILECOPY | /* We did our own file copying */
DI_DONOTCALLCONFIGMG |
DI_ENUMSINGLEINF; /* .DriverPath specifies an inf file */
/* Path to inf file */
wsprintf(DeviceInstallParams.DriverPath,
TEXT("%ws\\%ws"),
szDriverDir, TEXT(VBOXGUEST_VIDEO_INF_NAME));
rc=SetupDiSetDeviceInstallParams(hDevInfo,
NULL,
&DeviceInstallParams);
if(!rc)
return FALSE;
/* Read the drivers from the inf file */
if (!SetupDiBuildDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER))
{
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
/* Get the first found driver.
Our Inf file only contains one so this is fine */
drvInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
if(FALSE==SetupDiEnumDriverInfo(hDevInfo, NULL, SPDIT_CLASSDRIVER,
0, &drvInfoData)){
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
/* Get necessary driver details */
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
if (!(!SetupDiGetDriverInfoDetail(hDevInfo,
NULL,
&drvInfoData,
&DriverInfoDetailData,
DriverInfoDetailData.cbSize,
&cbReqSize)
&&GetLastError()== ERROR_INSUFFICIENT_BUFFER) )
{
SetupDiDestroyDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER);
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
hInf = SetupOpenInfFile(DriverInfoDetailData.InfFileName,
NULL, INF_STYLE_WIN4, NULL);
if (hInf == INVALID_HANDLE_VALUE)
{
SetupDiDestroyDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER);
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
/* First install the service */
wsprintf(szServiceSection, TEXT("%ws.Services"),
DriverInfoDetailData.SectionName);
if(!SetupFindFirstLine(hInf, szServiceSection, NULL, &serviceContext))
{
/* No service line?? Can't be... */
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
/* Get the name */
SetupGetStringField(&serviceContext,
1,
szServiceData,
sizeof(szServiceData),
NULL);
wsprintf(deviceRegStr, TEXT("Root\\LEGACY_%ws\\0000"), szServiceData);
memset(&deviceInfoData, 0, sizeof(SP_DEVINFO_DATA));
deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if (SetupDiOpenDeviceInfo(hDevInfo, deviceRegStr, NULL, 0, &deviceInfoData) //Check for existing
||(SetupDiCreateDeviceInfo(hDevInfo, deviceRegStr, //Create new
(LPGUID) &GUID_DEVCLASS_DISPLAY,
NULL, //Do we need a description here?
NULL, //No user interface
0,
&deviceInfoData) &&
SetupDiRegisterDeviceInfo(hDevInfo,
&deviceInfoData,
0,
NULL,
NULL,
NULL)) )
{
/* We created a new key in the registry */
memset(&DeviceInstallParams, 0,sizeof(SP_DEVINSTALL_PARAMS));
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
SetupDiGetDeviceInstallParams(hDevInfo,
&deviceInfoData,
&DeviceInstallParams);
DeviceInstallParams.Flags |= DI_NOFILECOPY | //We already copied the files
DI_DONOTCALLCONFIGMG |
DI_ENUMSINGLEINF; //Use our INF file only
/* Path to inf file */
wsprintf(DeviceInstallParams.DriverPath,
TEXT("%ws\\%ws"),
szDriverDir, TEXT(VBOXGUEST_VIDEO_INF_NAME));
SetupDiSetDeviceInstallParams(hDevInfo,
&deviceInfoData,
&DeviceInstallParams);
if(!SetupDiBuildDriverInfoList(hDevInfo,
&deviceInfoData,
SPDIT_CLASSDRIVER))
{
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
drvInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
if (!SetupDiEnumDriverInfo(hDevInfo,
&deviceInfoData,
SPDIT_CLASSDRIVER,
0,
&drvInfoData))
{
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
if(!SetupDiSetSelectedDriver(hDevInfo,
&deviceInfoData,
&drvInfoData))
{
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
if(!SetupDiInstallDevice(hDevInfo,
&deviceInfoData))
{
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
}
/* Make sure the device is enabled */
if (SetupDiGetDeviceRegistryProperty(hDevInfo,
&deviceInfoData, SPDRP_CONFIGFLAGS,
NULL, (LPBYTE) &configFlags,
sizeof(DWORD),
NULL)
&& (configFlags & CONFIGFLAG_DISABLED))
{
configFlags &= ~CONFIGFLAG_DISABLED;
SetupDiSetDeviceRegistryProperty(hDevInfo,
&deviceInfoData,
SPDRP_CONFIGFLAGS,
(LPBYTE) &configFlags,
sizeof(DWORD));
}
wsprintf(regKeyName,
TEXT("System\\CurrentControlSet\\Services\\%ws\\Device%d"),
szServiceData, 0); //We only have one device
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
regKeyName,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_READ | KEY_WRITE,
NULL,
&hkey,
&disp) == ERROR_SUCCESS)
{
/* Insert description */
RegSetValueEx(hkey,
TEXT("Device Description"),
0,
REG_SZ,
(LPBYTE) DriverInfoDetailData.DrvDescription,
(lstrlen(DriverInfoDetailData.DrvDescription) + 1) *
sizeof(TCHAR) );
TCHAR szSoftwareSection[LINE_LEN];
wsprintf(szSoftwareSection,
TEXT("%ws.SoftwareSettings"),
szServiceData);
if (!SetupInstallFromInfSection(NULL,
hInf,
szSoftwareSection,
SPINST_REGISTRY,
hkey,
NULL,
0,
NULL,
NULL,
NULL,
NULL))
{
RegCloseKey(hkey);
closeAndDestroy(hDevInfo, hInf);
return FALSE;
}
RegCloseKey(hkey);
}
/* Install OpenGL stuff */
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\OpenGLDrivers"),
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_READ | KEY_WRITE,
NULL,
&hkey,
&disp) == ERROR_SUCCESS)
{
/* Do installation here if ever necessary. Currently there is no OpenGL stuff */
RegCloseKey(hkey);
}
/* Cleanup */
closeAndDestroy(hDevInfo, hInf);
#if 0
/* If this key is inserted into the registry, windows will show the desktop
applet on next boot. We decide in the installer if we want that so the code
is disabled here. */
/* Set registry keys so windows picks up the changes */
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Control\\GraphicsDrivers\\NewDisplay"),
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_READ | KEY_WRITE,
NULL,
&hkey,
&disp) == ERROR_SUCCESS)
{
RegCloseKey(hkey);
}
#endif
/* We must reboot at some point */
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
TEXT("SYSTEM\\CurrentControlSet\\Control\\GraphicsDrivers\\RebootNecessary"),
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_READ | KEY_WRITE,
NULL,
&hkey,
&disp) == ERROR_SUCCESS)
{
RegCloseKey(hkey);
}
return TRUE;
}
extern "C" DWORD InstallLoopBack(LPCTSTR pConnectionName, LPCTSTR ip, LPCTSTR mask)
{
BOOL ok;
DWORD ret = 0;
GUID netGuid;
HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA DeviceInfoData;
SP_DRVINFO_DATA DriverInfoData;
SP_DEVINSTALL_PARAMS DeviceInstallParams;
TCHAR className[MAX_PATH];
TCHAR temp[MAX_PATH];
DWORD index = 0;
BOOL found = FALSE;
BOOL registered = FALSE;
BOOL destroyList = FALSE;
PSP_DRVINFO_DETAIL_DATA pDriverInfoDetail;
DWORD detailBuf[2048]; // for our purposes, 8k buffer is more
// than enough to obtain the hardware ID
// of the loopback driver.
HKEY hkey = NULL;
DWORD cbSize;
DWORD dwValueType;
TCHAR pCfgGuidString[40];
// initialize the structure size
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
// copy the net class GUID
memcpy(&netGuid, &GUID_DEVCLASS_NET, sizeof(GUID_DEVCLASS_NET));
// create an empty device info set associated with the net class GUID
hDeviceInfo = SetupDiCreateDeviceInfoList(&netGuid, NULL);
if (hDeviceInfo == INVALID_HANDLE_VALUE)
return GetLastError();
// get the class name from GUID
ok = SetupDiClassNameFromGuid(&netGuid, className, MAX_PATH, NULL);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// create a device info element and add the new device instance
// key to registry
ok = SetupDiCreateDeviceInfo(hDeviceInfo, className, &netGuid, NULL, NULL,
DICD_GENERATE_ID, &DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// select the newly created device info to be the currently
// selected member
ok = SetupDiSetSelectedDevice(hDeviceInfo, &DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// build a list of class drivers
ok = SetupDiBuildDriverInfoList(hDeviceInfo, &DeviceInfoData,
SPDIT_CLASSDRIVER);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
destroyList = TRUE;
// enumerate the driver info list
while (TRUE)
{
BOOL ret;
ret = SetupDiEnumDriverInfo(hDeviceInfo, &DeviceInfoData,
SPDIT_CLASSDRIVER, index, &DriverInfoData);
// 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;
}
}
pDriverInfoDetail = (PSP_DRVINFO_DETAIL_DATA) detailBuf;
pDriverInfoDetail->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
// if we successfully find the hardware ID and it turns out to
// be the one for the loopback driver, then we are done.
if (SetupDiGetDriverInfoDetail(hDeviceInfo,
&DeviceInfoData,
&DriverInfoData,
pDriverInfoDetail,
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;
while (t && *t && t < (TCHAR *) &detailBuf[sizeof(detailBuf)/sizeof(detailBuf[0])]) {
if (!_tcsicmp(t, DRIVERHWID))
break;
t += _tcslen(t) + 1;
}
if (t && *t && t < (TCHAR *) &detailBuf[sizeof(detailBuf)/sizeof(detailBuf[0])]) {
found = TRUE;
break;
}
}
index++;
}
if (!found)
{
ret = GetLastError();
ReportMessage(0,"Could not find the driver to install", DRIVER_DESC, NULL, 0);
goto cleanup;
}
// set the loopback driver to be the currently selected
ok = SetupDiSetSelectedDriver(hDeviceInfo, &DeviceInfoData,
&DriverInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// register the phantom device to repare for install
ok = SetupDiCallClassInstaller(DIF_REGISTERDEVICE, hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// registered, but remove if errors occur in the following code
registered = TRUE;
// ask the installer if we can install the device
ok = SetupDiCallClassInstaller(DIF_ALLOW_INSTALL, hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
if (ret != ERROR_DI_DO_DEFAULT)
{
goto cleanup;
}
else
ret = 0;
}
// install the files first
ok = SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES, hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
// get the device install parameters and disable filecopy
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
ok = SetupDiGetDeviceInstallParams(hDeviceInfo, &DeviceInfoData,
&DeviceInstallParams);
if (ok)
{
DeviceInstallParams.Flags |= DI_NOFILECOPY;
ok = SetupDiSetDeviceInstallParams(hDeviceInfo, &DeviceInfoData,
&DeviceInstallParams);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
}
//
// Register any device-specific co-installers for this device,
//
ok = SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS,
hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
//
// install any installer-specified interfaces.
// and then do the real install
//
ok = SetupDiCallClassInstaller(DIF_INSTALLINTERFACES,
hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
goto cleanup;
}
PAUSE;
ok = SetupDiCallClassInstaller(DIF_INSTALLDEVICE,
hDeviceInfo,
&DeviceInfoData);
if (!ok)
{
ret = GetLastError();
PAUSE;
goto cleanup;
}
/* Skip to the end if we aren't setting the name */
if (!pConnectionName) goto cleanup;
// Figure out NetCfgInstanceId
hkey = SetupDiOpenDevRegKey(hDeviceInfo,
&DeviceInfoData,
DICS_FLAG_GLOBAL,
0,
DIREG_DRV,
KEY_READ);
if (hkey == INVALID_HANDLE_VALUE)
{
ret = GetLastError();
goto cleanup;
}
cbSize = sizeof(pCfgGuidString);
ret = RegQueryValueEx(hkey, _T("NetCfgInstanceId"), NULL,
&dwValueType, (LPBYTE)pCfgGuidString, &cbSize);
RegCloseKey(hkey);
ret = RenameConnection(pCfgGuidString, pConnectionName);
if (ret)
{
ReportMessage(0,"Could not set the connection name", NULL, pConnectionName, 0);
goto cleanup;
}
if (!ip) goto cleanup;
ret = SetIpAddress(pCfgGuidString, ip, mask);
if (ret)
{
ReportMessage(0,"Could not set the ip address and network mask",NULL,NULL,ret);
goto cleanup;
}
ret = LoopbackBindings(pCfgGuidString);
if (ret)
{
ReportMessage(0,"Could not properly set the bindings",NULL,NULL,0);
goto cleanup;
}
ret = !UpdateHostsFile( pConnectionName, ip, "hosts", FALSE );
if (ret)
{
ReportMessage(0,"Could not update hosts file",NULL,NULL,0);
goto cleanup;
}
ret = !UpdateHostsFile( pConnectionName, ip, "lmhosts", TRUE );
if (ret)
{
ReportMessage(0,"Could not update lmhosts file",NULL,NULL,0);
goto cleanup;
}
cleanup:
// an error has occured, but the device is registered, we must remove it
if (ret != 0 && registered)
SetupDiCallClassInstaller(DIF_REMOVE, hDeviceInfo, &DeviceInfoData);
found = SetupDiDeleteDeviceInfo(hDeviceInfo, &DeviceInfoData);
// destroy the driver info list
if (destroyList)
SetupDiDestroyDriverInfoList(hDeviceInfo, &DeviceInfoData,
SPDIT_CLASSDRIVER);
// clean up the device info set
if (hDeviceInfo != INVALID_HANDLE_VALUE)
SetupDiDestroyDeviceInfoList(hDeviceInfo);
return ret;
};
static HRESULT vboxDrvCfgCollectInfsSetupDi(const GUID * pGuid, LPCWSTR pPnPId, VBoxDrvCfgStringList & list)
{
DWORD dwErr = ERROR_SUCCESS;
int counter = 0;
HDEVINFO hDevInfo = SetupDiCreateDeviceInfoList(
pGuid, /* IN LPGUID ClassGuid, OPTIONAL */
NULL /*IN HWND hwndParent OPTIONAL */
);
if (hDevInfo != INVALID_HANDLE_VALUE)
{
if (SetupDiBuildDriverInfoList(hDevInfo,
NULL, /*IN OUT PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER /*IN DWORD DriverType*/
))
{
SP_DRVINFO_DATA DrvInfo;
DrvInfo.cbSize = sizeof(SP_DRVINFO_DATA);
char DetailBuf[16384];
PSP_DRVINFO_DETAIL_DATA pDrvDetail = (PSP_DRVINFO_DETAIL_DATA)DetailBuf;
for (DWORD i = 0; ; i++)
{
if (SetupDiEnumDriverInfo(hDevInfo,
NULL, /* IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER , /*IN DWORD DriverType,*/
i, /*IN DWORD MemberIndex,*/
&DrvInfo /*OUT PSP_DRVINFO_DATA DriverInfoData*/
))
{
DWORD dwReq;
pDrvDetail->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
if (SetupDiGetDriverInfoDetail(
hDevInfo, /*IN HDEVINFO DeviceInfoSet,*/
NULL, /*IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
&DrvInfo, /*IN PSP_DRVINFO_DATA DriverInfoData,*/
pDrvDetail, /*OUT PSP_DRVINFO_DETAIL_DATA DriverInfoDetailData, OPTIONAL*/
sizeof(DetailBuf), /*IN DWORD DriverInfoDetailDataSize,*/
&dwReq /*OUT PDWORD RequiredSize OPTIONAL*/
))
{
for (WCHAR * pHwId = pDrvDetail->HardwareID; pHwId && *pHwId && pHwId < (TCHAR*)(DetailBuf + sizeof(DetailBuf)/sizeof(DetailBuf[0])) ;pHwId += wcslen(pHwId) + 1)
{
if (!wcsicmp(pHwId, pPnPId))
{
NonStandardAssert(pDrvDetail->InfFileName[0]);
if (pDrvDetail->InfFileName)
{
list.add(pDrvDetail->InfFileName);
}
}
}
}
else
{
DWORD dwErr = GetLastError();
NonStandardLogRelCrap((__FUNCTION__": SetupDiGetDriverInfoDetail fail dwErr=%ld, size(%d)", dwErr, dwReq));
// NonStandardAssert(0);
}
}
else
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_NO_MORE_ITEMS)
{
break;
}
NonStandardAssert(0);
}
}
SetupDiDestroyDriverInfoList(hDevInfo,
NULL, /*IN PSP_DEVINFO_DATA DeviceInfoData, OPTIONAL*/
SPDIT_CLASSDRIVER/*IN DWORD DriverType*/
);
}
else
{
dwErr = GetLastError();
NonStandardAssert(0);
}
SetupDiDestroyDeviceInfoList(hDevInfo);
}
else
{
dwErr = GetLastError();
NonStandardAssert(0);
}
return HRESULT_FROM_WIN32(dwErr);
}
HRESULT
xDiEnumDriverFiles(
__in_opt HWND Owner,
__in LPCWSTR OemInfFullPath,
__in DWORD Flags,
__in XDI_ENUM_DRIVER_FILE_CALLBACK EnumCallback,
__in LPVOID EnumContext)
{
HRESULT hr;
BOOL success;
WCHAR infFullPath[MAX_PATH];
DWORD n = GetFullPathNameW(OemInfFullPath, MAX_PATH, infFullPath, NULL);
if (0 == n)
{
hr = HRESULT_FROM_WIN32(GetLastError());
hr = (SUCCEEDED(hr)) ? E_FAIL : hr;
goto error0;
}
HDEVINFO devInfoSet = SetupDiCreateDeviceInfoList(NULL, Owner);
if (INVALID_HANDLE_VALUE == devInfoSet)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error0;
}
SP_DEVINFO_DATA devInfoData = { sizeof(SP_DEVINFO_DATA) };
success = SetupDiCreateDeviceInfoW(
devInfoSet,
L"XDI_Temporary_Enumerator",
&GUID_NULL,
NULL,
NULL,
DICD_GENERATE_ID,
&devInfoData);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error1;
}
HSPFILEQ fileQueueHandle = SetupOpenFileQueue();
if (INVALID_HANDLE_VALUE == fileQueueHandle)
{
// Error from SetupOpenFileQueue is only from out-of-memory situation
// without the last error set
hr = E_OUTOFMEMORY;
goto error2;
}
SP_DEVINSTALL_PARAMS devInstallParams = {sizeof(SP_DEVINSTALL_PARAMS)};
success = SetupDiGetDeviceInstallParamsW(
devInfoSet,
&devInfoData,
&devInstallParams);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error3;
}
//
// Specify the search path
//
hr = StringCchCopyW(
devInstallParams.DriverPath,
MAX_PATH,
infFullPath);
if (FAILED(hr))
{
goto error3;
}
devInstallParams.FlagsEx |= DI_FLAGSEX_ALLOWEXCLUDEDDRVS;
devInstallParams.FileQueue = fileQueueHandle;
devInstallParams.Flags |= DI_NOVCP;
devInstallParams.Flags |= DI_ENUMSINGLEINF;
success = SetupDiSetDeviceInstallParamsW(
devInfoSet,
&devInfoData,
&devInstallParams);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error3;
}
//
// use DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE if possible
// to ensure we look at duplicate nodes (which is broken in itself)
//
#ifndef DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE
#define DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE 0x08000000L // Don't remove identical driver nodes from the class list
#endif
if (xDipWindowsXPOrLater())
{
devInstallParams.FlagsEx |= DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE;
success = SetupDiSetDeviceInstallParamsW(
devInfoSet,
&devInfoData,
&devInstallParams);
if (!success)
{
devInstallParams.FlagsEx &= ~DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE;
}
}
//
// Build a class driver list with every driver
//
success = SetupDiBuildDriverInfoList(
devInfoSet,
&devInfoData,
SPDIT_CLASSDRIVER);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error3;
}
SP_DRVINFO_DATA drvInfoData = { sizeof(SP_DRVINFO_DATA) };
for (DWORD index = 0; ; ++index)
{
success = SetupDiEnumDriverInfoW(
devInfoSet,
&devInfoData,
SPDIT_CLASSDRIVER,
index,
&drvInfoData);
if (!success)
{
break;
}
SP_DRVINFO_DETAIL_DATA drvInfoDetail = { sizeof(SP_DRVINFO_DETAIL_DATA) };
success = SetupDiGetDriverInfoDetailW(
devInfoSet,
&devInfoData,
&drvInfoData,
&drvInfoDetail,
sizeof(SP_DRVINFO_DETAIL_DATA),
NULL);
if (!success && ERROR_INSUFFICIENT_BUFFER != GetLastError())
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error4;
}
success = SetupDiSetSelectedDriverW(
devInfoSet,
&devInfoData,
&drvInfoData);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error4;
}
if (Flags & XDI_EDF_NO_CLASS_INSTALLER)
{
success = SetupDiInstallDriverFiles(
devInfoSet, &devInfoData);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error4;
}
}
else
{
success = SetupDiCallClassInstaller(
DIF_INSTALLDEVICEFILES, devInfoSet, &devInfoData);
if (!success)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error4;
}
}
}
//
// SPQ_SCAN_USE_CALLBACK_EX checks the digital signature of the file
// We do not want to check the signature here.
//
// SPQ_SCAN_FILE_PRESENCE avoids checking the digital signature of the file
// in Windows XP or later. (Not in Windows 2000) when used
// with SPQ_SCAN_USE_CALLBACK_EX
//
XDI_ENUM_FQS_CONTEXT fqsContext = {0};
fqsContext.Callback = EnumCallback;
fqsContext.CallbackContext = EnumContext;
DWORD scanResult;
success = SetupScanFileQueueW(
fileQueueHandle,
SPQ_SCAN_USE_CALLBACK,
// SPQ_SCAN_USE_CALLBACKEX | SPQ_SCAN_FILE_PRESENCE,
Owner,
xDipEnumFileQueueScanCallback,
&fqsContext,
&scanResult);
if (!success)
{
//
// SetupScanFileQueue may fail using SPQ_SCAN_FILE_PRESENSE flag
// Try again without SPQ_SCAN_FILE_PRESENSE
// (when using SPQ_SCAN_USE_CALLBACKEX)
//
hr = HRESULT_FROM_SETUPAPI(GetLastError());
goto error4;
}
hr = S_OK;
#pragma warning(disable: 4533) // to use goto in cpp
error4:
SetupDiDestroyDriverInfoList(
devInfoSet, &devInfoData, SPDIT_CLASSDRIVER);
error3:
SetupCloseFileQueue(fileQueueHandle);
error2:
SetupDiDeleteDeviceInfo(devInfoSet, &devInfoData);
error1:
SetupDiDestroyDeviceInfoList(devInfoSet);
error0:
#pragma warning(default: 4533)
return hr;
}
/* Directory and InfFile MUST NOT be specified simultaneously */
static BOOL
SearchDriver(
IN PDEVINSTDATA DevInstData,
IN LPCWSTR Directory OPTIONAL,
IN LPCWSTR InfFile OPTIONAL)
{
SP_DEVINSTALL_PARAMS_W DevInstallParams = {0,};
BOOL ret;
DevInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
if (!SetupDiGetDeviceInstallParamsW(DevInstData->hDevInfo, &DevInstData->devInfoData, &DevInstallParams))
{
TRACE("SetupDiGetDeviceInstallParams() failed with error 0x%x\n", GetLastError());
return FALSE;
}
DevInstallParams.FlagsEx |= DI_FLAGSEX_ALLOWEXCLUDEDDRVS;
if (InfFile)
{
DevInstallParams.Flags |= DI_ENUMSINGLEINF;
wcsncpy(DevInstallParams.DriverPath, InfFile, MAX_PATH);
}
else if (Directory)
{
DevInstallParams.Flags &= ~DI_ENUMSINGLEINF;
wcsncpy(DevInstallParams.DriverPath, Directory, MAX_PATH);
}
else
{
DevInstallParams.Flags &= ~DI_ENUMSINGLEINF;
*DevInstallParams.DriverPath = '\0';
}
ret = SetupDiSetDeviceInstallParamsW(
DevInstData->hDevInfo,
&DevInstData->devInfoData,
&DevInstallParams);
if (!ret)
{
TRACE("SetupDiSetDeviceInstallParams() failed with error 0x%x\n", GetLastError());
return FALSE;
}
ret = SetupDiBuildDriverInfoList(
DevInstData->hDevInfo,
&DevInstData->devInfoData,
SPDIT_COMPATDRIVER);
if (!ret)
{
TRACE("SetupDiBuildDriverInfoList() failed with error 0x%x\n", GetLastError());
return FALSE;
}
DevInstData->drvInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
ret = SetupDiEnumDriverInfoW(
DevInstData->hDevInfo,
&DevInstData->devInfoData,
SPDIT_COMPATDRIVER,
0,
&DevInstData->drvInfoData);
if (!ret)
{
if (GetLastError() == ERROR_NO_MORE_ITEMS)
return FALSE;
TRACE("SetupDiEnumDriverInfo() failed with error 0x%x\n", GetLastError());
return FALSE;
}
return TRUE;
}
BOOL FindCurrentDriver(_In_ HDEVINFO Devs, _In_ PSP_DEVINFO_DATA DevInfo, _In_ PSP_DRVINFO_DATA DriverInfoData)
/*++
Routine Description:
Find the driver that is associated with the current device
We can do this either the quick way (available in WinXP)
or the long way that works in Win2k.
Arguments:
Devs )_ uniquely identify device
DevInfo )
Return Value:
TRUE if we managed to determine and select current driver
--*/
{
SP_DEVINSTALL_PARAMS deviceInstallParams;
WCHAR SectionName[LINE_LEN];
WCHAR DrvDescription[LINE_LEN];
WCHAR MfgName[LINE_LEN];
WCHAR ProviderName[LINE_LEN];
HKEY hKey = NULL;
DWORD RegDataLength;
DWORD RegDataType;
DWORD c;
BOOL match = FALSE;
long regerr;
ZeroMemory(&deviceInstallParams, sizeof(deviceInstallParams));
deviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
if(!SetupDiGetDeviceInstallParams(Devs, DevInfo, &deviceInstallParams)) {
return FALSE;
}
#ifdef DI_FLAGSEX_INSTALLEDDRIVER
//
// Set the flags that tell SetupDiBuildDriverInfoList to just put the
// currently installed driver node in the list, and that it should allow
// excluded drivers. This flag introduced in WinXP.
//
deviceInstallParams.FlagsEx |= (DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
if(SetupDiSetDeviceInstallParams(Devs, DevInfo, &deviceInstallParams)) {
//
// we were able to specify this flag, so proceed the easy way
// we should get a list of no more than 1 driver
//
if(!SetupDiBuildDriverInfoList(Devs, DevInfo, SPDIT_CLASSDRIVER)) {
return FALSE;
}
if (!SetupDiEnumDriverInfo(Devs, DevInfo, SPDIT_CLASSDRIVER,
0, DriverInfoData)) {
return FALSE;
}
//
// we've selected the current driver
//
return TRUE;
}
deviceInstallParams.FlagsEx &= ~(DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
#endif
//
// The following method works in Win2k, but it's slow and painful.
//
// First, get driver key - if it doesn't exist, no driver
//
hKey = SetupDiOpenDevRegKey(Devs,
DevInfo,
DICS_FLAG_GLOBAL,
0,
DIREG_DRV,
KEY_READ
);
if(hKey == INVALID_HANDLE_VALUE) {
//
// no such value exists, so there can't be an associated driver
//
RegCloseKey(hKey);
return FALSE;
}
//
// obtain path of INF - we'll do a search on this specific INF
//
RegDataLength = sizeof(deviceInstallParams.DriverPath); // bytes!!!
regerr = RegQueryValueEx(hKey,
REGSTR_VAL_INFPATH,
NULL,
&RegDataType,
(PBYTE)deviceInstallParams.DriverPath,
&RegDataLength
);
if((regerr != ERROR_SUCCESS) || (RegDataType != REG_SZ)) {
//
// no such value exists, so no associated driver
//
RegCloseKey(hKey);
return FALSE;
}
//
// obtain name of Provider to fill into DriverInfoData
//
RegDataLength = sizeof(ProviderName); // bytes!!!
regerr = RegQueryValueEx(hKey,
REGSTR_VAL_PROVIDER_NAME,
NULL,
&RegDataType,
(PBYTE)ProviderName,
&RegDataLength
);
if((regerr != ERROR_SUCCESS) || (RegDataType != REG_SZ)) {
//
// no such value exists, so we don't have a valid associated driver
//
RegCloseKey(hKey);
return FALSE;
}
//
// obtain name of section - for final verification
//
RegDataLength = sizeof(SectionName); // bytes!!!
regerr = RegQueryValueEx(hKey,
REGSTR_VAL_INFSECTION,
NULL,
&RegDataType,
(PBYTE)SectionName,
&RegDataLength
);
if((regerr != ERROR_SUCCESS) || (RegDataType != REG_SZ)) {
//
// no such value exists, so we don't have a valid associated driver
//
RegCloseKey(hKey);
return FALSE;
}
//
// driver description (need not be same as device description)
// - for final verification
//
RegDataLength = sizeof(DrvDescription); // bytes!!!
regerr = RegQueryValueEx(hKey,
REGSTR_VAL_DRVDESC,
NULL,
&RegDataType,
(PBYTE)DrvDescription,
&RegDataLength
);
RegCloseKey(hKey);
if((regerr != ERROR_SUCCESS) || (RegDataType != REG_SZ)) {
//
// no such value exists, so we don't have a valid associated driver
//
return FALSE;
}
//
// Manufacturer (via SPDRP_MFG, don't access registry directly!)
//
if(!SetupDiGetDeviceRegistryProperty(Devs,
DevInfo,
SPDRP_MFG,
NULL, // datatype is guaranteed to always be REG_SZ.
(PBYTE)MfgName,
sizeof(MfgName), // bytes!!!
NULL)) {
//
// no such value exists, so we don't have a valid associated driver
//
return FALSE;
}
//
// now search for drivers listed in the INF
//
//
deviceInstallParams.Flags |= DI_ENUMSINGLEINF;
deviceInstallParams.FlagsEx |= DI_FLAGSEX_ALLOWEXCLUDEDDRVS;
if(!SetupDiSetDeviceInstallParams(Devs, DevInfo, &deviceInstallParams)) {
return FALSE;
}
if(!SetupDiBuildDriverInfoList(Devs, DevInfo, SPDIT_CLASSDRIVER)) {
return FALSE;
}
//
// find the entry in the INF that was used to install the driver for
// this device
//
for(c=0;SetupDiEnumDriverInfo(Devs,DevInfo,SPDIT_CLASSDRIVER,c,DriverInfoData);c++) {
if((_tcscmp(DriverInfoData->MfgName,MfgName)==0)
&&(_tcscmp(DriverInfoData->ProviderName,ProviderName)==0)) {
//
// these two fields match, try more detailed info
// to ensure we have the exact driver entry used
//
SP_DRVINFO_DETAIL_DATA detail;
detail.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
if(!SetupDiGetDriverInfoDetail(Devs,DevInfo,DriverInfoData,&detail,sizeof(detail),NULL)
&& (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
continue;
}
if((_tcscmp(detail.SectionName,SectionName)==0) &&
(_tcscmp(detail.DrvDescription,DrvDescription)==0)) {
match = TRUE;
break;
}
}
}
if(!match) {
SetupDiDestroyDriverInfoList(Devs,DevInfo,SPDIT_CLASSDRIVER);
}
return match;
}
int uninstallCMUDriver()
{
GUID guid = t1394CmdrGetGUID();
HDEVINFO hDI = SetupDiGetClassDevs(&guid,NULL,NULL,DIGCF_DEVICEINTERFACE);
if(hDI != INVALID_HANDLE_VALUE)
{
SP_DEVINFO_DATA devInfoData;
int index = 0;
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
while(SetupDiEnumDeviceInfo(hDI,index,&devInfoData))
{
printf(" - Device %d:\n",index);
if(index == 0)
{
// look for OEM inf files
if(SetupDiBuildDriverInfoList(hDI,&devInfoData,SPDIT_COMPATDRIVER))
{
SP_DRVINFO_DATA drvInfoData;
drvInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
int driverIndex = 0;
while(SetupDiEnumDriverInfo(hDI,&devInfoData,SPDIT_COMPATDRIVER,driverIndex++,&drvInfoData))
{
SP_DRVINFO_DETAIL_DATA drvInfoDetail;
drvInfoDetail.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
BOOL ret = SetupDiGetDriverInfoDetail(hDI,&devInfoData,&drvInfoData,&drvInfoDetail,drvInfoDetail.cbSize,NULL);
if(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
printf(" - has OEM inf file '%s'\n",drvInfoDetail.InfFileName);
if(!DeleteFile(drvInfoDetail.InfFileName))
{
printf(" - could not delete '%s' : %d",drvInfoDetail.InfFileName,GetLastError());
}
drvInfoDetail.InfFileName[lstrlen(drvInfoDetail.InfFileName) - 3] = 'p';
if(!DeleteFile(drvInfoDetail.InfFileName))
{
printf(" - could not delete '%s' : %d",drvInfoDetail.InfFileName,GetLastError());
}
} else {
printf(" - SetupDiGetDriverInfoDetail: %d\n",GetLastError());
}
}
if(GetLastError() != ERROR_NO_MORE_ITEMS)
{
printf(" - SetupDiEnumDriverInfo: %d\n",GetLastError());
}
SetupDiDestroyDriverInfoList(hDI,&devInfoData,SPDIT_COMPATDRIVER);
} else {
printf(" - SetupDiEnumDriverInfo: %d\n",GetLastError());
}
} // else already nuked oem inf files
if(SetupDiCallClassInstaller(DIF_REMOVE,hDI,&devInfoData))
{
printf(" - has been removed!\n");
} else {
printf(" - could not be removed: %d\n",GetLastError());
}
index++;
}
if(index == 0)
{
printf("No Devices Found!\n");
}
SetupDiDestroyDeviceInfoList(hDI);
} else {
printf("Failed to get class devs!\n");
}
return 0;
}
////////////////////////////
// FETCH USB DRIVER VERSION
void windozeHelpers::FetchUsbDriverVersion( const uint16_t DeviceNum, std::string & version )
{
HDEVINFO deviceInfo = 0;
SP_DEVICE_INTERFACE_DATA interfaceData;
std::string msg;
if( !EnumerateDevice( DeviceNum, deviceInfo, interfaceData, msg ) )
{
apgHelper::throwRuntimeException( __FILE__, msg, __LINE__, Apg::ErrorType_Connection );
}
SP_DEVINFO_DATA deviceData;
deviceData.cbSize = sizeof(SP_DEVINFO_DATA);
if( !SetupDiEnumDeviceInfo( deviceInfo, DeviceNum, &deviceData ) )
{
//getting the windows error message b4 the next winapi calls
//nukes it out. then throw the error
std::string errMsg = "SetupDiEnumDeviceInfo failed "
+ windozeHelpers::GetLastWinError();
SetupDiDestroyDeviceInfoList(deviceInfo);
apgHelper::throwRuntimeException( __FILE__,
errMsg , __LINE__,Apg::ErrorType_Connection );
}
//from BOOL DumpDeviceDriverNodes in dump.cpp in
//C:\WinDDK\6001.18002\src\setup\devcon
SP_DEVINSTALL_PARAMS deviceInstallParams;
SP_DRVINFO_DATA driverInfoData;
ZeroMemory(&deviceInstallParams, sizeof(deviceInstallParams));
ZeroMemory(&driverInfoData, sizeof(driverInfoData));
driverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
deviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
if( !SetupDiGetDeviceInstallParams(deviceInfo, &deviceData,
&deviceInstallParams) )
{
std::string errMsg = "SetupDiGetDeviceInstallParams failed "
+ windozeHelpers::GetLastWinError();
SetupDiDestroyDeviceInfoList(deviceInfo);
apgHelper::throwRuntimeException( __FILE__,
errMsg , __LINE__,Apg::ErrorType_Connection );
}
//
// Set the flags that tell SetupDiBuildDriverInfoList to allow excluded drivers.
//
deviceInstallParams.FlagsEx |= (DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
if( !SetupDiSetDeviceInstallParams(deviceInfo, &deviceData,
&deviceInstallParams) )
{
std::string errMsg = "SetupDiGetDeviceInstallParams failed "
+ windozeHelpers::GetLastWinError();
SetupDiDestroyDeviceInfoList(deviceInfo);
apgHelper::throwRuntimeException( __FILE__,
errMsg , __LINE__,Apg::ErrorType_Connection );
}
if( !SetupDiBuildDriverInfoList(deviceInfo, &deviceData,
SPDIT_COMPATDRIVER) )
{
std::string errMsg = "SetupDiBuildDriverInfoList failed "
+ windozeHelpers::GetLastWinError();
SetupDiDestroyDeviceInfoList(deviceInfo);
apgHelper::throwRuntimeException( __FILE__,
errMsg , __LINE__,Apg::ErrorType_Connection );
}
// believe the member index should be set to 0 for all
// devices...not 100% sure what this parameter is referring
// to, the number of devices, the number of driver interfaces,
// number of device interfaces????
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff551018(v=vs.85).aspx
if( !SetupDiEnumDriverInfo(deviceInfo, &deviceData,
SPDIT_COMPATDRIVER, 0, &driverInfoData) )
{
std::string errMsg = "SetupDiEnumDriverInfo failed "
+ windozeHelpers::GetLastWinError();
SetupDiDestroyDriverInfoList(deviceInfo, &deviceData,
SPDIT_COMPATDRIVER);
SetupDiDestroyDeviceInfoList(deviceInfo);
apgHelper::throwRuntimeException( __FILE__,
errMsg , __LINE__,Apg::ErrorType_Connection );
}
ULARGE_INTEGER Version;
Version.QuadPart = driverInfoData.DriverVersion;
std::stringstream ss;
ss << HIWORD(Version.HighPart) << ".";
ss << LOWORD(Version.HighPart) << ".";
ss << HIWORD(Version.LowPart) << ".";
ss << LOWORD(Version.LowPart);
version = ss.str();
SetupDiDestroyDriverInfoList(deviceInfo, &deviceData,
SPDIT_COMPATDRIVER);
SetupDiDestroyDeviceInfoList(deviceInfo);
}
void InstallDriver( HANDLE DeviceInformation, SP_DEVINFO_DATA* DeviceData )
{
SP_DEVINSTALL_PARAMS_W deviceInstallParams;
SP_DRVINFO_DATA_V2_W driverData;
UINT32 reboot = 0;
HANDLE module;
DWORD address;
BYTE *addr;
if (!SetupDiSetSelectedDevice(DeviceInformation, DeviceData))
{
Log(L"Set Selected Device fail.");
return;
}
Memory_Clear(&deviceInstallParams, sizeof(SP_DEVINSTALL_PARAMS_W));
if (sizeof(int*) == 8)
{
deviceInstallParams.cbSize = 584;
}
else
{
deviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
}
if (!SetupDiGetDeviceInstallParamsW(DeviceInformation, DeviceData, &deviceInstallParams))
{
Log(L"Get Device Install Params fail.");
return;
}
String_Copy(deviceInstallParams.DriverPath, L"C:\\mij\\drivers\\MijXinput.inf");
deviceInstallParams.Flags |= 65536;
if (!SetupDiSetDeviceInstallParamsW(DeviceInformation, DeviceData, &deviceInstallParams))
{
Log(L"Set Device Install Params fail.");
return;
}
if (!SetupDiBuildDriverInfoList(DeviceInformation, DeviceData, SPDIT_COMPATDRIVER))
{
Log(L"Building Driver Info List fail.");
return;
}
if (!SetupDiSelectBestCompatDrv(DeviceInformation, DeviceData))
{
Log(L"Select Best Compatible Driver fail.");
return;
}
Memory_Clear(&driverData, sizeof(SP_DRVINFO_DATA_V2_W));
driverData.cbSize = sizeof(SP_DRVINFO_DATA_V2_W);
if (!SetupDiGetSelectedDriverW(DeviceInformation, DeviceData, &driverData))
{
Log(L"Get MotioninJoy Driver fail.");
return;
}
//DiInstallDevice willfully returns 0xE0000235 (ERROR_IN_WOW64) in a WOW64 environment.
//I don't know if this was a security restraint but there is no reason why this function
//should not work under WOW64. All we have to do is insert one, literally one jmp patch to
//skip the WOW64 check and the function succeeds as normal.
module = Module_GetHandle(L"newdev.dll");
address = Module_GetProcedureAddress(module, "DiInstallDevice");
address += 0x134;
addr = address;
if ((*addr) == 0x74) //je
{
DWORD oldPageProtection = 0;
//We firstly have to remove page protection of course.
VirtualProtect(addr, 1, PAGE_EXECUTE_READWRITE, &oldPageProtection);
//patch to jne
*addr = 0x75;
//Lastly, make it look like we were never even there by restoring protection
VirtualProtect(addr, 1, oldPageProtection, &oldPageProtection);
}
if (!DiInstallDevice(NULL, DeviceInformation, DeviceData, &driverData, 0, &reboot))
{
Log(L"Install MotioninJoy Driver fail.");
}
}
