Adding upstream version 1:3.11.1.upstream/1%3.11.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1765 insertions, 0 deletions

diff --git a/lib/win32-cfgmgr32.c b/lib/win32-cfgmgr32.c
new file mode 100644
index 0000000..dbddc54
--- /dev/null
+++ b/lib/win32-cfgmgr32.c
@@ -0,0 +1,1765 @@
+/*
+ *      The PCI Library -- List PCI devices on Win32 via Configuration Manager
+ *
+ *      Copyright (c) 2021 Pali Rohár <pali@kernel.org>
+ *
+ *	Can be freely distributed and used under the terms of the GNU GPL v2+.
+ *
+ *	SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <windows.h>
+#include <cfgmgr32.h>
+
+#include <ctype.h> /* for isxdigit() */
+#include <stdio.h> /* for sprintf() */
+#include <string.h> /* for strlen(), strchr(), strncmp() */
+#include <wchar.h> /* for wcslen(), wcscpy() */
+
+#include "internal.h"
+#include "win32-helpers.h"
+
+/* Unfortunately MinGW32 toolchain does not provide these cfgmgr32 constants. */
+
+#ifndef RegDisposition_OpenExisting
+#define RegDisposition_OpenExisting 0x00000001
+#endif
+
+#ifndef CM_REGISTRY_SOFTWARE
+#define CM_REGISTRY_SOFTWARE 0x00000001
+#endif
+
+#ifndef CM_DRP_HARDWAREID
+#define CM_DRP_HARDWAREID 0x00000002
+#endif
+#ifndef CM_DRP_SERVICE
+#define CM_DRP_SERVICE 0x00000005
+#endif
+#ifndef CM_DRP_BUSNUMBER
+#define CM_DRP_BUSNUMBER 0x00000016
+#endif
+#ifndef CM_DRP_ADDRESS
+#define CM_DRP_ADDRESS 0x0000001D
+#endif
+
+#ifndef CR_INVALID_CONFLICT_LIST
+#define CR_INVALID_CONFLICT_LIST 0x00000039
+#endif
+#ifndef CR_INVALID_INDEX
+#define CR_INVALID_INDEX 0x0000003A
+#endif
+#ifndef CR_INVALID_STRUCTURE_SIZE
+#define CR_INVALID_STRUCTURE_SIZE 0x0000003B
+#endif
+
+#ifndef fIOD_10_BIT_DECODE
+#define fIOD_10_BIT_DECODE 0x0004
+#endif
+#ifndef fIOD_12_BIT_DECODE
+#define fIOD_12_BIT_DECODE 0x0008
+#endif
+#ifndef fIOD_16_BIT_DECODE
+#define fIOD_16_BIT_DECODE 0x0010
+#endif
+#ifndef fIOD_POSITIVE_DECODE
+#define fIOD_POSITIVE_DECODE 0x0020
+#endif
+#ifndef fIOD_PASSIVE_DECODE
+#define fIOD_PASSIVE_DECODE 0x0040
+#endif
+#ifndef fIOD_WINDOW_DECODE
+#define fIOD_WINDOW_DECODE 0x0080
+#endif
+#ifndef fIOD_PORT_BAR
+#define fIOD_PORT_BAR 0x0100
+#endif
+
+#ifndef fMD_WINDOW_DECODE
+#define fMD_WINDOW_DECODE 0x0040
+#endif
+#ifndef fMD_MEMORY_BAR
+#define fMD_MEMORY_BAR 0x0080
+#endif
+
+#ifndef mMD_Prefetchable
+#define mMD_Prefetchable fMD_Prefetchable
+#endif
+
+/*
+ * Unfortunately MinGW32 toolchain does not provide import library for these
+ * cfgmgr32.dll functions. So resolve pointers to these functions at runtime.
+ * MinGW-w64 toolchain provides them also in 32-bit mode.
+ */
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+
+#ifdef CM_Get_DevNode_Registry_PropertyA
+#undef CM_Get_DevNode_Registry_PropertyA
+#endif
+static CONFIGRET (WINAPI *MyCM_Get_DevNode_Registry_PropertyA)(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
+#define CM_Get_DevNode_Registry_PropertyA MyCM_Get_DevNode_Registry_PropertyA
+
+#ifdef CM_Get_DevNode_Registry_PropertyW
+#undef CM_Get_DevNode_Registry_PropertyW
+#endif
+static CONFIGRET (WINAPI *MyCM_Get_DevNode_Registry_PropertyW)(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
+#define CM_Get_DevNode_Registry_PropertyW MyCM_Get_DevNode_Registry_PropertyW
+
+#ifndef CM_Open_DevNode_Key
+#undef CM_Open_DevNode_Key
+#endif
+static CONFIGRET (WINAPI *MyCM_Open_DevNode_Key)(DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags);
+#define CM_Open_DevNode_Key MyCM_Open_DevNode_Key
+
+static BOOL
+resolve_cfgmgr32_functions(void)
+{
+  HMODULE cfgmgr32;
+
+  if (CM_Get_DevNode_Registry_PropertyA && CM_Get_DevNode_Registry_PropertyW && CM_Open_DevNode_Key)
+    return TRUE;
+
+  cfgmgr32 = GetModuleHandleA("cfgmgr32.dll");
+  if (!cfgmgr32)
+    return FALSE;
+
+  CM_Get_DevNode_Registry_PropertyA = (void *)GetProcAddress(cfgmgr32, "CM_Get_DevNode_Registry_PropertyA");
+  CM_Get_DevNode_Registry_PropertyW = (void *)GetProcAddress(cfgmgr32, "CM_Get_DevNode_Registry_PropertyW");
+  CM_Open_DevNode_Key = (void *)GetProcAddress(cfgmgr32, "CM_Open_DevNode_Key");
+  if (!CM_Get_DevNode_Registry_PropertyA || !CM_Get_DevNode_Registry_PropertyW || !CM_Open_DevNode_Key)
+    return FALSE;
+
+  return TRUE;
+}
+
+#endif
+
+/*
+ * cfgmgr32.dll uses custom non-Win32 error numbers which are unsupported by
+ * Win32 APIs like GetLastError() and FormatMessage() functions.
+ *
+ * Windows 7 introduced new cfgmgr32.dll function CM_MapCrToWin32Err() for
+ * translating mapping CR_* errors to Win32 errors but most error codes are
+ * not mapped. So this function is unusable.
+ *
+ * Error strings for CR_* errors are defined in cmapi.rc file which is
+ * statically linked into some system libraries (e.g. filemgmt.dll,
+ * acledit.dll, netui0.dll or netui2.dll) but due to static linking it is
+ * not possible to access these error strings easily at runtime.
+ *
+ * So define own function for translating CR_* errors directly to strings.
+ */
+static const char *
+cr_strerror(CONFIGRET cr_error_id)
+{
+  static char unknown_error[sizeof("Unknown CR error XXXXXXXXXX")];
+  static const char *cr_errors[] = {
+    "The operation completed successfully",
+    "CR_DEFAULT",
+    "Not enough memory is available to process this command",
+    "A required pointer parameter is invalid",
+    "The ulFlags parameter specified is invalid for this operation",
+    "The device instance handle parameter is not valid",
+    "The supplied resource descriptor parameter is invalid",
+    "The supplied logical configuration parameter is invalid",
+    "CR_INVALID_ARBITRATOR",
+    "CR_INVALID_NODELIST",
+    "CR_DEVNODE_HAS_REQS/CR_DEVINST_HAS_REQS",
+    "The RESOURCEID parameter does not contain a valid RESOURCEID",
+    "CR_DLVXD_NOT_FOUND",
+    "The specified device instance handle does not correspond to a present device",
+    "There are no more logical configurations available",
+    "There are no more resource descriptions available",
+    "This device instance already exists",
+    "The supplied range list parameter is invalid",
+    "CR_INVALID_RANGE",
+    "A general internal error occurred",
+    "CR_NO_SUCH_LOGICAL_DEV",
+    "The device is disabled for this configuration",
+    "CR_NOT_SYSTEM_VM",
+    "A service or application refused to allow removal of this device",
+    "CR_APM_VETOED",
+    "CR_INVALID_LOAD_TYPE",
+    "An output parameter was too small to hold all the data available",
+    "CR_NO_ARBITRATOR",
+    "CR_NO_REGISTRY_HANDLE",
+    "A required entry in the registry is missing or an attempt to write to the registry failed",
+    "The specified Device ID is not a valid Device ID",
+    "One or more parameters were invalid",
+    "CR_INVALID_API",
+    "CR_DEVLOADER_NOT_READY",
+    "CR_NEED_RESTART",
+    "There are no more hardware profiles available",
+    "CR_DEVICE_NOT_THERE",
+    "The specified value does not exist in the registry",
+    "CR_WRONG_TYPE",
+    "The specified priority is invalid for this operation",
+    "This device cannot be disabled",
+    "CR_FREE_RESOURCES",
+    "CR_QUERY_VETOED",
+    "CR_CANT_SHARE_IRQ",
+    "CR_NO_DEPENDENT",
+    "CR_SAME_RESOURCES",
+    "The specified key does not exist in the registry",
+    "The specified machine name does not meet the UNC naming conventions",
+    "A general remote communication error occurred",
+    "The machine selected for remote communication is not available at this time",
+    "The Plug and Play service or another required service is not available",
+    "Access denied",
+    "This routine is not implemented in this version of the operating system",
+    "The specified property type is invalid for this operation",
+    "Device interface is active",
+    "No such device interface",
+    "Invalid reference string",
+    "Invalid conflict list",
+    "Invalid index",
+    "Invalid structure size"
+  };
+  if (cr_error_id <= 0 || cr_error_id >= sizeof(cr_errors)/sizeof(*cr_errors))
+    {
+      sprintf(unknown_error, "Unknown CR error %lu", cr_error_id);
+      return unknown_error;
+    }
+  return cr_errors[cr_error_id];
+}
+
+static int
+fmt_validate(const char *s, int len, const char *fmt)
+{
+  int i;
+
+  for (i = 0; i < len; i++)
+    if (!fmt[i] || (fmt[i] == '#' ? !isxdigit(s[i]) : fmt[i] != s[i]))
+      return 0;
+
+  return 1;
+}
+
+static int
+seq_xdigit_validate(const char *s, int mult, int min)
+{
+  int i, len;
+
+  len = strlen(s);
+  if (len < min*mult || len % mult)
+    return 0;
+
+  for (i = 0; i < len; i++)
+    if (!isxdigit(s[i]))
+      return 0;
+
+  return 1;
+}
+
+static LPWSTR
+get_device_service_name(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id, BOOL *supported)
+{
+  ULONG reg_type, reg_size, reg_len;
+  LPWSTR service_name;
+  CONFIGRET cr;
+
+  /*
+   * All data are stored as 7-bit ASCII strings in system but service name is
+   * exception. It can contain UNICODE. Moreover it is passed to other Win32 API
+   * functions and therefore it cannot be converted to 8-bit ANSI string without
+   * data loss. So use wide function CM_Get_DevNode_Registry_PropertyW() in this
+   * case and deal with all wchar_t problems...
+   */
+
+  reg_size = 0;
+  cr = CM_Get_DevNode_Registry_PropertyW(devinst, CM_DRP_SERVICE, &reg_type, NULL, &reg_size, 0);
+  if (cr == CR_CALL_NOT_IMPLEMENTED)
+    {
+      *supported = FALSE;
+      return NULL;
+    }
+  else if (cr == CR_NO_SUCH_VALUE)
+    {
+      *supported = TRUE;
+      return NULL;
+    }
+  else if (cr != CR_SUCCESS &&
+           cr != CR_BUFFER_SMALL)
+    {
+      a->warning("Cannot retrieve service name for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      *supported = TRUE;
+      return NULL;
+    }
+  else if (reg_type != REG_SZ)
+    {
+      a->warning("Cannot retrieve service name for PCI device %s: Service name is stored as unknown type 0x%lx.", devinst_id, reg_type);
+      *supported = TRUE;
+      return NULL;
+    }
+
+retry:
+  /*
+   * Returned size is on older Windows versions without nul-term char.
+   * So explicitly increase size and fill nul-term byte.
+   */
+  reg_size += sizeof(service_name[0]);
+  service_name = pci_malloc(a, reg_size);
+  reg_len = reg_size;
+  cr = CM_Get_DevNode_Registry_PropertyW(devinst, CM_DRP_SERVICE, &reg_type, service_name, &reg_len, 0);
+  service_name[reg_size/sizeof(service_name[0]) - 1] = 0;
+  if (reg_len > reg_size)
+    {
+      pci_mfree(service_name);
+      reg_size = reg_len;
+      goto retry;
+    }
+  else if (cr != CR_SUCCESS)
+    {
+      a->warning("Cannot retrieve service name for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      pci_mfree(service_name);
+      *supported = TRUE;
+      return NULL;
+    }
+  else if (reg_type != REG_SZ)
+    {
+      a->warning("Cannot retrieve service name for PCI device %s: Service name is stored as unknown type 0x%lx.", devinst_id, reg_type);
+      pci_mfree(service_name);
+      *supported = TRUE;
+      return NULL;
+    }
+
+
+  return service_name;
+}
+
+static char*
+get_driver_path_for_service(struct pci_access *a, LPCWSTR service_name, SC_HANDLE manager)
+{
+  UINT (WINAPI *get_system_root_path)(LPWSTR buffer, UINT size) = NULL;
+  DWORD service_config_size, service_config_len;
+  LPQUERY_SERVICE_CONFIGW service_config = NULL;
+  LPWSTR service_image_path = NULL;
+  SERVICE_STATUS service_status;
+  SC_HANDLE service = NULL;
+  char *driver_path = NULL;
+  int trim_system32 = 0;
+  UINT systemroot_len;
+  int driver_path_len;
+  UINT system32_len;
+  HMODULE kernel32;
+  WCHAR *trim_ptr;
+  DWORD error;
+
+  service = OpenServiceW(manager, service_name, SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS);
+  if (!service)
+    {
+      error = GetLastError();
+      if (error != ERROR_SERVICE_DOES_NOT_EXIST)
+        a->warning("Cannot open service %ls with query rights: %s.", service_name, win32_strerror(error));
+      goto out;
+    }
+
+  if (!QueryServiceStatus(service, &service_status))
+    {
+      error = GetLastError();
+      a->warning("Cannot query status of service %ls: %s.", service_name, win32_strerror(error));
+      goto out;
+    }
+
+  if (service_status.dwCurrentState == SERVICE_STOPPED)
+    goto out;
+
+  if (service_status.dwServiceType != SERVICE_KERNEL_DRIVER)
+    goto out;
+
+  if (!QueryServiceConfigW(service, NULL, 0, &service_config_size))
+    {
+      error = GetLastError();
+      if (error != ERROR_INSUFFICIENT_BUFFER)
+      {
+        a->warning("Cannot query config of service %ls: %s.", service_name, win32_strerror(error));
+        goto out;
+      }
+    }
+
+retry_service_config:
+  service_config = pci_malloc(a, service_config_size);
+  if (!QueryServiceConfigW(service, service_config, service_config_size, &service_config_len))
+    {
+      error = GetLastError();
+      if (error == ERROR_INSUFFICIENT_BUFFER)
+        {
+          pci_mfree(service_config);
+          service_config_size = service_config_len;
+          goto retry_service_config;
+        }
+      a->warning("Cannot query config of service %ls: %s.", service_name, win32_strerror(error));
+      goto out;
+    }
+
+  if (service_config->dwServiceType != SERVICE_KERNEL_DRIVER)
+    goto out;
+
+  /*
+   * Despite QueryServiceConfig() is Win32 API, it returns lpBinaryPathName
+   * (ImagePath registry) in NT format. Unfortunately there is no Win32
+   * function for converting NT paths to Win32 paths. So do it manually and
+   * convert this NT format to human-readable Win32 path format.
+   */
+
+  /*
+   * GetSystemWindowsDirectoryW() returns path to NT SystemRoot namespace.
+   * Alternativelly path to NT SystemRoot namespace can be constructed by
+   * GetSystemDirectoryW() by trimming "\\system32" from the end of path.
+   * GetSystemWindowsDirectoryW() is not provided in old Windows versions,
+   * so use GetProcAddress() for compatibility with all Windows versions.
+   */
+  kernel32 = GetModuleHandleW(L"kernel32.dll");
+  if (kernel32)
+    get_system_root_path = (void *)GetProcAddress(kernel32, "GetSystemWindowsDirectoryW");
+  else
+    {
+      get_system_root_path = &GetSystemDirectoryW;
+      trim_system32 = 1;
+    }
+
+  if (!service_config->lpBinaryPathName || !service_config->lpBinaryPathName[0])
+    {
+      /* No ImagePath is specified, NT kernel assumes implicit kernel driver path by service name, which is relative to "\\system32\\drivers". */
+      /* GetSystemDirectoryW() returns path to "\\system32" directory on all Windows versions. */
+      system32_len = GetSystemDirectoryW(NULL, 0); /* Returns number of WCHARs plus 1 for nul-term. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * (system32_len + sizeof("\\drivers\\")-1 + wcslen(service_name) + sizeof(".sys")-1));
+      system32_len = GetSystemDirectoryW(service_image_path, system32_len); /* Now it returns number of WCHARs without nul-term. */
+      if (system32_len && service_image_path[system32_len-1] != L'\\')
+        service_image_path[system32_len++] = L'\\';
+      wcscpy(service_image_path + system32_len, L"drivers\\");
+      wcscpy(service_image_path + system32_len + sizeof("drivers\\")-1, service_name);
+      wcscpy(service_image_path + system32_len + sizeof("drivers\\")-1 + wcslen(service_name), L".sys");
+    }
+  else if (wcsncmp(service_config->lpBinaryPathName, L"\\SystemRoot\\", sizeof("\\SystemRoot\\")-1) == 0)
+    {
+      /* ImagePath is in NT SystemRoot namespace, convert to Win32 path via GetSystemWindowsDirectoryW()/GetSystemDirectoryW(). */
+      systemroot_len = get_system_root_path(NULL, 0); /* Returns number of WCHARs plus 1 for nul-term. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * (systemroot_len + wcslen(service_config->lpBinaryPathName) - (sizeof("\\SystemRoot")-1)));
+      systemroot_len = get_system_root_path(service_image_path, systemroot_len); /* Now it returns number of WCHARs without nul-term. */
+      if (trim_system32 && systemroot_len && (trim_ptr = wcsrchr(service_image_path, L'\\')) != NULL)
+        systemroot_len = trim_ptr - service_image_path;
+      if (systemroot_len && service_image_path[systemroot_len-1] != L'\\')
+        service_image_path[systemroot_len++] = L'\\';
+      wcscpy(service_image_path + systemroot_len, service_config->lpBinaryPathName + sizeof("\\SystemRoot\\")-1);
+    }
+  else if (wcsncmp(service_config->lpBinaryPathName, L"\\??\\UNC\\", sizeof("\\??\\UNC\\")-1) == 0 ||
+           wcsncmp(service_config->lpBinaryPathName, L"\\??\\\\UNC\\", sizeof("\\??\\\\UNC\\")-1) == 0)
+    {
+      /* ImagePath is in NT UNC namespace, convert to Win32 UNC path via "\\\\" prefix. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * (sizeof("\\\\") + wcslen(service_config->lpBinaryPathName) - (sizeof("\\??\\UNC\\")-1)));
+      /* Namespace separator may be single or double backslash. */
+      driver_path_len = sizeof("\\??\\")-1;
+      if (service_config->lpBinaryPathName[driver_path_len] == L'\\')
+        driver_path_len++;
+      driver_path_len += sizeof("UNC\\")-1;
+      wcscpy(service_image_path, L"\\\\");
+      wcscpy(service_image_path + sizeof("\\\\")-1, service_config->lpBinaryPathName + driver_path_len);
+    }
+  else if (wcsncmp(service_config->lpBinaryPathName, L"\\??\\", sizeof("\\??\\")-1) == 0)
+    {
+      /* ImagePath is in NT Global?? namespace, root of the Win32 file namespace, so just remove "\\??\\" prefix to get Win32 path. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * (wcslen(service_config->lpBinaryPathName) - (sizeof("\\??\\")-1)));
+      /* Namespace separator may be single or double backslash. */
+      driver_path_len = sizeof("\\??\\")-1;
+      if (service_config->lpBinaryPathName[driver_path_len] == L'\\')
+        driver_path_len++;
+      wcscpy(service_image_path, service_config->lpBinaryPathName + driver_path_len);
+    }
+  else if (service_config->lpBinaryPathName[0] != L'\\')
+    {
+      /* ImagePath is relative to the NT SystemRoot namespace, convert to Win32 path via GetSystemWindowsDirectoryW()/GetSystemDirectoryW(). */
+      systemroot_len = get_system_root_path(NULL, 0); /* Returns number of WCHARs plus 1 for nul-term. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * (systemroot_len + sizeof("\\")-1 + wcslen(service_config->lpBinaryPathName)));
+      systemroot_len = get_system_root_path(service_image_path, systemroot_len); /* Now it returns number of WCHARs without nul-term. */
+      if (trim_system32 && systemroot_len && (trim_ptr = wcsrchr(service_image_path, L'\\')) != NULL)
+        systemroot_len = trim_ptr - service_image_path;
+      if (systemroot_len && service_image_path[systemroot_len-1] != L'\\')
+        service_image_path[systemroot_len++] = L'\\';
+      wcscpy(service_image_path + systemroot_len, service_config->lpBinaryPathName);
+    }
+  else
+    {
+      /* ImagePath is in some unhandled NT namespace, copy it as is. It cannot be used in Win32 API but libpci user can be still interested in it. */
+      service_image_path = pci_malloc(a, sizeof(WCHAR) * wcslen(service_config->lpBinaryPathName));
+      wcscpy(service_image_path, service_config->lpBinaryPathName);
+    }
+
+  /* Calculate len of buffer needed for conversion from LPWSTR to char*. */
+  driver_path_len = WideCharToMultiByte(CP_ACP, 0, service_image_path, -1, NULL, 0, NULL, NULL);
+  if (driver_path_len <= 0)
+    {
+      error = GetLastError();
+      a->warning("Cannot convert kernel driver path from wide string to 8-bit string: %s.", win32_strerror(error));
+      goto out;
+    }
+
+  driver_path = pci_malloc(a, driver_path_len);
+  driver_path_len = WideCharToMultiByte(CP_ACP, 0, service_image_path, -1, driver_path, driver_path_len, NULL, NULL);
+  if (driver_path_len <= 0)
+    {
+      error = GetLastError();
+      a->warning("Cannot convert kernel driver path from wide string to 8-bit string: %s.", win32_strerror(error));
+      pci_mfree(driver_path);
+      driver_path = NULL;
+      goto out;
+    }
+
+out:
+  if (service_image_path)
+    pci_mfree(service_image_path);
+  if (service_config)
+    pci_mfree(service_config);
+  if (service)
+    CloseServiceHandle(service);
+  return driver_path;
+}
+
+static HKEY
+get_device_driver_devreg(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id)
+{
+  CONFIGRET cr;
+  HKEY key;
+
+  cr = CM_Open_DevNode_Key(devinst, KEY_READ, 0, RegDisposition_OpenExisting, &key, CM_REGISTRY_SOFTWARE);
+  if (cr != CR_SUCCESS)
+    {
+      if (cr != CR_NO_SUCH_VALUE)
+        a->warning("Cannot retrieve driver key for device %s: %s.", devinst_id, cr_strerror(cr));
+      return NULL;
+    }
+
+  return key;
+}
+
+static char*
+read_reg_key_string_value(struct pci_access *a, HKEY key, const char *name, DWORD *unkn_reg_type)
+{
+  DWORD reg_type, reg_size, reg_len;
+  char *value;
+  LONG error;
+
+  reg_size = 0;
+  error = RegQueryValueExA(key, name, NULL, &reg_type, NULL, &reg_size);
+  if (error != ERROR_SUCCESS &&
+      error != ERROR_MORE_DATA)
+    {
+      SetLastError(error);
+      return NULL;
+    }
+  else if (reg_type != REG_SZ)
+    {
+      SetLastError(0);
+      *unkn_reg_type = reg_type;
+      return NULL;
+    }
+
+retry:
+  value = pci_malloc(a, reg_size + 1);
+  reg_len = reg_size;
+  error = RegQueryValueExA(key, name, NULL, &reg_type, (PBYTE)value, &reg_len);
+  if (error != ERROR_SUCCESS)
+    {
+      pci_mfree(value);
+      if (error == ERROR_MORE_DATA)
+        {
+          reg_size = reg_len;
+          goto retry;
+        }
+      SetLastError(error);
+      return NULL;
+    }
+  else if (reg_type != REG_SZ)
+    {
+      pci_mfree(value);
+      SetLastError(0);
+      *unkn_reg_type = reg_type;
+      return NULL;
+    }
+  value[reg_len] = '\0';
+
+  return value;
+}
+
+static int
+driver_cmp(const char *driver, const char *match)
+{
+  int len = strlen(driver);
+  if (driver[0] == '*')
+    driver++;
+  if (len >= 4 && strcasecmp(driver + len - 4, ".vxd") == 0)
+    len -= 4;
+  return strncasecmp(driver, match, len);
+}
+
+static char*
+get_driver_path_for_regkey(struct pci_access *a, DEVINSTID_A devinst_id, HKEY key)
+{
+  char *driver_list, *driver, *driver_next;
+  char *subdriver, *subname;
+  char *driver_ptr;
+  char *driver_path;
+  DWORD unkn_reg_type;
+  UINT systemdir_len;
+  HKEY subkey;
+  LONG error;
+  BOOL vmm32;
+  BOOL noext;
+  int len;
+
+  driver_list = read_reg_key_string_value(a, key, "DevLoader", &unkn_reg_type);
+  if (!driver_list)
+    {
+      error = GetLastError();
+      if (error == 0)
+        a->warning("Cannot read driver DevLoader key for PCI device %s: DevLoader key is stored as unknown type 0x%lx.", devinst_id, unkn_reg_type);
+      else if (error != ERROR_FILE_NOT_FOUND)
+        a->warning("Cannot read driver DevLoader key for PCI device %s: %s.", devinst_id, win32_strerror(error));
+      return NULL;
+    }
+
+  subdriver = NULL;
+  driver = driver_list;
+  while (*driver)
+    {
+      driver_next = strchr(driver, ',');
+      if (driver_next)
+          *(driver_next++) = '\0';
+
+      if (driver_cmp(driver, "ios") == 0 ||
+          driver_cmp(driver, "vcomm") == 0)
+        subname = "PortDriver";
+      else if (driver_cmp(driver, "ntkern") == 0)
+        subname = "NTMPDriver";
+      else if (driver_cmp(driver, "ndis") == 0)
+        subname = "DeviceVxDs";
+      else if (driver_cmp(driver, "vdd") == 0)
+        subname = "minivdd";
+      else
+        subname = NULL;
+
+      subkey = key;
+      if (subname && strcmp(subname, "minivdd") == 0)
+        {
+          error = RegOpenKeyA(key, "Default", &subkey);
+          if (error != ERROR_SUCCESS)
+            {
+              a->warning("Cannot open driver subkey Default for PCI device %s: %s.", devinst_id, win32_strerror(error));
+              subkey = NULL;
+            }
+        }
+
+      if (!subname)
+        break;
+
+      if (subkey)
+        {
+retry_subname:
+          subdriver = read_reg_key_string_value(a, subkey, subname, &unkn_reg_type);
+          if (!subdriver)
+            {
+              error = GetLastError();
+              if (error == 0)
+                a->warning("Cannot read driver %s key for PCI device %s: %s key is stored as unknown type 0x%lx.", subname, devinst_id, subname, unkn_reg_type);
+              else if (error != ERROR_FILE_NOT_FOUND)
+                a->warning("Cannot read driver %s key for PCI device %s: %s.", subname, devinst_id, win32_strerror(error));
+              else if (strcmp(subname, "minivdd") == 0)
+                {
+                  subname = "drv";
+                  goto retry_subname;
+                }
+              else if (strcmp(subname, "drv") == 0)
+                {
+                  subname = "vdd";
+                  goto retry_subname;
+                }
+            }
+
+          if (subkey != key)
+            RegCloseKey(subkey);
+
+          if (subdriver)
+            {
+              char *endptr = strchr(subdriver, ',');
+              if (endptr)
+                *endptr = '\0';
+              break;
+            }
+        }
+
+      driver = driver_next;
+    }
+
+  if (subdriver && subdriver[0])
+    driver_ptr = subdriver;
+  else if (driver[0])
+    driver_ptr = driver;
+  else
+    driver_ptr = NULL;
+
+  if (driver_ptr && driver_ptr[0] == '*')
+    {
+      vmm32 = TRUE;
+      driver_ptr++;
+    }
+  else
+    vmm32 = FALSE;
+
+  if (!driver_ptr[0])
+    driver_ptr = NULL;
+
+  len = driver_ptr ? strlen(driver_ptr) : 0;
+  noext = driver_ptr && (len < 4 || driver_ptr[len-4] != '.');
+
+  if (!driver_ptr)
+    driver_path = NULL;
+  else
+    {
+      if (tolower(driver_ptr[0]) >= 'a' && tolower(driver_ptr[0]) <= 'z' && driver_ptr[1] == ':')
+        {
+          /* Driver is already with absolute path. */
+          driver_path = pci_strdup(a, driver_ptr);
+        }
+      else if (driver_cmp(driver, "ntkern") == 0 && subdriver)
+        {
+          /* Driver is relative to system32\drivers\ directory which is relative to windows directory. */
+          systemdir_len = GetWindowsDirectoryA(NULL, 0);
+          driver_path = pci_malloc(a, systemdir_len + 1 + sizeof("system32\\drivers\\")-1 + strlen(driver_ptr) + 4 + 1);
+          systemdir_len = GetWindowsDirectoryA(driver_path, systemdir_len + 1);
+          if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
+            driver_path[systemdir_len++] = '\\';
+          sprintf(driver_path + systemdir_len, "system32\\drivers\\%s%s", driver_ptr, noext ? ".sys" : "");
+        }
+      else if (vmm32)
+        {
+          /* Driver is packed in vmm32.vxd which is stored in system directory. */
+          systemdir_len = GetSystemDirectoryA(NULL, 0);
+          driver_path = pci_malloc(a, systemdir_len + 1 + sizeof("vmm32.vxd ()")-1 + strlen(driver_ptr) + 4 + 1);
+          systemdir_len = GetSystemDirectoryA(driver_path, systemdir_len + 1);
+          if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
+            driver_path[systemdir_len++] = '\\';
+          sprintf(driver_path + systemdir_len, "vmm32.vxd (%s%s)", driver_ptr, noext ? ".vxd" : "");
+        }
+      else
+        {
+          /* Otherwise driver is relative to system directory. */
+          systemdir_len = GetSystemDirectoryA(NULL, 0);
+          driver_path = pci_malloc(a, systemdir_len + 1 + strlen(driver_ptr) + 4 + 1);
+          systemdir_len = GetSystemDirectoryA(driver_path, systemdir_len + 1);
+          if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
+            driver_path[systemdir_len++] = '\\';
+          sprintf(driver_path + systemdir_len, "%s%s", driver_ptr, noext ? ".vxd" : "");
+        }
+    }
+
+  if (subdriver)
+    pci_mfree(subdriver);
+  pci_mfree(driver_list);
+  return driver_path;
+}
+
+static char *
+get_device_driver_path(struct pci_dev *d, SC_HANDLE manager, BOOL manager_supported)
+{
+  struct pci_access *a = d->access;
+  BOOL service_supported = TRUE;
+  DEVINSTID_A devinst_id = NULL;
+  LPWSTR service_name = NULL;
+  ULONG devinst_id_len = 0;
+  char *driver_path = NULL;
+  DEVINST devinst = (DEVINST)d->backend_data;
+  ULONG problem = 0;
+  ULONG status = 0;
+  HKEY key = NULL;
+
+  if (CM_Get_DevNode_Status(&status, &problem, devinst, 0) != CR_SUCCESS || !(status & DN_DRIVER_LOADED))
+    return NULL;
+
+  if (CM_Get_Device_ID_Size(&devinst_id_len, devinst, 0) == CR_SUCCESS)
+    {
+      devinst_id = pci_malloc(a, devinst_id_len + 1);
+      if (CM_Get_Device_IDA(devinst, devinst_id, devinst_id_len + 1, 0) != CR_SUCCESS)
+        {
+          pci_mfree(devinst_id);
+          devinst_id = pci_strdup(a, "UNKNOWN");
+        }
+    }
+  else
+    devinst_id = pci_strdup(a, "UNKNOWN");
+
+  service_name = get_device_service_name(d->access, devinst, devinst_id, &service_supported);
+  if ((!service_name || !manager) && service_supported && manager_supported)
+    goto out;
+  else if (service_name && manager)
+    {
+      driver_path = get_driver_path_for_service(d->access, service_name, manager);
+      goto out;
+    }
+
+  key = get_device_driver_devreg(d->access, devinst, devinst_id);
+  if (key)
+    {
+      driver_path = get_driver_path_for_regkey(d->access, devinst_id, key);
+      goto out;
+    }
+
+out:
+  if (key)
+    RegCloseKey(key);
+  if (service_name)
+    pci_mfree(service_name);
+  pci_mfree(devinst_id);
+  return driver_path;
+}
+
+static void
+fill_drivers(struct pci_access *a)
+{
+  BOOL manager_supported;
+  SC_HANDLE manager;
+  struct pci_dev *d;
+  char *driver;
+  DWORD error;
+
+  /* ERROR_CALL_NOT_IMPLEMENTED is returned on systems without Service Manager support. */
+  manager_supported = TRUE;
+  manager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
+  if (!manager)
+    {
+      error = GetLastError();
+      if (error != ERROR_CALL_NOT_IMPLEMENTED)
+        a->warning("Cannot open Service Manager with connect right: %s.", win32_strerror(error));
+      else
+        manager_supported = FALSE;
+    }
+
+  for (d = a->devices; d; d = d->next)
+    {
+      driver = get_device_driver_path(d, manager, manager_supported);
+      if (driver)
+        {
+          pci_set_property(d, PCI_FILL_DRIVER, driver);
+          pci_mfree(driver);
+        }
+      d->known_fields |= PCI_FILL_DRIVER;
+    }
+
+  if (manager)
+    CloseServiceHandle(manager);
+}
+
+static const char *
+res_id_to_str(RESOURCEID res_id)
+{
+  static char hex_res_id[sizeof("0xffffffff")];
+
+  if (res_id == ResType_IO)
+    return "IO";
+  else if (res_id == ResType_Mem)
+    return "MEM";
+  else if (res_id == ResType_IRQ)
+    return "IRQ";
+
+  sprintf(hex_res_id, "0x%lx", res_id);
+  return hex_res_id;
+}
+
+static void
+fill_resources(struct pci_dev *d, DEVINST devinst, DEVINSTID_A devinst_id)
+{
+  struct pci_access *a = d->access;
+
+  CONFIGRET cr;
+
+  LOG_CONF config;
+  ULONG problem;
+  ULONG status;
+
+  RES_DES prev_res_des;
+  RES_DES res_des;
+  RESOURCEID res_id;
+  DWORD bar_res_count;
+
+  BOOL is_bar_res;
+  BOOL non_nt_system;
+
+  int last_irq = -1;
+  int last_shared_irq = -1;
+
+  cr = CM_Get_DevNode_Status(&status, &problem, devinst, 0);
+  if (cr != CR_SUCCESS)
+    {
+      a->warning("Cannot retrieve status of PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      return;
+    }
+
+  cr = CR_NO_MORE_LOG_CONF;
+
+  /*
+   * If the device is running then retrieve allocated configuration by PnP
+   * manager which is currently in use by a device.
+   */
+  if (!(status & DN_HAS_PROBLEM))
+    cr = CM_Get_First_Log_Conf(&config, devinst, ALLOC_LOG_CONF);
+
+  /*
+   * If the device is not running or it does not have allocated configuration by
+   * PnP manager then retrieve forced configuration which prevents PnP manager
+   * from assigning resources.
+   */
+  if (cr == CR_NO_MORE_LOG_CONF)
+    cr = CM_Get_First_Log_Conf(&config, devinst, FORCED_LOG_CONF);
+
+  /*
+   * If the device does not have neither allocated configuration by PnP manager
+   * nor forced configuration and it is not disabled in the BIOS then retrieve
+   * boot configuration supplied by the BIOS.
+   */
+  if (cr == CR_NO_MORE_LOG_CONF &&
+      (!(status & DN_HAS_PROBLEM) || problem != CM_PROB_HARDWARE_DISABLED))
+    cr = CM_Get_First_Log_Conf(&config, devinst, BOOT_LOG_CONF);
+
+  if (cr != CR_SUCCESS)
+    {
+      /*
+       * Note: Starting with Windows 8, CM_Get_First_Log_Conf returns
+       * CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario.
+       * To request information about the hardware resources on a local machine
+       * it is necessary implement an architecture-native version of the
+       * application using the hardware resource APIs. For example: An AMD64
+       * application for AMD64 systems.
+       */
+      if (cr == CR_CALL_NOT_IMPLEMENTED && win32_is_32bit_on_win8_64bit_system())
+        {
+          static BOOL warn_once = FALSE;
+          if (!warn_once)
+            {
+              warn_once = TRUE;
+              a->warning("Cannot retrieve resources of PCI devices from 32-bit application on 64-bit system.");
+            }
+        }
+      else if (cr != CR_NO_MORE_LOG_CONF)
+        a->warning("Cannot retrieve resources of PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      return;
+    }
+
+  bar_res_count = 0;
+  non_nt_system = win32_is_non_nt_system();
+
+  is_bar_res = TRUE;
+  if (non_nt_system)
+    {
+      BOOL has_child;
+      DEVINST child;
+      ULONG child_name_len;
+      PSTR child_name;
+      BOOL is_bridge;
+
+      if (CM_Get_Child(&child, devinst, 0) != CR_SUCCESS)
+        has_child = FALSE;
+      else if (CM_Get_Device_ID_Size(&child_name_len, child, 0) != CR_SUCCESS)
+        has_child = FALSE;
+      else
+        {
+          child_name_len++;
+          child_name = pci_malloc(a, child_name_len);
+          if (CM_Get_Device_IDA(child, child_name, child_name_len, 0) != CR_SUCCESS)
+            has_child = FALSE;
+          else if (strncmp(child_name, "PCI\\", 4) != 0)
+            has_child = FALSE;
+          else
+            has_child = TRUE;
+          pci_mfree(child_name);
+        }
+
+      if (has_child || d->device_class == PCI_CLASS_BRIDGE_PCI || d->device_class == PCI_CLASS_BRIDGE_CARDBUS)
+        is_bridge = TRUE;
+      else
+        is_bridge = FALSE;
+
+      if (is_bridge)
+        is_bar_res = FALSE;
+    }
+
+  prev_res_des = (RES_DES)config;
+  while ((cr = CM_Get_Next_Res_Des(&res_des, prev_res_des, ResType_All, &res_id, 0)) == CR_SUCCESS)
+    {
+      pciaddr_t start, end, size, flags;
+      ULONG res_des_data_size;
+      PBYTE res_des_data;
+
+      if (prev_res_des != config)
+        CM_Free_Res_Des_Handle(prev_res_des);
+
+      prev_res_des = res_des;
+
+      /* Skip other resources early */
+      if (res_id != ResType_IO && res_id != ResType_Mem && res_id != ResType_IRQ)
+        continue;
+
+      cr = CM_Get_Res_Des_Data_Size(&res_des_data_size, res_des, 0);
+      if (cr != CR_SUCCESS)
+        {
+          a->warning("Cannot retrieve %s resource data of PCI device %s: %s.", res_id_to_str(res_id), devinst_id, cr_strerror(cr));
+          continue;
+        }
+
+      if (!res_des_data_size)
+        {
+          a->warning("Cannot retrieve %s resource data of PCI device %s: %s.", res_id_to_str(res_id), devinst_id, "Empty data");
+          continue;
+        }
+
+      res_des_data = pci_malloc(a, res_des_data_size);
+      cr = CM_Get_Res_Des_Data(res_des, res_des_data, res_des_data_size, 0);
+      if (cr != CR_SUCCESS)
+        {
+          a->warning("Cannot retrieve %s resource data of PCI device %s: %s.", res_id_to_str(res_id), devinst_id, cr_strerror(cr));
+          pci_mfree(res_des_data);
+          continue;
+        }
+
+      /*
+       * There can be more resources with the same id. In this case we are
+       * interested in the last one in the list as at the beginning of the list
+       * can be some virtual resources (which are not set in PCI config space).
+       */
+
+      if (res_id == ResType_IO)
+        {
+          PIO_RESOURCE io_data = (PIO_RESOURCE)res_des_data;
+
+          start = io_data->IO_Header.IOD_Alloc_Base;
+          end = io_data->IO_Header.IOD_Alloc_End;
+          size = (end > start) ? (end - start + 1) : 0;
+          flags = PCI_IORESOURCE_IO;
+
+          /*
+           * If neither 10-bit, 12-bit, nor 16-bit support is presented then
+           * expects that this is 32-bit I/O resource. If resource does not fit
+           * into 16-bit space then it must be 32-bit. If PCI I/O resource is
+           * not 32-bit then it is 16-bit.
+           */
+          if (end <= 0xffff && (io_data->IO_Header.IOD_DesFlags & (fIOD_10_BIT_DECODE|fIOD_12_BIT_DECODE|fIOD_16_BIT_DECODE)))
+            flags |= PCI_IORESOURCE_IO_16BIT_ADDR;
+
+          /*
+           * 16/32-bit non-NT systems do not support these two flags.
+           * Most NT-based Windows versions support only the fIOD_WINDOW_DECODE
+           * flag and put all BAR resources before window resources in this
+           * resource list. So use this fIOD_WINDOW_DECODE flag as separator
+           * between IO/MEM windows and IO/MEM BARs of PCI Bridges.
+           */
+          if (io_data->IO_Header.IOD_DesFlags & fIOD_WINDOW_DECODE)
+            is_bar_res = FALSE;
+          else if (io_data->IO_Header.IOD_DesFlags & fIOD_PORT_BAR)
+            is_bar_res = TRUE;
+
+          if (is_bar_res && bar_res_count < 6)
+            {
+              d->flags[bar_res_count] = flags;
+              d->base_addr[bar_res_count] = start;
+              d->size[bar_res_count] = size;
+              bar_res_count++;
+            }
+          else if (!is_bar_res)
+            {
+              d->bridge_flags[0] = flags;
+              d->bridge_base_addr[0] = start;
+              d->bridge_size[0] = size;
+              d->known_fields |= PCI_FILL_BRIDGE_BASES;
+            }
+        }
+      else if (res_id == ResType_Mem)
+        {
+          PMEM_RESOURCE mem_data = (PMEM_RESOURCE)res_des_data;
+
+          start = mem_data->MEM_Header.MD_Alloc_Base;
+          end = mem_data->MEM_Header.MD_Alloc_End;
+          size = (end > start) ? (end - start + 1) : 0;
+          flags = PCI_IORESOURCE_MEM;
+
+          /*
+           * If fMD_PrefetchAllowed flag is set then this is
+           * PCI Prefetchable Memory resource.
+           */
+          if ((mem_data->MEM_Header.MD_Flags & mMD_Prefetchable) == fMD_PrefetchAllowed)
+            flags |= PCI_IORESOURCE_PREFETCH;
+
+          /* If resource does not fit into 32-bit space then it must be 64-bit. */
+          if (is_bar_res && end > 0xffffffff)
+            flags |= PCI_IORESOURCE_MEM_64;
+
+          /*
+           * These two flags (fMD_WINDOW_DECODE and fMD_MEMORY_BAR) are
+           * unsupported on most Windows versions, so distinguish between
+           * window and BAR based on previous resource type.
+           */
+          if (mem_data->MEM_Header.MD_Flags & fMD_WINDOW_DECODE)
+            is_bar_res = FALSE;
+          else if (mem_data->MEM_Header.MD_Flags & fMD_MEMORY_BAR)
+            is_bar_res = TRUE;
+
+          /* 64-bit BAR resource must be at even position. */
+          if (is_bar_res && (flags & PCI_IORESOURCE_MEM_64) && bar_res_count % 2)
+            bar_res_count++;
+
+          if (is_bar_res && bar_res_count < 6)
+            {
+              d->flags[bar_res_count] = flags;
+              d->base_addr[bar_res_count] = start;
+              d->size[bar_res_count] = size;
+              bar_res_count++;
+              /* 64-bit BAR resource occupies two slots. */
+              if (flags & PCI_IORESOURCE_MEM_64)
+                bar_res_count++;
+            }
+          else if (!is_bar_res && !(flags & PCI_IORESOURCE_PREFETCH))
+            {
+              d->bridge_flags[1] = flags;
+              d->bridge_base_addr[1] = start;
+              d->bridge_size[1] = size;
+              d->known_fields |= PCI_FILL_BRIDGE_BASES;
+            }
+          else if (!is_bar_res && (flags & PCI_IORESOURCE_PREFETCH))
+            {
+              d->bridge_flags[2] = flags;
+              d->bridge_base_addr[2] = start;
+              d->bridge_size[2] = size;
+              d->known_fields |= PCI_FILL_BRIDGE_BASES;
+            }
+        }
+      else if (res_id == ResType_IRQ)
+        {
+          PIRQ_RESOURCE irq_data = (PIRQ_RESOURCE)res_des_data;
+
+          /*
+           * libpci's d->irq should be set to the non-MSI PCI IRQ and therefore
+           * it should be level IRQ which may be shared with other PCI devices
+           * and drivers in the system. As always we want to retrieve the last
+           * IRQ number from the resource list.
+           *
+           * On 16/32-bit non-NT systems is fIRQD_Level set to 2 but on NT
+           * systems to 0. Moreover it looks like that different PCI drivers
+           * on both NT and non-NT systems set bits 0 and 1 to wrong values
+           * and so reported value in this list may be incorrect.
+           *
+           * Therefore take the last level-shared IRQ number from the resource
+           * list and if there is none of this type then take the last IRQ
+           * number from the list.
+           */
+          last_irq = irq_data->IRQ_Header.IRQD_Alloc_Num;
+          if ((irq_data->IRQ_Header.IRQD_Flags & (mIRQD_Share|mIRQD_Edge_Level)) == (fIRQD_Share|fIRQD_Level))
+            last_shared_irq = irq_data->IRQ_Header.IRQD_Alloc_Num;
+
+          /*
+           * IRQ resource on 16/32-bit non-NT systems is separator between
+           * IO/MEM windows and IO/MEM BARs of PCI Bridges. After the IRQ
+           * resource are IO/MEM BAR resources.
+           */
+          if (!is_bar_res && non_nt_system)
+            is_bar_res = TRUE;
+        }
+
+      pci_mfree(res_des_data);
+    }
+  if (cr != CR_NO_MORE_RES_DES)
+    a->warning("Cannot retrieve resources of PCI device %s: %s.", devinst_id, cr_strerror(cr));
+
+  if (prev_res_des != config)
+    CM_Free_Res_Des_Handle(prev_res_des);
+
+  CM_Free_Log_Conf_Handle(config);
+
+  /* Set the last IRQ from the resource list to pci_dev. */
+  if (last_shared_irq >= 0)
+    d->irq = last_shared_irq;
+  else if (last_irq >= 0)
+    d->irq = last_irq;
+  if (last_shared_irq >= 0 || last_irq >= 0)
+    d->known_fields |= PCI_FILL_IRQ;
+
+  if (bar_res_count > 0)
+    d->known_fields |= PCI_FILL_BASES | PCI_FILL_SIZES | PCI_FILL_IO_FLAGS;
+}
+
+static BOOL
+get_device_location(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id, unsigned int *domain, unsigned int *bus, unsigned int *dev, unsigned int *func)
+{
+  ULONG reg_type, reg_len;
+  CONFIGRET cr;
+  BOOL have_bus, have_devfunc;
+  DWORD drp_bus_num, drp_address;
+
+  *domain = 0;
+  have_bus = FALSE;
+  have_devfunc = FALSE;
+
+  /*
+   * DRP_BUSNUMBER consists of PCI domain number in high 24 bits
+   * and PCI bus number in low 8 bits.
+   */
+  reg_len = sizeof(drp_bus_num);
+  cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_BUSNUMBER, &reg_type, &drp_bus_num, &reg_len, 0);
+  if (cr == CR_SUCCESS && reg_type == REG_DWORD && reg_len == sizeof(drp_bus_num))
+    {
+      *domain = drp_bus_num >> 8;
+      *bus = drp_bus_num & 0xff;
+      have_bus = TRUE;
+    }
+
+  /*
+   * DRP_ADDRESS consists of PCI device number in high 16 bits
+   * and PCI function number in low 16 bits.
+   */
+  reg_len = sizeof(drp_address);
+  cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_ADDRESS, &reg_type, &drp_address, &reg_len, 0);
+  if (cr == CR_SUCCESS && reg_type == REG_DWORD && reg_len == sizeof(drp_address))
+    {
+      *dev = drp_address >> 16;
+      *func = drp_address & 0xffff;
+      have_devfunc = TRUE;
+    }
+
+  /*
+   * Device Instance Id for PCI devices is of format:
+   *  "<enumerator>\\<device_id>\\<instance_id>"
+   * where:
+   *  "<enumerator>" is "PCI"
+   *  "<device_id>" is "VEN_####&DEV_####&SUBSYS_########&REV_##"
+   * and "<instance_id>" for PCI devices is at least in one of following format:
+   *  "BUS_##&DEV_##&FUNC_##"
+   *  "##.." (sequence of devfn hex bytes, where bytes represents tree path to the root)
+   *  "#..&#..&#..&#.." (four hex numbers separated by "&"; meaning is unknown yet)
+   *
+   * First two formats are used only on systems without support for multiple
+   * domains. The second format uses intel-conf encoding of device and function
+   * number: Low 3 bits is function number and high 5 bits is device number.
+   * Bus number is not really encoded in second format!
+   *
+   * The third format is used on systems with support for multiple domains but
+   * format is variable length and currently its meaning is unknown. Apparently
+   * it looks like that DRP_BUSNUMBER and DRP_ADDRESS registry properties are
+   * supported on these systems.
+   *
+   * If DRP_BUSNUMBER or DRP_ADDRESS failed then try to parse PCI bus, device
+   * and function numbers from Instance Id part.
+   */
+  if (!have_bus || !have_devfunc)
+    {
+      const char *device_id0 = strchr(devinst_id, '\\');
+      const char *instance_id0 = device_id0 ? strchr(device_id0 + 1, '\\') : NULL;
+      const char *instance_id = instance_id0 ? instance_id0 + 1 : NULL;
+      unsigned int devfn;
+
+      if (instance_id)
+        {
+          if (fmt_validate(instance_id, strlen(instance_id), "BUS_##&DEV_##&FUNC_##") &&
+              sscanf(instance_id, "BUS_%x&DEV_%x&FUNC_%x", bus, dev, func) == 3)
+            {
+              have_bus = TRUE;
+              have_devfunc = TRUE;
+            }
+          else if (seq_xdigit_validate(instance_id, 2, 2) &&
+                   sscanf(instance_id, "%2x", &devfn) == 1)
+            {
+              *dev = devfn >> 3;
+              *func = devfn & 0x7;
+              have_devfunc = TRUE;
+            }
+        }
+    }
+
+  /*
+   * Virtual IRQ holder devices do not have assigned any bus/dev/func number and
+   * have "IRQHOLDER" in their Device Id part. So skip them.
+   */
+  if (!have_bus && !have_devfunc && strncmp(devinst_id, "PCI\\IRQHOLDER\\", 14) == 0)
+    return FALSE;
+
+  /*
+   * When some numbers cannot be retrieved via cfgmgr32 then set them to zeros
+   * to have structure initialized. It makes sense to report via libpci also
+   * such "incomplete" device as cfgmgr32 can provide additional information
+   * like device/vendor ids or assigned resources.
+   */
+  if (!have_bus && !have_devfunc)
+    {
+      *bus = *dev = *func = 0;
+      a->warning("Cannot retrieve bus, device and function numbers for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+    }
+  else if (!have_bus)
+    {
+      *bus = 0;
+      a->warning("Cannot retrieve bus number for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+    }
+  else if (!have_devfunc)
+    {
+      *dev = *func = 0;
+      a->warning("Cannot retrieve device and function numbers for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+    }
+
+  return TRUE;
+}
+
+static void
+fill_data_from_string(struct pci_dev *d, const char *str)
+{
+  BOOL have_device_id;
+  BOOL have_vendor_id;
+  BOOL have_prog_if;
+  BOOL have_rev_id;
+  const char *endptr, *endptr2;
+  unsigned int hex;
+  int len;
+
+  have_device_id = have_vendor_id = (d->known_fields & PCI_FILL_IDENT);
+  have_prog_if = have_rev_id = (d->known_fields & PCI_FILL_CLASS_EXT);
+
+  while (1)
+    {
+      endptr = strchr(str, '&');
+      endptr2 = strchr(str, '\\');
+      if (endptr2 && (!endptr || endptr > endptr2))
+        endptr = endptr2;
+      len = endptr ? endptr-str : (int)strlen(str);
+
+      if (!have_vendor_id &&
+          fmt_validate(str, len, "VEN_####") &&
+          sscanf(str, "VEN_%x", &hex) == 1)
+        {
+          d->vendor_id = hex;
+          have_vendor_id = TRUE;
+        }
+      else if (!have_device_id &&
+               fmt_validate(str, len, "DEV_####") &&
+               sscanf(str, "DEV_%x", &hex) == 1)
+        {
+          d->device_id = hex;
+          have_device_id = TRUE;
+        }
+      else if (!(d->known_fields & PCI_FILL_SUBSYS) &&
+               fmt_validate(str, len, "SUBSYS_########") &&
+               sscanf(str, "SUBSYS_%x", &hex) == 1)
+        {
+          d->subsys_vendor_id = hex & 0xffff;
+          d->subsys_id = hex >> 16;
+          d->known_fields |= PCI_FILL_SUBSYS;
+        }
+      else if (!have_rev_id &&
+               fmt_validate(str, len, "REV_##") &&
+               sscanf(str, "REV_%x", &hex) == 1)
+        {
+          d->rev_id = hex;
+          have_rev_id = TRUE;
+        }
+      else if (!((d->known_fields & PCI_FILL_CLASS) && have_prog_if) &&
+               (fmt_validate(str, len, "CC_####") || fmt_validate(str, len, "CC_######")) &&
+               sscanf(str, "CC_%x", &hex) == 1)
+        {
+          if (len == 9)
+            {
+              if (!have_prog_if)
+                {
+                  d->prog_if = hex & 0xff;
+                  have_prog_if = TRUE;
+                }
+              hex >>= 8;
+            }
+          if (!(d->known_fields & PCI_FILL_CLASS))
+            {
+              d->device_class = hex;
+              d->known_fields |= PCI_FILL_CLASS;
+            }
+        }
+
+      if (!endptr || endptr == endptr2)
+        break;
+
+      str = endptr + 1;
+    }
+
+  if ((have_device_id || d->device_id) && (have_vendor_id || d->vendor_id))
+    d->known_fields |= PCI_FILL_IDENT;
+
+  if ((have_prog_if || d->prog_if) && (have_rev_id || d->rev_id))
+    d->known_fields |= PCI_FILL_CLASS_EXT;
+}
+
+static void
+fill_data_from_devinst_id(struct pci_dev *d, DEVINSTID_A devinst_id)
+{
+  const char *device_id;
+
+  device_id = strchr(devinst_id, '\\');
+  if (!device_id)
+    return;
+  device_id++;
+
+  /*
+   * Device Id part of Device Instance Id is in format:
+   *  "VEN_####&DEV_####&SUBSYS_########&REV_##"
+   */
+  fill_data_from_string(d, device_id);
+}
+
+static void
+fill_data_from_hardware_ids(struct pci_dev *d, DEVINST devinst, DEVINSTID_A devinst_id)
+{
+  ULONG reg_type, reg_size, reg_len;
+  struct pci_access *a = d->access;
+  char *hardware_ids = NULL;
+  const char *str;
+  CONFIGRET cr;
+
+  reg_size = 0;
+  cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_HARDWAREID, &reg_type, NULL, &reg_size, 0);
+  if (cr != CR_SUCCESS && cr != CR_BUFFER_SMALL)
+    {
+      a->warning("Cannot retrieve hardware ids for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      return;
+    }
+  else if (reg_type != REG_MULTI_SZ && reg_type != REG_SZ) /* Older Windows versions return REG_SZ and new versions REG_MULTI_SZ. */
+    {
+      a->warning("Cannot retrieve hardware ids for PCI device %s: Hardware ids are stored as unknown type 0x%lx.", devinst_id, reg_type);
+      return;
+    }
+
+retry:
+  /*
+   * Returned size is on older Windows versions without nul-term char.
+   * So explicitly increase size and fill nul-term byte.
+   */
+  reg_size++;
+  hardware_ids = pci_malloc(a, reg_size);
+  reg_len = reg_size;
+  cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_HARDWAREID, &reg_type, hardware_ids, &reg_len, 0);
+  hardware_ids[reg_size - 1] = 0;
+  if (reg_len > reg_size)
+    {
+      pci_mfree(hardware_ids);
+      reg_size = reg_len;
+      goto retry;
+    }
+  else if (cr != CR_SUCCESS)
+    {
+      a->warning("Cannot retrieve hardware ids for PCI device %s: %s.", devinst_id, cr_strerror(cr));
+      pci_mfree(hardware_ids);
+      return;
+    }
+  else if (reg_type != REG_MULTI_SZ && reg_type != REG_SZ) /* Older Windows versions return REG_SZ and new versions REG_MULTI_SZ. */
+    {
+      a->warning("Cannot retrieve hardware ids for PCI device %s: Hardware ids are stored as unknown type 0x%lx.", devinst_id, reg_type);
+      pci_mfree(hardware_ids);
+      return;
+    }
+
+  /*
+   * Hardware ids is nul-separated nul-term string list where each string has
+   * one of the following format:
+   *  "PCI\\VEN_####&DEV_####&SUBSYS_########&REV_##"
+   *  "PCI\\VEN_####&DEV_####&SUBSYS_########"
+   *  "PCI\\VEN_####&DEV_####&REV_##&CC_####"
+   *  "PCI\\VEN_####&DEV_####&CC_######"
+   *  "PCI\\VEN_####&DEV_####&CC_####"
+   *  "PCI\\VEN_####&DEV_####&REV_##"
+   *  "PCI\\VEN_####&DEV_####"
+   */
+  for (str = hardware_ids; *str != '\0'; str += strlen(str) + 1)
+    {
+      if (strncmp(str, "PCI\\", 4) != 0)
+        continue;
+      str += 4;
+      fill_data_from_string(d, str);
+    }
+
+  pci_mfree(hardware_ids);
+}
+
+static void
+scan_devinst_id(struct pci_access *a, DEVINSTID_A devinst_id)
+{
+  unsigned int domain, bus, dev, func;
+  struct pci_dev *d;
+  DEVINST devinst;
+  CONFIGRET cr;
+
+  cr = CM_Locate_DevNodeA(&devinst, devinst_id, CM_LOCATE_DEVNODE_NORMAL);
+  if (cr != CR_SUCCESS)
+    {
+      /* Do not show warning when device is not present (= does not match NORMAL flag). */
+      if (cr != CR_NO_SUCH_DEVNODE)
+        a->warning("Cannot retrieve handle for device %s: %s.", devinst_id, cr_strerror(cr));
+      return;
+    }
+
+  /* get_device_location() returns FALSE if devinst is not real PCI device. */
+  if (!get_device_location(a, devinst, devinst_id, &domain, &bus, &dev, &func))
+    return;
+
+  d = pci_get_dev(a, domain, bus, dev, func);
+  pci_link_dev(a, d);
+  if (!d->access->backend_data)
+    d->no_config_access = 1;
+  d->backend_data = (void *)devinst;
+
+  /* Parse device id part of devinst id and fill details into pci_dev. */
+  if (!a->buscentric)
+    fill_data_from_devinst_id(d, devinst_id);
+
+  /* Retrieve hardware ids of devinst, parse them and fill details into pci_dev. */
+  if (!a->buscentric)
+    fill_data_from_hardware_ids(d, devinst, devinst_id);
+
+  if (!a->buscentric)
+    fill_resources(d, devinst, devinst_id);
+
+  /*
+   * Set parent field to cfgmgr32 parent devinst handle and backend_data field to current
+   * devinst handle. At later stage in win32_cfgmgr32_scan() when all pci_dev
+   * devices are linked, change every devinst handle by pci_dev.
+   */
+  if (!a->buscentric)
+    {
+      DEVINST parent_devinst;
+      if (CM_Get_Parent(&parent_devinst, devinst, 0) != CR_SUCCESS)
+        {
+          parent_devinst = 0;
+          a->warning("Cannot retrieve parent handle for device %s: %s.", devinst_id, cr_strerror(cr));
+        }
+      d->parent = (void *)parent_devinst;
+    }
+}
+
+static void
+win32_cfgmgr32_scan(struct pci_access *a)
+{
+  ULONG devinst_id_list_size;
+  PCHAR devinst_id_list;
+  DEVINSTID_A devinst_id;
+  struct pci_dev *d;
+  CONFIGRET cr;
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+  if (!resolve_cfgmgr32_functions())
+    {
+      a->warning("Required cfgmgr32.dll functions are unavailable.");
+      return;
+    }
+#endif
+
+  /*
+   * Explicitly initialize size to zero as wine cfgmgr32 implementation does not
+   * support this API but returns CR_SUCCESS without touching size argument.
+   */
+  devinst_id_list_size = 0;
+  cr = CM_Get_Device_ID_List_SizeA(&devinst_id_list_size, "PCI", CM_GETIDLIST_FILTER_ENUMERATOR);
+  if (cr != CR_SUCCESS)
+    {
+      a->warning("Cannot retrieve list of PCI devices: %s.", cr_strerror(cr));
+      return;
+    }
+  else if (devinst_id_list_size <= 1)
+    {
+      a->warning("Cannot retrieve list of PCI devices: No device was found.");
+      return;
+    }
+
+  devinst_id_list = pci_malloc(a, devinst_id_list_size);
+  cr = CM_Get_Device_ID_ListA("PCI", devinst_id_list, devinst_id_list_size, CM_GETIDLIST_FILTER_ENUMERATOR);
+  if (cr != CR_SUCCESS)
+    {
+      a->warning("Cannot retrieve list of PCI devices: %s.", cr_strerror(cr));
+      pci_mfree(devinst_id_list);
+      return;
+    }
+
+  /* Register pci_dev for each cfgmgr32 devinst handle. */
+  for (devinst_id = devinst_id_list; *devinst_id; devinst_id += strlen(devinst_id) + 1)
+    scan_devinst_id(a, devinst_id);
+
+  /* Fill all drivers. */
+  if (!a->buscentric)
+    fill_drivers(a);
+
+  /* Switch parent fields from cfgmgr32 devinst handle to pci_dev. */
+  if (!a->buscentric)
+    {
+      struct pci_dev *d1, *d2;
+      for (d1 = a->devices; d1; d1 = d1->next)
+        {
+          for (d2 = a->devices; d2; d2 = d2->next)
+            if ((DEVINST)d1->parent == (DEVINST)d2->backend_data)
+              break;
+          d1->parent = d2;
+          if (d1->parent)
+            d1->known_fields |= PCI_FILL_PARENT;
+        }
+    }
+
+  /* devinst stored in ->backend_data is not needed anymore, clear it. */
+  for (d = a->devices; d; d = d->next)
+    d->backend_data = NULL;
+
+  pci_mfree(devinst_id_list);
+}
+
+static void
+win32_cfgmgr32_config(struct pci_access *a)
+{
+  pci_define_param(a, "win32.cfgmethod", "auto", "PCI config space access method");
+}
+
+static int
+win32_cfgmgr32_detect(struct pci_access *a)
+{
+  ULONG devinst_id_list_size;
+  CONFIGRET cr;
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+  if (!resolve_cfgmgr32_functions())
+    {
+      a->debug("Required cfgmgr32.dll functions are unavailable.");
+      return 0;
+    }
+#endif
+
+  /*
+   * Explicitly initialize size to zero as wine cfgmgr32 implementation does not
+   * support this API but returns CR_SUCCESS without touching size argument.
+   */
+  devinst_id_list_size = 0;
+  cr = CM_Get_Device_ID_List_SizeA(&devinst_id_list_size, "PCI", CM_GETIDLIST_FILTER_ENUMERATOR);
+  if (cr != CR_SUCCESS)
+    {
+      a->debug("CM_Get_Device_ID_List_SizeA(\"PCI\"): %s.", cr_strerror(cr));
+      return 0;
+    }
+  else if (devinst_id_list_size <= 1)
+    {
+      a->debug("CM_Get_Device_ID_List_SizeA(\"PCI\"): No device was found.");
+      return 0;
+    }
+
+  return 1;
+}
+
+static void
+win32_cfgmgr32_fill_info(struct pci_dev *d, unsigned int flags)
+{
+  /*
+   * All available flags were filled by win32_cfgmgr32_scan().
+   * Filling more flags is possible only from config space.
+   */
+  if (!d->access->backend_data)
+    return;
+
+  pci_generic_fill_info(d, flags);
+}
+
+static int
+win32_cfgmgr32_read(struct pci_dev *d, int pos, byte *buf, int len)
+{
+  struct pci_access *a = d->access;
+  struct pci_access *acfg = a->backend_data;
+  struct pci_dev *dcfg = d->backend_data;
+
+  if (!acfg)
+    return pci_emulated_read(d, pos, buf, len);
+
+  if (!dcfg)
+    d->backend_data = dcfg = pci_get_dev(acfg, d->domain, d->bus, d->dev, d->func);
+
+  return pci_read_block(dcfg, pos, buf, len);
+}
+
+static int
+win32_cfgmgr32_write(struct pci_dev *d, int pos, byte *buf, int len)
+{
+  struct pci_access *a = d->access;
+  struct pci_access *acfg = a->backend_data;
+  struct pci_dev *dcfg = d->backend_data;
+
+  if (!acfg)
+    return 0;
+
+  if (!dcfg)
+    d->backend_data = dcfg = pci_get_dev(acfg, d->domain, d->bus, d->dev, d->func);
+
+  return pci_write_block(dcfg, pos, buf, len);
+}
+
+static void
+win32_cfgmgr32_cleanup_dev(struct pci_dev *d)
+{
+  struct pci_dev *dcfg = d->backend_data;
+
+  if (dcfg)
+    pci_free_dev(dcfg);
+}
+
+static void
+win32_cfgmgr32_init(struct pci_access *a)
+{
+  char *cfgmethod = pci_get_param(a, "win32.cfgmethod");
+  struct pci_access *acfg;
+
+  if (strcmp(cfgmethod, "") == 0 ||
+      strcmp(cfgmethod, "auto") == 0)
+    {
+      acfg = pci_clone_access(a);
+      acfg->method = PCI_ACCESS_AUTO;
+    }
+  else if (strcmp(cfgmethod, "none") == 0 ||
+           strcmp(cfgmethod, "win32-cfgmgr32") == 0)
+    {
+      if (a->writeable)
+        a->error("Write access requested but option win32.cfgmethod was not set.");
+      return;
+    }
+  else
+    {
+      int m = pci_lookup_method(cfgmethod);
+      if (m < 0)
+        a->error("Option win32.cfgmethod is set to an unknown access method \"%s\".", cfgmethod);
+      acfg = pci_clone_access(a);
+      acfg->method = m;
+    }
+
+  a->debug("Loading config space access method...\n");
+  if (!pci_init_internal(acfg, PCI_ACCESS_WIN32_CFGMGR32))
+    {
+      pci_cleanup(acfg);
+      a->debug("Cannot find any working config space access method.\n");
+      if (a->writeable)
+        a->error("Write access requested but no usable access method found.");
+      return;
+    }
+
+  a->backend_data = acfg;
+}
+
+static void
+win32_cfgmgr32_cleanup(struct pci_access *a)
+{
+  struct pci_access *acfg = a->backend_data;
+
+  if (acfg)
+    pci_cleanup(acfg);
+}
+
+struct pci_methods pm_win32_cfgmgr32 = {
+  "win32-cfgmgr32",
+  "Win32 device listing via Configuration Manager",
+  win32_cfgmgr32_config,
+  win32_cfgmgr32_detect,
+  win32_cfgmgr32_init,
+  win32_cfgmgr32_cleanup,
+  win32_cfgmgr32_scan,
+  win32_cfgmgr32_fill_info,
+  win32_cfgmgr32_read,
+  win32_cfgmgr32_write,
+  NULL,                                 /* read_vpd */
+  NULL,                                 /* init_dev */
+  win32_cfgmgr32_cleanup_dev,
+};