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); }