ReactOS  r75919
Classes | Macros | Typedefs | Functions | Variables
devinst.c File Reference
#include "setupapi_private.h"
Include dependency graph for devinst.c:

Go to the source code of this file.

Classes

struct  CoInstallerElement
 
struct  GetSectionCallbackInfo
 
struct  PropertyMapEntry
 

Macros

#define CLASS_COINSTALLER   0x1
 
#define DEVICE_COINSTALLER   0x2
 
#define CLASS_INSTALLER   0x4
 

Typedefs

typedef IN HDEVINFO DeviceInfoSet
 
typedef IN HDEVINFO IN
PSP_DEVINFO_DATA
DeviceInfoData 		OPTIONAL
 
typedef IN OUT PSP_DEVINFO_DATA DeviceInfoData
 
typedef IN HDEVINFO IN
PSP_DEVINFO_DATA
DeviceInfoData IN OUT
PCOINSTALLER_CONTEXT_DATA 		Context
 

Functions

typedef DWORD (CALLBACK *CLASS_INSTALL_PROC)(IN DI_FUNCTION InstallFunction
 
typedef BOOL (WINAPI *DEFAULT_CLASS_INSTALL_PROC)(IN HDEVINFO DeviceInfoSet
 
static void SETUPDI_GuidToString (const GUID *guid, LPWSTR guidStr)
 
static DWORD GetErrorCodeFromCrCode (const IN CONFIGRET cr)
 
static BOOL CheckSectionValid (IN LPCWSTR SectionName, IN PSP_ALTPLATFORM_INFO PlatformInfo, IN BYTE ProductType, IN WORD SuiteMask, OUT PDWORD ScorePlatform, OUT PDWORD ScoreMajorVersion, OUT PDWORD ScoreMinorVersion, OUT PDWORD ScoreProductType, OUT PDWORD ScoreSuiteMask)
 
static BOOL GetSectionCallback (IN LPCWSTR SectionName, IN PVOID Context)
 
BOOL WINAPI SetupDiGetActualSectionToInstallExW (IN HINF InfHandle, IN PCWSTR InfSectionName, IN PSP_ALTPLATFORM_INFO AlternatePlatformInfo OPTIONAL, OUT PWSTR InfSectionWithExt OPTIONAL, IN DWORD InfSectionWithExtSize, OUT PDWORD RequiredSize OPTIONAL, OUT PWSTR *Extension OPTIONAL, IN PVOID Reserved)
 
BOOL CreateDeviceInfo (IN struct DeviceInfoSet *list, IN LPCWSTR InstancePath, IN LPCGUID pClassGuid, OUT struct DeviceInfo **pDeviceInfo)
 
static BOOL DestroyClassInstallParams (struct ClassInstallParams *installParams)
 
static BOOL DestroyDeviceInfo (struct DeviceInfo *deviceInfo)
 
static BOOL DestroyDeviceInfoSet (struct DeviceInfoSet *list)
 
BOOL WINAPI SetupDiBuildClassInfoList (DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiBuildClassInfoListExA (DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiBuildClassInfoListExW (DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiClassGuidsFromNameA (LPCSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiClassGuidsFromNameW (LPCWSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiClassGuidsFromNameExA (LPCSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiClassGuidsFromNameExW (LPCWSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiClassNameFromGuidA (const GUID *ClassGuid, PSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiClassNameFromGuidW (const GUID *ClassGuid, PWSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiClassNameFromGuidExA (const GUID *ClassGuid, PSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize, PCSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiClassNameFromGuidExW (const GUID *ClassGuid, PWSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize, PCWSTR MachineName, PVOID Reserved)
 
HDEVINFO WINAPI SetupDiCreateDeviceInfoList (const GUID *ClassGuid, HWND hwndParent)
 
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExA (const GUID *ClassGuid, HWND hwndParent, PCSTR MachineName, PVOID Reserved)
 
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExW (const GUID *ClassGuid, HWND hwndParent, PCWSTR MachineName, PVOID Reserved)
 
HKEY WINAPI SetupDiCreateDevRegKeyA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, HINF InfHandle, PCSTR InfSectionName)
 
static HKEY OpenHardwareProfileKey (IN HKEY HKLM, IN DWORD HwProfile, IN DWORD samDesired)
 
HKEY WINAPI SetupDiCreateDevRegKeyW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, HINF InfHandle, PCWSTR InfSectionName)
 
BOOL WINAPI SetupDiCreateDeviceInfoA (HDEVINFO DeviceInfoSet, PCSTR DeviceName, CONST GUID *ClassGuid, PCSTR DeviceDescription, HWND hwndParent, DWORD CreationFlags, PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiCreateDeviceInfoW (HDEVINFO DeviceInfoSet, PCWSTR DeviceName, CONST GUID *ClassGuid, PCWSTR DeviceDescription, HWND hwndParent, DWORD CreationFlags, PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiRegisterDeviceInfo (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Flags, PSP_DETSIG_CMPPROC CompareProc, PVOID CompareContext, PSP_DEVINFO_DATA DupDeviceInfoData)
 
BOOL WINAPI SetupDiEnumDeviceInfo (HDEVINFO devinfo, DWORD index, PSP_DEVINFO_DATA info)
 
BOOL WINAPI SetupDiGetDeviceInstanceIdA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PSTR DeviceInstanceId, DWORD DeviceInstanceIdSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiGetDeviceInstanceIdW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PWSTR DeviceInstanceId, DWORD DeviceInstanceIdSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiGetActualSectionToInstallA (HINF InfHandle, PCSTR InfSectionName, PSTR InfSectionWithExt, DWORD InfSectionWithExtSize, PDWORD RequiredSize, PSTR *Extension)
 
BOOL WINAPI SetupDiGetActualSectionToInstallW (HINF InfHandle, PCWSTR InfSectionName, PWSTR InfSectionWithExt, DWORD InfSectionWithExtSize, PDWORD RequiredSize, PWSTR *Extension)
 
BOOL WINAPI SetupDiGetActualSectionToInstallExA (IN HINF InfHandle, IN PCSTR InfSectionName, IN PSP_ALTPLATFORM_INFO AlternatePlatformInfo OPTIONAL, OUT PSTR InfSectionWithExt OPTIONAL, IN DWORD InfSectionWithExtSize, OUT PDWORD RequiredSize OPTIONAL, OUT PSTR *Extension OPTIONAL, IN PVOID Reserved)
 
BOOL WINAPI SetupDiGetClassDescriptionA (const GUID *ClassGuid, PSTR ClassDescription, DWORD ClassDescriptionSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiGetClassDescriptionW (const GUID *ClassGuid, PWSTR ClassDescription, DWORD ClassDescriptionSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiGetClassDescriptionExA (const GUID *ClassGuid, PSTR ClassDescription, DWORD ClassDescriptionSize, PDWORD RequiredSize, PCSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiGetClassDescriptionExW (const GUID *ClassGuid, PWSTR ClassDescription, DWORD ClassDescriptionSize, PDWORD RequiredSize, PCWSTR MachineName, PVOID Reserved)
 
HDEVINFO WINAPI SetupDiGetClassDevsA (CONST GUID *class, LPCSTR enumstr, HWND parent, DWORD flags)
 
HDEVINFO WINAPI SetupDiGetClassDevsExA (const GUID *class, PCSTR enumstr, HWND parent, DWORD flags, HDEVINFO deviceset, PCSTR machine, PVOID reserved)
 
HDEVINFO WINAPI SetupDiGetClassDevsW (CONST GUID *class, LPCWSTR enumstr, HWND parent, DWORD flags)
 
HDEVINFO WINAPI SetupDiGetClassDevsExW (CONST GUID *class, PCWSTR enumstr, HWND parent, DWORD flags, HDEVINFO deviceset, PCWSTR machine, PVOID reserved)
 
BOOL WINAPI SetupDiGetDeviceInfoListDetailA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_LIST_DETAIL_DATA_A DevInfoData)
 
BOOL WINAPI SetupDiGetDeviceInfoListDetailW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_LIST_DETAIL_DATA_W DevInfoData)
 
BOOL WINAPI SetupDiCreateDeviceInterfaceA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, const GUID *InterfaceClassGuid, PCSTR ReferenceString, DWORD CreationFlags, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
 
BOOL WINAPI SetupDiCreateDeviceInterfaceW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, const GUID *InterfaceClassGuid, PCWSTR ReferenceString, DWORD CreationFlags, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
 
HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyA (HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Reserved, REGSAM samDesired, HINF InfHandle, PCSTR InfSectionName)
 
HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyW (HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Reserved, REGSAM samDesired, HINF InfHandle, PCWSTR InfSectionName)
 
BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey (HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, DWORD Reserved)
 
BOOL WINAPI SetupDiEnumDeviceInterfaces (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, CONST GUID *InterfaceClassGuid, DWORD MemberIndex, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
 
BOOL WINAPI SetupDiDestroyDeviceInfoList (HDEVINFO devinfo)
 
BOOL WINAPI SetupDiGetDeviceInterfaceDetailA (HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData, DWORD DeviceInterfaceDetailDataSize, PDWORD RequiredSize, PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiGetDeviceInterfaceDetailW (HDEVINFO DeviceInfoSet, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData, PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData, DWORD DeviceInterfaceDetailDataSize, PDWORD RequiredSize, PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiGetDeviceRegistryPropertyA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiGetDeviceRegistryPropertyW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize)
 
BOOL WINAPI SetupDiSetDeviceRegistryPropertyA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, const BYTE *PropertyBuffer, DWORD PropertyBufferSize)
 
BOOL WINAPI SetupDiSetDeviceRegistryPropertyW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, const BYTE *PropertyBuffer, DWORD PropertyBufferSize)
 
BOOL WINAPI SetupDiInstallClassA (HWND hwndParent, PCSTR InfFileName, DWORD Flags, HSPFILEQ FileQueue)
 
BOOL WINAPI SetupDiInstallClassExA (IN HWND hwndParent OPTIONAL, IN PCSTR InfFileName OPTIONAL, IN DWORD Flags, IN HSPFILEQ FileQueue OPTIONAL, IN CONST GUID *InterfaceClassGuid OPTIONAL, IN PVOID Reserved1, IN PVOID Reserved2)
 
HKEY SETUP_CreateClassKey (HINF hInf)
 
BOOL WINAPI SetupDiInstallClassW (HWND hwndParent, PCWSTR InfFileName, DWORD Flags, HSPFILEQ FileQueue)
 
HKEY WINAPI SetupDiOpenClassRegKey (const GUID *ClassGuid, REGSAM samDesired)
 
HKEY WINAPI SetupDiOpenClassRegKeyExA (const GUID *ClassGuid, REGSAM samDesired, DWORD Flags, PCSTR MachineName, PVOID Reserved)
 
HKEY WINAPI SetupDiOpenClassRegKeyExW (const GUID *ClassGuid, REGSAM samDesired, DWORD Flags, PCWSTR MachineName, PVOID Reserved)
 
BOOL WINAPI SetupDiOpenDeviceInterfaceW (HDEVINFO DeviceInfoSet, PCWSTR DevicePath, DWORD OpenFlags, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
 
BOOL WINAPI SetupDiOpenDeviceInterfaceA (HDEVINFO DeviceInfoSet, PCSTR DevicePath, DWORD OpenFlags, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
 
BOOL WINAPI SetupDiSetClassInstallParamsA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PSP_CLASSINSTALL_HEADER ClassInstallParams, DWORD ClassInstallParamsSize)
 
static BOOL WINAPI IntSetupDiRegisterDeviceInfo (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiCallClassInstaller (DI_FUNCTION InstallFunction, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiGetDeviceInstallParamsA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
 
BOOL WINAPI SetupDiGetDeviceInfoListClass (IN HDEVINFO DeviceInfoSet, OUT LPGUID ClassGuid)
 
BOOL WINAPI SetupDiGetDeviceInstallParamsW (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, OUT PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
 
static BOOL CheckDeviceInstallParameters (IN PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
 
BOOL WINAPI SetupDiSetDeviceInstallParamsW (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, IN PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
 
BOOL WINAPI SetupDiSetDeviceInstallParamsA (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
 
static BOOL IsDeviceInfoInDeviceInfoSet (struct DeviceInfoSet *deviceInfoSet, struct DeviceInfo *deviceInfo)
 
BOOL WINAPI SetupDiDeleteDeviceInfo (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiOpenDeviceInfoA (IN HDEVINFO DeviceInfoSet, IN PCSTR DeviceInstanceId, IN HWND hwndParent OPTIONAL, IN DWORD OpenFlags, OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
 
BOOL WINAPI SetupDiOpenDeviceInfoW (IN HDEVINFO DeviceInfoSet, IN PCWSTR DeviceInstanceId, IN HWND hwndParent OPTIONAL, IN DWORD OpenFlags, OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
 
BOOL WINAPI SetupDiGetSelectedDevice (IN HDEVINFO DeviceInfoSet, OUT PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiSetSelectedDevice (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
 
static DWORD SETUPAPI_GetCurrentHwProfile (IN HDEVINFO DeviceInfoSet)
 
static BOOL ResetDevice (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
 
static BOOL StopDevice (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiChangeState (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
 
BOOL WINAPI SetupDiSelectDevice (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
 
BOOL WINAPI SetupDiRegisterCoDeviceInstallers (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
 
static BOOL InfIsFromOEMLocation (IN PCWSTR FullName, OUT LPBOOL IsOEMLocation)
 
BOOL WINAPI SetupDiInstallDevice (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
 
static HKEY SETUPDI_OpenDevKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
 
static HKEY SETUPDI_OpenDrvKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
 
HKEY WINAPI SetupDiOpenDevRegKey (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, REGSAM samDesired)
 
static BOOL SETUPDI_DeleteDevKey (HKEY RootKey, struct DeviceInfo *devInfo)
 
static BOOL SETUPDI_DeleteDrvKey (HKEY RootKey, struct DeviceInfo *devInfo)
 
BOOL WINAPI SetupDiDeleteDevRegKey (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType)
 

Variables

static const WCHAR BackSlash [] = {'\\',0}
 
static const WCHAR DateFormat [] = {'%','u','-','%','u','-','%','u',0}
 
static const WCHAR DotCoInstallers [] = {'.','C','o','I','n','s','t','a','l','l','e','r','s',0}
 
static const WCHAR DotHW [] = {'.','H','W',0}
 
static const WCHAR DotServices [] = {'.','S','e','r','v','i','c','e','s',0}
 
static const WCHAR InfDirectory [] = {'i','n','f','\\',0}
 
static const WCHAR InstanceKeyFormat [] = {'%','0','4','l','u',0}
 
static const WCHAR Version [] = {'V','e','r','s','i','o','n',0}
 
static const WCHAR VersionFormat [] = {'%','u','.','%','u','.','%','u','.','%','u',0}
 
static const WCHAR REGSTR_DRIVER_DATE [] = {'D','r','i','v','e','r','D','a','t','e',0}
 
static const WCHAR REGSTR_DRIVER_DATE_DATA [] = {'D','r','i','v','e','r','D','a','t','e','D','a','t','a',0}
 
static const WCHAR REGSTR_DRIVER_VERSION [] = {'D','r','i','v','e','r','V','e','r','s','i','o','n',0}
 
static const WCHAR REGSTR_SECURITY [] = {'S','e','c','u','r','i','t','y',0}
 
static const WCHAR REGSTR_UI_NUMBER_DESC_FORMAT [] = {'U','I','N','u','m','b','e','r','D','e','s','c','F','o','r','m','a','t',0}
 
static struct PropertyMapEntry PropertyMap []
 

Macro Definition Documentation

#define CLASS_COINSTALLER   0x1

Referenced by SetupDiCallClassInstaller().

#define CLASS_INSTALLER   0x4

Referenced by SetupDiCallClassInstaller().

#define DEVICE_COINSTALLER   0x2

Referenced by SetupDiCallClassInstaller().

Typedef Documentation

typedef IN HDEVINFO IN PSP_DEVINFO_DATA DeviceInfoData IN OUT PCOINSTALLER_CONTEXT_DATA Context

Definition at line 53 of file devinst.c.

_In_opt_ PSP_DEVINFO_DATA DeviceInfoData

Definition at line 49 of file devinst.c.

typedef IN HDEVINFO DeviceInfoSet

Definition at line 44 of file devinst.c.

typedef IN HDEVINFO IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL

Definition at line 44 of file devinst.c.

Function Documentation

typedef BOOL ( WINAPI *  DEFAULT_CLASS_INSTALL_PROC)
static BOOL CheckDeviceInstallParameters ( IN PSP_DEVINSTALL_PARAMS_W  DeviceInstallParams)
static

Definition at line 4582 of file devinst.c.

Referenced by SetupDiSetDeviceInstallParamsW().

4584 {
4585  DWORD SupportedFlags =
4586  DI_NOVCP | /* 0x00000008 */
4587  DI_DIDCOMPAT | /* 0x00000010 */
4588  DI_DIDCLASS | /* 0x00000020 */
4589  DI_NEEDRESTART | /* 0x00000080 */
4590  DI_NEEDREBOOT | /* 0x00000100 */
4591  DI_RESOURCEPAGE_ADDED | /* 0x00002000 */
4592  DI_PROPERTIES_CHANGE | /* 0x00004000 */
4593  DI_ENUMSINGLEINF | /* 0x00010000 */
4594  DI_DONOTCALLCONFIGMG | /* 0x00020000 */
4595  DI_CLASSINSTALLPARAMS | /* 0x00100000 */
4596  DI_NODI_DEFAULTACTION | /* 0x00200000 */
4597  DI_QUIETINSTALL | /* 0x00800000 */
4598  DI_NOFILECOPY | /* 0x01000000 */
4599  DI_DRIVERPAGE_ADDED; /* 0x04000000 */
4600  DWORD SupportedFlagsEx =
4601  DI_FLAGSEX_CI_FAILED | /* 0x00000004 */
4602  DI_FLAGSEX_DIDINFOLIST | /* 0x00000010 */
4603  DI_FLAGSEX_DIDCOMPATINFO | /* 0x00000020 */
4604  DI_FLAGSEX_ALLOWEXCLUDEDDRVS | /* 0x00000800 */
4605  DI_FLAGSEX_NO_DRVREG_MODIFY | /* 0x00008000 */
4606  DI_FLAGSEX_INSTALLEDDRIVER; /* 0x04000000 */
4607  BOOL ret = FALSE;
4608 
4609  /* FIXME: add support for more flags */
4610 
4611  /* FIXME: DI_CLASSINSTALLPARAMS flag is not correctly used.
4612  * It should be checked before accessing to other values
4613  * of the SP_DEVINSTALL_PARAMS structure */
4614 
4615  if (DeviceInstallParams->Flags & ~SupportedFlags)
4616  {
4617  FIXME("Unknown Flags: 0x%08lx\n", DeviceInstallParams->Flags & ~SupportedFlags);
4618  SetLastError(ERROR_INVALID_FLAGS);
4619  }
4620  else if (DeviceInstallParams->FlagsEx & ~SupportedFlagsEx)
4621  {
4622  FIXME("Unknown FlagsEx: 0x%08lx\n", DeviceInstallParams->FlagsEx & ~SupportedFlagsEx);
4623  SetLastError(ERROR_INVALID_FLAGS);
4624  }
4625  else if ((DeviceInstallParams->Flags & DI_NOVCP)
4626  && (DeviceInstallParams->FileQueue == NULL || DeviceInstallParams->FileQueue == (HSPFILEQ)INVALID_HANDLE_VALUE))
4627  SetLastError(ERROR_INVALID_USER_BUFFER);
4628  else
4629  {
4630  /* FIXME: check Reserved field */
4631  ret = TRUE;
4632  }
4633 
4634  return ret;
4635 }
TRUE
#define TRUE
Definition: types.h:120
DI_NEEDREBOOT
#define DI_NEEDREBOOT
Definition: setupapi.h:54
HSPFILEQ
PVOID HSPFILEQ
Definition: filequeue.h:52
DI_FLAGSEX_NO_DRVREG_MODIFY
#define DI_FLAGSEX_NO_DRVREG_MODIFY
Definition: setupapi.h:91
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DI_FLAGSEX_ALLOWEXCLUDEDDRVS
#define DI_FLAGSEX_ALLOWEXCLUDEDDRVS
Definition: setupapi.h:87
DI_DRIVERPAGE_ADDED
#define DI_DRIVERPAGE_ADDED
Definition: setupapi.h:71
DWORD
DWORD DWORD
Definition: winlogon.h:75
ERROR_INVALID_USER_BUFFER
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
DI_DIDCLASS
#define DI_DIDCLASS
Definition: setupapi.h:51
FALSE
#define FALSE
Definition: types.h:117
DI_DONOTCALLCONFIGMG
#define DI_DONOTCALLCONFIGMG
Definition: setupapi.h:63
DI_NOFILECOPY
#define DI_NOFILECOPY
Definition: setupapi.h:69
FIXME
#define FIXME(fmt,...)
Definition: debug.h:110
DI_DIDCOMPAT
#define DI_DIDCOMPAT
Definition: setupapi.h:50
DI_NOVCP
#define DI_NOVCP
Definition: setupapi.h:49
NULL
smooth NULL
Definition: ftsmooth.c:513
DI_PROPERTIES_CHANGE
#define DI_PROPERTIES_CHANGE
Definition: setupapi.h:60
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DI_NODI_DEFAULTACTION
#define DI_NODI_DEFAULTACTION
Definition: setupapi.h:67
SetLastError
#define SetLastError(x)
Definition: compat.h:409
DI_QUIETINSTALL
#define DI_QUIETINSTALL
Definition: setupapi.h:68
DI_RESOURCEPAGE_ADDED
#define DI_RESOURCEPAGE_ADDED
Definition: setupapi.h:59
DI_CLASSINSTALLPARAMS
#define DI_CLASSINSTALLPARAMS
Definition: setupapi.h:66
ret
int ret
Definition: wcstombs-tests.c:31
DI_FLAGSEX_DIDINFOLIST
#define DI_FLAGSEX_DIDINFOLIST
Definition: setupapi.h:80
DI_FLAGSEX_DIDCOMPATINFO
#define DI_FLAGSEX_DIDCOMPATINFO
Definition: setupapi.h:81
DI_FLAGSEX_CI_FAILED
#define DI_FLAGSEX_CI_FAILED
Definition: setupapi.h:79
DI_ENUMSINGLEINF
#define DI_ENUMSINGLEINF
Definition: setupapi.h:62
DI_NEEDRESTART
#define DI_NEEDRESTART
Definition: setupapi.h:53
ERROR_INVALID_FLAGS
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
static BOOL CheckSectionValid ( IN LPCWSTR  SectionName,
IN PSP_ALTPLATFORM_INFO  PlatformInfo,
IN BYTE  ProductType,
IN WORD  SuiteMask,
OUT PDWORD  ScorePlatform,
OUT PDWORD  ScoreMajorVersion,
OUT PDWORD  ScoreMinorVersion,
OUT PDWORD  ScoreProductType,
OUT PDWORD  ScoreSuiteMask 
)
static

Definition at line 122 of file devinst.c.

Referenced by GetSectionCallback().

132 {
133  LPWSTR Section = NULL;
134  //LPCWSTR pExtensionPlatform;
135  LPCWSTR pExtensionArchitecture;
136  LPWSTR Fields[6];
137  DWORD i;
138  BOOL ret = FALSE;
139 
140  //static const WCHAR ExtensionPlatformNone[] = {'.',0};
141  static const WCHAR ExtensionPlatformNT[] = {'.','N','T',0};
142  static const WCHAR ExtensionPlatformWindows[] = {'.','W','i','n',0};
143 
144  static const WCHAR ExtensionArchitectureNone[] = {0};
145  static const WCHAR ExtensionArchitecturealpha[] = {'a','l','p','h','a',0};
146  static const WCHAR ExtensionArchitectureamd64[] = {'A','M','D','6','4',0};
147  static const WCHAR ExtensionArchitectureia64[] = {'I','A','6','4',0};
148  static const WCHAR ExtensionArchitecturemips[] = {'m','i','p','s',0};
149  static const WCHAR ExtensionArchitectureppc[] = {'p','p','c',0};
150  static const WCHAR ExtensionArchitecturex86[] = {'x','8','6',0};
151 
152  TRACE("%s %p 0x%x 0x%x\n",
153  debugstr_w(SectionName), PlatformInfo, ProductType, SuiteMask);
154 
155  *ScorePlatform = *ScoreMajorVersion = *ScoreMinorVersion = *ScoreProductType = *ScoreSuiteMask = 0;
156 
157  Section = pSetupDuplicateString(SectionName);
158  if (!Section)
159  {
160  TRACE("pSetupDuplicateString() failed\n");
161  goto cleanup;
162  }
163 
164  /* Set various extensions values */
165  switch (PlatformInfo->Platform)
166  {
167  case VER_PLATFORM_WIN32_WINDOWS:
168  //pExtensionPlatform = ExtensionPlatformWindows;
169  break;
170  case VER_PLATFORM_WIN32_NT:
171  //pExtensionPlatform = ExtensionPlatformNT;
172  break;
173  default:
174  ERR("Unknown platform 0x%lx\n", PlatformInfo->Platform);
175  //pExtensionPlatform = ExtensionPlatformNone;
176  break;
177  }
178  switch (PlatformInfo->ProcessorArchitecture)
179  {
180  case PROCESSOR_ARCHITECTURE_ALPHA:
181  pExtensionArchitecture = ExtensionArchitecturealpha;
182  break;
183  case PROCESSOR_ARCHITECTURE_AMD64:
184  pExtensionArchitecture = ExtensionArchitectureamd64;
185  break;
186  case PROCESSOR_ARCHITECTURE_IA64:
187  pExtensionArchitecture = ExtensionArchitectureia64;
188  break;
189  case PROCESSOR_ARCHITECTURE_INTEL:
190  pExtensionArchitecture = ExtensionArchitecturex86;
191  break;
192  case PROCESSOR_ARCHITECTURE_MIPS:
193  pExtensionArchitecture = ExtensionArchitecturemips;
194  break;
195  case PROCESSOR_ARCHITECTURE_PPC:
196  pExtensionArchitecture = ExtensionArchitectureppc;
197  break;
198  default:
199  ERR("Unknown processor architecture 0x%x\n", PlatformInfo->ProcessorArchitecture);
200  case PROCESSOR_ARCHITECTURE_UNKNOWN:
201  pExtensionArchitecture = ExtensionArchitectureNone;
202  break;
203  }
204 
205  /*
206  * Field[0] Platform
207  * Field[1] Architecture
208  * Field[2] Major version
209  * Field[3] Minor version
210  * Field[4] Product type
211  * Field[5] Suite mask
212  * Remark: these fields may be NULL if the information is not provided
213  */
214  Fields[0] = Section;
215  if (Fields[0] == NULL)
216  {
217  TRACE("No extension found\n");
218  *ScorePlatform = *ScoreMajorVersion = *ScoreMinorVersion = *ScoreProductType = *ScoreSuiteMask = ULONG_MAX;
219  ret = TRUE;
220  goto cleanup;
221  }
222  Fields[1] = Fields[0] + 1;
223  Fields[2] = Fields[3] = Fields[4] = Fields[5] = NULL;
224  for (i = 2; Fields[i - 1] != NULL && i < 6; i++)
225  {
226  Fields[i] = wcschr(Fields[i - 1], '.');
227  if (Fields[i])
228  {
229  Fields[i]++;
230  *(Fields[i] - 1) = UNICODE_NULL;
231  }
232  }
233  /* Take care of first 2 fields */
234  if (strncmpiW(Fields[0], ExtensionPlatformWindows, strlenW(ExtensionPlatformWindows)) == 0)
235  {
236  if (PlatformInfo->Platform != VER_PLATFORM_WIN32_WINDOWS)
237  {
238  TRACE("Mismatch on platform field\n");
239  goto cleanup;
240  }
241  Fields[1] += wcslen(ExtensionPlatformWindows) - 1;
242  }
243  else if (strncmpiW(Fields[0], ExtensionPlatformNT, strlenW(ExtensionPlatformNT)) == 0)
244  {
245  if (PlatformInfo->Platform != VER_PLATFORM_WIN32_NT)
246  {
247  TRACE("Mismatch on platform field\n");
248  goto cleanup;
249  }
250  Fields[1] += wcslen(ExtensionPlatformNT) - 1;
251  }
252  else
253  {
254  /* No platform specified */
255  *ScorePlatform |= 0x02;
256  }
257  if (strcmpiW(Fields[1], ExtensionArchitectureNone) == 0)
258  {
259  /* No architecture specified */
260  *ScorePlatform |= 0x01;
261  }
262  else if (strcmpiW(Fields[1], pExtensionArchitecture) != 0)
263  {
264  TRACE("Mismatch on architecture field ('%s' and '%s')\n",
265  debugstr_w(Fields[1]), debugstr_w(pExtensionArchitecture));
266  goto cleanup;
267  }
268 
269  /* Check if informations are matching */
270  if (Fields[2] && *Fields[2])
271  {
272  DWORD MajorVersion, MinorVersion = 0;
273  MajorVersion = strtoulW(Fields[2], NULL, 0);
274  if ((MajorVersion == 0 || MajorVersion == ULONG_MAX) &&
275  (errno == ERANGE || errno == EINVAL))
276  {
277  TRACE("Wrong MajorVersion ('%s')\n", debugstr_w(Fields[2]));
278  goto cleanup;
279  }
280  if (Fields[3] && *Fields[3])
281  {
282  MinorVersion = strtoulW(Fields[3], NULL, 0);
283  if ((MinorVersion == 0 || MinorVersion == ULONG_MAX) &&
284  (errno == ERANGE || errno == EINVAL))
285  {
286  TRACE("Wrong MinorVersion ('%s')\n", debugstr_w(Fields[3]));
287  goto cleanup;
288  }
289  }
290  if (PlatformInfo->MajorVersion < MajorVersion ||
291  (PlatformInfo->MajorVersion == MajorVersion && PlatformInfo->MinorVersion < MinorVersion))
292  {
293  TRACE("Mismatch on version field (%lu.%lu and %lu.%lu)\n",
294  MajorVersion, MinorVersion, PlatformInfo->MajorVersion, PlatformInfo->MinorVersion);
295  goto cleanup;
296  }
297  *ScoreMajorVersion = MajorVersion - PlatformInfo->MajorVersion;
298  if (MajorVersion == PlatformInfo->MajorVersion)
299  *ScoreMinorVersion = MinorVersion - PlatformInfo->MinorVersion;
300  else
301  *ScoreMinorVersion = MinorVersion;
302  }
303  else if (Fields[3] && *Fields[3])
304  {
305  TRACE("Minor version found without major version\n");
306  goto cleanup;
307  }
308  else
309  {
310  *ScoreMajorVersion = PlatformInfo->MajorVersion;
311  *ScoreMinorVersion = PlatformInfo->MinorVersion;
312  }
313 
314  if (Fields[4] && *Fields[4])
315  {
316  DWORD CurrentProductType;
317  CurrentProductType = strtoulW(Fields[4], NULL, 0);
318  if ((CurrentProductType == 0 || CurrentProductType == ULONG_MAX) &&
319  (errno == ERANGE || errno == EINVAL))
320  {
321  TRACE("Wrong Product type ('%s')\n", debugstr_w(Fields[4]));
322  goto cleanup;
323  }
324  if (CurrentProductType != ProductType)
325  {
326  TRACE("Mismatch on product type (0x%08lx and 0x%08x)\n",
327  CurrentProductType, ProductType);
328  goto cleanup;
329  }
330  }
331  else
332  *ScoreProductType = 1;
333 
334  if (Fields[5] && *Fields[5])
335  {
336  DWORD CurrentSuiteMask;
337  CurrentSuiteMask = strtoulW(Fields[5], NULL, 0);
338  if ((CurrentSuiteMask == 0 || CurrentSuiteMask == ULONG_MAX) &&
339  (errno == ERANGE || errno == EINVAL))
340  {
341  TRACE("Wrong Suite mask ('%s')\n", debugstr_w(Fields[5]));
342  goto cleanup;
343  }
344  if ((CurrentSuiteMask & ~SuiteMask) != 0)
345  {
346  TRACE("Mismatch on suite mask (0x%08lx and 0x%08x)\n",
347  CurrentSuiteMask, SuiteMask);
348  goto cleanup;
349  }
350  *ScoreSuiteMask = SuiteMask & ~CurrentSuiteMask;
351  }
352  else
353  *ScoreSuiteMask = SuiteMask;
354 
355  ret = TRUE;
356 
357 cleanup:
358  MyFree(Section);
359  return ret;
360 }
VER_PLATFORM_WIN32_NT
#define VER_PLATFORM_WIN32_NT
Definition: rtltypes.h:236
TRUE
#define TRUE
Definition: types.h:120
MinorVersion
ULONG MinorVersion
Definition: ros_glue.cpp:5
MajorVersion
ULONG MajorVersion
Definition: ros_glue.cpp:4
strlenW
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
PROCESSOR_ARCHITECTURE_UNKNOWN
#define PROCESSOR_ARCHITECTURE_UNKNOWN
Definition: ketypes.h:115
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
EINVAL
Definition: arc.h:39
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
errno
int errno
strncmpiW
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
PROCESSOR_ARCHITECTURE_MIPS
#define PROCESSOR_ARCHITECTURE_MIPS
Definition: ketypes.h:106
DWORD
DWORD DWORD
Definition: winlogon.h:75
PROCESSOR_ARCHITECTURE_IA64
#define PROCESSOR_ARCHITECTURE_IA64
Definition: ketypes.h:111
i
GLenum GLclampf GLint i
Definition: glfuncs.h:14
PROCESSOR_ARCHITECTURE_ALPHA
#define PROCESSOR_ARCHITECTURE_ALPHA
Definition: ketypes.h:107
pSetupDuplicateString
LPWSTR WINAPI pSetupDuplicateString(LPCWSTR lpSrc)
Definition: misc.c:198
FALSE
#define FALSE
Definition: types.h:117
UNICODE_NULL
#define UNICODE_NULL
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
NULL
smooth NULL
Definition: ftsmooth.c:513
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
wcschr
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
PROCESSOR_ARCHITECTURE_AMD64
#define PROCESSOR_ARCHITECTURE_AMD64
Definition: ketypes.h:114
ERANGE
#define ERANGE
Definition: acclib.h:92
ret
int ret
Definition: wcstombs-tests.c:31
strcmpiW
#define strcmpiW(s1, s2)
Definition: unicode.h:39
PROCESSOR_ARCHITECTURE_INTEL
#define PROCESSOR_ARCHITECTURE_INTEL
Definition: ketypes.h:105
ERR
#define ERR(fmt,...)
Definition: debug.h:109
PROCESSOR_ARCHITECTURE_PPC
#define PROCESSOR_ARCHITECTURE_PPC
Definition: ketypes.h:108
VER_PLATFORM_WIN32_WINDOWS
#define VER_PLATFORM_WIN32_WINDOWS
Definition: rtltypes.h:235
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
strtoulW
#define strtoulW(s1, s2, b)
Definition: unicode.h:41
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
wcslen
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
ULONG_MAX
#define ULONG_MAX
Definition: limits.h:44
BOOL CreateDeviceInfo ( IN struct DeviceInfoSet *  list,
IN LPCWSTR  InstancePath,
IN LPCGUID  pClassGuid,
OUT struct DeviceInfo **  pDeviceInfo 
)

Definition at line 526 of file devinst.c.

Referenced by SETUP_CreateDevicesListFromEnumerator(), SETUP_CreateInterfaceList(), SetupDiCreateDeviceInfoW(), SetupDiOpenDeviceInfoW(), and SetupDiOpenDeviceInterfaceW().

531 {
532  DWORD size;
533  CONFIGRET cr;
534  struct DeviceInfo *deviceInfo;
535 
536  *pDeviceInfo = NULL;
537 
538  size = FIELD_OFFSET(struct DeviceInfo, Data) + (strlenW(InstancePath) + 1) * sizeof(WCHAR);
539  deviceInfo = HeapAlloc(GetProcessHeap(), 0, size);
540  if (!deviceInfo)
541  {
542  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
543  return FALSE;
544  }
545  ZeroMemory(deviceInfo, size);
546 
547  cr = CM_Locate_DevNode_ExW(&deviceInfo->dnDevInst, (DEVINSTID_W)InstancePath, CM_LOCATE_DEVNODE_PHANTOM, list->hMachine);
548  if (cr != CR_SUCCESS)
549  {
550  SetLastError(GetErrorCodeFromCrCode(cr));
551  return FALSE;
552  }
553 
554  deviceInfo->set = list;
555  deviceInfo->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
556  strcpyW(deviceInfo->Data, InstancePath);
557  deviceInfo->instanceId = deviceInfo->Data;
558  deviceInfo->UniqueId = strrchrW(deviceInfo->Data, '\\');
559  deviceInfo->DeviceDescription = NULL;
560  memcpy(&deviceInfo->ClassGuid, pClassGuid, sizeof(GUID));
561  deviceInfo->CreationFlags = 0;
562  InitializeListHead(&deviceInfo->DriverListHead);
563  InitializeListHead(&deviceInfo->InterfaceListHead);
564 
565  *pDeviceInfo = deviceInfo;
566  return TRUE;
567 }
TRUE
#define TRUE
Definition: types.h:120
strlenW
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
DeviceInfo::InterfaceListHead
LIST_ENTRY InterfaceListHead
Definition: setupapi_private.h:177
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1621
DeviceInfo::InstallParams
SP_DEVINSTALL_PARAMS_W InstallParams
Definition: setupapi_private.h:139
DWORD
DWORD DWORD
Definition: winlogon.h:75
DEVINSTID_W
_Null_terminated_ WCHAR * DEVINSTID_W
Definition: cfgmgr32.h:80
FALSE
#define FALSE
Definition: types.h:117
GetErrorCodeFromCrCode
static DWORD GetErrorCodeFromCrCode(const IN CONFIGRET cr)
Definition: devinst.c:92
CR_SUCCESS
#define CR_SUCCESS
Definition: cfgmgr32.h:842
NULL
smooth NULL
Definition: ftsmooth.c:513
DeviceInfo::DeviceDescription
PCWSTR DeviceDescription
Definition: setupapi_private.h:168
DeviceInfo::Data
WCHAR Data[ANYSIZE_ARRAY]
Definition: setupapi_private.h:187
DeviceInfo::set
struct DeviceInfoSet * set
Definition: setupapi_private.h:135
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
_SP_DEVINSTALL_PARAMS_W::cbSize
DWORD cbSize
Definition: setupapi.h:886
SetLastError
#define SetLastError(x)
Definition: compat.h:409
DeviceInfo::DriverListHead
LIST_ENTRY DriverListHead
Definition: setupapi_private.h:174
DeviceInfo::dnDevInst
DEVINST dnDevInst
Definition: setupapi_private.h:132
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
list
Definition: _list.h:228
strrchrW
WINE_UNICODE_INLINE WCHAR * strrchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:254
strcpyW
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
size
GLsizeiptr size
Definition: glext.h:5919
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
CM_LOCATE_DEVNODE_PHANTOM
#define CM_LOCATE_DEVNODE_PHANTOM
Definition: cfgmgr32.h:761
CONFIGRET
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
SP_DEVINSTALL_PARAMS_W
struct _SP_DEVINSTALL_PARAMS_W SP_DEVINSTALL_PARAMS_W
CM_Locate_DevNode_ExW
CONFIGRET WINAPI CM_Locate_DevNode_ExW(PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine)
Definition: cfgmgr.c:4477
list
#define list
Definition: rosglue.h:35
static BOOL DestroyClassInstallParams ( struct ClassInstallParams *  installParams)
static

Definition at line 571 of file devinst.c.

Referenced by DestroyDeviceInfo(), and DestroyDeviceInfoSet().

572 {
573  HeapFree(GetProcessHeap(), 0, installParams->PropChangeParams);
574  HeapFree(GetProcessHeap(), 0, installParams->AddPropertyPageData);
575  return TRUE;
576 }
TRUE
#define TRUE
Definition: types.h:120
ClassInstallParams::AddPropertyPageData
PSP_ADDPROPERTYPAGE_DATA AddPropertyPageData
Definition: setupapi_private.h:125
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
ClassInstallParams::PropChangeParams
PSP_PROPCHANGE_PARAMS PropChangeParams
Definition: setupapi_private.h:124
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
static BOOL DestroyDeviceInfo ( struct DeviceInfo *  deviceInfo)
static

Definition at line 579 of file devinst.c.

Referenced by DestroyDeviceInfoSet(), SetupDiCreateDeviceInfoW(), and SetupDiDeleteDeviceInfo().

580 {
581  PLIST_ENTRY ListEntry;
582  struct DriverInfoElement *driverInfo;
583  struct DeviceInterface *deviceInterface;
584 
585  while (!IsListEmpty(&deviceInfo->DriverListHead))
586  {
587  ListEntry = RemoveHeadList(&deviceInfo->DriverListHead);
588  driverInfo = CONTAINING_RECORD(ListEntry, struct DriverInfoElement, ListEntry);
589  if (!DestroyDriverInfoElement(driverInfo))
590  return FALSE;
591  }
592  while (!IsListEmpty(&deviceInfo->InterfaceListHead))
593  {
594  ListEntry = RemoveHeadList(&deviceInfo->InterfaceListHead);
595  deviceInterface = CONTAINING_RECORD(ListEntry, struct DeviceInterface, ListEntry);
596  if (!DestroyDeviceInterface(deviceInterface))
597  return FALSE;
598  }
599  DestroyClassInstallParams(&deviceInfo->ClassInstallParams);
600  if (deviceInfo->hmodDevicePropPageProvider)
601  FreeLibrary(deviceInfo->hmodDevicePropPageProvider);
602  return HeapFree(GetProcessHeap(), 0, deviceInfo);
603 }
DeviceInfo::InterfaceListHead
LIST_ENTRY InterfaceListHead
Definition: setupapi_private.h:177
IsListEmpty
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
FALSE
#define FALSE
Definition: types.h:117
DestroyDeviceInterface
BOOL DestroyDeviceInterface(struct DeviceInterface *deviceInterface)
Definition: interface.c:61
RemoveHeadList
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
DeviceInfo::hmodDevicePropPageProvider
HMODULE hmodDevicePropPageProvider
Definition: setupapi_private.h:183
DestroyClassInstallParams
static BOOL DestroyClassInstallParams(struct ClassInstallParams *installParams)
Definition: devinst.c:571
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:405
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
DestroyDriverInfoElement
BOOL DestroyDriverInfoElement(struct DriverInfoElement *driverInfo)
Definition: driver.c:94
DeviceInfo::DriverListHead
LIST_ENTRY DriverListHead
Definition: setupapi_private.h:174
_LIST_ENTRY
Definition: typedefs.h:118
DeviceInfo::ListEntry
LIST_ENTRY ListEntry
Definition: setupapi_private.h:130
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
DeviceInfo::ClassInstallParams
struct ClassInstallParams ClassInstallParams
Definition: setupapi_private.h:180
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
static BOOL DestroyDeviceInfoSet ( struct DeviceInfoSet *  list)
static

Definition at line 606 of file devinst.c.

Referenced by SetupDiDestroyDeviceInfoList().

607 {
608  PLIST_ENTRY ListEntry;
609  struct DeviceInfo *deviceInfo;
610 
611  while (!IsListEmpty(&list->ListHead))
612  {
613  ListEntry = RemoveHeadList(&list->ListHead);
614  deviceInfo = CONTAINING_RECORD(ListEntry, struct DeviceInfo, ListEntry);
615  if (!DestroyDeviceInfo(deviceInfo))
616  return FALSE;
617  }
618  if (list->HKLM != HKEY_LOCAL_MACHINE)
619  RegCloseKey(list->HKLM);
620  CM_Disconnect_Machine(list->hMachine);
621  DestroyClassInstallParams(&list->ClassInstallParams);
622  if (list->hmodClassPropPageProvider)
623  FreeLibrary(list->hmodClassPropPageProvider);
624  return HeapFree(GetProcessHeap(), 0, list);
625 }
DeviceInfoSet::ListHead
LIST_ENTRY ListHead
Definition: setupapi_private.h:208
DeviceInfoSet::hmodClassPropPageProvider
HMODULE hmodClassPropPageProvider
Definition: setupapi_private.h:215
IsListEmpty
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
DeviceInfoSet::ClassInstallParams
struct ClassInstallParams ClassInstallParams
Definition: setupapi_private.h:212
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
FALSE
#define FALSE
Definition: types.h:117
RemoveHeadList
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
DestroyClassInstallParams
static BOOL DestroyClassInstallParams(struct ClassInstallParams *installParams)
Definition: devinst.c:571
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:405
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
DestroyDeviceInfo
static BOOL DestroyDeviceInfo(struct DeviceInfo *deviceInfo)
Definition: devinst.c:579
_LIST_ENTRY
Definition: typedefs.h:118
DeviceInterface::ListEntry
LIST_ENTRY ListEntry
Definition: setupapi_private.h:70
CM_Disconnect_Machine
CONFIGRET WINAPI CM_Disconnect_Machine(HMACHINE hMachine)
Definition: cfgmgr.c:1215
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
typedef DWORD ( CALLBACK *  CLASS_INSTALL_PROC)
static DWORD GetErrorCodeFromCrCode ( const IN CONFIGRET  cr)
static

Definition at line 92 of file devinst.c.

Referenced by CreateDeviceInfo(), ResetDevice(), SetupDiCreateDeviceInfoListExW(), and SetupDiCreateDeviceInfoW().

93 {
94  switch (cr)
95  {
96  case CR_ACCESS_DENIED: return ERROR_ACCESS_DENIED;
97  case CR_BUFFER_SMALL: return ERROR_INSUFFICIENT_BUFFER;
98  case CR_CALL_NOT_IMPLEMENTED: return ERROR_CALL_NOT_IMPLEMENTED;
99  case CR_FAILURE: return ERROR_GEN_FAILURE;
100  case CR_INVALID_DATA: return ERROR_INVALID_USER_BUFFER;
101  case CR_INVALID_DEVICE_ID: return ERROR_INVALID_PARAMETER;
102  case CR_INVALID_MACHINENAME: return ERROR_INVALID_COMPUTERNAME;
103  case CR_INVALID_DEVNODE: return ERROR_INVALID_PARAMETER;
104  case CR_INVALID_FLAG: return ERROR_INVALID_FLAGS;
105  case CR_INVALID_POINTER: return ERROR_INVALID_PARAMETER;
106  case CR_INVALID_PROPERTY: return ERROR_INVALID_PARAMETER;
107  case CR_NO_SUCH_DEVNODE: return ERROR_FILE_NOT_FOUND;
108  case CR_NO_SUCH_REGISTRY_KEY: return ERROR_FILE_NOT_FOUND;
109  case CR_NO_SUCH_VALUE: return ERROR_FILE_NOT_FOUND;
110  case CR_OUT_OF_MEMORY: return ERROR_NOT_ENOUGH_MEMORY;
111  case CR_REGISTRY_ERROR: return ERROR_GEN_FAILURE;
112  case CR_ALREADY_SUCH_DEVINST: return ERROR_DEVINST_ALREADY_EXISTS;
113  case CR_SUCCESS: return ERROR_SUCCESS;
114  default: return ERROR_GEN_FAILURE;
115  }
116 
117  /* Does not happen */
118 }
CR_NO_SUCH_REGISTRY_KEY
#define CR_NO_SUCH_REGISTRY_KEY
Definition: cfgmgr32.h:892
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
CR_INVALID_FLAG
#define CR_INVALID_FLAG
Definition: cfgmgr32.h:846
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
CR_NO_SUCH_VALUE
#define CR_NO_SUCH_VALUE
Definition: cfgmgr32.h:883
CR_ALREADY_SUCH_DEVINST
#define CR_ALREADY_SUCH_DEVINST
Definition: cfgmgr32.h:862
CR_ACCESS_DENIED
#define CR_ACCESS_DENIED
Definition: cfgmgr32.h:897
CR_INVALID_DEVICE_ID
#define CR_INVALID_DEVICE_ID
Definition: cfgmgr32.h:876
ERROR_INVALID_USER_BUFFER
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
CR_SUCCESS
#define CR_SUCCESS
Definition: cfgmgr32.h:842
ERROR_INVALID_COMPUTERNAME
#define ERROR_INVALID_COMPUTERNAME
Definition: winerror.h:713
CR_INVALID_PROPERTY
#define CR_INVALID_PROPERTY
Definition: cfgmgr32.h:899
CR_OUT_OF_MEMORY
#define CR_OUT_OF_MEMORY
Definition: cfgmgr32.h:844
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
CR_BUFFER_SMALL
#define CR_BUFFER_SMALL
Definition: cfgmgr32.h:872
CR_FAILURE
#define CR_FAILURE
Definition: cfgmgr32.h:865
CR_INVALID_DATA
#define CR_INVALID_DATA
Definition: cfgmgr32.h:877
CR_INVALID_DEVNODE
#define CR_INVALID_DEVNODE
Definition: cfgmgr32.h:847
CR_INVALID_MACHINENAME
#define CR_INVALID_MACHINENAME
Definition: cfgmgr32.h:893
CR_CALL_NOT_IMPLEMENTED
#define CR_CALL_NOT_IMPLEMENTED
Definition: cfgmgr32.h:898
ERROR_DEVINST_ALREADY_EXISTS
#define ERROR_DEVINST_ALREADY_EXISTS
Definition: setupapi.h:298
CR_NO_SUCH_DEVNODE
#define CR_NO_SUCH_DEVNODE
Definition: cfgmgr32.h:857
CR_INVALID_POINTER
#define CR_INVALID_POINTER
Definition: cfgmgr32.h:845
ERROR_CALL_NOT_IMPLEMENTED
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:92
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
ERROR_INVALID_FLAGS
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
CR_REGISTRY_ERROR
#define CR_REGISTRY_ERROR
Definition: cfgmgr32.h:875
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
static BOOL GetSectionCallback ( IN LPCWSTR  SectionName,
IN PVOID  Context 
)
static

Definition at line 363 of file devinst.c.

Referenced by SetupDiGetActualSectionToInstallExW().

366 {
367  struct GetSectionCallbackInfo *info = Context;
368  DWORD Score1, Score2, Score3, Score4, Score5;
369  BOOL ret;
370 
371  if (SectionName[info->PrefixLength] != '.')
372  return TRUE;
373 
374  ret = CheckSectionValid(
375  &SectionName[info->PrefixLength],
376  info->PlatformInfo,
377  info->ProductType,
378  info->SuiteMask,
379  &Score1, &Score2, &Score3, &Score4, &Score5);
380  if (!ret)
381  {
382  TRACE("Section %s not compatible\n", debugstr_w(SectionName));
383  return TRUE;
384  }
385  if (Score1 > info->BestScore1) goto done;
386  if (Score1 < info->BestScore1) goto bettersection;
387  if (Score2 > info->BestScore2) goto done;
388  if (Score2 < info->BestScore2) goto bettersection;
389  if (Score3 > info->BestScore3) goto done;
390  if (Score3 < info->BestScore3) goto bettersection;
391  if (Score4 > info->BestScore4) goto done;
392  if (Score4 < info->BestScore4) goto bettersection;
393  if (Score5 > info->BestScore5) goto done;
394  if (Score5 < info->BestScore5) goto bettersection;
395  goto done;
396 
397 bettersection:
398  strcpyW(info->BestSection, SectionName);
399  info->BestScore1 = Score1;
400  info->BestScore2 = Score2;
401  info->BestScore3 = Score3;
402  info->BestScore4 = Score4;
403  info->BestScore5 = Score5;
404 
405 done:
406  return TRUE;
407 }
TRUE
#define TRUE
Definition: types.h:120
info
Definition: compobj.c:613
DWORD
DWORD DWORD
Definition: winlogon.h:75
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
GetSectionCallbackInfo::BestSection
WCHAR BestSection[LINE_LEN+1]
Definition: devinst.c:73
Context
IN HDEVINFO IN PSP_DEVINFO_DATA DeviceInfoData IN OUT PCOINSTALLER_CONTEXT_DATA Context
Definition: devinst.c:53
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
CheckSectionValid
static BOOL CheckSectionValid(IN LPCWSTR SectionName, IN PSP_ALTPLATFORM_INFO PlatformInfo, IN BYTE ProductType, IN WORD SuiteMask, OUT PDWORD ScorePlatform, OUT PDWORD ScoreMajorVersion, OUT PDWORD ScoreMinorVersion, OUT PDWORD ScoreProductType, OUT PDWORD ScoreSuiteMask)
Definition: devinst.c:122
ret
int ret
Definition: wcstombs-tests.c:31
strcpyW
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
GetSectionCallbackInfo::PlatformInfo
PSP_ALTPLATFORM_INFO PlatformInfo
Definition: devinst.c:69
static BOOL InfIsFromOEMLocation ( IN PCWSTR  FullName,
OUT LPBOOL  IsOEMLocation 
)
static

Definition at line 5356 of file devinst.c.

Referenced by SetupDiInstallDevice().

5359 {
5360  PWCHAR last;
5361 
5362  last = strrchrW(FullName, '\\');
5363  if (!last)
5364  {
5365  /* No directory specified */
5366  *IsOEMLocation = FALSE;
5367  }
5368  else
5369  {
5370  LPWSTR Windir;
5371  UINT ret;
5372 
5373  Windir = MyMalloc((MAX_PATH + 1 + strlenW(InfDirectory)) * sizeof(WCHAR));
5374  if (!Windir)
5375  {
5376  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5377  return FALSE;
5378  }
5379 
5380  ret = GetSystemWindowsDirectoryW(Windir, MAX_PATH);
5381  if (ret == 0 || ret > MAX_PATH)
5382  {
5383  MyFree(Windir);
5384  SetLastError(ERROR_GEN_FAILURE);
5385  return FALSE;
5386  }
5387  if (*Windir && Windir[strlenW(Windir) - 1] != '\\')
5388  strcatW(Windir, BackSlash);
5389  strcatW(Windir, InfDirectory);
5390 
5391  if (strncmpiW(FullName, Windir, last - FullName) == 0)
5392  {
5393  /* The path is %SYSTEMROOT%\Inf */
5394  *IsOEMLocation = FALSE;
5395  }
5396  else
5397  {
5398  /* The file is in another place */
5399  *IsOEMLocation = TRUE;
5400  }
5401  MyFree(Windir);
5402  }
5403  return TRUE;
5404 }
GetSystemWindowsDirectoryW
UINT WINAPI GetSystemWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2397
TRUE
#define TRUE
Definition: types.h:120
strlenW
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
last
POINT last
Definition: font.c:45
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
PWCHAR
uint16_t * PWCHAR
Definition: typedefs.h:55
strncmpiW
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
FALSE
#define FALSE
Definition: types.h:117
InfDirectory
static const WCHAR InfDirectory[]
Definition: devinst.c:30
MAX_PATH
#define MAX_PATH
Definition: compat.h:26
FullName
_In_ PSTRING FullName
Definition: rtlfuncs.h:1649
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ret
int ret
Definition: wcstombs-tests.c:31
strrchrW
WINE_UNICODE_INLINE WCHAR * strrchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:254
strcatW
WINE_UNICODE_INLINE WCHAR * strcatW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:242
UINT
unsigned int UINT
Definition: ndis.h:50
BackSlash
static const WCHAR BackSlash[]
Definition: devinst.c:25
MyMalloc
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
static BOOL WINAPI IntSetupDiRegisterDeviceInfo ( IN HDEVINFO  DeviceInfoSet,
IN OUT PSP_DEVINFO_DATA  DeviceInfoData 
)
static

Definition at line 4096 of file devinst.c.

Referenced by SetupDiCallClassInstaller().

4099 {
4100  return SetupDiRegisterDeviceInfo(DeviceInfoSet, DeviceInfoData, 0, NULL, NULL, NULL);
4101 }
NULL
smooth NULL
Definition: ftsmooth.c:513
SetupDiRegisterDeviceInfo
BOOL WINAPI SetupDiRegisterDeviceInfo(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Flags, PSP_DETSIG_CMPPROC CompareProc, PVOID CompareContext, PSP_DEVINFO_DATA DupDeviceInfoData)
Definition: devinst.c:1849
DeviceInfoData
IN OUT PSP_DEVINFO_DATA DeviceInfoData
Definition: devinst.c:49
static BOOL IsDeviceInfoInDeviceInfoSet ( struct DeviceInfoSet *  deviceInfoSet,
struct DeviceInfo *  deviceInfo 
)
static

Definition at line 4773 of file devinst.c.

Referenced by SetupDiDeleteDeviceInfo().

4776 {
4777  PLIST_ENTRY ListEntry;
4778 
4779  ListEntry = deviceInfoSet->ListHead.Flink;
4780  while (ListEntry != &deviceInfoSet->ListHead)
4781  {
4782  if (deviceInfo == CONTAINING_RECORD(ListEntry, struct DeviceInfo, ListEntry))
4783  return TRUE;
4784 
4785  ListEntry = ListEntry->Flink;
4786  }
4787 
4788  return FALSE;
4789 }
TRUE
#define TRUE
Definition: types.h:120
DeviceInfoSet::ListHead
LIST_ENTRY ListHead
Definition: setupapi_private.h:208
FALSE
#define FALSE
Definition: types.h:117
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:120
_LIST_ENTRY
Definition: typedefs.h:118
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
static HKEY OpenHardwareProfileKey ( IN HKEY  HKLM,
IN DWORD  HwProfile,
IN DWORD  samDesired 
)
static

Definition at line 4718 of file devinst.c.

Referenced by SetupDiCreateDevRegKeyW(), SetupDiDeleteDevRegKey(), and SetupDiOpenDevRegKey().

4722 {
4723  HKEY hHWProfilesKey = NULL;
4724  HKEY hHWProfileKey = NULL;
4725  HKEY ret = INVALID_HANDLE_VALUE;
4726  LONG rc;
4727 
4728  rc = RegOpenKeyExW(HKLM,
4729  REGSTR_PATH_HWPROFILES,
4730  0,
4731  READ_CONTROL,
4732  &hHWProfilesKey);
4733  if (rc != ERROR_SUCCESS)
4734  {
4735  SetLastError(rc);
4736  goto cleanup;
4737  }
4738  if (HwProfile == 0)
4739  {
4740  rc = RegOpenKeyExW(hHWProfilesKey,
4741  REGSTR_KEY_CURRENT,
4742  0,
4743  KEY_CREATE_SUB_KEY,
4744  &hHWProfileKey);
4745  }
4746  else
4747  {
4748  WCHAR subKey[5];
4749  snprintfW(subKey, 4, InstanceKeyFormat, HwProfile);
4750  subKey[4] = '\0';
4751  rc = RegOpenKeyExW(hHWProfilesKey,
4752  subKey,
4753  0,
4754  KEY_CREATE_SUB_KEY,
4755  &hHWProfileKey);
4756  }
4757  if (rc != ERROR_SUCCESS)
4758  {
4759  SetLastError(rc);
4760  goto cleanup;
4761  }
4762  ret = hHWProfileKey;
4763 
4764 cleanup:
4765  if (hHWProfilesKey != NULL)
4766  RegCloseKey(hHWProfilesKey);
4767  if (hHWProfileKey != NULL && hHWProfileKey != ret)
4768  RegCloseKey(hHWProfileKey);
4769  return ret;
4770 }
snprintfW
#define snprintfW
Definition: unicode.h:60
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
InstanceKeyFormat
static const WCHAR InstanceKeyFormat[]
Definition: devinst.c:31
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
REGSTR_PATH_HWPROFILES
#define REGSTR_PATH_HWPROFILES
Definition: regstr.h:482
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
LONG
long LONG
Definition: pedump.c:60
NULL
smooth NULL
Definition: ftsmooth.c:513
HKLM
static const WCHAR HKLM[]
Definition: reginf.c:54
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
READ_CONTROL
#define READ_CONTROL
Definition: nt_native.h:58
ret
int ret
Definition: wcstombs-tests.c:31
REGSTR_KEY_CURRENT
#define REGSTR_KEY_CURRENT
Definition: regstr.h:493
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
KEY_CREATE_SUB_KEY
#define KEY_CREATE_SUB_KEY
Definition: nt_native.h:1018
static BOOL ResetDevice ( IN HDEVINFO  DeviceInfoSet,
IN PSP_DEVINFO_DATA  DeviceInfoData 
)
static

Definition at line 5103 of file devinst.c.

5106 {
5107 #ifndef __WINESRC__
5108  struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
5109  struct DeviceInfo *deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
5110  CONFIGRET cr;
5111 
5112  cr = CM_Enable_DevNode_Ex(deviceInfo->dnDevInst, 0, set->hMachine);
5113  if (cr != CR_SUCCESS)
5114  {
5115  SetLastError(GetErrorCodeFromCrCode(cr));
5116  return FALSE;
5117  }
5118 
5119  return TRUE;
5120 #else
5121  FIXME("Stub: ResetDevice(%p %p)\n", DeviceInfoSet, DeviceInfoData);
5122  return TRUE;
5123 #endif
5124 }
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
GetErrorCodeFromCrCode
static DWORD GetErrorCodeFromCrCode(const IN CONFIGRET cr)
Definition: devinst.c:92
FIXME
#define FIXME(fmt,...)
Definition: debug.h:110
CR_SUCCESS
#define CR_SUCCESS
Definition: cfgmgr32.h:842
CM_Enable_DevNode_Ex
CONFIGRET WINAPI CM_Enable_DevNode_Ex(DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
Definition: cfgmgr.c:1270
SetLastError
#define SetLastError(x)
Definition: compat.h:409
DeviceInfo::dnDevInst
DEVINST dnDevInst
Definition: setupapi_private.h:132
CONFIGRET
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
DeviceInfoData
IN OUT PSP_DEVINFO_DATA DeviceInfoData
Definition: devinst.c:49
set
Definition: _set.h:46
HKEY SETUP_CreateClassKey ( HINF  hInf)

Definition at line 3600 of file devinst.c.

Referenced by SetupDiInstallClassExW().

3601 {
3602  WCHAR FullBuffer[MAX_PATH];
3603  WCHAR Buffer[MAX_PATH];
3604  DWORD RequiredSize;
3605  HKEY hClassKey;
3606  DWORD Disposition;
3607 
3608  /* Obtain the Class GUID for this class */
3609  if (!SetupGetLineTextW(NULL,
3610  hInf,
3611  Version,
3612  REGSTR_VAL_CLASSGUID,
3613  Buffer,
3614  sizeof(Buffer) / sizeof(WCHAR),
3615  &RequiredSize))
3616  {
3617  return INVALID_HANDLE_VALUE;
3618  }
3619 
3620  /* Build the corresponding registry key name */
3621  lstrcpyW(FullBuffer, REGSTR_PATH_CLASS_NT);
3622  lstrcatW(FullBuffer, BackSlash);
3623  lstrcatW(FullBuffer, Buffer);
3624 
3625  /* Obtain the Class name for this class */
3626  if (!SetupGetLineTextW(NULL,
3627  hInf,
3628  Version,
3629  REGSTR_VAL_CLASS,
3630  Buffer,
3631  sizeof(Buffer) / sizeof(WCHAR),
3632  &RequiredSize))
3633  {
3634  return INVALID_HANDLE_VALUE;
3635  }
3636 
3637  /* Try to open or create the registry key */
3638  TRACE("Opening class key %s\n", debugstr_w(FullBuffer));
3639 #if 0 // I keep this for reference...
3640  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3641  FullBuffer,
3642  0,
3643  KEY_SET_VALUE,
3644  &hClassKey))
3645  {
3646  /* Use RegCreateKeyExW */
3647  }
3648 #endif
3649  if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
3650  FullBuffer,
3651  0,
3652  NULL,
3653  REG_OPTION_NON_VOLATILE,
3654  KEY_SET_VALUE,
3655  NULL,
3656  &hClassKey,
3657  &Disposition))
3658  {
3659  ERR("RegCreateKeyExW(%s) failed\n", debugstr_w(FullBuffer));
3660  return INVALID_HANDLE_VALUE;
3661  }
3662  if (Disposition == REG_CREATED_NEW_KEY)
3663  TRACE("The class key %s was successfully created\n", debugstr_w(FullBuffer));
3664  else
3665  TRACE("The class key %s was successfully opened\n", debugstr_w(FullBuffer));
3666 
3667  TRACE( "setting value %s to %s\n", debugstr_w(REGSTR_VAL_CLASS), debugstr_w(Buffer) );
3668  if (RegSetValueExW(hClassKey,
3669  REGSTR_VAL_CLASS,
3670  0,
3671  REG_SZ,
3672  (LPBYTE)Buffer,
3673  RequiredSize * sizeof(WCHAR)))
3674  {
3675  RegCloseKey(hClassKey);
3676  RegDeleteKeyW(HKEY_LOCAL_MACHINE,
3677  FullBuffer);
3678  return INVALID_HANDLE_VALUE;
3679  }
3680 
3681  return hClassKey;
3682 }
REGSTR_VAL_CLASS
#define REGSTR_VAL_CLASS
Definition: regstr.h:291
KEY_SET_VALUE
#define KEY_SET_VALUE
Definition: nt_native.h:1017
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
RegDeleteKeyW
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1240
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
Version
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:359
DWORD
DWORD DWORD
Definition: winlogon.h:75
Disposition
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:50
RegCreateKeyExW
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1094
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
NULL
smooth NULL
Definition: ftsmooth.c:513
Buffer
Definition: bufpool.h:45
REG_CREATED_NEW_KEY
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
REG_OPTION_NON_VOLATILE
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
RegSetValueExW
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4917
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
HKEY
HANDLE HKEY
Definition: registry.h:24
MAX_PATH
#define MAX_PATH
Definition: compat.h:26
REGSTR_VAL_CLASSGUID
#define REGSTR_VAL_CLASSGUID
Definition: regstr.h:422
ERR
#define ERR(fmt,...)
Definition: debug.h:109
lstrcpyW
#define lstrcpyW
Definition: compat.h:406
BackSlash
static const WCHAR BackSlash[]
Definition: devinst.c:25
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
lstrcatW
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
hClassKey
static HKEY hClassKey
Definition: umpnpmgr.c:66
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
REGSTR_PATH_CLASS_NT
#define REGSTR_PATH_CLASS_NT
Definition: regstr.h:479
SetupGetLineTextW
BOOL WINAPI SetupGetLineTextW(PINFCONTEXT context, HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required)
Definition: parser.c:1756
REG_SZ
#define REG_SZ
Definition: layer.c:22
static DWORD SETUPAPI_GetCurrentHwProfile ( IN HDEVINFO  DeviceInfoSet)
static

Definition at line 5056 of file devinst.c.

Referenced by SetupDiChangeState().

5058 {
5059  HKEY hKey = NULL;
5060  DWORD dwRegType, dwLength;
5061  DWORD hwProfile;
5062  LONG rc;
5063  DWORD ret = (DWORD)-1;
5064 
5065  rc = RegOpenKeyExW(((struct DeviceInfoSet *)DeviceInfoSet)->HKLM,
5066  REGSTR_PATH_IDCONFIGDB,
5067  0, /* Options */
5068  KEY_QUERY_VALUE,
5069  &hKey);
5070  if (rc != ERROR_SUCCESS)
5071  {
5072  SetLastError(rc);
5073  goto cleanup;
5074  }
5075 
5076  dwLength = sizeof(DWORD);
5077  rc = RegQueryValueExW(hKey,
5078  REGSTR_VAL_CURRENTCONFIG,
5079  NULL,
5080  &dwRegType,
5081  (LPBYTE)&hwProfile, &dwLength);
5082  if (rc != ERROR_SUCCESS)
5083  {
5084  SetLastError(rc);
5085  goto cleanup;
5086  }
5087  else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
5088  {
5089  SetLastError(ERROR_GEN_FAILURE);
5090  goto cleanup;
5091  }
5092 
5093  ret = hwProfile;
5094 
5095 cleanup:
5096  if (hKey != NULL)
5097  RegCloseKey(hKey);
5098 
5099  return ret;
5100 }
DWORD
static const GUID DWORD
Definition: devinst.c:39
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
DWORD
DWORD DWORD
Definition: winlogon.h:75
REGSTR_VAL_CURRENTCONFIG
#define REGSTR_VAL_CURRENTCONFIG
Definition: regstr.h:466
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
LONG
long LONG
Definition: pedump.c:60
NULL
smooth NULL
Definition: ftsmooth.c:513
HKLM
static const WCHAR HKLM[]
Definition: reginf.c:54
REGSTR_PATH_IDCONFIGDB
#define REGSTR_PATH_IDCONFIGDB
Definition: regstr.h:41
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ret
int ret
Definition: wcstombs-tests.c:31
REG_DWORD
#define REG_DWORD
Definition: nt_native.h:1497
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
static BOOL SETUPDI_DeleteDevKey ( HKEY  RootKey,
struct DeviceInfo *  devInfo 
)
static

Definition at line 5869 of file devinst.c.

Referenced by SetupDiDeleteDevRegKey().

5870 {
5871  FIXME("\n");
5872  return FALSE;
5873 }
FALSE
#define FALSE
Definition: types.h:117
FIXME
#define FIXME(fmt,...)
Definition: debug.h:110
static BOOL SETUPDI_DeleteDrvKey ( HKEY  RootKey,
struct DeviceInfo *  devInfo 
)
static

Definition at line 5875 of file devinst.c.

Referenced by SetupDiDeleteDevRegKey().

5876 {
5877  FIXME("\n");
5878  return FALSE;
5879 }
FALSE
#define FALSE
Definition: types.h:117
FIXME
#define FIXME(fmt,...)
Definition: debug.h:110
static void SETUPDI_GuidToString ( const GUID *  guid,
LPWSTR  guidStr 
)
static

Definition at line 79 of file devinst.c.

Referenced by SetupDiCreateDeviceInterfaceRegKeyW(), and SetupDiOpenClassRegKeyExW().

80 {
81  static const WCHAR fmt[] = {'{','%','0','8','X','-','%','0','4','X','-',
82  '%','0','4','X','-','%','0','2','X','%','0','2','X','-','%','0','2',
83  'X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%',
84  '0','2','X','}',0};
85 
86  sprintfW(guidStr, fmt, guid->Data1, guid->Data2, guid->Data3,
87  guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
88  guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
89 }
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
guidStr
static WCHAR guidStr[]
Definition: asn.c:531
sprintfW
#define sprintfW
Definition: unicode.h:58
fmt
Definition: dsound.c:958
static HKEY SETUPDI_OpenDevKey ( HKEY  RootKey,
struct DeviceInfo *  devInfo,
REGSAM  samDesired 
)
static

Definition at line 5704 of file devinst.c.

Referenced by SETUPDI_OpenDrvKey(), and SetupDiOpenDevRegKey().

5705 {
5706  HKEY enumKey, key = INVALID_HANDLE_VALUE;
5707  LONG l;
5708 
5709  l = RegOpenKeyExW(RootKey, REGSTR_PATH_SYSTEMENUM, 0, READ_CONTROL, &enumKey);
5710  if (!l)
5711  {
5712  l = RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
5713  RegCloseKey(enumKey);
5714  }
5715  if (l)
5716  SetLastError(l);
5717  return key;
5718 }
RootKey
static PMEMKEY RootKey
Definition: registry.c:40
REGSTR_PATH_SYSTEMENUM
#define REGSTR_PATH_SYSTEMENUM
Definition: regstr.h:483
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
LONG
long LONG
Definition: pedump.c:60
l
r l[0]
Definition: byte_order.h:167
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
READ_CONTROL
#define READ_CONTROL
Definition: nt_native.h:58
key
HKEY key
Definition: reg.c:48
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
key
Definition: path.c:42
static HKEY SETUPDI_OpenDrvKey ( HKEY  RootKey,
struct DeviceInfo *  devInfo,
REGSAM  samDesired 
)
static

Definition at line 5720 of file devinst.c.

Referenced by SetupDiOpenDevRegKey().

5721 {
5722  LPWSTR DriverKey = NULL;
5723  DWORD dwLength = 0;
5724  DWORD dwRegType;
5725  DWORD rc;
5726  HKEY hEnumKey = NULL;
5727  HKEY hKey = NULL;
5728  HKEY key = INVALID_HANDLE_VALUE;
5729 
5730  hKey = SETUPDI_OpenDevKey(RootKey, devInfo, KEY_QUERY_VALUE);
5731  if (hKey == INVALID_HANDLE_VALUE)
5732  goto cleanup;
5733  /* Read the 'Driver' key */
5734  rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, NULL, &dwLength);
5735  if (rc != ERROR_SUCCESS)
5736  {
5737  SetLastError(rc);
5738  goto cleanup;
5739  }
5740  else if (dwRegType != REG_SZ)
5741  {
5742  SetLastError(ERROR_GEN_FAILURE);
5743  goto cleanup;
5744  }
5745  DriverKey = HeapAlloc(GetProcessHeap(), 0, dwLength);
5746  if (!DriverKey)
5747  {
5748  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5749  goto cleanup;
5750  }
5751  rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, (LPBYTE)DriverKey, &dwLength);
5752  if (rc != ERROR_SUCCESS)
5753  {
5754  SetLastError(rc);
5755  goto cleanup;
5756  }
5757  RegCloseKey(hKey);
5758  hKey = NULL;
5759  /* Need to open the driver key */
5760  rc = RegOpenKeyExW(
5761  RootKey,
5762  REGSTR_PATH_CLASS_NT,
5763  0, /* Options */
5764  READ_CONTROL,
5765  &hEnumKey);
5766  if (rc != ERROR_SUCCESS)
5767  {
5768  SetLastError(rc);
5769  goto cleanup;
5770  }
5771  rc = RegOpenKeyExW(
5772  hEnumKey,
5773  DriverKey,
5774  0, /* Options */
5775  samDesired,
5776  &hKey);
5777  if (rc != ERROR_SUCCESS)
5778  {
5779  SetLastError(rc);
5780  goto cleanup;
5781  }
5782  key = hKey;
5783 
5784 cleanup:
5785  if (hEnumKey != NULL)
5786  RegCloseKey(hEnumKey);
5787  if (hKey != NULL && hKey != key)
5788  RegCloseKey(hKey);
5789  if (DriverKey)
5790  HeapFree(GetProcessHeap(), 0, DriverKey);
5791  return key;
5792 }
REGSTR_VAL_DRIVER
#define REGSTR_VAL_DRIVER
Definition: regstr.h:385
RootKey
static PMEMKEY RootKey
Definition: registry.c:40
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
SETUPDI_OpenDevKey
static HKEY SETUPDI_OpenDevKey(HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)
Definition: devinst.c:5704
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD
DWORD DWORD
Definition: winlogon.h:75
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
hEnumKey
static HKEY hEnumKey
Definition: umpnpmgr.c:65
NULL
smooth NULL
Definition: ftsmooth.c:513
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
READ_CONTROL
#define READ_CONTROL
Definition: nt_native.h:58
key
HKEY key
Definition: reg.c:48
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
key
Definition: path.c:42
REGSTR_PATH_CLASS_NT
#define REGSTR_PATH_CLASS_NT
Definition: regstr.h:479
REG_SZ
#define REG_SZ
Definition: layer.c:22
BOOL WINAPI SetupDiBuildClassInfoList ( DWORD  Flags,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize 
)

Definition at line 643 of file devinst.c.

Referenced by test_SetupDiBuildClassInfoList().

648 {
649  TRACE("\n");
650  return SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
651  ClassGuidListSize, RequiredSize,
652  NULL, NULL);
653 }
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
SetupDiBuildClassInfoListExW
BOOL WINAPI SetupDiBuildClassInfoListExW(DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:720
BOOL WINAPI SetupDiBuildClassInfoListExA ( DWORD  Flags,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize,
LPCSTR  MachineName,
PVOID  Reserved 
)

Definition at line 673 of file devinst.c.

680 {
681  LPWSTR MachineNameW = NULL;
682  BOOL bResult;
683 
684  TRACE("0x%lx %p %lu %p %s %p\n", Flags, ClassGuidList,
685  ClassGuidListSize, RequiredSize, debugstr_a(MachineName), Reserved);
686 
687  if (MachineName)
688  {
689  MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
690  if (MachineNameW == NULL) return FALSE;
691  }
692 
693  bResult = SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
694  ClassGuidListSize, RequiredSize,
695  MachineNameW, Reserved);
696 
697  MyFree(MachineNameW);
698 
699  return bResult;
700 }
CP_ACP
#define CP_ACP
Definition: compat.h:99
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
FALSE
#define FALSE
Definition: types.h:117
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
SetupDiBuildClassInfoListExW
BOOL WINAPI SetupDiBuildClassInfoListExW(DWORD Flags, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:720
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
BOOL WINAPI SetupDiBuildClassInfoListExW ( DWORD  Flags,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize,
LPCWSTR  MachineName,
PVOID  Reserved 
)

Definition at line 720 of file devinst.c.

Referenced by SetupDiBuildClassInfoList(), SetupDiBuildClassInfoListExA(), and SetupDiGetClassImageListExW().

727 {
728  WCHAR szKeyName[40];
729  HKEY hClassesKey = INVALID_HANDLE_VALUE;
730  HKEY hClassKey;
731  DWORD dwLength;
732  DWORD dwIndex;
733  LONG lError;
734  DWORD dwGuidListIndex = 0;
735 
736  TRACE("0x%lx %p %lu %p %s %p\n", Flags, ClassGuidList,
737  ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
738 
739  if (!RequiredSize)
740  {
741  SetLastError(ERROR_INVALID_PARAMETER);
742  return FALSE;
743  }
744  else if (!ClassGuidList && ClassGuidListSize > 0)
745  {
746  SetLastError(ERROR_INVALID_PARAMETER);
747  return FALSE;
748  }
749 
750  hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
751  KEY_ENUMERATE_SUB_KEYS,
752  DIOCR_INSTALLER,
753  MachineName,
754  Reserved);
755  if (hClassesKey == INVALID_HANDLE_VALUE)
756  {
757  return FALSE;
758  }
759 
760  for (dwIndex = 0; ; dwIndex++)
761  {
762  dwLength = 40;
763  lError = RegEnumKeyExW(hClassesKey,
764  dwIndex,
765  szKeyName,
766  &dwLength,
767  NULL,
768  NULL,
769  NULL,
770  NULL);
771  TRACE("RegEnumKeyExW() returns %d\n", lError);
772  if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
773  {
774  TRACE("Key name: %s\n", debugstr_w(szKeyName));
775 
776  if (RegOpenKeyExW(hClassesKey,
777  szKeyName,
778  0,
779  KEY_QUERY_VALUE,
780  &hClassKey))
781  {
782  RegCloseKey(hClassesKey);
783  return FALSE;
784  }
785 
786  if (!RegQueryValueExW(hClassKey,
787  REGSTR_VAL_NOUSECLASS,
788  NULL,
789  NULL,
790  NULL,
791  NULL))
792  {
793  TRACE("'NoUseClass' value found!\n");
794  RegCloseKey(hClassKey);
795  continue;
796  }
797 
798  if ((Flags & DIBCI_NOINSTALLCLASS) &&
799  (!RegQueryValueExW(hClassKey,
800  REGSTR_VAL_NOINSTALLCLASS,
801  NULL,
802  NULL,
803  NULL,
804  NULL)))
805  {
806  TRACE("'NoInstallClass' value found!\n");
807  RegCloseKey(hClassKey);
808  continue;
809  }
810 
811  if ((Flags & DIBCI_NODISPLAYCLASS) &&
812  (!RegQueryValueExW(hClassKey,
813  REGSTR_VAL_NODISPLAYCLASS,
814  NULL,
815  NULL,
816  NULL,
817  NULL)))
818  {
819  TRACE("'NoDisplayClass' value found!\n");
820  RegCloseKey(hClassKey);
821  continue;
822  }
823 
824  RegCloseKey(hClassKey);
825 
826  TRACE("Guid: %s\n", debugstr_w(szKeyName));
827  if (dwGuidListIndex < ClassGuidListSize)
828  {
829  if (szKeyName[0] == '{' && szKeyName[37] == '}')
830  {
831  szKeyName[37] = 0;
832  }
833  TRACE("Guid: %p\n", &szKeyName[1]);
834 
835  UuidFromStringW(&szKeyName[1],
836  &ClassGuidList[dwGuidListIndex]);
837  }
838 
839  dwGuidListIndex++;
840  }
841 
842  if (lError != ERROR_SUCCESS)
843  break;
844  }
845 
846  RegCloseKey(hClassesKey);
847 
848  if (RequiredSize != NULL)
849  *RequiredSize = dwGuidListIndex;
850 
851  if (ClassGuidListSize < dwGuidListIndex)
852  {
853  SetLastError(ERROR_INSUFFICIENT_BUFFER);
854  return FALSE;
855  }
856 
857  return TRUE;
858 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
REGSTR_VAL_NOUSECLASS
#define REGSTR_VAL_NOUSECLASS
Definition: regstr.h:238
TRUE
#define TRUE
Definition: types.h:120
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
DWORD
DWORD DWORD
Definition: winlogon.h:75
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
FALSE
#define FALSE
Definition: types.h:117
UuidFromStringW
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:590
LONG
long LONG
Definition: pedump.c:60
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
DIOCR_INSTALLER
#define DIOCR_INSTALLER
Definition: setupapi.h:176
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
DIBCI_NODISPLAYCLASS
#define DIBCI_NODISPLAYCLASS
Definition: setupapi.h:109
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
DIBCI_NOINSTALLCLASS
#define DIBCI_NOINSTALLCLASS
Definition: setupapi.h:108
REGSTR_VAL_NOINSTALLCLASS
#define REGSTR_VAL_NOINSTALLCLASS
Definition: regstr.h:239
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
REGSTR_VAL_NODISPLAYCLASS
#define REGSTR_VAL_NODISPLAYCLASS
Definition: regstr.h:240
SetupDiOpenClassRegKeyExW
HKEY WINAPI SetupDiOpenClassRegKeyExW(const GUID *ClassGuid, REGSAM samDesired, DWORD Flags, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:3744
RegEnumKeyExW
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2541
hClassKey
static HKEY hClassKey
Definition: umpnpmgr.c:66
KEY_ENUMERATE_SUB_KEYS
#define KEY_ENUMERATE_SUB_KEYS
Definition: nt_native.h:1019
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
BOOL WINAPI SetupDiCallClassInstaller ( DI_FUNCTION  InstallFunction,
HDEVINFO  DeviceInfoSet,
PSP_DEVINFO_DATA  DeviceInfoData 
)

Definition at line 4106 of file devinst.c.

Referenced by DisableNetworkAdapter(), CDeviceNode::EnableDevice(), EnableDevice(), EnumerateDrivers(), InstallCurrentDriver(), InstallSoftwareBusPnpEnumerator(), StartDevice(), CDeviceNode::UninstallDevice(), UpdateDevInfo(), and UpdateDriverDetailsDlg().

4110 {
4111  BOOL ret = FALSE;
4112 
4113  TRACE("%u %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
4114 
4115  if (!DeviceInfoSet)
4116  SetLastError(ERROR_INVALID_PARAMETER);
4117  else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
4118  SetLastError(ERROR_INVALID_HANDLE);
4119  else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
4120  SetLastError(ERROR_INVALID_HANDLE);
4121  else if (((struct DeviceInfoSet *)DeviceInfoSet)->HKLM != HKEY_LOCAL_MACHINE)
4122  SetLastError(ERROR_INVALID_HANDLE);
4123  else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4124  SetLastError(ERROR_INVALID_USER_BUFFER);
4125  else
4126  {
4127  SP_DEVINSTALL_PARAMS_W InstallParams;
4128 #define CLASS_COINSTALLER 0x1
4129 #define DEVICE_COINSTALLER 0x2
4130 #define CLASS_INSTALLER 0x4
4131  UCHAR CanHandle = 0;
4132  DEFAULT_CLASS_INSTALL_PROC DefaultHandler = NULL;
4133 
4134  switch (InstallFunction)
4135  {
4136  case DIF_ADDPROPERTYPAGE_ADVANCED:
4137  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4138  break;
4139  case DIF_ADDREMOTEPROPERTYPAGE_ADVANCED:
4140  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4141  break;
4142  case DIF_ALLOW_INSTALL:
4143  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4144  break;
4145  case DIF_DETECT:
4146  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4147  break;
4148  case DIF_DESTROYPRIVATEDATA:
4149  CanHandle = CLASS_INSTALLER;
4150  break;
4151  case DIF_INSTALLDEVICE:
4152  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4153  DefaultHandler = SetupDiInstallDevice;
4154  break;
4155  case DIF_INSTALLDEVICEFILES:
4156  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4157  DefaultHandler = SetupDiInstallDriverFiles;
4158  break;
4159  case DIF_INSTALLINTERFACES:
4160  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4161  DefaultHandler = SetupDiInstallDeviceInterfaces;
4162  break;
4163  case DIF_NEWDEVICEWIZARD_FINISHINSTALL:
4164  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4165  break;
4166  case DIF_NEWDEVICEWIZARD_POSTANALYZE:
4167  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4168  break;
4169  case DIF_NEWDEVICEWIZARD_PREANALYZE:
4170  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4171  break;
4172  case DIF_NEWDEVICEWIZARD_PRESELECT:
4173  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4174  break;
4175  case DIF_NEWDEVICEWIZARD_SELECT:
4176  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4177  break;
4178  case DIF_POWERMESSAGEWAKE:
4179  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4180  break;
4181  case DIF_PROPERTYCHANGE:
4182  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4183  DefaultHandler = SetupDiChangeState;
4184  break;
4185  case DIF_REGISTER_COINSTALLERS:
4186  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4187  DefaultHandler = SetupDiRegisterCoDeviceInstallers;
4188  break;
4189  case DIF_REGISTERDEVICE:
4190  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4191  DefaultHandler = IntSetupDiRegisterDeviceInfo;
4192  break;
4193  case DIF_REMOVE:
4194  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4195  DefaultHandler = SetupDiRemoveDevice;
4196  break;
4197  case DIF_SELECTBESTCOMPATDRV:
4198  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4199  DefaultHandler = SetupDiSelectBestCompatDrv;
4200  break;
4201  case DIF_SELECTDEVICE:
4202  CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
4203  DefaultHandler = SetupDiSelectDevice;
4204  break;
4205  case DIF_TROUBLESHOOTER:
4206  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4207  break;
4208  case DIF_UNREMOVE:
4209  CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
4210  DefaultHandler = SetupDiUnremoveDevice;
4211  break;
4212  default:
4213  ERR("Install function %u not supported\n", InstallFunction);
4214  SetLastError(ERROR_NOT_SUPPORTED);
4215  }
4216 
4217  InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
4218  if (!SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams))
4219  /* Don't process this call, as a parameter is invalid */
4220  CanHandle = 0;
4221 
4222  if (CanHandle != 0)
4223  {
4224  LIST_ENTRY ClassCoInstallersListHead;
4225  LIST_ENTRY DeviceCoInstallersListHead;
4226  HMODULE ClassInstallerLibrary = NULL;
4227  CLASS_INSTALL_PROC ClassInstaller = NULL;
4228  COINSTALLER_CONTEXT_DATA Context;
4229  PLIST_ENTRY ListEntry;
4230  HKEY hKey;
4231  DWORD dwRegType, dwLength;
4232  DWORD rc = NO_ERROR;
4233 
4234  InitializeListHead(&ClassCoInstallersListHead);
4235  InitializeListHead(&DeviceCoInstallersListHead);
4236 
4237  if (CanHandle & DEVICE_COINSTALLER)
4238  {
4239  hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_QUERY_VALUE);
4240  if (hKey != INVALID_HANDLE_VALUE)
4241  {
4242  rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, &dwRegType, NULL, &dwLength);
4243  if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
4244  {
4245  LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
4246  if (KeyBuffer != NULL)
4247  {
4248  rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
4249  if (rc == ERROR_SUCCESS)
4250  {
4251  LPWSTR ptr;
4252  for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
4253  {
4254  /* Add coinstaller to DeviceCoInstallersListHead list */
4255  struct CoInstallerElement *coinstaller;
4256  TRACE("Got device coinstaller '%s'\n", debugstr_w(ptr));
4257  coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
4258  if (!coinstaller)
4259  continue;
4260  ZeroMemory(coinstaller, sizeof(struct CoInstallerElement));
4261  if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
4262  InsertTailList(&DeviceCoInstallersListHead, &coinstaller->ListEntry);
4263  else
4264  HeapFree(GetProcessHeap(), 0, coinstaller);
4265  }
4266  }
4267  HeapFree(GetProcessHeap(), 0, KeyBuffer);
4268  }
4269  }
4270  RegCloseKey(hKey);
4271  }
4272  }
4273  if (CanHandle & CLASS_COINSTALLER)
4274  {
4275  rc = RegOpenKeyExW(
4276  HKEY_LOCAL_MACHINE,
4277  REGSTR_PATH_CODEVICEINSTALLERS,
4278  0, /* Options */
4279  KEY_QUERY_VALUE,
4280  &hKey);
4281  if (rc == ERROR_SUCCESS)
4282  {
4283  LPWSTR lpGuidString;
4284  if (UuidToStringW((UUID*)&DeviceInfoData->ClassGuid, &lpGuidString) == RPC_S_OK)
4285  {
4286  rc = RegQueryValueExW(hKey, lpGuidString, NULL, &dwRegType, NULL, &dwLength);
4287  if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
4288  {
4289  LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
4290  if (KeyBuffer != NULL)
4291  {
4292  rc = RegQueryValueExW(hKey, lpGuidString, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
4293  if (rc == ERROR_SUCCESS)
4294  {
4295  LPWSTR ptr;
4296  for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
4297  {
4298  /* Add coinstaller to ClassCoInstallersListHead list */
4299  struct CoInstallerElement *coinstaller;
4300  TRACE("Got class coinstaller '%s'\n", debugstr_w(ptr));
4301  coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
4302  if (!coinstaller)
4303  continue;
4304  ZeroMemory(coinstaller, sizeof(struct CoInstallerElement));
4305  if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
4306  InsertTailList(&ClassCoInstallersListHead, &coinstaller->ListEntry);
4307  else
4308  HeapFree(GetProcessHeap(), 0, coinstaller);
4309  }
4310  }
4311  HeapFree(GetProcessHeap(), 0, KeyBuffer);
4312  }
4313  }
4314  RpcStringFreeW(&lpGuidString);
4315  }
4316  RegCloseKey(hKey);
4317  }
4318  }
4319  if ((CanHandle & CLASS_INSTALLER) && !(InstallParams.FlagsEx & DI_FLAGSEX_CI_FAILED))
4320  {
4321  hKey = SetupDiOpenClassRegKey(&DeviceInfoData->ClassGuid, KEY_QUERY_VALUE);
4322  if (hKey != INVALID_HANDLE_VALUE)
4323  {
4324  rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, &dwRegType, NULL, &dwLength);
4325  if (rc == ERROR_SUCCESS && dwRegType == REG_SZ)
4326  {
4327  LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
4328  if (KeyBuffer != NULL)
4329  {
4330  rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
4331  if (rc == ERROR_SUCCESS)
4332  {
4333  /* Get ClassInstaller function pointer */
4334  TRACE("Got class installer '%s'\n", debugstr_w(KeyBuffer));
4335  if (GetFunctionPointer(KeyBuffer, &ClassInstallerLibrary, (PVOID*)&ClassInstaller) != ERROR_SUCCESS)
4336  {
4337  InstallParams.FlagsEx |= DI_FLAGSEX_CI_FAILED;
4338  SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
4339  }
4340  }
4341  HeapFree(GetProcessHeap(), 0, KeyBuffer);
4342  }
4343  }
4344  RegCloseKey(hKey);
4345  }
4346  }
4347 
4348  /* Call Class co-installers */
4349  Context.PostProcessing = FALSE;
4350  rc = NO_ERROR;
4351  ListEntry = ClassCoInstallersListHead.Flink;
4352  while (rc == NO_ERROR && ListEntry != &ClassCoInstallersListHead)
4353  {
4354  struct CoInstallerElement *coinstaller;
4355  coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
4356  rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
4357  coinstaller->PrivateData = Context.PrivateData;
4358  if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
4359  {
4360  coinstaller->DoPostProcessing = TRUE;
4361  rc = NO_ERROR;
4362  }
4363  ListEntry = ListEntry->Flink;
4364  }
4365 
4366  /* Call Device co-installers */
4367  ListEntry = DeviceCoInstallersListHead.Flink;
4368  while (rc == NO_ERROR && ListEntry != &DeviceCoInstallersListHead)
4369  {
4370  struct CoInstallerElement *coinstaller;
4371  coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
4372  rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
4373  coinstaller->PrivateData = Context.PrivateData;
4374  if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
4375  {
4376  coinstaller->DoPostProcessing = TRUE;
4377  rc = NO_ERROR;
4378  }
4379  ListEntry = ListEntry->Flink;
4380  }
4381 
4382  /* Call Class installer */
4383  if (ClassInstaller)
4384  {
4385  rc = (*ClassInstaller)(InstallFunction, DeviceInfoSet, DeviceInfoData);
4386  FreeFunctionPointer(ClassInstallerLibrary, ClassInstaller);
4387  }
4388  else
4389  rc = ERROR_DI_DO_DEFAULT;
4390 
4391  /* Call default handler */
4392  if (rc == ERROR_DI_DO_DEFAULT)
4393  {
4394  if (DefaultHandler && !(InstallParams.Flags & DI_NODI_DEFAULTACTION))
4395  {
4396  if ((*DefaultHandler)(DeviceInfoSet, DeviceInfoData))
4397  rc = NO_ERROR;
4398  else
4399  rc = GetLastError();
4400  }
4401  else
4402  rc = NO_ERROR;
4403  }
4404 
4405  /* Call Class co-installers that required postprocessing */
4406  Context.PostProcessing = TRUE;
4407  ListEntry = ClassCoInstallersListHead.Flink;
4408  while (ListEntry != &ClassCoInstallersListHead)
4409  {
4410  struct CoInstallerElement *coinstaller;
4411  coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
4412  if (coinstaller->DoPostProcessing)
4413  {
4414  Context.InstallResult = rc;
4415  Context.PrivateData = coinstaller->PrivateData;
4416  rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
4417  }
4418  FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
4419  ListEntry = ListEntry->Flink;
4420  }
4421 
4422  /* Call Device co-installers that required postprocessing */
4423  ListEntry = DeviceCoInstallersListHead.Flink;
4424  while (ListEntry != &DeviceCoInstallersListHead)
4425  {
4426  struct CoInstallerElement *coinstaller;
4427  coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
4428  if (coinstaller->DoPostProcessing)
4429  {
4430  Context.InstallResult = rc;
4431  Context.PrivateData = coinstaller->PrivateData;
4432  rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
4433  }
4434  FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
4435  ListEntry = ListEntry->Flink;
4436  }
4437 
4438  /* Free allocated memory */
4439  while (!IsListEmpty(&ClassCoInstallersListHead))
4440  {
4441  ListEntry = RemoveHeadList(&ClassCoInstallersListHead);
4442  HeapFree(GetProcessHeap(), 0, CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry));
4443  }
4444  while (!IsListEmpty(&DeviceCoInstallersListHead))
4445  {
4446  ListEntry = RemoveHeadList(&DeviceCoInstallersListHead);
4447  HeapFree(GetProcessHeap(), 0, CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry));
4448  }
4449 
4450  ret = (rc == NO_ERROR);
4451  }
4452  }
4453 
4454  TRACE("Returning %d\n", ret);
4455  return ret;
4456 }
PVOID
DWORD *typedef PVOID
Definition: winlogon.h:52
DIF_SELECTDEVICE
#define DIF_SELECTDEVICE
Definition: setupapi.h:120
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
SetupDiSelectBestCompatDrv
BOOL WINAPI SetupDiSelectBestCompatDrv(IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
Definition: driver.c:2063
TRUE
#define TRUE
Definition: types.h:120
strlenW
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
RpcStringFreeW
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:152
SetupDiSetDeviceInstallParamsW
BOOL WINAPI SetupDiSetDeviceInstallParamsW(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, IN PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
Definition: devinst.c:4641
DIF_ADDREMOTEPROPERTYPAGE_ADVANCED
#define DIF_ADDREMOTEPROPERTYPAGE_ADVANCED
Definition: setupapi.h:159
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
magic
u32_t magic(void)
CoInstallerElement::Module
HMODULE Module
Definition: devinst.c:61
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
GetLastError
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1056
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1621
SetupDiUnremoveDevice
BOOL WINAPI SetupDiUnremoveDevice(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: stubs.c:78
REGSTR_PATH_CODEVICEINSTALLERS
#define REGSTR_PATH_CODEVICEINSTALLERS
Definition: regstr.h:480
DIF_NEWDEVICEWIZARD_PREANALYZE
#define DIF_NEWDEVICEWIZARD_PREANALYZE
Definition: setupapi.h:147
CoInstallerElement::ListEntry
LIST_ENTRY ListEntry
Definition: devinst.c:59
DeviceInfo::InstallParams
SP_DEVINSTALL_PARAMS_W InstallParams
Definition: setupapi_private.h:139
DIF_PROPERTYCHANGE
#define DIF_PROPERTYCHANGE
Definition: setupapi.h:137
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
NO_ERROR
#define NO_ERROR
Definition: dderror.h:5
DIF_UNREMOVE
#define DIF_UNREMOVE
Definition: setupapi.h:141
DIF_NEWDEVICEWIZARD_POSTANALYZE
#define DIF_NEWDEVICEWIZARD_POSTANALYZE
Definition: setupapi.h:148
DIF_DESTROYPRIVATEDATA
#define DIF_DESTROYPRIVATEDATA
Definition: setupapi.h:131
IsListEmpty
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
SETUP_DEVICE_INFO_SET_MAGIC
#define SETUP_DEVICE_INFO_SET_MAGIC
Definition: setupapi_private.h:63
DWORD
DWORD DWORD
Definition: winlogon.h:75
_COINSTALLER_CONTEXT_DATA
Definition: setupapi.h:1085
_SP_DEVINSTALL_PARAMS_W::Flags
DWORD Flags
Definition: setupapi.h:887
ERROR_INVALID_USER_BUFFER
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
CoInstallerElement::Function
COINSTALLER_PROC Function
Definition: devinst.c:62
_SP_DEVINFO_DATA
Definition: setupapi.h:829
FALSE
#define FALSE
Definition: types.h:117
CoInstallerElement::DoPostProcessing
BOOL DoPostProcessing
Definition: devinst.c:63
DIF_REGISTERDEVICE
#define DIF_REGISTERDEVICE
Definition: setupapi.h:144
REG_MULTI_SZ
#define REG_MULTI_SZ
Definition: nt_native.h:1501
_SP_DEVINFO_DATA::ClassGuid
GUID ClassGuid
Definition: setupapi.h:831
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
REGSTR_VAL_INSTALLER_32
#define REGSTR_VAL_INSTALLER_32
Definition: regstr.h:487
SetupDiInstallDevice
BOOL WINAPI SetupDiInstallDevice(IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:5410
ptr
static PVOID ptr
Definition: dispmode.c:30
SetupDiGetDeviceInstallParamsW
BOOL WINAPI SetupDiGetDeviceInstallParamsW(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, OUT PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
Definition: devinst.c:4534
IntSetupDiRegisterDeviceInfo
static BOOL WINAPI IntSetupDiRegisterDeviceInfo(IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:4096
DIF_REGISTER_COINSTALLERS
#define DIF_REGISTER_COINSTALLERS
Definition: setupapi.h:153
NULL
smooth NULL
Definition: ftsmooth.c:513
_SP_DEVINSTALL_PARAMS_W::FlagsEx
DWORD FlagsEx
Definition: setupapi.h:888
DIF_ADDPROPERTYPAGE_ADVANCED
#define DIF_ADDPROPERTYPAGE_ADVANCED
Definition: setupapi.h:154
RemoveHeadList
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
_COINSTALLER_CONTEXT_DATA::PrivateData
PVOID PrivateData
Definition: setupapi.h:1088
DIF_NEWDEVICEWIZARD_FINISHINSTALL
#define DIF_NEWDEVICEWIZARD_FINISHINSTALL
Definition: setupapi.h:149
DIF_NEWDEVICEWIZARD_SELECT
#define DIF_NEWDEVICEWIZARD_SELECT
Definition: setupapi.h:146
_SP_DEVINFO_DATA::cbSize
DWORD cbSize
Definition: setupapi.h:830
CoInstallerElement::PrivateData
PVOID PrivateData
Definition: devinst.c:64
HKLM
static const WCHAR HKLM[]
Definition: reginf.c:54
DIF_INSTALLDEVICE
#define DIF_INSTALLDEVICE
Definition: setupapi.h:121
Context
IN HDEVINFO IN PSP_DEVINFO_DATA DeviceInfoData IN OUT PCOINSTALLER_CONTEXT_DATA Context
Definition: devinst.c:53
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:120
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DI_NODI_DEFAULTACTION
#define DI_NODI_DEFAULTACTION
Definition: setupapi.h:67
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:395
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
_SP_DEVINSTALL_PARAMS_W::cbSize
DWORD cbSize
Definition: setupapi.h:886
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
FreeFunctionPointer
DWORD FreeFunctionPointer(IN HMODULE ModulePointer, IN PVOID FunctionPointer)
Definition: misc.c:105
GetFunctionPointer
DWORD GetFunctionPointer(IN PWSTR InstallerName, OUT HMODULE *ModulePointer, OUT PVOID *FunctionPointer)
Definition: misc.c:44
HDEVINFO
PVOID HDEVINFO
Definition: setupapi.h:664
DIF_TROUBLESHOOTER
#define DIF_TROUBLESHOOTER
Definition: setupapi.h:157
SetLastError
#define SetLastError(x)
Definition: compat.h:409
SetupDiRegisterCoDeviceInstallers
BOOL WINAPI SetupDiRegisterCoDeviceInstallers(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:5264
UuidToStringW
RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR *StringUuid)
Definition: rpcrt4_main.c:516
DeviceInfoSet
IN HDEVINFO DeviceInfoSet
Definition: devinst.c:44
_COINSTALLER_CONTEXT_DATA::PostProcessing
BOOL PostProcessing
Definition: setupapi.h:1086
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181
ret
int ret
Definition: wcstombs-tests.c:31
DIF_POWERMESSAGEWAKE
#define DIF_POWERMESSAGEWAKE
Definition: setupapi.h:158
SetupDiChangeState
BOOL WINAPI SetupDiChangeState(IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:5138
SetupDiOpenDevRegKey
HKEY WINAPI SetupDiOpenDevRegKey(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, REGSAM samDesired)
Definition: devinst.c:5797
_LIST_ENTRY
Definition: typedefs.h:118
ERR
#define ERR(fmt,...)
Definition: debug.h:109
DIF_INSTALLINTERFACES
#define DIF_INSTALLINTERFACES
Definition: setupapi.h:151
DICS_FLAG_GLOBAL
#define DICS_FLAG_GLOBAL
Definition: setupapi.h:113
SetupDiSelectDevice
BOOL WINAPI SetupDiSelectDevice(IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
Definition: devinst.c:5250
SetupDiRemoveDevice
BOOL WINAPI SetupDiRemoveDevice(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: stubs.c:64
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
SetupDiInstallDeviceInterfaces
BOOL WINAPI SetupDiInstallDeviceInterfaces(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: interface.c:414
DI_FLAGSEX_CI_FAILED
#define DI_FLAGSEX_CI_FAILED
Definition: setupapi.h:79
_COINSTALLER_CONTEXT_DATA::InstallResult
DWORD InstallResult
Definition: setupapi.h:1087
HMODULE
HANDLE HMODULE
Definition: typedefs.h:76
DEVICE_COINSTALLER
#define DEVICE_COINSTALLER
SP_DEVINSTALL_PARAMS_W
struct _SP_DEVINSTALL_PARAMS_W SP_DEVINSTALL_PARAMS_W
DeviceInfo::ListEntry
LIST_ENTRY ListEntry
Definition: setupapi_private.h:130
ERROR_DI_DO_DEFAULT
#define ERROR_DI_DO_DEFAULT
Definition: setupapi.h:305
ERROR_NOT_SUPPORTED
#define ERROR_NOT_SUPPORTED
Definition: compat.h:90
CLASS_INSTALLER
#define CLASS_INSTALLER
DIF_ALLOW_INSTALL
#define DIF_ALLOW_INSTALL
Definition: setupapi.h:143
DIF_REMOVE
#define DIF_REMOVE
Definition: setupapi.h:124
DIREG_DRV
#define DIREG_DRV
Definition: setupapi.h:182
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
DIF_NEWDEVICEWIZARD_PRESELECT
#define DIF_NEWDEVICEWIZARD_PRESELECT
Definition: setupapi.h:145
DIF_SELECTBESTCOMPATDRV
#define DIF_SELECTBESTCOMPATDRV
Definition: setupapi.h:142
DeviceInfoData
IN OUT PSP_DEVINFO_DATA DeviceInfoData
Definition: devinst.c:49
_SP_DEVINSTALL_PARAMS_W
Definition: setupapi.h:885
DIF_DETECT
#define DIF_DETECT
Definition: setupapi.h:134
ERROR_DI_POSTPROCESSING_REQUIRED
#define ERROR_DI_POSTPROCESSING_REQUIRED
Definition: setupapi.h:329
SetupDiInstallDriverFiles
BOOL WINAPI SetupDiInstallDriverFiles(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: driver.c:2099
DIF_INSTALLDEVICEFILES
#define DIF_INSTALLDEVICEFILES
Definition: setupapi.h:140
REGSTR_VAL_COINSTALLERS_32
#define REGSTR_VAL_COINSTALLERS_32
Definition: regstr.h:484
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:394
SetupDiOpenClassRegKey
HKEY WINAPI SetupDiOpenClassRegKey(const GUID *ClassGuid, REGSAM samDesired)
Definition: devinst.c:3700
RPC_S_OK
#define RPC_S_OK
Definition: rpcnterr.h:22
CLASS_COINSTALLER
#define CLASS_COINSTALLER
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
REG_SZ
#define REG_SZ
Definition: layer.c:22
BOOL WINAPI SetupDiChangeState ( IN HDEVINFO  DeviceInfoSet,
IN OUT PSP_DEVINFO_DATA  DeviceInfoData 
)

Definition at line 5138 of file devinst.c.

Referenced by CDeviceNode::EnableDevice(), and SetupDiCallClassInstaller().

5141 {
5142  PSP_PROPCHANGE_PARAMS PropChange;
5143  HKEY hKey = INVALID_HANDLE_VALUE;
5144  LPCWSTR RegistryValueName;
5145  DWORD dwConfigFlags, dwLength, dwRegType;
5146  LONG rc;
5147  BOOL ret = FALSE;
5148 
5149  TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
5150 
5151  if (!DeviceInfoData)
5152  PropChange = ((struct DeviceInfoSet *)DeviceInfoSet)->ClassInstallParams.PropChangeParams;
5153  else
5154  PropChange = ((struct DeviceInfo *)DeviceInfoData->Reserved)->ClassInstallParams.PropChangeParams;
5155  if (!PropChange)
5156  {
5157  SetLastError(ERROR_INVALID_PARAMETER);
5158  goto cleanup;
5159  }
5160 
5161  if (PropChange->Scope == DICS_FLAG_GLOBAL)
5162  RegistryValueName = REGSTR_VAL_CONFIGFLAGS;
5163  else
5164  RegistryValueName = REGSTR_VAL_CSCONFIGFLAGS;
5165 
5166  switch (PropChange->StateChange)
5167  {
5168  case DICS_ENABLE:
5169  case DICS_DISABLE:
5170  {
5171  /* Enable/disable device in registry */
5172  hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, PropChange->Scope, PropChange->HwProfile, DIREG_DEV, KEY_QUERY_VALUE | KEY_SET_VALUE);
5173  if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
5174  hKey = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, PropChange->Scope, PropChange->HwProfile, DIREG_DEV, NULL, NULL);
5175  if (hKey == INVALID_HANDLE_VALUE)
5176  break;
5177  dwLength = sizeof(DWORD);
5178  rc = RegQueryValueExW(
5179  hKey,
5180  RegistryValueName,
5181  NULL,
5182  &dwRegType,
5183  (LPBYTE)&dwConfigFlags, &dwLength);
5184  if (rc == ERROR_FILE_NOT_FOUND)
5185  dwConfigFlags = 0;
5186  else if (rc != ERROR_SUCCESS)
5187  {
5188  SetLastError(rc);
5189  goto cleanup;
5190  }
5191  else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
5192  {
5193  SetLastError(ERROR_GEN_FAILURE);
5194  goto cleanup;
5195  }
5196  if (PropChange->StateChange == DICS_ENABLE)
5197  dwConfigFlags &= ~(PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
5198  else
5199  dwConfigFlags |= (PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
5200  rc = RegSetValueExW(
5201  hKey,
5202  RegistryValueName,
5203  0,
5204  REG_DWORD,
5205  (LPBYTE)&dwConfigFlags, sizeof(DWORD));
5206  if (rc != ERROR_SUCCESS)
5207  {
5208  SetLastError(rc);
5209  goto cleanup;
5210  }
5211 
5212  /* Enable/disable device if needed */
5213  if (PropChange->Scope == DICS_FLAG_GLOBAL
5214  || PropChange->HwProfile == 0
5215  || PropChange->HwProfile == SETUPAPI_GetCurrentHwProfile(DeviceInfoSet))
5216  {
5217  if (PropChange->StateChange == DICS_ENABLE)
5218  ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
5219  else
5220  ret = StopDevice(DeviceInfoSet, DeviceInfoData);
5221  }
5222  else
5223  ret = TRUE;
5224  break;
5225  }
5226  case DICS_PROPCHANGE:
5227  {
5228  ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
5229  break;
5230  }
5231  default:
5232  {
5233  ERR("Unknown StateChange 0x%lx\n", PropChange->StateChange);
5234  SetLastError(ERROR_NOT_SUPPORTED);
5235  }
5236  }
5237 
5238 cleanup:
5239  if (hKey != INVALID_HANDLE_VALUE)
5240  RegCloseKey(hKey);
5241 
5242  TRACE("Returning %d\n", ret);
5243  return ret;
5244 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
DWORD
static const GUID DWORD
Definition: devinst.c:39
TRUE
#define TRUE
Definition: types.h:120
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
KEY_SET_VALUE
#define KEY_SET_VALUE
Definition: nt_native.h:1017
ResetDevice
BOOLEAN ResetDevice(IN LPCWSTR DeviceId)
Definition: devinst.c:19
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
SETUPAPI_GetCurrentHwProfile
static DWORD SETUPAPI_GetCurrentHwProfile(IN HDEVINFO DeviceInfoSet)
Definition: devinst.c:5056
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
_SP_PROPCHANGE_PARAMS
Definition: setupapi.h:910
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
GetLastError
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1056
REGSTR_VAL_CONFIGFLAGS
#define REGSTR_VAL_CONFIGFLAGS
Definition: regstr.h:388
_SP_PROPCHANGE_PARAMS::StateChange
DWORD StateChange
Definition: setupapi.h:912
CSCONFIGFLAG_DISABLED
#define CSCONFIGFLAG_DISABLED
Definition: regstr.h:401
DICS_ENABLE
#define DICS_ENABLE
Definition: setupapi.h:112
REGSTR_VAL_CSCONFIGFLAGS
#define REGSTR_VAL_CSCONFIGFLAGS
Definition: regstr.h:389
DWORD
DWORD DWORD
Definition: winlogon.h:75
_SP_PROPCHANGE_PARAMS::HwProfile
DWORD HwProfile
Definition: setupapi.h:914
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
FALSE
#define FALSE
Definition: types.h:117
LONG
long LONG
Definition: pedump.c:60
DICS_DISABLE
#define DICS_DISABLE
Definition: setupapi.h:114
NULL
smooth NULL
Definition: ftsmooth.c:513
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
SetupDiCreateDevRegKeyW
HKEY WINAPI SetupDiCreateDevRegKeyW(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, HINF InfHandle, PCWSTR InfSectionName)
Definition: devinst.c:1405
RegSetValueExW
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4917
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
CONFIGFLAG_DISABLED
#define CONFIGFLAG_DISABLED
Definition: regstr.h:390
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
DIREG_DEV
#define DIREG_DEV
Definition: setupapi.h:181
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ret
int ret
Definition: wcstombs-tests.c:31
_SP_PROPCHANGE_PARAMS::Scope
DWORD Scope
Definition: setupapi.h:913
SetupDiOpenDevRegKey
HKEY WINAPI SetupDiOpenDevRegKey(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Scope, DWORD HwProfile, DWORD KeyType, REGSAM samDesired)
Definition: devinst.c:5797
REG_DWORD
#define REG_DWORD
Definition: nt_native.h:1497
ERR
#define ERR(fmt,...)
Definition: debug.h:109
DICS_FLAG_GLOBAL
#define DICS_FLAG_GLOBAL
Definition: setupapi.h:113
DICS_PROPCHANGE
#define DICS_PROPCHANGE
Definition: setupapi.h:116
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
ERROR_NOT_SUPPORTED
#define ERROR_NOT_SUPPORTED
Definition: compat.h:90
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
DeviceInfoData
IN OUT PSP_DEVINFO_DATA DeviceInfoData
Definition: devinst.c:49
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
StopDevice
static BOOL StopDevice(IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:5126
BOOL WINAPI SetupDiClassGuidsFromNameA ( LPCSTR  ClassName,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize 
)

Definition at line 863 of file devinst.c.

Referenced by test_SetupDiClassGuidsFromNameA().

868 {
869  return SetupDiClassGuidsFromNameExA(ClassName, ClassGuidList,
870  ClassGuidListSize, RequiredSize,
871  NULL, NULL);
872 }
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
SetupDiClassGuidsFromNameExA
BOOL WINAPI SetupDiClassGuidsFromNameExA(LPCSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCSTR MachineName, PVOID Reserved)
Definition: devinst.c:891
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
BOOL WINAPI SetupDiClassGuidsFromNameExA ( LPCSTR  ClassName,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize,
LPCSTR  MachineName,
PVOID  Reserved 
)

Definition at line 891 of file devinst.c.

Referenced by SetupDiClassGuidsFromNameA().

898 {
899  LPWSTR ClassNameW = NULL;
900  LPWSTR MachineNameW = NULL;
901  BOOL bResult;
902 
903  TRACE("%s %p %lu %p %s %p\n", debugstr_a(ClassName), ClassGuidList,
904  ClassGuidListSize, RequiredSize, debugstr_a(MachineName), Reserved);
905 
906  if (!ClassName)
907  {
908  SetLastError(ERROR_INVALID_PARAMETER);
909  return FALSE;
910  }
911 
912  ClassNameW = pSetupMultiByteToUnicode(ClassName, CP_ACP);
913  if (ClassNameW == NULL)
914  return FALSE;
915 
916  if (MachineName)
917  {
918  MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
919  if (MachineNameW == NULL)
920  {
921  MyFree(ClassNameW);
922  return FALSE;
923  }
924  }
925 
926  bResult = SetupDiClassGuidsFromNameExW(ClassNameW, ClassGuidList,
927  ClassGuidListSize, RequiredSize,
928  MachineNameW, Reserved);
929 
930  MyFree(MachineNameW);
931  MyFree(ClassNameW);
932 
933  return bResult;
934 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
CP_ACP
#define CP_ACP
Definition: compat.h:99
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
FALSE
#define FALSE
Definition: types.h:117
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
SetLastError
#define SetLastError(x)
Definition: compat.h:409
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
SetupDiClassGuidsFromNameExW
BOOL WINAPI SetupDiClassGuidsFromNameExW(LPCWSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:939
BOOL WINAPI SetupDiClassGuidsFromNameExW ( LPCWSTR  ClassName,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize,
LPCWSTR  MachineName,
PVOID  Reserved 
)

Definition at line 939 of file devinst.c.

Referenced by SetupDiClassGuidsFromNameExA(), and SetupDiClassGuidsFromNameW().

946 {
947  WCHAR szKeyName[40];
948  WCHAR szClassName[MAX_CLASS_NAME_LEN];
949  HKEY hClassesKey;
950  HKEY hClassKey;
951  DWORD dwLength;
952  DWORD dwIndex;
953  LONG lError;
954  DWORD dwGuidListIndex = 0;
955 
956  TRACE("%s %p %lu %p %s %p\n", debugstr_w(ClassName), ClassGuidList,
957  ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
958 
959  if (!ClassName || !RequiredSize)
960  {
961  SetLastError(ERROR_INVALID_PARAMETER);
962  return FALSE;
963  }
964  if (!ClassGuidList && ClassGuidListSize > 0)
965  {
966  SetLastError(ERROR_INVALID_PARAMETER);
967  return FALSE;
968  }
969  *RequiredSize = 0;
970 
971  hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
972  KEY_ENUMERATE_SUB_KEYS,
973  DIOCR_INSTALLER,
974  MachineName,
975  Reserved);
976  if (hClassesKey == INVALID_HANDLE_VALUE)
977  {
978  return FALSE;
979  }
980 
981  for (dwIndex = 0; ; dwIndex++)
982  {
983  dwLength = 40;
984  lError = RegEnumKeyExW(hClassesKey,
985  dwIndex,
986  szKeyName,
987  &dwLength,
988  NULL,
989  NULL,
990  NULL,
991  NULL);
992  TRACE("RegEnumKeyExW() returns %d\n", lError);
993  if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
994  {
995  TRACE("Key name: %p\n", szKeyName);
996 
997  if (RegOpenKeyExW(hClassesKey,
998  szKeyName,
999  0,
1000  KEY_QUERY_VALUE,
1001  &hClassKey))
1002  {
1003  RegCloseKey(hClassesKey);
1004  return FALSE;
1005  }
1006 
1007  dwLength = MAX_CLASS_NAME_LEN * sizeof(WCHAR);
1008  if (!RegQueryValueExW(hClassKey,
1009  REGSTR_VAL_CLASS,
1010  NULL,
1011  NULL,
1012  (LPBYTE)szClassName,
1013  &dwLength))
1014  {
1015  TRACE("Class name: %p\n", szClassName);
1016 
1017  if (strcmpiW(szClassName, ClassName) == 0)
1018  {
1019  TRACE("Found matching class name\n");
1020 
1021  TRACE("Guid: %p\n", szKeyName);
1022  if (dwGuidListIndex < ClassGuidListSize)
1023  {
1024  if (szKeyName[0] == '{' && szKeyName[37] == '}')
1025  {
1026  szKeyName[37] = 0;
1027  }
1028  TRACE("Guid: %p\n", &szKeyName[1]);
1029 
1030  UuidFromStringW(&szKeyName[1],
1031  &ClassGuidList[dwGuidListIndex]);
1032  }
1033 
1034  dwGuidListIndex++;
1035  }
1036  }
1037 
1038  RegCloseKey(hClassKey);
1039  }
1040 
1041  if (lError != ERROR_SUCCESS)
1042  break;
1043  }
1044 
1045  RegCloseKey(hClassesKey);
1046 
1047  if (RequiredSize != NULL)
1048  *RequiredSize = dwGuidListIndex;
1049 
1050  if (ClassGuidListSize < dwGuidListIndex)
1051  {
1052  SetLastError(ERROR_INSUFFICIENT_BUFFER);
1053  return FALSE;
1054  }
1055 
1056  return TRUE;
1057 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
REGSTR_VAL_CLASS
#define REGSTR_VAL_CLASS
Definition: regstr.h:291
TRUE
#define TRUE
Definition: types.h:120
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
WCHAR
#define WCHAR
Definition: msvc.h:43
DWORD
DWORD DWORD
Definition: winlogon.h:75
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
FALSE
#define FALSE
Definition: types.h:117
UuidFromStringW
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:590
LONG
long LONG
Definition: pedump.c:60
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
DIOCR_INSTALLER
#define DIOCR_INSTALLER
Definition: setupapi.h:176
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
szClassName
static const WCHAR szClassName[]
Definition: clipbrd.c:11
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
strcmpiW
#define strcmpiW(s1, s2)
Definition: unicode.h:39
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
SetupDiOpenClassRegKeyExW
HKEY WINAPI SetupDiOpenClassRegKeyExW(const GUID *ClassGuid, REGSAM samDesired, DWORD Flags, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:3744
MAX_CLASS_NAME_LEN
#define MAX_CLASS_NAME_LEN
Definition: cfgmgr32.h:52
RegEnumKeyExW
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2541
hClassKey
static HKEY hClassKey
Definition: umpnpmgr.c:66
KEY_ENUMERATE_SUB_KEYS
#define KEY_ENUMERATE_SUB_KEYS
Definition: nt_native.h:1019
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
BOOL WINAPI SetupDiClassGuidsFromNameW ( LPCWSTR  ClassName,
LPGUID  ClassGuidList,
DWORD  ClassGuidListSize,
PDWORD  RequiredSize 
)

Definition at line 877 of file devinst.c.

882 {
883  return SetupDiClassGuidsFromNameExW(ClassName, ClassGuidList,
884  ClassGuidListSize, RequiredSize,
885  NULL, NULL);
886 }
NULL
smooth NULL
Definition: ftsmooth.c:513
ClassGuidListSize
_In_ DWORD ClassGuidListSize
Definition: setupapi.h:1276
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
SetupDiClassGuidsFromNameExW
BOOL WINAPI SetupDiClassGuidsFromNameExW(LPCWSTR ClassName, LPGUID ClassGuidList, DWORD ClassGuidListSize, PDWORD RequiredSize, LPCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:939
BOOL WINAPI SetupDiClassNameFromGuidA ( const GUID *  ClassGuid,
PSTR  ClassName,
DWORD  ClassNameSize,
PDWORD  RequiredSize 
)

Definition at line 1062 of file devinst.c.

Referenced by test_SetupDiBuildClassInfoList(), and test_SetupDiClassNameFromGuidA().

1067 {
1068  return SetupDiClassNameFromGuidExA(ClassGuid, ClassName,
1069  ClassNameSize, RequiredSize,
1070  NULL, NULL);
1071 }
NULL
smooth NULL
Definition: ftsmooth.c:513
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
SetupDiClassNameFromGuidExA
BOOL WINAPI SetupDiClassNameFromGuidExA(const GUID *ClassGuid, PSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize, PCSTR MachineName, PVOID Reserved)
Definition: devinst.c:1090
BOOL WINAPI SetupDiClassNameFromGuidExA ( const GUID *  ClassGuid,
PSTR  ClassName,
DWORD  ClassNameSize,
PDWORD  RequiredSize,
PCSTR  MachineName,
PVOID  Reserved 
)

Definition at line 1090 of file devinst.c.

Referenced by SetupDiClassNameFromGuidA().

1097 {
1098  WCHAR ClassNameW[MAX_CLASS_NAME_LEN];
1099  LPWSTR MachineNameW = NULL;
1100  BOOL ret;
1101 
1102  if (MachineName)
1103  MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
1104  ret = SetupDiClassNameFromGuidExW(ClassGuid, ClassNameW, MAX_CLASS_NAME_LEN,
1105  RequiredSize, MachineNameW, Reserved);
1106  if (ret)
1107  {
1108  int len = WideCharToMultiByte(CP_ACP, 0, ClassNameW, -1, ClassName,
1109  ClassNameSize, NULL, NULL);
1110  if (len == 0 || len > ClassNameSize)
1111  {
1112  SetLastError(ERROR_INSUFFICIENT_BUFFER);
1113  ret = FALSE;
1114  }
1115  }
1116  MyFree(MachineNameW);
1117  return ret;
1118 }
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:101
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
CP_ACP
#define CP_ACP
Definition: compat.h:99
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
SetupDiClassNameFromGuidExW
BOOL WINAPI SetupDiClassNameFromGuidExW(const GUID *ClassGuid, PWSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:1123
FALSE
#define FALSE
Definition: types.h:117
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
NULL
smooth NULL
Definition: ftsmooth.c:513
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ret
int ret
Definition: wcstombs-tests.c:31
len
GLenum GLsizei len
Definition: glext.h:6722
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
MAX_CLASS_NAME_LEN
#define MAX_CLASS_NAME_LEN
Definition: cfgmgr32.h:52
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
BOOL WINAPI SetupDiClassNameFromGuidExW ( const GUID *  ClassGuid,
PWSTR  ClassName,
DWORD  ClassNameSize,
PDWORD  RequiredSize,
PCWSTR  MachineName,
PVOID  Reserved 
)

Definition at line 1123 of file devinst.c.

Referenced by SetupDiClassNameFromGuidExA(), and SetupDiClassNameFromGuidW().

1130 {
1131  HKEY hKey;
1132  DWORD dwLength;
1133  DWORD dwRegType;
1134  LONG rc;
1135  PWSTR Buffer;
1136 
1137  TRACE("%s %p %lu %p %s %p\n", debugstr_guid(ClassGuid), ClassName,
1138  ClassNameSize, RequiredSize, debugstr_w(MachineName), Reserved);
1139 
1140  /* Make sure there's a GUID */
1141  if (ClassGuid == NULL)
1142  {
1143  SetLastError(ERROR_INVALID_CLASS); /* On Vista: ERROR_INVALID_USER_BUFFER */
1144  return FALSE;
1145  }
1146 
1147  /* Make sure there's a real buffer when there's a size */
1148  if ((ClassNameSize > 0) && (ClassName == NULL))
1149  {
1150  SetLastError(ERROR_INVALID_PARAMETER); /* On Vista: ERROR_INVALID_USER_BUFFER */
1151  return FALSE;
1152  }
1153 
1154  /* Open the key for the GUID */
1155  hKey = SetupDiOpenClassRegKeyExW(ClassGuid, KEY_QUERY_VALUE, DIOCR_INSTALLER, MachineName, Reserved);
1156 
1157  if (hKey == INVALID_HANDLE_VALUE)
1158  return FALSE;
1159 
1160  /* Retrieve the class name data and close the key */
1161  rc = QueryRegistryValue(hKey, REGSTR_VAL_CLASS, (LPBYTE *) &Buffer, &dwRegType, &dwLength);
1162  RegCloseKey(hKey);
1163 
1164  /* Make sure we got the data */
1165  if (rc != ERROR_SUCCESS)
1166  {
1167  SetLastError(rc);
1168  return FALSE;
1169  }
1170 
1171  /* Make sure the data is a string */
1172  if (dwRegType != REG_SZ)
1173  {
1174  MyFree(Buffer);
1175  SetLastError(ERROR_GEN_FAILURE);
1176  return FALSE;
1177  }
1178 
1179  /* Determine the length of the class name */
1180  dwLength /= sizeof(WCHAR);
1181 
1182  if ((dwLength == 0) || (Buffer[dwLength - 1] != UNICODE_NULL))
1183  /* Count the null-terminator */
1184  dwLength++;
1185 
1186  /* Inform the caller about the class name */
1187  if ((ClassName != NULL) && (dwLength <= ClassNameSize))
1188  {
1189  memcpy(ClassName, Buffer, (dwLength - 1) * sizeof(WCHAR));
1190  ClassName[dwLength - 1] = UNICODE_NULL;
1191  }
1192 
1193  /* Inform the caller about the required size */
1194  if (RequiredSize != NULL)
1195  *RequiredSize = dwLength;
1196 
1197  /* Clean up the buffer */
1198  MyFree(Buffer);
1199 
1200  /* Make sure the buffer was large enough */
1201  if ((ClassName == NULL) || (dwLength > ClassNameSize))
1202  {
1203  SetLastError(ERROR_INSUFFICIENT_BUFFER);
1204  return FALSE;
1205  }
1206 
1207  return TRUE;
1208 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
REGSTR_VAL_CLASS
#define REGSTR_VAL_CLASS
Definition: regstr.h:291
TRUE
#define TRUE
Definition: types.h:120
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
PWSTR
PVOID *typedef PWSTR
Definition: winlogon.h:57
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
WCHAR
#define WCHAR
Definition: msvc.h:43
DWORD
DWORD DWORD
Definition: winlogon.h:75
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
FALSE
#define FALSE
Definition: types.h:117
UNICODE_NULL
#define UNICODE_NULL
LONG
long LONG
Definition: pedump.c:60
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
DIOCR_INSTALLER
#define DIOCR_INSTALLER
Definition: setupapi.h:176
NULL
smooth NULL
Definition: ftsmooth.c:513
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
QueryRegistryValue
PVOID QueryRegistryValue(HANDLE RegHandle, PWCHAR ValueName, LPDWORD RegistryType, LPDWORD Length)
Definition: registry.c:67
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
dwLength
static DWORD DWORD * dwLength
Definition: fusion.c:70
HKEY
HANDLE HKEY
Definition: registry.h:24
SetLastError
#define SetLastError(x)
Definition: compat.h:409
Buffer
UINTN VOID * Buffer
Definition: acefiex.h:370
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
KEY_QUERY_VALUE
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
ERROR_INVALID_CLASS
#define ERROR_INVALID_CLASS
Definition: setupapi.h:297
SetupDiOpenClassRegKeyExW
HKEY WINAPI SetupDiOpenClassRegKeyExW(const GUID *ClassGuid, REGSAM samDesired, DWORD Flags, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:3744
ERROR_GEN_FAILURE
#define ERROR_GEN_FAILURE
Definition: winerror.h:134
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
REG_SZ
#define REG_SZ
Definition: layer.c:22
BOOL WINAPI SetupDiClassNameFromGuidW ( const GUID *  ClassGuid,
PWSTR  ClassName,
DWORD  ClassNameSize,
PDWORD  RequiredSize 
)

Definition at line 1076 of file devinst.c.

Referenced by PARSER_GetInfClassW(), and CClassNode::SetupNode().

1081 {
1082  return SetupDiClassNameFromGuidExW(ClassGuid, ClassName,
1083  ClassNameSize, RequiredSize,
1084  NULL, NULL);
1085 }
SetupDiClassNameFromGuidExW
BOOL WINAPI SetupDiClassNameFromGuidExW(const GUID *ClassGuid, PWSTR ClassName, DWORD ClassNameSize, PDWORD RequiredSize, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:1123
NULL
smooth NULL
Definition: ftsmooth.c:513
RequiredSize
_Inout_ PRTL_BUFFER _In_ SIZE_T RequiredSize
Definition: RtlpEnsureBufferSize.c:15
BOOL WINAPI SetupDiCreateDeviceInfoA ( HDEVINFO  DeviceInfoSet,
PCSTR  DeviceName,
CONST GUID *  ClassGuid,
PCSTR  DeviceDescription,
HWND  hwndParent,
DWORD  CreationFlags,
PSP_DEVINFO_DATA  DeviceInfoData 
)

Definition at line 1670 of file devinst.c.

1678 {
1679  BOOL ret;
1680  LPWSTR DeviceNameW = NULL;
1681  LPWSTR DeviceDescriptionW = NULL;
1682 
1683  TRACE("\n");
1684 
1685  if (DeviceName)
1686  {
1687  DeviceNameW = pSetupMultiByteToUnicode(DeviceName, CP_ACP);
1688  if (DeviceNameW == NULL) return FALSE;
1689  }
1690  if (DeviceDescription)
1691  {
1692  DeviceDescriptionW = pSetupMultiByteToUnicode(DeviceDescription, CP_ACP);
1693  if (DeviceDescriptionW == NULL)
1694  {
1695  MyFree(DeviceNameW);
1696  return FALSE;
1697  }
1698  }
1699 
1700  ret = SetupDiCreateDeviceInfoW(DeviceInfoSet, DeviceNameW, ClassGuid, DeviceDescriptionW,
1701  hwndParent, CreationFlags, DeviceInfoData);
1702 
1703  MyFree(DeviceNameW);
1704  MyFree(DeviceDescriptionW);
1705 
1706  return ret;
1707 }
CP_ACP
#define CP_ACP
Definition: compat.h:99
DeviceName
WCHAR DeviceName[]
Definition: adapter.cpp:21
FALSE
#define FALSE
Definition: types.h:117
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
NULL
smooth NULL
Definition: ftsmooth.c:513
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
DeviceDescription
_Must_inspect_result_ _In_ PDEVICE_DESCRIPTION DeviceDescription
Definition: iofuncs.h:1015
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
ret
int ret
Definition: wcstombs-tests.c:31
SetupDiCreateDeviceInfoW
BOOL WINAPI SetupDiCreateDeviceInfoW(HDEVINFO DeviceInfoSet, PCWSTR DeviceName, CONST GUID *ClassGuid, PCWSTR DeviceDescription, HWND hwndParent, DWORD CreationFlags, PSP_DEVINFO_DATA DeviceInfoData)
Definition: devinst.c:1712
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
HDEVINFO WINAPI SetupDiCreateDeviceInfoList ( const GUID *  ClassGuid,
HWND  hwndParent 
)

Definition at line 1214 of file devinst.c.

Referenced by InstallSoftwareBusPnpEnumerator(), and SetupDiInstallClassExW().

1216 {
1217  return SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent, NULL, NULL);
1218 }
SetupDiCreateDeviceInfoListExW
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid, HWND hwndParent, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:1268
NULL
smooth NULL
Definition: ftsmooth.c:513
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExA ( const GUID *  ClassGuid,
HWND  hwndParent,
PCSTR  MachineName,
PVOID  Reserved 
)

Definition at line 1224 of file devinst.c.

1228 {
1229  LPWSTR MachineNameW = NULL;
1230  HDEVINFO hDevInfo;
1231 
1232  TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
1233  debugstr_a(MachineName), Reserved);
1234 
1235  if (MachineName)
1236  {
1237  MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
1238  if (MachineNameW == NULL)
1239  return INVALID_HANDLE_VALUE;
1240  }
1241 
1242  hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent,
1243  MachineNameW, Reserved);
1244 
1245  MyFree(MachineNameW);
1246 
1247  return hDevInfo;
1248 }
CP_ACP
#define CP_ACP
Definition: compat.h:99
SetupDiCreateDeviceInfoListExW
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid, HWND hwndParent, PCWSTR MachineName, PVOID Reserved)
Definition: devinst.c:1268
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
NULL
smooth NULL
Definition: ftsmooth.c:513
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
HDEVINFO
PVOID HDEVINFO
Definition: setupapi.h:664
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
HDEVINFO WINAPI SetupDiCreateDeviceInfoListExW ( const GUID *  ClassGuid,
HWND  hwndParent,
PCWSTR  MachineName,
PVOID  Reserved 
)

Definition at line 1268 of file devinst.c.

Referenced by DevInstallW(), InstallDevInst(), CKsProxy::Load(), SetupDiCreateDeviceInfoList(), SetupDiCreateDeviceInfoListExA(), SetupDiGetClassDevsExW(), and CDeviceNode::SetupNode().

1272 {
1273  struct DeviceInfoSet *list = NULL;
1274  DWORD size = FIELD_OFFSET(struct DeviceInfoSet, szData);
1275  DWORD rc;
1276  CONFIGRET cr;
1277  HDEVINFO ret = INVALID_HANDLE_VALUE;
1278 
1279  TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
1280  debugstr_w(MachineName), Reserved);
1281 
1282  if (MachineName != NULL)
1283  {
1284  SIZE_T len = strlenW(MachineName);
1285  if (len >= SP_MAX_MACHINENAME_LENGTH - 4)
1286  {
1287  SetLastError(ERROR_INVALID_MACHINENAME);
1288  goto cleanup;
1289  }
1290  if(len > 0)
1291  size += (len + 3) * sizeof(WCHAR);
1292  else
1293  MachineName = NULL;
1294  }
1295 
1296  if (Reserved != NULL)
1297  {
1298  SetLastError(ERROR_INVALID_PARAMETER);
1299  return INVALID_HANDLE_VALUE;
1300  }
1301 
1302  list = MyMalloc(size);
1303  if (!list)
1304  {
1305  SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1306  return INVALID_HANDLE_VALUE;
1307  }
1308  ZeroMemory(list, FIELD_OFFSET(struct DeviceInfoSet, szData));
1309 
1310  list->magic = SETUP_DEVICE_INFO_SET_MAGIC;
1311  memcpy(&list->ClassGuid,
1312  ClassGuid ? ClassGuid : &GUID_NULL,
1313  sizeof(list->ClassGuid));
1314  list->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
1315  list->InstallParams.Flags |= DI_CLASSINSTALLPARAMS;
1316  list->InstallParams.hwndParent = hwndParent;
1317  if (MachineName)
1318  {
1319  rc = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &list->HKLM);
1320  if (rc != ERROR_SUCCESS)
1321  {
1322  SetLastError(ERROR_INVALID_MACHINENAME);
1323  goto cleanup;
1324  }
1325 
1326  list->szData[0] = list->szData[1] = '\\';
1327  strcpyW(list->szData + 2, MachineName);
1328  list->MachineName = list->szData;
1329  }
1330  else
1331  {
1332  list->HKLM = HKEY_LOCAL_MACHINE;
1333  list->MachineName = NULL;
1334  }
1335  cr = CM_Connect_MachineW(list->MachineName, &list->hMachine);
1336  if (cr != CR_SUCCESS)
1337  {
1338  SetLastError(GetErrorCodeFromCrCode(cr));
1339  goto cleanup;
1340  }
1341  InitializeListHead(&list->DriverListHead);
1342  InitializeListHead(&list->ListHead);
1343 
1344  return (HDEVINFO)list;
1345 
1346 cleanup:
1347  if (ret == INVALID_HANDLE_VALUE)
1348  {
1349  if (list)
1350  {
1351  if (list->HKLM != NULL && list->HKLM != HKEY_LOCAL_MACHINE)
1352  RegCloseKey(list->HKLM);
1353  MyFree(list);
1354  }
1355  }
1356  return ret;
1357 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
SP_MAX_MACHINENAME_LENGTH
#define SP_MAX_MACHINENAME_LENGTH
Definition: setupapi.h:27
CM_Connect_MachineW
CONFIGRET WINAPI CM_Connect_MachineW(PCWSTR UNCServerName, PHMACHINE phMachine)
Definition: cfgmgr.c:810
strlenW
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
DeviceInfoSet::ListHead
LIST_ENTRY ListHead
Definition: setupapi_private.h:208
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
szData
static const WCHAR szData[]
Definition: msipriv.h:1213
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
MachineName
_In_ DWORD _Out_ PDWORD _In_opt_ PCSTR MachineName
Definition: setupapi.h:1286
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1621
DeviceInfoSet::InstallParams
SP_DEVINSTALL_PARAMS_W InstallParams
Definition: setupapi_private.h:201
SETUP_DEVICE_INFO_SET_MAGIC
#define SETUP_DEVICE_INFO_SET_MAGIC
Definition: setupapi_private.h:63
DWORD
DWORD DWORD
Definition: winlogon.h:75
_SP_DEVINSTALL_PARAMS_W::Flags
DWORD Flags
Definition: setupapi.h:887
RegCloseKey
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
GetErrorCodeFromCrCode
static DWORD GetErrorCodeFromCrCode(const IN CONFIGRET cr)
Definition: devinst.c:92
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
CR_SUCCESS
#define CR_SUCCESS
Definition: cfgmgr32.h:842
RegConnectRegistryW
LONG WINAPI RegConnectRegistryW(LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult)
Definition: reg.c:872
NULL
smooth NULL
Definition: ftsmooth.c:513
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_SP_DEVINSTALL_PARAMS_W::cbSize
DWORD cbSize
Definition: setupapi.h:886
DeviceInfoSet::DriverListHead
LIST_ENTRY DriverListHead
Definition: setupapi_private.h:205
HDEVINFO
PVOID HDEVINFO
Definition: setupapi.h:664
SetLastError
#define SetLastError(x)
Definition: compat.h:409
DI_CLASSINSTALLPARAMS
#define DI_CLASSINSTALLPARAMS
Definition: setupapi.h:66
ret
int ret
Definition: wcstombs-tests.c:31
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GUID_NULL
#define GUID_NULL
Definition: ks.h:106
list
Definition: _list.h:228
len
GLenum GLsizei len
Definition: glext.h:6722
Reserved
ULONG PVOID Reserved
Definition: ntimage.h:533
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:79
strcpyW
WINE_UNICODE_INLINE WCHAR * strcpyW(WCHAR *dst, const WCHAR *src)
Definition: unicode.h:219
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
size
GLsizeiptr size
Definition: glext.h:5919
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
_SP_DEVINSTALL_PARAMS_W::hwndParent
HWND hwndParent
Definition: setupapi.h:889
CONFIGRET
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
DeviceInfoSet::szData
WCHAR szData[ANYSIZE_ARRAY]
Definition: setupapi_private.h:224
SP_DEVINSTALL_PARAMS_W
struct _SP_DEVINSTALL_PARAMS_W SP_DEVINSTALL_PARAMS_W
ERROR_INVALID_MACHINENAME
#define ERROR_INVALID_MACHINENAME
Definition: setupapi.h:323
cleanup
char * cleanup(char *str)
Definition: wpickclick.c:99
list
#define list
Definition: rosglue.h:35
MyMalloc
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
BOOL WINAPI SetupDiCreateDeviceInfoW ( HDEVINFO  DeviceInfoSet,
PCWSTR  DeviceName,
CONST GUID *  ClassGuid,
PCWSTR  DeviceDescription,
HWND  hwndParent,
DWORD  CreationFlags,
PSP_DEVINFO_DATA  DeviceInfoData 
)

Definition at line 1712 of file devinst.c.

Referenced by SetupDiCreateDeviceInfoA().

1720 {
1721  struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
1722  struct DeviceInfo *deviceInfo = NULL;
1723  BOOL ret = FALSE;
1724  CONFIGRET cr;
1725  DEVINST RootDevInst;
1726  DEVINST DevInst;
1727  WCHAR GenInstanceId[MAX_DEVICE_ID_LEN];
1728 
1729  TRACE("%p %s %s %s %p %x %p\n", DeviceInfoSet, debugstr_w(DeviceName),
1730  debugstr_guid(ClassGuid), debugstr_w(DeviceDescription),
1731  hwndParent, CreationFlags, DeviceInfoData);
1732 
1733  if (!DeviceName)
1734  {
1735  SetLastError(ERROR_INVALID_DEVINST_NAME);
1736  return FALSE;
1737  }
1738  if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
1739  {
1740  SetLastError(ERROR_INVALID_HANDLE);
1741  return FALSE;
1742  }
1743  if (!ClassGuid)
1744  {
1745  SetLastError(ERROR_INVALID_PARAMETER);
1746  return FALSE;
1747  }
1748  if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
1749  {
1750  SetLastError(ERROR_INVALID_HANDLE);
1751  return FALSE;
1752  }
1753  if (!IsEqualGUID(&set->ClassGuid, &GUID_NULL) &&
1754  !IsEqualGUID(ClassGuid, &set->ClassGuid))
1755  {
1756  SetLastError(ERROR_CLASS_MISMATCH);
1757  return FALSE;
1758  }
1759  if (CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS))
1760  {
1761  TRACE("Unknown flags: 0x%08lx\n", CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS));
1762  SetLastError(ERROR_INVALID_FLAGS);
1763  return FALSE;
1764  }
1765 
1766  /* Get the root device instance */
1767  cr = CM_Locate_DevInst_ExW(&RootDevInst,
1768  NULL,
1769  CM_LOCATE_DEVINST_NORMAL,
1770  set->hMachine);
1771  if (cr != CR_SUCCESS)
1772  {
1773  SetLastError(ERROR_INVALID_DATA);
1774  return FALSE;
1775  }
1776 
1777  /* Create the new device instance */
1778  cr = CM_Create_DevInst_ExW(&DevInst,
1779  (DEVINSTID)DeviceName,
1780  RootDevInst,
1781  (CreationFlags & DICD_GENERATE_ID) ?
1782  CM_CREATE_DEVINST_GENERATE_ID : 0,
1783  set->hMachine);
1784  if (cr != CR_SUCCESS)
1785  {
1786  SetLastError(GetErrorCodeFromCrCode(cr));
1787  return FALSE;
1788  }
1789 
1790  if (CreationFlags & DICD_GENERATE_ID)
1791  {
1792  /* Grab the actual instance ID that was created */
1793  cr = CM_Get_Device_ID_Ex(DevInst,
1794  GenInstanceId,
1795  MAX_DEVICE_ID_LEN,
1796  0,
1797  set->hMachine);
1798  if (cr != CR_SUCCESS)
1799  {
1800  SetLastError(GetErrorCodeFromCrCode(cr));
1801  return FALSE;
1802  }
1803 
1804  DeviceName = GenInstanceId;
1805  TRACE("Using generated instance ID: %s\n", debugstr_w(DeviceName));
1806  }
1807 
1808  if (CreateDeviceInfo(set, DeviceName, ClassGuid, &deviceInfo))
1809  {
1810  InsertTailList(&set->ListHead, &deviceInfo->ListEntry);
1811 
1812  if (!DeviceInfoData)
1813  ret = TRUE;
1814  else
1815  {
1816  if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
1817  {
1818  SetLastError(ERROR_INVALID_USER_BUFFER);
1819  }
1820  else
1821  {
1822  memcpy(&DeviceInfoData->ClassGuid, ClassGuid, sizeof(GUID));
1823  DeviceInfoData->DevInst = deviceInfo->dnDevInst;
1824  DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
1825  ret = TRUE;
1826  }
1827  }
1828  }
1829 
1830  if (ret == FALSE)
1831  {
1832  if (deviceInfo != NULL)
1833  {
1834  /* Remove deviceInfo from List */
1835  RemoveEntryList(&deviceInfo->ListEntry);
1836 
1837  /* Destroy deviceInfo */
1838  DestroyDeviceInfo(deviceInfo);
1839  }
1840  }
1841 
1842  TRACE("Returning %d\n", ret);
1843  return ret;
1844 }
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
DICD_INHERIT_CLASSDRVS
#define DICD_INHERIT_CLASSDRVS
Definition: setupapi.h:111
TRUE
#define TRUE
Definition: types.h:120
DeviceInfoSet::ListHead
LIST_ENTRY ListHead
Definition: setupapi_private.h:208
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
CM_Locate_DevInst_ExW
#define CM_Locate_DevInst_ExW
Definition: cfgmgr32.h:2395
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DEVINSTID
DEVINSTID_A DEVINSTID
Definition: cfgmgr32.h:87
DeviceName
WCHAR DeviceName[]
Definition: adapter.cpp:21
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
SETUP_DEVICE_INFO_SET_MAGIC
#define SETUP_DEVICE_INFO_SET_MAGIC
Definition: setupapi_private.h:63
CreateDeviceInfo
BOOL CreateDeviceInfo(IN struct DeviceInfoSet *list, IN LPCWSTR InstancePath, IN LPCGUID pClassGuid, OUT struct DeviceInfo **pDeviceInfo)
Definition: devinst.c:526
ERROR_INVALID_USER_BUFFER
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
RemoveEntryList
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
_SP_DEVINFO_DATA
Definition: setupapi.h:829
FALSE
#define FALSE
Definition: types.h:117
GetErrorCodeFromCrCode
static DWORD GetErrorCodeFromCrCode(const IN CONFIGRET cr)
Definition: devinst.c:92
_SP_DEVINFO_DATA::ClassGuid
GUID ClassGuid
Definition: setupapi.h:831
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
ERROR_CLASS_MISMATCH
#define ERROR_CLASS_MISMATCH
Definition: setupapi.h:292
CM_Get_Device_ID_Ex
#define CM_Get_Device_ID_Ex
Definition: cfgmgr32.h:1566
CR_SUCCESS
#define CR_SUCCESS
Definition: cfgmgr32.h:842
NULL
smooth NULL
Definition: ftsmooth.c:513
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
_SP_DEVINFO_DATA::cbSize
DWORD cbSize
Definition: setupapi.h:830
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
_SP_DEVINFO_DATA::Reserved
ULONG_PTR Reserved
Definition: setupapi.h:833
DeviceDescription
_Must_inspect_result_ _In_ PDEVICE_DESCRIPTION DeviceDescription
Definition: iofuncs.h:1015
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
CM_Create_DevInst_ExW
#define CM_Create_DevInst_ExW
Definition: cfgmgr32.h:1117
SetLastError
#define SetLastError(x)
Definition: compat.h:409
ret
int ret
Definition: wcstombs-tests.c:31
DestroyDeviceInfo
static BOOL DestroyDeviceInfo(struct DeviceInfo *deviceInfo)
Definition: devinst.c:579
DeviceInfo::dnDevInst
DEVINST dnDevInst
Definition: setupapi_private.h:132
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GUID_NULL
#define GUID_NULL
Definition: ks.h:106
_SP_DEVINFO_DATA::DevInst
DWORD DevInst
Definition: setupapi.h:832
ERROR_INVALID_DATA
#define ERROR_INVALID_DATA
Definition: winerror.h:116
DEVINST
DWORD DEVINST
Definition: cfgmgr32.h:76
MAX_DEVICE_ID_LEN
#define MAX_DEVICE_ID_LEN
Definition: cfgmgr32.h:49
IsEqualGUID
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:3970
CONFIGRET
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
DeviceInfo::ListEntry
LIST_ENTRY ListEntry
Definition: setupapi_private.h:130
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
ERROR_INVALID_DEVINST_NAME
#define ERROR_INVALID_DEVINST_NAME
Definition: setupapi.h:296
CM_CREATE_DEVINST_GENERATE_ID
#define CM_CREATE_DEVINST_GENERATE_ID
Definition: cfgmgr32.h:629
set
Definition: _set.h:46
CM_LOCATE_DEVINST_NORMAL
#define CM_LOCATE_DEVINST_NORMAL
Definition: cfgmgr32.h:766
ERROR_INVALID_FLAGS
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
DICD_GENERATE_ID
#define DICD_GENERATE_ID
Definition: setupapi.h:110
BOOL WINAPI SetupDiCreateDeviceInterfaceA ( HDEVINFO  DeviceInfoSet,
PSP_DEVINFO_DATA  DeviceInfoData,
const GUID *  InterfaceClassGuid,
PCSTR  ReferenceString,
DWORD  CreationFlags,
PSP_DEVICE_INTERFACE_DATA  DeviceInterfaceData 
)

Definition at line 2639 of file devinst.c.

2646 {
2647  BOOL ret;
2648  LPWSTR ReferenceStringW = NULL;
2649 
2650  TRACE("%p %p %s %s %08x %p\n", DeviceInfoSet, DeviceInfoData,
2651  debugstr_guid(InterfaceClassGuid), debugstr_a(ReferenceString),
2652  CreationFlags, DeviceInterfaceData);
2653 
2654  if (ReferenceString)
2655  {
2656  ReferenceStringW = pSetupMultiByteToUnicode(ReferenceString, CP_ACP);
2657  if (ReferenceStringW == NULL) return FALSE;
2658  }
2659 
2660  ret = SetupDiCreateDeviceInterfaceW(DeviceInfoSet, DeviceInfoData,
2661  InterfaceClassGuid, ReferenceStringW, CreationFlags,
2662  DeviceInterfaceData);
2663 
2664  MyFree(ReferenceStringW);
2665 
2666  return ret;
2667 }
SetupDiCreateDeviceInterfaceW
BOOL WINAPI SetupDiCreateDeviceInterfaceW(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, const GUID *InterfaceClassGuid, PCWSTR ReferenceString, DWORD CreationFlags, PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
Definition: devinst.c:2672
CP_ACP
#define CP_ACP
Definition: compat.h:99
FALSE
#define FALSE
Definition: types.h:117
pSetupMultiByteToUnicode
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
ReferenceString
_In_ CONST GUID _In_opt_ PUNICODE_STRING ReferenceString
Definition: iofuncs.h:1134
NULL
smooth NULL
Definition: ftsmooth.c:513
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
ret
int ret
Definition: wcstombs-tests.c:31
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
MyFree
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyA ( HDEVINFO  DeviceInfoSet,