BOOL CDeviceSetup::DevInstToDevInfoData(DEVINST devInstance, PSP_DEVINFO_DATA pDevInfoData)
{
assert(devInstance!=NULL);
assert(pDevInfoData!=NULL);
if(devInstance==NULL || pDevInfoData==NULL)
return 0;
HDEVINFO hDevList=SetupDiCreateDeviceInfoList(0,0);
if(hDevList==INVALID_HANDLE_VALUE)
return 0;
char devInstanceID[512];
if(CM_Get_Device_ID(devInstance,devInstanceID,sizeof(devInstanceID),0)!=CR_SUCCESS)
{
SetupDiDestroyDeviceInfoList(hDevList);
return 0;
}
pDevInfoData->cbSize=sizeof(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(hDevList,devInstanceID,0,0,pDevInfoData)==0)
{
SetupDiDestroyDeviceInfoList(hDevList);
return 0;
}
SetupDiDestroyDeviceInfoList(hDevList);
return 1;
}
CDeviceSetup::CDeviceSetup(SP_DEVINFO_DATA devInfoData)
{
ZeroMemory(&m_devInfoData,sizeof(m_devInfoData));
m_hDevList=INVALID_HANDLE_VALUE;
m_hDevList=SetupDiCreateDeviceInfoList(0,0);
assert(m_hDevList!=INVALID_HANDLE_VALUE);
if(m_hDevList==INVALID_HANDLE_VALUE)
return;
char devInstanceID[512];
if(CM_Get_Device_ID(devInfoData.DevInst,devInstanceID,sizeof(devInstanceID),0)!=CR_SUCCESS)
{
SetupDiDestroyDeviceInfoList(m_hDevList);
m_hDevList=INVALID_HANDLE_VALUE;
return;
}
m_devInfoData.cbSize=sizeof(SP_DEVINFO_DATA);
if(SetupDiOpenDeviceInfo(m_hDevList,devInstanceID,0,0,&m_devInfoData)==0)
{
SetupDiDestroyDeviceInfoList(m_hDevList);
m_hDevList=INVALID_HANDLE_VALUE;
return;
}
}
nsresult
sbWinGetDeviceInstanceIDFromDeviceInterfaceName(nsAString& aDeviceInterfaceName,
nsAString& aDeviceInstanceID)
{
BOOL success;
nsresult rv;
// Create a device info set and set it up for auto-disposal.
HDEVINFO devInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL);
NS_ENSURE_TRUE(devInfoSet != INVALID_HANDLE_VALUE, NS_ERROR_FAILURE);
sbAutoHDEVINFO autoDevInfoSet(devInfoSet);
// Add the device interface data, including the device info data, to the
// device info set.
SP_DEVICE_INTERFACE_DATA devIfData;
ZeroMemory(&devIfData, sizeof(SP_DEVICE_INTERFACE_DATA));
devIfData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
success = SetupDiOpenDeviceInterfaceW(devInfoSet,
aDeviceInterfaceName.BeginReading(),
0,
&devIfData);
NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
// Get the device info data.
SP_DEVINFO_DATA devInfoData;
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
success = SetupDiEnumDeviceInfo(devInfoSet, 0, &devInfoData);
NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
// Get the device instance ID.
rv = sbWinGetDeviceInstanceID(devInfoData.DevInst, aDeviceInstanceID);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
// Moves up one node in the device tree and returns its device info data along with an info set only
// including that device for further processing
// See https://msdn.microsoft.com/en-us/library/windows/hardware/ff549417(v=vs.85).aspx
static bool GetParentDevice(const DEVINST& child_device_instance, HDEVINFO* parent_device_info,
PSP_DEVINFO_DATA parent_device_data)
{
ULONG status;
ULONG problem_number;
CONFIGRET result;
// Check if that device instance has device node present
result = CM_Get_DevNode_Status(&status, &problem_number, child_device_instance, 0);
if (result != CR_SUCCESS)
{
return false;
}
DEVINST parent_device;
// Get the device instance of the parent
result = CM_Get_Parent(&parent_device, child_device_instance, 0);
if (result != CR_SUCCESS)
{
return false;
}
std::vector<WCHAR> parent_device_id(MAX_DEVICE_ID_LEN);
;
// Get the device id of the parent, required to open the device info
result =
CM_Get_Device_ID(parent_device, parent_device_id.data(), (ULONG)parent_device_id.size(), 0);
if (result != CR_SUCCESS)
{
return false;
}
// Create a new empty device info set for the device info data
(*parent_device_info) = SetupDiCreateDeviceInfoList(nullptr, nullptr);
// Open the device info data of the parent and put it in the emtpy info set
if (!SetupDiOpenDeviceInfo((*parent_device_info), parent_device_id.data(), nullptr, 0,
parent_device_data))
{
SetupDiDestroyDeviceInfoList(parent_device_info);
return false;
}
return true;
}
HDEVINFO
GetNonPresentDevices(
_In_ LPCWSTR Enumerator OPTIONAL,
_In_ LPCWSTR HardwareID
)
/*++
Routine Description:
This routine retrieves any non-present devices matching the specified
criteria, and returns them in a device information set.
Arguments:
Enumerator - Optionally, supplies the name of the Enumerator under which
this device may be found. If the device may show up under more than
one enumerator, the routine can be called with Enumerator specified as
NULL, in which case all device instances in the registry are examined.
HardwareID - Supplies the hardware ID to be searched for. This will be
compared against each of the hardware IDs for all device instances in
the system (potentially filtered based on Enumerator), present or not.
Return Value:
If any non-present devices are discovered, this routine returns a device
information set containing those devices. This set must be freed via
SetupDiDestroyDeviceInfoList by the caller.
If no such devices are encountered (or if an error occurs), the return
value is INVALID_HANDLE_VALUE. GetLastError will indicate the cause of
failure.
--*/
{
HDEVINFO AllDevs, ExistingNonPresentDevices;
DWORD i, Err;
SP_DEVINFO_DATA DeviceInfoData;
LPWSTR HwIdBuffer, CurId;
DWORD HwIdBufferLen, RegDataType, RequiredSize;
BOOL bRet;
ULONG Status, Problem;
TCHAR DeviceInstanceId[MAX_DEVNODE_ID_LEN];
ExistingNonPresentDevices = INVALID_HANDLE_VALUE;
AllDevs = SetupDiGetClassDevs(NULL,
Enumerator,
NULL,
DIGCF_ALLCLASSES
);
if(AllDevs == INVALID_HANDLE_VALUE) {
//
// last error has already been set during the above call.
//
return INVALID_HANDLE_VALUE;
}
//
// Iterate through each device we found, comparing its hardware ID(s)
// against the one we were passed in.
//
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
HwIdBuffer = NULL;
HwIdBufferLen = 0;
Err = NO_ERROR;
bRet = FALSE;
i = 0;
while(SetupDiEnumDeviceInfo(AllDevs, i, &DeviceInfoData)) {
//
// Retrieve the HardwareID property for this device info element
//
if(!SetupDiGetDeviceRegistryProperty(AllDevs,
&DeviceInfoData,
SPDRP_HARDWAREID,
&RegDataType,
(PBYTE)HwIdBuffer,
HwIdBufferLen,
&RequiredSize)) {
//
// If the failure was due to buffer-too-small, we can resize and
// try again.
//
if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
if(HwIdBuffer) {
GlobalFree(HwIdBuffer);
}
HwIdBuffer = GlobalAlloc(0, RequiredSize);
if(HwIdBuffer) {
HwIdBufferLen = RequiredSize;
//
// try again
//
continue;
} else {
//
// We failed to allocate the buffer we needed. This is
// considered a critical failure that should cause us to
// bail.
//
Err = ERROR_NOT_ENOUGH_MEMORY;
break;
}
} else {
//
// We failed to retrieve the property for some other reason.
// Skip this device and move on to the next.
//
i++;
continue;
}
}
if((RegDataType != REG_MULTI_SZ) || (RequiredSize < sizeof(TCHAR))) {
//
// Data is invalid--this should never happen, but we'll skip the
// device in this case...
//
i++;
continue;
}
//
// If we get to here, then we successfully retrieved the multi-sz
// hardware id list for this device. Compare each of those IDs with
// the caller-supplied one.
//
for(CurId = HwIdBuffer; CurId && *CurId; CurId += (lstrlen(CurId) + 1)) {
if(!lstrcmpi(CurId, HardwareID)) {
//
// We found a match!
//
bRet = TRUE;
//
// If the device isn't currently present (as indicated by
// failure to retrieve its status), then add it to the list of
// such devices to be returned to the caller.
//
if(CR_SUCCESS != CM_Get_DevNode_Status(&Status,
&Problem,
(DEVNODE)DeviceInfoData.DevInst,
0))
{
if(ExistingNonPresentDevices == INVALID_HANDLE_VALUE) {
//
// This is the first non-present device we've
// encountered--we need to create the HDEVINFO set.
//
ExistingNonPresentDevices =
SetupDiCreateDeviceInfoList(NULL, NULL);
if(ExistingNonPresentDevices == INVALID_HANDLE_VALUE) {
//
// Failure to create this set is a critical error!
//
Err = GetLastError();
bRet = FALSE;
break;
}
}
//
// We need to get the device instance's name so we can
// open it up into our "non-present devices" list
//
if(!SetupDiGetDeviceInstanceId(AllDevs,
&DeviceInfoData,
DeviceInstanceId,
sizeof(DeviceInstanceId) / sizeof(TCHAR),
NULL)) {
//
// Should never fail, but considered critical if it
// does...
//
Err = GetLastError();
bRet = FALSE;
break;
}
//
// Now open up the non-present device into our list.
//
if(!SetupDiOpenDeviceInfo(ExistingNonPresentDevices,
DeviceInstanceId,
NULL,
0,
NULL)) {
//
// This failure is also considered critical!
//
Err = GetLastError();
bRet = FALSE;
}
break;
}
}
}
if(Err != NO_ERROR) {
//
// Critical error encountered--bail!
//
break;
}
//
// Move onto the next device instance
//
i++;
}
if(HwIdBuffer) {
GlobalFree(HwIdBuffer);
}
//
// We can now destroy our temporary list of all devices under consideration
//
SetupDiDestroyDeviceInfoList(AllDevs);
if((Err != NO_ERROR) &&
(ExistingNonPresentDevices != INVALID_HANDLE_VALUE)) {
//
// We encountered a critical error, so we need to destroy the (partial)
// list of non-present devices we'd built.
//
SetupDiDestroyDeviceInfoList(ExistingNonPresentDevices);
ExistingNonPresentDevices = INVALID_HANDLE_VALUE;
}
SetLastError(Err);
return ExistingNonPresentDevices;
}
NDASDI_API
BOOL
WINAPI
NdasDiInstallRootEnumeratedDevice(
IN HWND hwndParent,
IN LPCTSTR szInfPath,
IN LPCTSTR szHardwareId,
IN DWORD InstallFlags,
IN LPBOOL pbRebootRequired OPTIONAL)
{
_ASSERTE(NULL == pbRebootRequired || !IsBadWritePtr(pbRebootRequired, sizeof(BOOL)));
BOOL fReturn = FALSE;
BOOL fSuccess = FALSE;
DWORD len;
SP_DEVINFO_DATA DeviceInfoData;
GUID ClassGuid;
TCHAR ClassName[MAX_CLASS_NAME_LEN];
LPTSTR lpszFullInfPath = ResolveFullPath(szInfPath, NULL, NULL, 0);
if (NULL == lpszFullInfPath) {
goto cleanup;
}
//
// List of hardware ID's must be double zero-terminated
//
TCHAR hardwareIdList[LINE_LEN+4] = {0};
size_t cchHardwareIdList = RTL_NUMBER_OF(hardwareIdList);
size_t cchRemaining = cchHardwareIdList;
HRESULT hr = StringCchCopyNEx(
hardwareIdList,
LINE_LEN + 4,
szHardwareId,
LINE_LEN,
NULL,
&cchRemaining,
STRSAFE_FILL_BEHIND_NULL);
_ASSERTE(SUCCEEDED(hr));
cchHardwareIdList -= cchRemaining - 1;
//
// Use the INF File to extract the Class GUID.
//
fSuccess = SetupDiGetINFClass(
lpszFullInfPath,
&ClassGuid,
ClassName,
RTL_NUMBER_OF(ClassName),
NULL);
if (!fSuccess) {
goto cleanup;
}
//
// Create the container for the to-be-created Device Information Element.
//
HDEVINFO DeviceInfoSet = SetupDiCreateDeviceInfoList(
&ClassGuid,
hwndParent);
if(INVALID_HANDLE_VALUE == DeviceInfoSet) {
goto cleanup;
}
//
// Now create the element.
// Use the Class GUID and Name from the INF file.
//
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
fSuccess = SetupDiCreateDeviceInfo(
DeviceInfoSet,
ClassName,
&ClassGuid,
NULL,
hwndParent,
DICD_GENERATE_ID,
&DeviceInfoData);
if (!fSuccess) {
goto cleanup;
}
//
// Add the HardwareID to the Device's HardwareID property.
//
fSuccess = SetupDiSetDeviceRegistryProperty(
DeviceInfoSet,
&DeviceInfoData,
SPDRP_HARDWAREID,
(LPBYTE)hardwareIdList,
cchHardwareIdList * sizeof(TCHAR));
if (!fSuccess) {
goto cleanup;
}
//
// Transform the registry element into an actual devnode
// in the PnP HW tree.
//
fSuccess = SetupDiCallClassInstaller(
DIF_REGISTERDEVICE,
DeviceInfoSet,
&DeviceInfoData);
if (!fSuccess) {
goto cleanup;
}
//
// The element is now registered.
// You must explicitly remove the device using DIF_REMOVE,
// if any failure is encountered from now on.
//
//
// update the driver for the device we just created
//
fSuccess = UpdateDriverForPlugAndPlayDevices(
hwndParent,
szHardwareId,
lpszFullInfPath,
InstallFlags,
pbRebootRequired);
if (!fSuccess) {
DWORD err = GetLastError();
fSuccess = SetupDiCallClassInstaller(
DIF_REMOVE,
DeviceInfoSet,
&DeviceInfoData);
//
// BUGBUG: If it may still require reboot?
//
SetLastError(err);
goto cleanup;
}
fReturn = TRUE;
cleanup:
// save the last error
DWORD err = GetLastError();
if (INVALID_HANDLE_VALUE != DeviceInfoSet) {
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
}
if (NULL != lpszFullInfPath) {
LocalFree(lpszFullInfPath);
}
// restore the last error
SetLastError(err);
return fReturn;
}
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 int TryInstallDevice(
const char *pInfFilePath,
const char *pDevId,
const char *pDevInstID,
PCNC_DEV_CALLBACK pDevCallBack,
void *pDevCallBackParam,
bool updateDriver,
BOOL *pRebootRequired)
{
GUID classGUID;
char className[32];
if (!SetupDiGetINFClass(pInfFilePath, &classGUID, className, sizeof(className)/sizeof(className[0]), 0)) {
ShowLastError(MB_OK|MB_ICONSTOP, "SetupDiGetINFClass(%s)", pInfFilePath);
return IDCANCEL;
}
//Trace("className=%s\n", className);
HDEVINFO hDevInfo;
hDevInfo = SetupDiCreateDeviceInfoList(&classGUID, 0);
if (hDevInfo == INVALID_HANDLE_VALUE) {
ShowLastError(MB_OK|MB_ICONSTOP, "SetupDiCreateDeviceInfoList()");
return IDCANCEL;
}
int res = IDCONTINUE;
SP_DEVINFO_DATA devInfoData;
devInfoData.cbSize = sizeof(devInfoData);
if (!pDevInstID) {
if (StrCmpNI(pDevId, "root\\", 5) == 0) {
/*
* root\<enumerator-specific-device-ID>
*/
if (!SetupDiCreateDeviceInfo(hDevInfo, pDevId + 5, &classGUID, NULL, 0, DICD_GENERATE_ID, &devInfoData))
res = IDCANCEL;
} else {
SetLastError(ERROR_INVALID_DEVINST_NAME);
res = IDCANCEL;
}
}
else
if (StrChr(pDevInstID, '\\')) {
/*
* <enumerator>\<enumerator-specific-device-ID>\<instance-specific-ID>
*/
if (!SetupDiCreateDeviceInfo(hDevInfo, pDevInstID, &classGUID, NULL, 0, 0, &devInfoData))
res = IDCANCEL;
if (res != IDCONTINUE && GetLastError() == ERROR_DEVINST_ALREADY_EXISTS) {
char *pTmpDevInstID = NULL;
if (SetStr(&pTmpDevInstID, pDevInstID)) {
char *pSave;
char *p;
p = STRTOK_R(pTmpDevInstID, "\\", &pSave);
if (p && !lstrcmp(p, REGSTR_KEY_ROOTENUM)) {
p = STRTOK_R(NULL, "\\", &pSave);
if (SetupDiCreateDeviceInfo(hDevInfo, p, &classGUID, NULL, 0, DICD_GENERATE_ID, &devInfoData))
res = IDCONTINUE;
}
SetStr(&pTmpDevInstID, NULL);
} else {
SetLastError(ERROR_DEVINST_ALREADY_EXISTS);
}
}
} else {
/*
* <enumerator-specific-device-ID>
*/
if (!SetupDiCreateDeviceInfo(hDevInfo, pDevInstID, &classGUID, NULL, 0, DICD_GENERATE_ID, &devInfoData))
res = IDCANCEL;
}
if (res != IDCONTINUE) {
ShowLastError(MB_OK|MB_ICONSTOP, "SetupDiCreateDeviceInfo()");
goto exit1;
}
char hardwareId[MAX_DEVICE_ID_LEN + 1 + 1];
SNPRINTF(hardwareId, sizeof(hardwareId)/sizeof(hardwareId[0]) - 1, "%s", pDevId);
int hardwareIdLen;
hardwareIdLen = lstrlen(hardwareId) + 1 + 1;
hardwareId[hardwareIdLen - 1] = 0;
if (!SetupDiSetDeviceRegistryProperty(hDevInfo, &devInfoData, SPDRP_HARDWAREID,
(LPBYTE)hardwareId, hardwareIdLen * sizeof(hardwareId[0])))
{
res = IDCANCEL;
ShowLastError(MB_OK|MB_ICONSTOP, "SetupDiSetDeviceRegistryProperty()");
goto exit1;
}
if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE, hDevInfo, &devInfoData)) {
res = IDCANCEL;
ShowLastError(MB_OK|MB_ICONSTOP, "SetupDiCallClassInstaller()");
goto exit1;
}
if (pDevCallBack) {
DevProperties devProperties;
if (!devProperties.DevId(pDevId)) {
res = IDCANCEL;
goto exit2;
}
if (!pDevCallBack(hDevInfo, &devInfoData, &devProperties, NULL, pDevCallBackParam)) {
res = IDCANCEL;
goto exit2;
}
}
if (updateDriver)
res = UpdateDriver(pInfFilePath, pDevId, 0, TRUE, pRebootRequired);
exit2:
if (res != IDCONTINUE) {
if (!SetupDiCallClassInstaller(DIF_REMOVE, hDevInfo, &devInfoData))
ShowLastError(MB_OK|MB_ICONWARNING, "SetupDiCallClassInstaller()");
}
exit1:
SetupDiDestroyDeviceInfoList(hDevInfo);
return res;
}
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;
}
int InstallInf(_TCHAR *inf)
{
GUID ClassGUID;
TCHAR ClassName[256];
HDEVINFO DeviceInfoSet = 0;
SP_DEVINFO_DATA DeviceInfoData;
TCHAR FullFilePath[1024];
PUpdateDriverForPlugAndPlayDevices pfnUpdateDriverForPlugAndPlayDevices;
HMODULE hNewDev = NULL;
DWORD Reboot;
HWND hwnd = NULL;
int ret = -1;
if (!GetFullPathName(inf, sizeof(FullFilePath), FullFilePath, NULL)) {
logError("GetFullPathName: %x\n", GetLastError());
return ret;
}
logInfo("Inf file: %s\n", FullFilePath);
hNewDev = LoadLibrary(_T("newdev.dll"));
if (!hNewDev) {
logError("newdev.dll: %x\n", GetLastError());
return ret;
}
pfnUpdateDriverForPlugAndPlayDevices = (PUpdateDriverForPlugAndPlayDevices)
GetProcAddress(hNewDev, (LPCSTR)"UpdateDriverForPlugAndPlayDevicesA");
if (!pfnUpdateDriverForPlugAndPlayDevices) {
logError("UpdateDriverForPlugAndPlayDevices: %x\n", GetLastError());
goto FreeLib;
}
if (!SetupDiGetINFClass(FullFilePath, &ClassGUID, ClassName, sizeof(ClassName), 0)) {
logError("SetupDiGetINFClass: %x\n", GetLastError());
goto FreeLib;
}
#if 0
logPrint("{%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX}\n",
ClassGUID.Data1, ClassGUID.Data2, ClassGUID.Data3, ClassGUID.Data4[0],
ClassGUID.Data4[1], ClassGUID.Data4[2], ClassGUID.Data4[3], ClassGUID.Data4[4],
ClassGUID.Data4[5], ClassGUID.Data4[6], ClassGUID.Data4[7]);
#endif
if ((DeviceInfoSet = SetupDiCreateDeviceInfoList(&ClassGUID,0)) == INVALID_HANDLE_VALUE) {
logError("SetupDiCreateDeviceInfoList: %x\n", GetLastError());
goto FreeLib;
}
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiCreateDeviceInfo(DeviceInfoSet,
ClassName,
&ClassGUID,
NULL,
0,
DICD_GENERATE_ID,
&DeviceInfoData)) {
logError("SetupDiCreateDeviceInfo: %x\n", GetLastError());
goto SetupDiCreateDeviceInfoListError;
}
if(!SetupDiSetDeviceRegistryProperty(DeviceInfoSet, &DeviceInfoData, SPDRP_HARDWAREID,
(LPBYTE)DRIVER_NAME,
(lstrlen(DRIVER_NAME)+2))) {
logError("SetupDiSetDeviceRegistryProperty: %x\n", GetLastError());
goto SetupDiCreateDeviceInfoListError;
}
if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE, DeviceInfoSet, &DeviceInfoData)) {
logError("SetupDiCallClassInstaller: %x\n", GetLastError());
goto SetupDiCreateDeviceInfoListError;
}
ret = pfnUpdateDriverForPlugAndPlayDevices(NULL, DRIVER_NAME, FullFilePath, 0, &Reboot);
if (Reboot == DI_NEEDRESTART || Reboot == DI_NEEDREBOOT) {
if (SetupPromptReboot(NULL, hwnd, FALSE) == -1) {
; // ToDo ??
}
}
ret = 0;
SetupDiCreateDeviceInfoListError:
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
FreeLib:
FreeLibrary(hNewDev);
return ret;
}
static
void
create_ramdisk_device(std::string full_inf_file_path,
std::string hardware_id) {
GUID class_guid;
WCHAR class_name_w[MAX_CLASS_NAME_LEN];
auto success =
SetupDiGetINFClassW(w32util::widen(full_inf_file_path).c_str(),
&class_guid,
class_name_w, safe::numelementsf(class_name_w),
nullptr);
if (!success) w32util::throw_windows_error();
/* don't install device if it already exists */
auto create_device = true;
{
HDEVINFO device_info_set =
SetupDiGetClassDevsEx(&class_guid, nullptr, nullptr, 0,
nullptr, nullptr, nullptr);
if (device_info_set == INVALID_HANDLE_VALUE) {
w32util::throw_setupapi_error();
}
SP_DEVINFO_DATA device_info_data;
zero_object(device_info_data);
device_info_data.cbSize = sizeof(device_info_data);
for (DWORD idx = 0;
create_device &&
SetupDiEnumDeviceInfo(device_info_set, idx, &device_info_data);
++idx) {
/* first get hardware id reg key for this device info */
CHAR buffer[1024];
BOOL success_prop =
SetupDiGetDeviceRegistryPropertyA(device_info_set,
&device_info_data,
SPDRP_HARDWAREID,
nullptr,
(PBYTE) buffer,
sizeof(buffer),
nullptr);
if (!success_prop) w32util::throw_setupapi_error();
PCHAR bp = buffer;
while(*bp) {
if (!strcmp(bp, hardware_id.c_str())) {
create_device = false;
break;
}
bp += strlen(bp) + 1;
}
}
}
// device already exists, no need to create it
if (!create_device) return;
auto device_info_set =
SetupDiCreateDeviceInfoList(&class_guid, NULL);
if (device_info_set == INVALID_HANDLE_VALUE) w32util::throw_setupapi_error();
auto _destroy_device_info_set =
safe::create_deferred(SetupDiDestroyDeviceInfoList, device_info_set);
SP_DEVINFO_DATA device_info_data;
zero_object(device_info_data);
device_info_data.cbSize = sizeof(device_info_data);
auto success_create_device_info =
SetupDiCreateDeviceInfoW(device_info_set, class_name_w,
&class_guid, nullptr, 0,
DICD_GENERATE_ID, &device_info_data);
if (!success_create_device_info) w32util::throw_setupapi_error();
// TODO: runtime stack array is a GCC extension
auto reg_hardware_id_len = hardware_id.size() + 2;
auto reg_hardware_id_size = reg_hardware_id_len * sizeof(WCHAR);
auto reg_hardware_id = std::unique_ptr<WCHAR[]>(new WCHAR[reg_hardware_id_len]);
memset(reg_hardware_id.get(), 0, reg_hardware_id_size);
memcpy(reg_hardware_id.get(), w32util::widen(hardware_id).data(),
hardware_id.size() * sizeof(WCHAR));
auto success_set_hardware_id =
SetupDiSetDeviceRegistryPropertyW(device_info_set,
&device_info_data,
SPDRP_HARDWAREID,
(BYTE *) reg_hardware_id.get(),
reg_hardware_id_size);
if (!success_set_hardware_id) w32util::throw_setupapi_error();
auto success_class_installer =
SetupDiCallClassInstaller(DIF_REGISTERDEVICE, device_info_set,
&device_info_data);
if (!success_class_installer) w32util::throw_setupapi_error();
create_ramdisk_hardware_keys(device_info_set, &device_info_data);
}
//------------------------------------------------------------------------------
// CDeviceContextMenu::GetDeviceHardwareID
//
// Get device hardware id from the devnode(s) of the device. You can get
// device properties that cannot be obtained directly from the shell item object
// throught the device devnode(s).
//
// Note there are two pieces of contextual information from the shell
// object you can use to find the devnodes for your device.
//
// 1) Function Paths (PKEY_Devices_FunctionPaths)
// This property is a vector of strings of the Device Instance Paths
// for your device's devnodes. This function below will show how to
// use this property to access properties off the devnodes.
//
// 2) Interface Paths (PKEY_Devices_InterfacePaths)
// This property is a vectory of strings of the Device Interface Paths
// of all your device's devnodes. Use of this property use not shown in
// this sample, but if you find the property helpful for your scenario
// you can use it.
//------------------------------------------------------------------------------
HRESULT CDeviceContextMenu::GetDeviceHardwareID(
__in IShellItem2* pShellItem2,
__out PWSTR* ppszHardwareID
)
{
DWORD cbBuffer = 0;
HDEVINFO devInfo = {0};
SP_DEVINFO_DATA devInfoData = {0};
DEVPROPTYPE devPropType = 0;
HRESULT hr = S_OK;
PBYTE pBuffer = NULL;
PROPVARIANT pv = {0};
PCWSTR pszHwid = NULL;
PropVariantInit( &pv );
//
// First get the Function Paths (Device Instance Paths) needed to grab the
// devnode info directly from PnP.
//
if( S_OK == hr )
{
hr = pShellItem2->GetProperty( PKEY_Devices_FunctionPaths, &pv );
}
if( S_OK == hr &&
((VT_VECTOR | VT_LPWSTR) != pv.vt ||
( 0 == pv.calpwstr.cElems ) ) )
{
// Function Paths doesn't exist or is the wrong type or empty.
// This should never happen, but its good practice to check anyway.
hr = HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
}
//
// For simplicity in the sample, we'll just work with the first path in the
// list. i.e. the first devnode in the list.
//
// IMPORTANT: In a real scenario, you need to keep in mind that your device
// shown in the Devices and Printers folder is likely made up of one or more
// Device Functions (devnodes). In this case, you may not be able to get all
// properties from just any devnode. You'll need to look at all devnodes and
// figure out which one contains the properties you're after. In this sample
// we're just attempting to get one device hardware id from the devnode who's
// Device Instance Path is in the FunctionPaths list retreived from the shell
// object.
//
//
// Create an empty HDEVINFO set to use for the first devnode's info
//
if( S_OK == hr )
{
devInfo = SetupDiCreateDeviceInfoList( NULL, NULL );
if( INVALID_HANDLE_VALUE == devInfo )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
//
// Open the devnode's info
//
if( S_OK == hr )
{
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if( FALSE == SetupDiOpenDeviceInfo(
devInfo,
pv.calpwstr.pElems[0],
NULL,
0,
&devInfoData
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
// You can ask for properties defined in devpkey.h. Some keys in
// FunctionDiscoveryKey.h are also available on devnodes; For example,
// devnodes from PnP-X (Network Devices) will have PKEY_PNPX properties
// set on them. These can be retreived with SetupDi* calls as well.
// PROPERTYKEY can be safely cast to DEVPROPKEY. However, keep in mind
// the types are defined differently. Variant types are essentially a
// superset of DEVPROPTYPEs. The mapping on many property types is
// straight forward. DEVPROP_TYPE_STRING and VT_LPWSTR
// are the same, for example. Below we'll get a PnP-X property so it's
// clear how this works.
//
// One case where the mapping isn't exact, is VT_VECTOR | VT_LPWSTR
// (vector of strings), which in the devnode is stored as a
// DEVPROP_TYPE_STRING_LIST (REG_MULTI_SZ style string list). Keep this
// in mind when asking for PKEY types from a devnode vs. DEVPKEY types.
//
//
// Get the hardware ids
//
if( S_OK == hr )
{
// Get the required buffer size
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_HardwareIds,
&devPropType,
NULL,
0,
&cbBuffer,
0
) &&
ERROR_INSUFFICIENT_BUFFER != GetLastError() )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
pBuffer = new (std::nothrow) BYTE[cbBuffer];
if( NULL == pBuffer )
{
hr = E_OUTOFMEMORY;
}
ZeroMemory( pBuffer, cbBuffer );
}
if( S_OK == hr )
{
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_HardwareIds,
&devPropType,
pBuffer,
cbBuffer,
NULL,
0
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr &&
DEVPROP_TYPE_STRING_LIST == devPropType )
{
//
// Get the first Hardware ID from the list
//
pszHwid = reinterpret_cast<PWSTR>(pBuffer);
hr = SHStrDup( pszHwid, ppszHardwareID );
}
//
// Cleanup
//
if( NULL != pBuffer )
{
delete[] pBuffer;
pBuffer = NULL;
}
if( INVALID_HANDLE_VALUE != devInfo )
{
(void) SetupDiDestroyDeviceInfoList( devInfo );
}
PropVariantClear( &pv );
return hr;
}// CDeviceContextMenu::GetDeviceHardwareID
//------------------------------------------------------------------------------
// CDevicePropertyPage::PopulateDevnodeProperties [STATIC FUNC]
//
// Populates the property page with some properties that come from the
// devnode(s) of the device directly. When implementing the property page
// for your device, this method is needed for all properties that cannot
// be obtained directly from the shell item object.
//
// Note there are two pieces of contextual information from the shell
// object you can use to find the devnodes for your device and farm extra
// properties and/or communicate with your device.
//
// 1) Function Paths (PKEY_Devices_FunctionPaths)
// This property is a vector of strings of the Device Instance Paths
// for your device's devnodes. This function below will show how to
// use this property to access properties off the devnodes.
//
// 2) Interface Paths (PKEY_Devices_InterfacePaths)
// This property is a vectory of strings of the Device Interface Paths
// of all your device's devnodes. Use of this property use not shown in
// this sample, but if you find the property helpful for your scenario
// you can use it.
//------------------------------------------------------------------------------
HRESULT CDevicePropertyPage::PopulateDevnodeProperties(
__in HWND hWndDlg,
__in IShellItem2* pShellItem
)
{
DWORD cbBuffer = 0;
HDEVINFO devInfo = {0};
SP_DEVINFO_DATA devInfoData = {0};
DEVPROPTYPE devPropType = 0;
HRESULT hr = S_OK;
SYSTEMTIME installTime = {0};
PBYTE pBuffer = NULL;
PROPVARIANT pv = {0};
PCWSTR pszHwid = NULL;
WCHAR szInstallTime[1024] = {0};
PropVariantInit( &pv );
//
// First get the Function Paths (Device Instance Paths) needed to grab the
// devnode info directly from PnP.
//
if( S_OK == hr )
{
hr = pShellItem->GetProperty( PKEY_Devices_FunctionPaths, &pv );
}
if( S_OK == hr &&
((VT_VECTOR | VT_LPWSTR) != pv.vt ||
( 0 == pv.calpwstr.cElems ) ) )
{
// Function Paths doesn't exist or is the wrong type or empty.
// This should never happen, but its good practice to check anyway.
hr = HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
}
//
// For simplicity in the sample, we'll just work with the first path in the
// list. i.e. the first devnode in the list.
//
// IMPORTANT: In a real scenario, you need to keep in mind that your device
// shown in the Devices and Printers folder is likely made up of one or more
// Device Functions (devnodes). In this case, you may not be able to get all
// properties from just any devnode. You'll need to look at all devnodes and
// figure out which one contains the properties you're after. In this sample
// we're just attempting to get a set of properties from the devnode who's
// Device Instance Path is in the FunctionPaths list retreived from the shell
// object.
//
//
// Create an empty HDEVINFO set to use for the first devnode's info
//
if( S_OK == hr )
{
devInfo = SetupDiCreateDeviceInfoList( NULL, NULL );
if( INVALID_HANDLE_VALUE == devInfo )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
//
// Open the devnode's info
//
if( S_OK == hr )
{
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if( FALSE == SetupDiOpenDeviceInfo(
devInfo,
pv.calpwstr.pElems[0],
NULL,
0,
&devInfoData
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
//
// Now populate the property page with some properties from the devnode
//
// You can ask for properties defined in devpkey.h. Some keys in
// FunctionDiscoveryKey.h are also available on devnodes; For example,
// devnodes from PnP-X (Network Devices) will have PKEY_PNPX properties
// set on them. These can be retreived with SetupDi* calls as well.
// PROPERTYKEY can be safely cast to DEVPROPKEY. However, keep in mind
// the types are defined differently. Variant types are essentially a
// superset of DEVPROPTYPEs. The mapping on many property types is
// straight forward. DEVPROP_TYPE_STRING and VT_LPWSTR
// are the same, for example. Below we'll get a PnP-X property so it's
// clear how this works.
//
// One case where the mapping isn't exact, is VT_VECTOR | VT_LPWSTR
// (vector of strings), which in the devnode is stored as a
// DEVPROP_TYPE_STRING_LIST (REG_MULTI_SZ style string list). Keep this
// in mind when asking for PKEY types from a devnode vs. DEVPKEY types.
//
//
// Get the hardware ids
//
if( S_OK == hr )
{
// Get the required buffer size
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_HardwareIds,
&devPropType,
NULL,
0,
&cbBuffer,
0
) &&
ERROR_INSUFFICIENT_BUFFER != GetLastError() )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
pBuffer = new (std::nothrow) BYTE[cbBuffer];
if( NULL == pBuffer )
{
hr = E_OUTOFMEMORY;
}
ZeroMemory( pBuffer, cbBuffer );
}
if( S_OK == hr )
{
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_HardwareIds,
&devPropType,
pBuffer,
cbBuffer,
NULL,
0
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr &&
DEVPROP_TYPE_STRING_LIST == devPropType )
{
//
// The UI only has slots for up to three hardware ids, so we'll
// just set up to the first three.
//
pszHwid = reinterpret_cast<PWSTR>(pBuffer);
if( NULL != *pszHwid )
{
SetDlgItemText(
hWndDlg,
IDC_HARDWAREID_FIELD1,
pszHwid
);
pszHwid = pszHwid + wcslen(pszHwid) + 1;
}
if( NULL != *pszHwid )
{
SetDlgItemText(
hWndDlg,
IDC_HARDWAREID_FIELD2,
pszHwid
);
pszHwid = pszHwid + wcslen(pszHwid) + 1;
}
if( NULL != *pszHwid )
{
SetDlgItemText(
hWndDlg,
IDC_HARDWAREID_FIELD3,
pszHwid
);
}
}
if( NULL != pBuffer )
{
delete[] pBuffer;
pBuffer = NULL;
}
//
// Get the install date
//
if( S_OK == hr )
{
// Get the required buffer size
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_InstallDate,
&devPropType,
NULL,
0,
&cbBuffer,
0
) &&
ERROR_INSUFFICIENT_BUFFER != GetLastError() )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
pBuffer = new (std::nothrow) BYTE[cbBuffer];
if( NULL == pBuffer )
{
hr = E_OUTOFMEMORY;
}
}
if( S_OK == hr )
{
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
&DEVPKEY_Device_InstallDate,
&devPropType,
pBuffer,
cbBuffer,
NULL,
0
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
else if( DEVPROP_TYPE_FILETIME != devPropType )
{
hr = E_INVALIDARG;
}
}
if( S_OK == hr )
{
if( FALSE == FileTimeToSystemTime(
reinterpret_cast<FILETIME*>(pBuffer),
&installTime ))
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
if( 0 == GetDateFormatEx(
LOCALE_NAME_USER_DEFAULT,
DATE_AUTOLAYOUT | DATE_LONGDATE,
&installTime,
NULL,
szInstallTime,
ARRAY_SIZE(szInstallTime),
NULL
))
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
SetDlgItemText( hWndDlg, IDC_INSTALLDATE_FIELD, szInstallTime );
}
if( NULL != pBuffer )
{
delete[] pBuffer;
pBuffer = NULL;
}
//
// Now get PKEY_** property instead of a DEVPKEY property
// to show how that's done. This would typically just be done
// for PNPX properties, but other properties in FunctionDisocovery.h
// might be available on the devnode.
//
// Let's attempt to get the IP Address, though it won't be available on
// Mice (which is what this sample property page binds to). It at least
// shows how the process would work. Also, as stated above, only *some*
// of the devnodes that make up your PnP-X device may contain the
// IP Address, so you might have to look through all the devnodes by
// iterating the FunctionPaths list.
//
// This property won't be set on the property page itself since a mouse
// will never have an IP Address.
//
if( S_OK == hr )
{
// Get the required buffer size
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
(const DEVPROPKEY*)&PKEY_PNPX_IpAddress,
&devPropType,
NULL,
0,
&cbBuffer,
0
) &&
ERROR_INSUFFICIENT_BUFFER != GetLastError() )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr )
{
pBuffer = new (std::nothrow) BYTE[cbBuffer];
if( NULL == pBuffer )
{
hr = E_OUTOFMEMORY;
}
}
if( S_OK == hr )
{
if( FALSE == SetupDiGetDeviceProperty(
devInfo,
&devInfoData,
(const DEVPROPKEY*)&PKEY_PNPX_IpAddress,
&devPropType,
pBuffer,
cbBuffer,
NULL,
0
) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
}
if( S_OK == hr &&
DEVPROP_TYPE_STRING == devPropType
)
{
// pBuffer now contains the IP Address if this is a PnP-X device and
// this was one of the devnodes that had the property set.
}
//
// Cleanup
//
if( NULL != pBuffer )
{
delete[] pBuffer;
}
if( INVALID_HANDLE_VALUE != devInfo )
{
(void) SetupDiDestroyDeviceInfoList( devInfo );
}
PropVariantClear( &pv );
return hr;
}// CDevicePropertyPage::PopulateDevnodeProperties
/**
* 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;
}
bool install(const std::wstring& inf, const std::wstring& hardware_id, bool& reboot_required)
{
TCHAR inf_path[MAX_PATH];
if (GetFullPathName(inf.c_str(), MAX_PATH, inf_path, NULL) >= MAX_PATH)
{
return false;
}
std::wcerr << "INF file full path: " << inf_path << std::endl;
bool result = false;
TCHAR hardware_id_list[LINE_LEN + 4];
ZeroMemory(hardware_id_list, sizeof(hardware_id_list));
if (SUCCEEDED(StringCchCopy(hardware_id_list, LINE_LEN, hardware_id.c_str())))
{
std::wcerr << "Hardware identifier list: " << hardware_id_list << std::endl;
GUID class_guid;
TCHAR class_name[MAX_CLASS_NAME_LEN];
if (SetupDiGetINFClass(inf_path, &class_guid, class_name, sizeof(class_name) / sizeof(class_name[0]), 0))
{
std::wcerr << "Class name: " << class_name << std::endl;
HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
device_info_set = SetupDiCreateDeviceInfoList(&class_guid, 0);
if (device_info_set != INVALID_HANDLE_VALUE)
{
std::wcerr << "Device information set created." << std::endl;
SP_DEVINFO_DATA device_info_data;
device_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
if (SetupDiCreateDeviceInfo(device_info_set,
class_name,
&class_guid,
NULL,
0,
DICD_GENERATE_ID,
&device_info_data))
{
std::wcerr << "Device information element created." << std::endl;
if (SetupDiSetDeviceRegistryProperty(device_info_set,
&device_info_data,
SPDRP_HARDWAREID,
(LPBYTE)hardware_id_list,
(lstrlen(hardware_id_list) + 1 + 1) * sizeof(TCHAR)))
{
std::wcerr << "Hardware id set." << std::endl;
if (SetupDiCallClassInstaller(DIF_REGISTERDEVICE, device_info_set, &device_info_data))
{
std::wcerr << "Device registered." << std::endl;
result = update(inf, hardware_id, reboot_required);
}
}
}
SetupDiDestroyDeviceInfoList(device_info_set);
}
}
}
return result;
}
int
InstallRootEnumeratedDriver(
IN HWND hWnd,
IN LPTSTR HardwareId,
IN LPTSTR INFFile
)
{
HDEVINFO DeviceInfoSet = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA DeviceInfoData;
GUID ClassGUID;
TCHAR ClassName[MAX_CLASS_NAME_LEN];
DWORD Err = NO_ERROR;
BOOL reboot;
LPTSTR MultiSzHardwareId = NULL;
DWORD cbMultiSzHardwareId;
//
// SPDRP_HARDWAREID needs to be a multi_sz string so allocate a buffer that is
// two characters more than the HardwareId passed in and use that buffer.
//
cbMultiSzHardwareId = (lstrlen(HardwareId) + 2) * sizeof(TCHAR);
MultiSzHardwareId = malloc(cbMultiSzHardwareId);
if (!MultiSzHardwareId) {
MessageBox(hWnd, "Cannot allocate memory", "Error", MB_OK);
Err = ERROR_NOT_ENOUGH_MEMORY;
goto clean;
}
ZeroMemory(MultiSzHardwareId, cbMultiSzHardwareId);
StringCbCopy(MultiSzHardwareId, cbMultiSzHardwareId, HardwareId);
//
// Use the INF File to extract the Class GUID.
//
if (!SetupDiGetINFClass(INFFile, &ClassGUID, ClassName, sizeof(ClassName), 0)) {
Err = GetLastError();
DisplayError(hWnd, TEXT("GetINFClass"));
DisplayError(hWnd, TEXT(INFFile));
goto clean;
}
//
// Create the container for the to-be-created Device Information Element.
//
DeviceInfoSet = SetupDiCreateDeviceInfoList(&ClassGUID, 0);
if(DeviceInfoSet == INVALID_HANDLE_VALUE) {
Err = GetLastError();
DisplayError(hWnd, TEXT("CreateDeviceInfoList"));
goto clean;
}
//
// Now create the element.
// Use the Class GUID and Name from the INF file.
//
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiCreateDeviceInfo(DeviceInfoSet,
ClassName,
&ClassGUID,
NULL,
0,
DICD_GENERATE_ID,
&DeviceInfoData)) {
Err = GetLastError();
DisplayError(hWnd, TEXT("CreateDeviceInfo"));
goto clean;
}
//
// Add the HardwareID to the Device's HardwareID property.
//
if(!SetupDiSetDeviceRegistryProperty(DeviceInfoSet,
&DeviceInfoData,
SPDRP_HARDWAREID,
(LPBYTE)MultiSzHardwareId,
cbMultiSzHardwareId)) {
Err = GetLastError();
DisplayError(hWnd, TEXT("SetDeviceRegistryProperty"));
goto clean;
}
//
// Transform the registry element into an actual devnode
// in the PnP HW tree.
//
if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE,
DeviceInfoSet,
&DeviceInfoData)) {
Err = GetLastError();
DisplayError(hWnd, TEXT("CallClassInstaller(REGISTERDEVICE)"));
goto clean;
}
//
// The element is now registered. We must explicitly remove the
// device using DIF_REMOVE, if we encounter any failure from now on.
//
//
// Install the Driver. We don't actually care about @reboot, but
// supplying it avoids an annoying popup on Windows 2000.
//
if (!UpdateDriverForPlugAndPlayDevices(hWnd,
HardwareId,
INFFile,
INSTALLFLAG_FORCE,
&reboot))
{
Err = GetLastError();
DisplayError(hWnd, TEXT("UpdateDriverForPlugAndPlayDevices"));
if (!SetupDiCallClassInstaller(DIF_REMOVE,
DeviceInfoSet,
&DeviceInfoData)) {
DisplayError(hWnd, TEXT("CallClassInstaller(REMOVE)"));
}
}
//
// Cleanup.
//
clean:
if (DeviceInfoSet != INVALID_HANDLE_VALUE) {
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
}
if (MultiSzHardwareId) {
free(MultiSzHardwareId);
}
if (Err == NO_ERROR) {
return 0;
} else {
return 1;
}
}
DWORD
InstallSoftwareBusPnpEnumerator(LPWSTR InfPath, LPCWSTR HardwareIdList)
{
HDEVINFO DeviceInfoSet = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA DeviceInfoData;
GUID ClassGUID;
TCHAR ClassName[50];
int Result = 0;
HMODULE hModule = NULL;
UpdateDriverForPlugAndPlayDevicesProto UpdateProc;
BOOL reboot = FALSE;
DWORD flags = 0;
if (!SetupDiGetINFClass(InfPath,&ClassGUID,ClassName,sizeof(ClassName)/sizeof(ClassName[0]),0))
{
return -1;
}
DeviceInfoSet = SetupDiCreateDeviceInfoList(&ClassGUID,0);
if(DeviceInfoSet == INVALID_HANDLE_VALUE)
{
return -1;
}
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiCreateDeviceInfo(DeviceInfoSet, ClassName, &ClassGUID, NULL, 0, DICD_GENERATE_ID, &DeviceInfoData))
{
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return -1;
}
if(!SetupDiSetDeviceRegistryProperty(DeviceInfoSet, &DeviceInfoData, SPDRP_HARDWAREID, (LPBYTE)HardwareIdList, (lstrlen(HardwareIdList)+1+1)*sizeof(TCHAR)))
{
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return -1;
}
if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE, DeviceInfoSet, &DeviceInfoData))
{
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return -1;
}
if(GetFileAttributes(InfPath)==(DWORD)(-1)) {
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return -1;
}
flags |= INSTALLFLAG_FORCE;
hModule = LoadLibraryW(L"newdev.dll");
if(!hModule) {
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return -1;
}
UpdateProc = (UpdateDriverForPlugAndPlayDevicesProto)GetProcAddress(hModule,UPDATEDRIVERFORPLUGANDPLAYDEVICES);
if(!UpdateProc)
{
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
FreeLibrary(hModule);
return -1;
}
if(!UpdateProc(NULL, HardwareIdList, InfPath, flags, &reboot))
{
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
FreeLibrary(hModule);
return -1;
}
FreeLibrary(hModule);
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
return Result;
}
