bool
CDeviceView::GetNextClass(
_In_ ULONG ClassIndex,
_Out_ LPGUID ClassGuid,
_Out_ HDEVINFO *hDevInfo
)
{
CONFIGRET cr;
// Get the next class in the list
cr = CM_Enumerate_Classes(ClassIndex,
ClassGuid,
0);
if (cr != CR_SUCCESS) return false;
// Check if this is the unknown class
if (IsEqualGUID(*ClassGuid, GUID_DEVCLASS_UNKNOWN))
{
// Get device info for all devices
*hDevInfo = SetupDiGetClassDevsW(NULL,
NULL,
NULL,
DIGCF_ALLCLASSES);
}
else
{
// We only want the devices for this class
*hDevInfo = SetupDiGetClassDevsW(ClassGuid,
NULL,
NULL,
DIGCF_PRESENT);
}
return (hDevInfo != INVALID_HANDLE_VALUE);
}
// Code for enumerating hardware devices that use the XINPUT device driver.
// The MSDN recommended code suffers from massive performance problems when using language packs,
// if the system and user languages differ then WMI Queries become incredibly slow (multiple
// seconds). This is more or less equivalent and much faster.
std::unordered_set<DWORD> GetXInputGUIDS()
{
static const GUID s_GUID_devclass_HID = {
0x745a17a0, 0x74d3, 0x11d0, {0xb6, 0xfe, 0x00, 0xa0, 0xc9, 0x0f, 0x57, 0xda} };
std::unordered_set<DWORD> guids;
// Enumerate everything under the "Human Interface Devices" tree in the Device Manager
// NOTE: Some devices show up multiple times due to sub-devices, we rely on the set to
// prevent duplicates.
HDEVINFO setup_enum = SetupDiGetClassDevsW(&s_GUID_devclass_HID, nullptr, nullptr, DIGCF_PRESENT);
if (setup_enum == INVALID_HANDLE_VALUE)
return guids;
std::vector<wchar_t> buffer(128);
SP_DEVINFO_DATA dev_info;
dev_info.cbSize = sizeof(SP_DEVINFO_DATA);
for (DWORD i = 0; SetupDiEnumDeviceInfo(setup_enum, i, &dev_info); ++i)
{
// Need to find the size of the data and set the buffer appropriately
DWORD buffer_size = 0;
while (!SetupDiGetDeviceRegistryPropertyW(setup_enum, &dev_info, SPDRP_HARDWAREID, nullptr,
reinterpret_cast<BYTE*>(buffer.data()),
static_cast<DWORD>(buffer.size()), &buffer_size))
{
if (buffer_size > buffer.size())
buffer.resize(buffer_size);
else
break;
}
if (GetLastError() != ERROR_SUCCESS)
continue;
// HARDWAREID is a REG_MULTI_SZ
// There are multiple strings separated by NULs, the list is ended by an empty string.
for (std::size_t j = 0; buffer[j]; j += std::wcslen(&buffer[j]) + 1)
{
// XINPUT devices have "IG_xx" embedded in their IDs which is what we look for.
if (!std::wcsstr(&buffer[j], L"IG_"))
continue;
unsigned int vid = 0;
unsigned int pid = 0;
// Extract Vendor and Product IDs for matching against DirectInput's device list.
wchar_t* pos = std::wcsstr(&buffer[j], L"VID_");
if (!pos || !std::swscanf(pos, L"VID_%4X", &vid))
continue;
pos = std::wcsstr(&buffer[j], L"PID_");
if (!pos || !std::swscanf(pos, L"PID_%4X", &pid))
continue;
guids.insert(MAKELONG(vid, pid));
break;
}
}
SetupDiDestroyDeviceInfoList(setup_enum);
return guids;
}
NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device)
{
SP_DEVINFO_DATA Data;
UNICODE_STRING nameW;
NTSTATUS status;
HDEVINFO devinfo;
GUID hidGuid;
BASE_DEVICE_EXTENSION *ext;
HidD_GetHidGuid(&hidGuid);
ext = device->DeviceExtension;
RtlInitUnicodeString( &nameW, ext->device_name);
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_HIDCLASS, NULL, NULL, DIGCF_DEVICEINTERFACE);
if (!devinfo)
{
FIXME( "failed to get ClassDevs %x\n", GetLastError());
return STATUS_UNSUCCESSFUL;
}
Data.cbSize = sizeof(Data);
if (!SetupDiCreateDeviceInfoW(devinfo, ext->instance_id, &GUID_DEVCLASS_HIDCLASS, NULL, NULL, DICD_INHERIT_CLASSDRVS, &Data))
{
if (GetLastError() == ERROR_DEVINST_ALREADY_EXISTS)
{
SetupDiDestroyDeviceInfoList(devinfo);
return STATUS_SUCCESS;
}
FIXME( "failed to Create Device Info %x\n", GetLastError());
goto error;
}
if (!SetupDiRegisterDeviceInfo( devinfo, &Data, 0, NULL, NULL, NULL ))
{
FIXME( "failed to Register Device Info %x\n", GetLastError());
goto error;
}
SetupDiDestroyDeviceInfoList(devinfo);
status = IoRegisterDeviceInterface(device, &hidGuid, NULL, &ext->link_name);
if (status != STATUS_SUCCESS)
{
FIXME( "failed to register device interface %x\n", status );
return status;
}
return STATUS_SUCCESS;
error:
SetupDiDestroyDeviceInfoList(devinfo);
return STATUS_UNSUCCESSFUL;
}
nsresult
sbWinDeviceHasInterface(DEVINST aDevInst,
const GUID* aGUID,
bool* aHasInterface)
{
// Validate arguments.
NS_ENSURE_ARG_POINTER(aGUID);
NS_ENSURE_ARG_POINTER(aHasInterface);
// Function variables.
nsresult rv;
// Set default result.
*aHasInterface = PR_FALSE;
// Get the device info set and set it up for auto-disposal.
nsAutoString deviceInstanceID;
rv = sbWinGetDeviceInstanceID(aDevInst, deviceInstanceID);
NS_ENSURE_SUCCESS(rv, rv);
HDEVINFO devInfo = SetupDiGetClassDevsW(aGUID,
deviceInstanceID.get(),
NULL,
DIGCF_DEVICEINTERFACE);
NS_ENSURE_TRUE(devInfo != INVALID_HANDLE_VALUE, NS_ERROR_FAILURE);
sbAutoHDEVINFO autoDevInfo(devInfo);
// Get the device info for the device instance. Device does not have the
// interface if it does not have a device info data record.
SP_DEVINFO_DATA devInfoData;
rv = sbWinGetDevInfoData(aDevInst, devInfo, &devInfoData);
if (NS_FAILED(rv))
return NS_OK;
// Get the device interface detail. Device does not have the interface if it
// does not have the interface detail.
PSP_DEVICE_INTERFACE_DETAIL_DATA devIfDetailData;
rv = sbWinGetDevInterfaceDetail(&devIfDetailData,
devInfo,
&devInfoData,
aGUID);
if (NS_FAILED(rv))
return NS_OK;
sbAutoNSMemPtr autoDevIfDetailData(devIfDetailData);
// Device has the interface.
*aHasInterface = PR_TRUE;
return NS_OK;
}
static
void
SetDeviceDetails(HWND * hDlgCtrls, LPCGUID classGUID, LPGUID * deviceGUID)
{
HDEVINFO hInfo;
DWORD dwIndex = 0;
SP_DEVINFO_DATA InfoData;
WCHAR szText[100];
/* create the setup list */
hInfo = SetupDiGetClassDevsW(classGUID, NULL, NULL, DIGCF_PRESENT|DIGCF_PROFILE);
if (hInfo == INVALID_HANDLE_VALUE)
return;
do
{
ZeroMemory(&InfoData, sizeof(InfoData));
InfoData.cbSize = sizeof(InfoData);
if (SetupDiEnumDeviceInfo(hInfo, dwIndex, &InfoData))
{
/* set device name */
if (SetupDiGetDeviceRegistryPropertyW(hInfo, &InfoData, SPDRP_DEVICEDESC, NULL, (PBYTE)szText, sizeof(szText), NULL))
SendMessageW(hDlgCtrls[0], WM_SETTEXT, 0, (LPARAM)szText);
/* set the manufacturer name */
if (SetupDiGetDeviceRegistryPropertyW(hInfo, &InfoData, SPDRP_MFG, NULL, (PBYTE)szText, sizeof(szText), NULL))
SendMessageW(hDlgCtrls[1], WM_SETTEXT, 0, (LPARAM)szText);
/* FIXME
* we currently enumerate only the first adapter
*/
EnumerateDrivers(&hDlgCtrls[2], hInfo, &InfoData);
break;
}
if (GetLastError() == ERROR_NO_MORE_ITEMS)
break;
dwIndex++;
}while(TRUE);
/* destroy the setup list */
SetupDiDestroyDeviceInfoList(hInfo);
}
DWORD
InstallSoftwareDeviceInterfaceInf(IN LPWSTR InfName,
IN LPWSTR SectionName)
{
HDEVINFO hDevInfo;
HINF hInf;
HKEY hKey;
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
GUID SWBusGuid = {STATIC_BUSID_SoftwareDeviceEnumerator};
hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, 0);
if (!hDevInfo)
{
// failed
return GetLastError();
}
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
{
// failed
return GetLastError();
}
hInf = SetupOpenInfFileW(InfName, NULL, INF_STYLE_WIN4, NULL);
if (hInf == INVALID_HANDLE_VALUE)
{
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
//
// FIXME check if interface is already installed
//
hKey = SetupDiCreateDeviceInterfaceRegKeyW(hDevInfo, &DeviceInterfaceData, 0, KEY_ALL_ACCESS, hInf, SectionName);
SetupCloseInfFile(hInf);
SetupDiDestroyDeviceInfoList(hDevInfo);
if (hKey != INVALID_HANDLE_VALUE)
{
RegCloseKey(hKey);
}
return ERROR_SUCCESS;
}
BOOL
IsSoftwareBusPnpEnumeratorInstalled()
{
HDEVINFO hDevInfo;
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
GUID SWBusGuid = {STATIC_BUSID_SoftwareDeviceEnumerator};
PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData;
hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, DIGCF_DEVICEINTERFACE| DIGCF_PRESENT);
if (!hDevInfo)
{
// failed
return FALSE;
}
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W));
if (!DeviceInterfaceDetailData)
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
if (!SetupDiGetDeviceInterfaceDetailW(hDevInfo, &DeviceInterfaceData, DeviceInterfaceDetailData,MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W), NULL, NULL))
{
// failed
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return FALSE;
}
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return TRUE;
}
nsresult
sbWinGetDevicePath(DEVINST aDevInst,
const GUID* aGUID,
nsAString& aDevicePath)
{
// Validate arguments.
NS_ENSURE_ARG_POINTER(aGUID);
// Function variables.
nsresult rv;
// Get the device info set and set it up for auto-disposal.
nsAutoString deviceInstanceID;
rv = sbWinGetDeviceInstanceID(aDevInst, deviceInstanceID);
NS_ENSURE_SUCCESS(rv, rv);
HDEVINFO devInfo = SetupDiGetClassDevsW(aGUID,
deviceInstanceID.get(),
NULL,
DIGCF_DEVICEINTERFACE);
NS_ENSURE_TRUE(devInfo != INVALID_HANDLE_VALUE, NS_ERROR_FAILURE);
sbAutoHDEVINFO autoDevInfo(devInfo);
// Get the device info for the device instance.
SP_DEVINFO_DATA devInfoData;
rv = sbWinGetDevInfoData(aDevInst, devInfo, &devInfoData);
NS_ENSURE_SUCCESS(rv, rv);
// Get the device interface detail data for the device instance.
PSP_DEVICE_INTERFACE_DETAIL_DATA devIfDetailData;
rv = sbWinGetDevInterfaceDetail(&devIfDetailData,
devInfo,
&devInfoData,
aGUID);
NS_ENSURE_SUCCESS(rv, rv);
sbAutoNSMemPtr autoDevIfDetailData(devIfDetailData);
// Return results.
aDevicePath.Assign(devIfDetailData->DevicePath);
return NS_OK;
}
nsresult
sbWinFindDevicesByStorageDevNum(STORAGE_DEVICE_NUMBER* aStorageDevNum,
PRBool aMatchPartitionNumber,
const GUID* aGUID,
nsTArray<DEVINST>& aDevInstList)
{
// Validate arguments.
NS_ENSURE_ARG_POINTER(aStorageDevNum);
NS_ENSURE_ARG_POINTER(aGUID);
// Function variables.
nsresult rv;
// Get the interface device class info and set up for auto-disposal.
HDEVINFO devInfo =
SetupDiGetClassDevsW(aGUID,
NULL,
NULL,
DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
NS_ENSURE_TRUE(devInfo != INVALID_HANDLE_VALUE, NS_ERROR_FAILURE);
sbAutoHDEVINFO autoDevInfo(devInfo);
// Search for device instances with a matching storage device number.
aDevInstList.Clear();
DWORD devIndex = 0;
while (1) {
// Get the next device detail data and set it up for auto-disposal.
PSP_DEVICE_INTERFACE_DETAIL_DATA devIfDetailData;
SP_DEVINFO_DATA devInfoData;
rv = sbWinGetDevDetail(&devIfDetailData,
&devInfoData,
devInfo,
aGUID,
devIndex++);
if (rv == NS_ERROR_NOT_AVAILABLE)
break;
NS_ENSURE_SUCCESS(rv, rv);
sbAutoMemPtr<SP_DEVICE_INTERFACE_DETAIL_DATA>
autoDevIfDetailData(devIfDetailData);
// Get the next storage device number.
STORAGE_DEVICE_NUMBER storageDevNum;
rv = sbWinGetStorageDevNum(devIfDetailData->DevicePath, &storageDevNum);
if (NS_FAILED(rv))
continue;
// Skip device instance if it doesn't match the target storage device
// number.
if (storageDevNum.DeviceType != aStorageDevNum->DeviceType)
continue;
if (storageDevNum.DeviceNumber != aStorageDevNum->DeviceNumber)
continue;
if (aMatchPartitionNumber &&
(storageDevNum.PartitionNumber != aStorageDevNum->PartitionNumber)) {
continue;
}
// Add device instance to list.
NS_ENSURE_TRUE(aDevInstList.AppendElement(devInfoData.DevInst),
NS_ERROR_OUT_OF_MEMORY);
}
return NS_OK;
}
VOID Mij_EnumerateDevices()
{
HANDLE deviceInfo = NULL;
deviceInfo = SetupDiGetClassDevsW(NULL, L"USB", NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT);
if (deviceInfo != INVALID_HANDLE_VALUE)
{
BOOLEAN flag = TRUE;
unsigned int num = 0;
while (flag)
{
SP_DEVINFO_DATA deviceData;
Memory_Clear(&deviceData, sizeof(SP_DEVINFO_DATA));
deviceData.cbSize = sizeof(SP_DEVINFO_DATA);
deviceData.DevInst = NULL;
deviceData.Reserved = 0;
flag = SetupDiEnumDeviceInfo(deviceInfo, num, &deviceData);
if (flag)
{
wchar_t propertyBuffer[1000];
DWORD requiredSize = 0;
DWORD propertyDataType = 1;
if (SetupDiGetDeviceRegistryPropertyW(
deviceInfo,
&deviceData,
SPDRP_HARDWAREID,
&propertyDataType,
&propertyBuffer,
1000 * sizeof(wchar_t),
&requiredSize))
{
BOOLEAN flag2 = FALSE;
int i;
// Direct Match, definitely a device we recognize
for (i = 0; i < sizeof(KnownDevices) / sizeof(KnownDevices[0]); i++)
{
if (String_CompareIgnoreCaseN(propertyBuffer, KnownDevices[i].RegistryId, 22))
{
flag2 = TRUE;
Log(L"found %s [%s]", KnownDevices[i].FriendlyName, propertyBuffer);
break;
}
}
// Possible devices that could work
if (!flag2
&& SetupDiGetDeviceRegistryPropertyW(
deviceInfo,
&deviceData,
SPDRP_COMPATIBLEIDS,
&propertyDataType,
&propertyBuffer,
1000 * sizeof(wchar_t),
&requiredSize))
{
//Bluetooth Device
//BaseClass[0xE0] = Wireless Controller,
//SubClass[0x01] = Wireless Radio,
//Protocol[0x01] = Bluetooth Programming Interface
//https://web.archive.org/web/20070626033649/http://www.usb.org/developers/defined_class/#BaseClassE0h
if (String_CompareIgnoreCaseN(propertyBuffer, L"usb\\Class_e0&subClass_01&Prot_01", 33))
{
Log(L"found Bluetooth device %s", propertyBuffer);
flag2 = TRUE;
}
//Controller
else if (String_CompareIgnoreCaseN(propertyBuffer, L"usb\\Class_58&subClass_42", 25))
{
Log(L"found Controller %s", propertyBuffer);
flag2 = TRUE;
}
}
if (flag2)
{
//Callback(&deviceData);
//GetDeviceDetail(deviceInfo, &deviceData);
Log(L"Installing driver...");
InstallDriver(deviceInfo, &deviceData);
Log(L"Finished Installing driver...");
}
}
}
num += 1;
}
}
}
DWORD
InstallSoftwareDeviceInterface(IN LPGUID DeviceId,
IN LPGUID InterfaceId,
IN LPWSTR ReferenceString)
{
HDEVINFO hDevInfo;
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
GUID SWBusGuid = {STATIC_BUSID_SoftwareDeviceEnumerator};
PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData;
HANDLE hDevice;
PSWENUM_INSTALL_INTERFACE InstallInterface;
DWORD dwResult;
hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, DIGCF_DEVICEINTERFACE| DIGCF_PRESENT);
if (!hDevInfo)
{
// failed
return GetLastError();
}
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W));
if (!DeviceInterfaceDetailData)
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
if (!SetupDiGetDeviceInterfaceDetailW(hDevInfo, &DeviceInterfaceData, DeviceInterfaceDetailData,MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W), NULL, NULL))
{
// failed
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
hDevice = CreateFileW(DeviceInterfaceDetailData->DevicePath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED|FILE_ATTRIBUTE_NORMAL, NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
// failed
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
InstallInterface = (PSWENUM_INSTALL_INTERFACE)HeapAlloc(GetProcessHeap(), 0, sizeof(SWENUM_INSTALL_INTERFACE) + wcslen(ReferenceString) * sizeof(WCHAR));
if (!InstallInterface)
{
// failed
CloseHandle(hDevice);
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return GetLastError();
}
// init install interface param
InstallInterface->DeviceId = *DeviceId;
InstallInterface->InterfaceId = *InterfaceId;
wcscpy(InstallInterface->ReferenceString, ReferenceString);
PerformIO(hDevice, IOCTL_SWENUM_INSTALL_INTERFACE, InstallInterface, sizeof(SWENUM_INSTALL_INTERFACE) + wcslen(ReferenceString) * sizeof(WCHAR), NULL, 0, NULL);
dwResult = HeapFree(GetProcessHeap(), 0, InstallInterface);
CloseHandle(hDevice);
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return dwResult;
}
VOID
DisableNetworkAdapter(INetConnection * pNet, LANSTATUSUI_CONTEXT * pContext, HWND hwndDlg)
{
HKEY hKey;
NETCON_PROPERTIES * pProperties;
LPOLESTR pDisplayName;
WCHAR szPath[200];
DWORD dwSize, dwType;
LPWSTR pPnp;
HDEVINFO hInfo;
SP_DEVINFO_DATA DevInfo;
SP_PROPCHANGE_PARAMS PropChangeParams;
BOOL bClose = FALSE;
NOTIFYICONDATAW nid;
if (FAILED(pNet->GetProperties(&pProperties)))
return;
hInfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_NET, NULL, NULL, DIGCF_PRESENT );
if (!hInfo)
{
NcFreeNetconProperties(pProperties);
return;
}
if (FAILED(StringFromCLSID((CLSID)pProperties->guidId, &pDisplayName)))
{
NcFreeNetconProperties(pProperties);
SetupDiDestroyDeviceInfoList(hInfo);
return;
}
NcFreeNetconProperties(pProperties);
if (FindNetworkAdapter(hInfo, &DevInfo, pDisplayName))
{
PropChangeParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER);
PropChangeParams.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE; //;
PropChangeParams.StateChange = DICS_DISABLE;
PropChangeParams.Scope = DICS_FLAG_CONFIGSPECIFIC;
PropChangeParams.HwProfile = 0;
if (SetupDiSetClassInstallParams(hInfo, &DevInfo, &PropChangeParams.ClassInstallHeader, sizeof(SP_PROPCHANGE_PARAMS)))
{
if (SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, hInfo, &DevInfo))
bClose = TRUE;
}
}
SetupDiDestroyDeviceInfoList(hInfo);
swprintf(szPath, L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", pDisplayName);
CoTaskMemFree(pDisplayName);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return;
dwSize = 0;
if (RegQueryValueExW(hKey, L"PnpInstanceID", NULL, &dwType, NULL, &dwSize) != ERROR_SUCCESS || dwType != REG_SZ)
{
RegCloseKey(hKey);
return;
}
pPnp = static_cast<PWSTR>(CoTaskMemAlloc(dwSize));
if (!pPnp)
{
RegCloseKey(hKey);
return;
}
if (RegQueryValueExW(hKey, L"PnpInstanceID", NULL, &dwType, (LPBYTE)pPnp, &dwSize) != ERROR_SUCCESS)
{
CoTaskMemFree(pPnp);
RegCloseKey(hKey);
return;
}
RegCloseKey(hKey);
swprintf(szPath, L"System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Enum\\%s", pPnp);
CoTaskMemFree(pPnp);
if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szPath, 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
return;
dwSize = 1; /* enable = 0, disable = 1 */
RegSetValueExW(hKey, L"CSConfigFlags", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
RegCloseKey(hKey);
if (!bClose)
return;
PropSheet_PressButton(GetParent(hwndDlg), PSBTN_CANCEL);
ZeroMemory(&nid, sizeof(nid));
nid.cbSize = sizeof(nid);
nid.uID = pContext->uID;
nid.hWnd = pContext->hwndDlg;
nid.uFlags = NIF_STATE;
nid.dwState = NIS_HIDDEN;
nid.dwStateMask = NIS_HIDDEN;
Shell_NotifyIconW(NIM_MODIFY, &nid);
}
NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device, LPCWSTR serial, LPCWSTR index)
{
WCHAR regname[255];
WCHAR dev_link[255];
SP_DEVINFO_DATA Data;
UNICODE_STRING nameW, linkW;
NTSTATUS status;
HDEVINFO devinfo;
GUID hidGuid;
BASE_DEVICE_EXTENSION *ext;
HidD_GetHidGuid(&hidGuid);
ext = device->DeviceExtension;
sprintfW(dev_link, device_link_fmtW, ext->information.VendorID,
ext->information.ProductID, index, ext->information.VersionNumber, serial,
class_guid);
struprW(dev_link);
RtlInitUnicodeString( &nameW, ext->device_name);
RtlInitUnicodeString( &linkW, dev_link );
TRACE("Create link %s\n", debugstr_w(dev_link));
ext->link_name = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(dev_link) + 1));
lstrcpyW(ext->link_name, dev_link);
status = IoCreateSymbolicLink( &linkW, &nameW );
if (status)
{
FIXME( "failed to create link error %x\n", status );
return status;
}
sprintfW(regname, device_regname_fmtW, ext->information.VendorID, ext->information.ProductID, index, ext->information.VersionNumber, serial);
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_HIDCLASS, NULL, NULL, DIGCF_DEVICEINTERFACE);
if (!devinfo)
{
FIXME( "failed to get ClassDevs %x\n", GetLastError());
return GetLastError();
}
Data.cbSize = sizeof(Data);
if (!SetupDiCreateDeviceInfoW(devinfo, regname, &GUID_DEVCLASS_HIDCLASS, NULL, NULL, DICD_INHERIT_CLASSDRVS, &Data))
{
if (GetLastError() == ERROR_DEVINST_ALREADY_EXISTS)
{
SetupDiDestroyDeviceInfoList(devinfo);
return ERROR_SUCCESS;
}
FIXME( "failed to Create Device Info %x\n", GetLastError());
return GetLastError();
}
if (!SetupDiRegisterDeviceInfo( devinfo, &Data, 0, NULL, NULL, NULL ))
{
FIXME( "failed to Register Device Info %x\n", GetLastError());
return GetLastError();
}
if (!SetupDiCreateDeviceInterfaceW( devinfo, &Data, &hidGuid, NULL, 0, NULL))
{
FIXME( "failed to Create Device Interface %x\n", GetLastError());
return GetLastError();
}
SetupDiDestroyDeviceInfoList(devinfo);
return S_OK;
}
HRESULT
pEnumerateNdasportLogicalUnits(
__inout CSimpleArray<HDEVNOTIFY>& DevNotifyHandles,
__in HWND hWnd)
{
HRESULT hr;
HDEVINFO devInfoSet = SetupDiGetClassDevsW(
NULL,
NULL,
NULL,
DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
if (INVALID_HANDLE_VALUE == devInfoSet)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
fprintf(stderr, "SetupDiGetClassDevs failed, hr=0x%X\n", hr);
return hr;
}
SP_DEVINFO_DATA devInfoData;
for (DWORD index = 0; ; ++index)
{
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
BOOL success = SetupDiEnumDeviceInfo(devInfoSet, index, &devInfoData);
if (!success)
{
if (ERROR_NO_MORE_ITEMS != GetLastError())
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
fprintf(stderr, "SetupDiEnumDeviceInfo failed, hr=0x%X\n", hr);
}
break;
}
devInfoData.ClassGuid;
}
fprintf(stdout, "Enumerating DISK...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_DISK);
fprintf(stdout, "Enumerating CDROM...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_CDROM);
fprintf(stdout, "Enumerating TAPE...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_TAPE);
fprintf(stdout, "Enumerating WRITEONCEDISK...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_WRITEONCEDISK);
fprintf(stdout, "Enumerating MEDIUMCHANGER...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_MEDIUMCHANGER);
fprintf(stdout, "Enumerating CDCHANGER...\n");
hr = pEnumerateNdasportLogicalUnits(
DevNotifyHandles,
hWnd,
devInfoSet,
&GUID_DEVINTERFACE_CDCHANGER);
ATLVERIFY( SetupDiDestroyDeviceInfoList(devInfoSet) );
return S_OK;
}
/*
* @implemented
*/
BOOL WINAPI
UpdateDriverForPlugAndPlayDevicesW(
IN HWND hwndParent,
IN LPCWSTR HardwareId,
IN LPCWSTR FullInfPath,
IN DWORD InstallFlags,
OUT PBOOL bRebootRequired OPTIONAL)
{
DEVINSTDATA DevInstData;
DWORD i;
LPWSTR Buffer = NULL;
DWORD BufferSize;
LPCWSTR CurrentHardwareId; /* Pointer into Buffer */
BOOL FoundHardwareId, FoundAtLeastOneDevice = FALSE;
BOOL ret = FALSE;
DevInstData.hDevInfo = INVALID_HANDLE_VALUE;
TRACE("UpdateDriverForPlugAndPlayDevicesW(%p %s %s 0x%x %p)\n",
hwndParent, debugstr_w(HardwareId), debugstr_w(FullInfPath), InstallFlags, bRebootRequired);
/* FIXME: InstallFlags bRebootRequired ignored! */
/* Check flags */
if (InstallFlags & ~(INSTALLFLAG_FORCE | INSTALLFLAG_READONLY | INSTALLFLAG_NONINTERACTIVE))
{
TRACE("Unknown flags: 0x%08lx\n", InstallFlags & ~(INSTALLFLAG_FORCE | INSTALLFLAG_READONLY | INSTALLFLAG_NONINTERACTIVE));
SetLastError(ERROR_INVALID_FLAGS);
goto cleanup;
}
/* Enumerate all devices of the system */
DevInstData.hDevInfo = SetupDiGetClassDevsW(NULL, NULL, hwndParent, DIGCF_ALLCLASSES | DIGCF_PRESENT);
if (DevInstData.hDevInfo == INVALID_HANDLE_VALUE)
goto cleanup;
DevInstData.devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
for (i = 0; ; i++)
{
if (!SetupDiEnumDeviceInfo(DevInstData.hDevInfo, i, &DevInstData.devInfoData))
{
if (GetLastError() != ERROR_NO_MORE_ITEMS)
{
TRACE("SetupDiEnumDeviceInfo() failed with error 0x%x\n", GetLastError());
goto cleanup;
}
/* This error was expected */
break;
}
/* Get Hardware ID */
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = NULL;
BufferSize = 0;
while (!SetupDiGetDeviceRegistryPropertyW(
DevInstData.hDevInfo,
&DevInstData.devInfoData,
SPDRP_HARDWAREID,
NULL,
(PBYTE)Buffer,
BufferSize,
&BufferSize))
{
if (GetLastError() == ERROR_FILE_NOT_FOUND)
{
Buffer = NULL;
break;
}
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
TRACE("SetupDiGetDeviceRegistryPropertyW() failed with error 0x%x\n", GetLastError());
goto cleanup;
}
/* This error was expected */
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = HeapAlloc(GetProcessHeap(), 0, BufferSize);
if (!Buffer)
{
TRACE("HeapAlloc() failed\n", GetLastError());
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto cleanup;
}
}
if (Buffer == NULL)
continue;
/* Check if we match the given hardware ID */
FoundHardwareId = FALSE;
for (CurrentHardwareId = Buffer; *CurrentHardwareId != UNICODE_NULL; CurrentHardwareId += wcslen(CurrentHardwareId) + 1)
{
if (wcscmp(CurrentHardwareId, HardwareId) == 0)
{
FoundHardwareId = TRUE;
break;
}
}
if (!FoundHardwareId)
continue;
/* We need to try to update the driver of this device */
/* Get Instance ID */
HeapFree(GetProcessHeap(), 0, Buffer);
Buffer = NULL;
if (SetupDiGetDeviceInstanceIdW(DevInstData.hDevInfo, &DevInstData.devInfoData, NULL, 0, &BufferSize))
{
/* Error, as the output buffer should be too small */
SetLastError(ERROR_GEN_FAILURE);
goto cleanup;
}
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
TRACE("SetupDiGetDeviceInstanceIdW() failed with error 0x%x\n", GetLastError());
goto cleanup;
}
else if ((Buffer = HeapAlloc(GetProcessHeap(), 0, BufferSize * sizeof(WCHAR))) == NULL)
{
TRACE("HeapAlloc() failed\n", GetLastError());
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto cleanup;
}
else if (!SetupDiGetDeviceInstanceIdW(DevInstData.hDevInfo, &DevInstData.devInfoData, Buffer, BufferSize, NULL))
{
TRACE("SetupDiGetDeviceInstanceIdW() failed with error 0x%x\n", GetLastError());
goto cleanup;
}
TRACE("Trying to update the driver of %s\n", debugstr_w(Buffer));
/* Search driver in the specified .inf file */
if (!SearchDriver(&DevInstData, NULL, FullInfPath))
{
TRACE("SearchDriver() failed with error 0x%x\n", GetLastError());
continue;
}
/* FIXME: HACK! We shouldn't check of ERROR_PRIVILEGE_NOT_HELD */
//if (!InstallCurrentDriver(&DevInstData))
if (!InstallCurrentDriver(&DevInstData) && GetLastError() != ERROR_PRIVILEGE_NOT_HELD)
{
TRACE("InstallCurrentDriver() failed with error 0x%x\n", GetLastError());
continue;
}
FoundAtLeastOneDevice = TRUE;
}
if (FoundAtLeastOneDevice)
{
SetLastError(NO_ERROR);
ret = TRUE;
}
else
{
TRACE("No device found with HardwareID %s\n", debugstr_w(HardwareId));
SetLastError(ERROR_NO_SUCH_DEVINST);
}
cleanup:
if (DevInstData.hDevInfo != INVALID_HANDLE_VALUE)
SetupDiDestroyDeviceInfoList(DevInstData.hDevInfo);
HeapFree(GetProcessHeap(), 0, Buffer);
return ret;
}
HRESULT
CNdasServiceDeviceEventHandler::pRegisterLogicalUnits()
{
HRESULT hr;
HDEVINFO devInfoSet = SetupDiGetClassDevsW(
NULL,
NULL,
NULL,
DIGCF_ALLCLASSES | DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
if (INVALID_HANDLE_VALUE == devInfoSet)
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_ERROR,
"SetupDiGetClassDevsW failed, hr=0x%X\n", hr);
return hr;
}
SP_DEVINFO_DATA devInfoData;
for (DWORD index = 0; ; ++index)
{
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
BOOL success = SetupDiEnumDeviceInfo(devInfoSet, index, &devInfoData);
if (!success)
{
if (ERROR_NO_MORE_ITEMS != GetLastError())
{
hr = HRESULT_FROM_SETUPAPI(GetLastError());
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_ERROR,
"SetupDiEnumDeviceInfo failed, hr=0x%X\n", hr);
}
break;
}
devInfoData.ClassGuid;
}
const struct {
LPCGUID Guid;
LPCSTR TypeName;
} LogicalUnitInterfaces[] = {
&GUID_DEVINTERFACE_DISK, "DISK",
&GUID_DEVINTERFACE_CDROM, "CDROM",
&GUID_DEVINTERFACE_TAPE, "TAPE",
&GUID_DEVINTERFACE_WRITEONCEDISK, "WRITEONCEDISK",
&GUID_DEVINTERFACE_MEDIUMCHANGER, "MEDIUMCHANGER",
&GUID_DEVINTERFACE_CDCHANGER, "CDCHANGER",
};
for (DWORD i = 0; i < RTL_NUMBER_OF(LogicalUnitInterfaces); ++i)
{
XTLTRACE2(NDASSVC_PNP, TRACE_LEVEL_WARNING,
"Enumerating %hs...\n", LogicalUnitInterfaces[i].TypeName);
pRegisterLogicalUnit(
devInfoSet,
LogicalUnitInterfaces[i].Guid);
}
XTLVERIFY( SetupDiDestroyDeviceInfoList(devInfoSet) );
return S_OK;
}
VOID
D3DKMTInitialize()
{
VOID *gdi32 = NULL;
VOID *deviceInfoSet;
UINT32 result;
UINT32 memberIndex;
UINT32 detailDataSize;
SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
SP_DEVICE_INTERFACE_DETAIL_DATA_W *detailData;
SP_DEVINFO_DATA deviceInfoData;
//D3DKMT_OPENADAPTERFROMDEVICENAME openAdapterFromDeviceName;
D3DKMT_QUERYSTATISTICS queryStatistics;
gdi32 = Module::Load(L"gdi32.dll");
if (!gdi32)
{
return;
}
D3DKMTOpenAdapterFromDeviceName = (TYPE_D3DKMTOpenAdapterFromDeviceName) Module::GetProcedureAddress(
gdi32,
"D3DKMTOpenAdapterFromDeviceName"
);
D3DKMTQueryStatistics = (TYPE_D3DKMTQueryStatistics) Module::GetProcedureAddress(gdi32, "D3DKMTQueryStatistics");
if (!D3DKMTOpenAdapterFromDeviceName || !D3DKMTQueryStatistics)
{
return;
}
deviceInfoSet = SetupDiGetClassDevsW(&GUID_DISPLAY_DEVICE_ARRIVAL_I,
NULL, NULL,
DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
if (!deviceInfoSet)
{
return;
}
memberIndex = 0;
deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
while (SetupDiEnumDeviceInterfaces(deviceInfoSet, NULL, &GUID_DISPLAY_DEVICE_ARRIVAL_I, memberIndex, &deviceInterfaceData))
{
detailDataSize = 0x100;
detailData = (SP_DEVICE_INTERFACE_DETAIL_DATA_W*) Memory::Allocate(detailDataSize);
detailData->cbSize = 6; /*sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)*/
deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
result = SetupDiGetDeviceInterfaceDetailW(
deviceInfoSet,
&deviceInterfaceData,
detailData,
detailDataSize,
&detailDataSize,
&deviceInfoData
);
if (result)
{
openAdapterFromDeviceName.pDeviceName = detailData->DevicePath;
if (NT_SUCCESS(D3DKMTOpenAdapterFromDeviceName(&openAdapterFromDeviceName)))
{
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_ADAPTER;
queryStatistics.AdapterLuid = openAdapterFromDeviceName.AdapterLuid;
if (NT_SUCCESS(D3DKMTQueryStatistics(&queryStatistics)))
{
UINT32 i;
D3dkmt_GpuAdapter = AllocateGpuAdapter(queryStatistics.QueryResult.AdapterInformation.NbSegments);
D3dkmt_GpuAdapter->AdapterLuid = openAdapterFromDeviceName.AdapterLuid;
D3dkmt_GpuAdapter->NodeCount = queryStatistics.QueryResult.AdapterInformation.NodeCount;
D3dkmt_GpuAdapter->SegmentCount = queryStatistics.QueryResult.AdapterInformation.NbSegments;
RtlInitializeBitMap(
&D3dkmt_GpuAdapter->ApertureBitMap,
D3dkmt_GpuAdapter->ApertureBitMapBuffer,
queryStatistics.QueryResult.AdapterInformation.NbSegments
);
EtGpuTotalNodeCount += D3dkmt_GpuAdapter->NodeCount;
EtGpuTotalSegmentCount += D3dkmt_GpuAdapter->SegmentCount;
D3dkmt_GpuAdapter->FirstNodeIndex = EtGpuNextNodeIndex;
EtGpuNextNodeIndex += D3dkmt_GpuAdapter->NodeCount;
for (i = 0; i < D3dkmt_GpuAdapter->SegmentCount; i++)
{
memset(&queryStatistics, 0, sizeof(D3DKMT_QUERYSTATISTICS));
queryStatistics.Type = D3DKMT_QUERYSTATISTICS_SEGMENT;
queryStatistics.AdapterLuid = D3dkmt_GpuAdapter->AdapterLuid;
queryStatistics.QuerySegment.SegmentId = i;
if (NT_SUCCESS(D3DKMTQueryStatistics(&queryStatistics)))
{
UINT64 commitLimit;
UINT32 aperature;
commitLimit = queryStatistics.QueryResult.SegmentInformationV1.CommitLimit;
aperature = queryStatistics.QueryResult.SegmentInformationV1.Aperture;
if (aperature)
RtlSetBits(&D3dkmt_GpuAdapter->ApertureBitMap, i, 1);
else
EtGpuDedicatedLimit += commitLimit;
}
}
}
}
}
Memory::Free(detailData);
memberIndex++;
}
SetupDiDestroyDeviceInfoList(deviceInfoSet);
EtGpuNodeBitMapBuffer = (UINT32*) Memory::Allocate(BYTES_NEEDED_FOR_BITS(EtGpuTotalNodeCount));
RtlInitializeBitMap(&EtGpuNodeBitMap, EtGpuNodeBitMapBuffer, EtGpuTotalNodeCount);
EtGpuNodesTotalRunningTimeDelta = (PPH_UINT64_DELTA) Memory::Allocate(sizeof(PH_UINT64_DELTA) * EtGpuTotalNodeCount);
memset(EtGpuNodesTotalRunningTimeDelta, 0, sizeof(PH_UINT64_DELTA) * EtGpuTotalNodeCount);
}
MMRESULT
WdmAudOpenSoundDeviceByLegacy(
IN PSOUND_DEVICE SoundDevice,
OUT PVOID *Handle)
{
HDEVINFO hDevInfo;
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
GUID SWBusGuid = {STATIC_KSCATEGORY_WDMAUD};
PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData;
if ( KernelHandle == INVALID_HANDLE_VALUE )
{
hDevInfo = SetupDiGetClassDevsW(&SWBusGuid, NULL, NULL, DIGCF_DEVICEINTERFACE| DIGCF_PRESENT);
if (!hDevInfo)
{
// failed
return MMSYSERR_ERROR;
}
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &SWBusGuid, 0, &DeviceInterfaceData))
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return MMSYSERR_ERROR;
}
DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W));
if (!DeviceInterfaceDetailData)
{
// failed
SetupDiDestroyDeviceInfoList(hDevInfo);
return MMSYSERR_ERROR;
}
DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
if (!SetupDiGetDeviceInterfaceDetailW(hDevInfo, &DeviceInterfaceData, DeviceInterfaceDetailData,MAX_PATH * sizeof(WCHAR) + sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W), NULL, NULL))
{
// failed
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
return MMSYSERR_ERROR;
}
SND_TRACE(L"Opening wdmaud device '%s'\n",DeviceInterfaceDetailData->DevicePath);
KernelHandle = CreateFileW(DeviceInterfaceDetailData->DevicePath,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);
HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailData);
SetupDiDestroyDeviceInfoList(hDevInfo);
}
if ( KernelHandle == INVALID_HANDLE_VALUE )
return MMSYSERR_ERROR;
++ OpenCount;
return MMSYSERR_NOERROR;
}
static
void
SetDeviceDetails(HWND hwndDlg, LPCGUID classGUID, LPCWSTR lpcstrDescription)
{
HDEVINFO hInfo;
DWORD dwIndex = 0;
SP_DEVINFO_DATA InfoData;
WCHAR szText[30];
HWND hDlgCtrls[3];
WAVEOUTCAPSW waveOut;
UINT numDev;
MMRESULT errCode;
/* enumerate waveout devices */
numDev = waveOutGetNumDevs();
if (numDev)
{
do
{
ZeroMemory(&waveOut, sizeof(waveOut));
errCode = waveOutGetDevCapsW(dwIndex++, &waveOut, sizeof(waveOut));
if (!wcsncmp(lpcstrDescription, waveOut.szPname, min(MAXPNAMELEN, wcslen(waveOut.szPname))))
{
/* set the product id */
SetDlgItemInt(hwndDlg, IDC_STATIC_DSOUND_PRODUCTID, waveOut.wPid, FALSE);
/* set the vendor id */
SetDlgItemInt(hwndDlg, IDC_STATIC_DSOUND_VENDORID, waveOut.wMid, FALSE);
/* check if its a wdm audio driver */
if (waveOut.wPid == MM_MSFT_WDMAUDIO_WAVEOUT)
SendDlgItemMessageW(hwndDlg, IDC_STATIC_DSOUND_TYPE, WM_SETTEXT, 0, (LPARAM)L"WDM");
/* check if device is default device */
szText[0] = L'\0';
if (dwIndex - 1 == 0) /* FIXME assume default playback device is device 0 */
LoadStringW(hInst, IDS_OPTION_YES, szText, sizeof(szText)/sizeof(WCHAR));
else
LoadStringW(hInst, IDS_OPTION_NO, szText, sizeof(szText)/sizeof(WCHAR));
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
/* set default device info */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_DSOUND_STANDARD, WM_SETTEXT, 0, (LPARAM)szText);
break;
}
}while(errCode == MMSYSERR_NOERROR && dwIndex < numDev);
}
dwIndex = 0;
/* create the setup list */
hInfo = SetupDiGetClassDevsW(classGUID, NULL, NULL, DIGCF_PRESENT|DIGCF_PROFILE);
if (hInfo == INVALID_HANDLE_VALUE)
return;
do
{
ZeroMemory(&InfoData, sizeof(InfoData));
InfoData.cbSize = sizeof(InfoData);
if (SetupDiEnumDeviceInfo(hInfo, dwIndex, &InfoData))
{
/* set device name */
if (SetupDiGetDeviceInstanceId(hInfo, &InfoData, szText, sizeof(szText)/sizeof(WCHAR), NULL))
SendDlgItemMessageW(hwndDlg, IDC_STATIC_DSOUND_DEVICEID, WM_SETTEXT, 0, (LPARAM)szText);
/* set the manufacturer name */
if (SetupDiGetDeviceRegistryPropertyW(hInfo, &InfoData, SPDRP_MFG, NULL, (PBYTE)szText, sizeof(szText), NULL))
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_PROVIDER, WM_SETTEXT, 0, (LPARAM)szText);
/* FIXME
* we currently enumerate only the first adapter
*/
hDlgCtrls[0] = GetDlgItem(hwndDlg, IDC_STATIC_DSOUND_DRIVER);
hDlgCtrls[1] = GetDlgItem(hwndDlg, IDC_STATIC_DSOUND_VERSION);
hDlgCtrls[2] = GetDlgItem(hwndDlg, IDC_STATIC_DSOUND_DATE);
EnumerateDrivers(hDlgCtrls, hInfo, &InfoData);
break;
}
if (GetLastError() == ERROR_NO_MORE_ITEMS)
break;
dwIndex++;
}while(TRUE);
/* destroy the setup list */
SetupDiDestroyDeviceInfoList(hInfo);
}
bool
CDeviceView::RefreshDeviceList()
{
GUID ClassGuid;
CClassNode *ClassNode;
CDeviceNode *DeviceNode;
HDEVINFO hDevInfo;
SP_DEVINFO_DATA DeviceInfoData;
DWORD i;
BOOL Success;
ULONG ClassIndex = 0;
EmptyLists();
if (m_RootNode) delete m_RootNode;
m_RootNode = new CRootNode(&m_ImageListData);
m_RootNode->SetupNode();
// Loop through all the classes
do
{
Success = GetNextClass(ClassIndex, &ClassGuid, &hDevInfo);
if (Success)
{
// Create a new class node and add it to the list
ClassNode = new CClassNode(&ClassGuid, &m_ImageListData);
if (ClassNode->SetupNode())
{
m_ClassNodeList.AddTail(ClassNode);
}
SetupDiDestroyDeviceInfoList(hDevInfo);
}
ClassIndex++;
} while (Success);
// Get all the devices on the local machine
hDevInfo = SetupDiGetClassDevsW(NULL,
0,
0,
DIGCF_PRESENT | DIGCF_ALLCLASSES);
if (hDevInfo == INVALID_HANDLE_VALUE)
{
return false;
}
// loop though all the devices
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
for (i = 0;; i++)
{
// Get the devinst for this device
Success = SetupDiEnumDeviceInfo(hDevInfo, i, &DeviceInfoData);
if (Success == FALSE) break;
// create a new device node and add it to the list
DeviceNode = new CDeviceNode(DeviceInfoData.DevInst, &m_ImageListData);
if (DeviceNode->SetupNode())
{
m_DeviceNodeList.AddTail(DeviceNode);
}
else
{
ATLASSERT(FALSE);
}
}
SetupDiDestroyDeviceInfoList(hDevInfo);
return TRUE;
}
/*
* sapiCreateSetupDBSnapshot
*
* Purpose:
*
* Collects Setup API information to the linked list.
*
* Returned buffer must be freed with sapiFreeSnapshot after usage.
*
*/
PVOID sapiCreateSetupDBSnapshot(
VOID
)
{
BOOL cond = FALSE;
PSAPIDBOBJ sObj;
SP_DEVINFO_DATA DeviceInfoData;
DWORD i, DataType = 0;
DWORD DataSize, ReturnedDataSize = 0;
PSAPIDBENTRY Entry;
sObj = VirtualAlloc(NULL, sizeof(SAPIDBOBJ), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (sObj == NULL)
return NULL;
sObj->hDevInfo = NULL;
sObj->sapiDBHead.Blink = NULL;
sObj->sapiDBHead.Flink = NULL;
InitializeCriticalSection(&sObj->objCS);
do {
sObj->hDevInfo = SetupDiGetClassDevsW(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES);
if (sObj->hDevInfo == INVALID_HANDLE_VALUE)
break;
InitializeListHead(&sObj->sapiDBHead);
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
for (i = 0; SetupDiEnumDeviceInfo(sObj->hDevInfo, i, &DeviceInfoData); i++) {
Entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SAPIDBENTRY));
if (Entry == NULL)
break;
// first query lpDeviceName
DataSize = MAX_PATH * sizeof(WCHAR);
Entry->lpDeviceName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, DataSize);
if (Entry->lpDeviceName != NULL) {
SetupDiGetDeviceRegistryPropertyW(sObj->hDevInfo,
&DeviceInfoData,
SPDRP_PHYSICAL_DEVICE_OBJECT_NAME,
&DataType,
(PBYTE)Entry->lpDeviceName,
DataSize,
&ReturnedDataSize);
// not enough memory for call, reallocate
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
HeapFree(GetProcessHeap(), 0, Entry->lpDeviceName);
Entry->lpDeviceName = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ReturnedDataSize);
if (Entry->lpDeviceName != NULL) {
SetupDiGetDeviceRegistryPropertyW(sObj->hDevInfo,
&DeviceInfoData,
SPDRP_PHYSICAL_DEVICE_OBJECT_NAME,
&DataType,
(PBYTE)Entry->lpDeviceName,
ReturnedDataSize,
&ReturnedDataSize);
}
}
}
DataSize = MAX_PATH * sizeof(WCHAR);
Entry->lpDeviceDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, DataSize);
if (Entry->lpDeviceDesc != NULL) {
SetupDiGetDeviceRegistryPropertyW(sObj->hDevInfo,
&DeviceInfoData,
SPDRP_DEVICEDESC,
&DataType,
(PBYTE)Entry->lpDeviceDesc,
DataSize,
&ReturnedDataSize);
// not enough memory for call, reallocate
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
HeapFree(GetProcessHeap(), 0, Entry->lpDeviceDesc);
Entry->lpDeviceDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ReturnedDataSize);
if (Entry->lpDeviceDesc != NULL) {
SetupDiGetDeviceRegistryPropertyW(sObj->hDevInfo,
&DeviceInfoData,
SPDRP_DEVICEDESC,
&DataType,
(PBYTE)Entry->lpDeviceDesc,
ReturnedDataSize,
&ReturnedDataSize);
}
}
}
InsertHeadList(&sObj->sapiDBHead, &Entry->ListEntry);
} //for
} while (cond);
return sObj;
}
GList *
ks_enumerate_devices (const GUID * category)
{
GList *result = NULL;
HDEVINFO devinfo;
gint i;
devinfo = SetupDiGetClassDevsW (category, NULL, NULL,
DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (!ks_is_valid_handle (devinfo))
return NULL; /* no devices */
for (i = 0;; i++) {
BOOL success;
SP_DEVICE_INTERFACE_DATA if_data = { 0, };
SP_DEVICE_INTERFACE_DETAIL_DATA_W *if_detail_data;
DWORD if_detail_data_size;
SP_DEVINFO_DATA devinfo_data = { 0, };
DWORD req_size;
if_data.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA);
success = SetupDiEnumDeviceInterfaces (devinfo, NULL, category, i,
&if_data);
if (!success) /* all devices enumerated? */
break;
if_detail_data_size = (MAX_PATH - 1) * sizeof (gunichar2);
if_detail_data = g_malloc0 (if_detail_data_size);
if_detail_data->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA_W);
devinfo_data.cbSize = sizeof (SP_DEVINFO_DATA);
success = SetupDiGetDeviceInterfaceDetailW (devinfo, &if_data,
if_detail_data, if_detail_data_size, &req_size, &devinfo_data);
if (success) {
KsDeviceEntry *entry;
WCHAR buf[512];
entry = g_new0 (KsDeviceEntry, 1);
entry->index = i;
entry->path =
g_utf16_to_utf8 (if_detail_data->DevicePath, -1, NULL, NULL, NULL);
if (SetupDiGetDeviceRegistryPropertyW (devinfo, &devinfo_data,
SPDRP_FRIENDLYNAME, NULL, (BYTE *) buf, sizeof (buf), NULL)) {
entry->name = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
}
if (entry->name == NULL) {
if (SetupDiGetDeviceRegistryPropertyW (devinfo, &devinfo_data,
SPDRP_DEVICEDESC, NULL, (BYTE *) buf, sizeof (buf), NULL)) {
entry->name = g_utf16_to_utf8 (buf, -1, NULL, NULL, NULL);
}
}
if (entry->name != NULL)
result = g_list_prepend (result, entry);
else
ks_device_entry_free (entry);
}
g_free (if_detail_data);
}
SetupDiDestroyDeviceInfoList (devinfo);
return g_list_reverse (result);
}
