#include "setupapi_private.h"

Include dependency graph for devinst.c:

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	IntSetupDiSetDeviceRegistryPropertyAW (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, const BYTE *PropertyBuffer, DWORD PropertyBufferSize, BOOL isAnsi)

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)

HKEY	SETUPDI_CreateDevKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)

HKEY	SETUPDI_CreateDrvKey (HKEY RootKey, struct DeviceInfo devInfo, UUID ClassGuid, REGSAM samDesired)

HKEY	SETUPDI_OpenDevKey (HKEY RootKey, struct DeviceInfo *devInfo, REGSAM samDesired)

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 4504 of file devinst.c.

Referenced by SetupDiSetDeviceInstallParamsW().

 {
     DWORD SupportedFlags =
         DI_NOVCP |                            /* 0x00000008 */
         DI_DIDCOMPAT |                        /* 0x00000010 */
         DI_DIDCLASS |                         /* 0x00000020 */
         DI_NEEDRESTART |                      /* 0x00000080 */
         DI_NEEDREBOOT |                       /* 0x00000100 */
         DI_RESOURCEPAGE_ADDED |               /* 0x00002000 */
         DI_PROPERTIES_CHANGE |                /* 0x00004000 */
         DI_ENUMSINGLEINF |                    /* 0x00010000 */
         DI_DONOTCALLCONFIGMG |                /* 0x00020000 */
         DI_CLASSINSTALLPARAMS |               /* 0x00100000 */
         DI_NODI_DEFAULTACTION |               /* 0x00200000 */
         DI_QUIETINSTALL |                     /* 0x00800000 */
         DI_NOFILECOPY |                       /* 0x01000000 */
         DI_DRIVERPAGE_ADDED;                  /* 0x04000000 */
     DWORD SupportedFlagsEx =
         DI_FLAGSEX_CI_FAILED |                /* 0x00000004 */
         DI_FLAGSEX_DIDINFOLIST |              /* 0x00000010 */
         DI_FLAGSEX_DIDCOMPATINFO |            /* 0x00000020 */
         DI_FLAGSEX_ALLOWEXCLUDEDDRVS |        /* 0x00000800 */
         DI_FLAGSEX_NO_DRVREG_MODIFY |         /* 0x00008000 */
         DI_FLAGSEX_INSTALLEDDRIVER;           /* 0x04000000 */
     BOOL ret = FALSE;
 
     /* FIXME: add support for more flags */
 
     /* FIXME: DI_CLASSINSTALLPARAMS flag is not correctly used.
      * It should be checked before accessing to other values
      * of the SP_DEVINSTALL_PARAMS structure */
 
     if (DeviceInstallParams->Flags & ~SupportedFlags)
     {
         FIXME("Unknown Flags: 0x%08lx\n", DeviceInstallParams->Flags & ~SupportedFlags);
         SetLastError(ERROR_INVALID_FLAGS);
     }
     else if (DeviceInstallParams->FlagsEx & ~SupportedFlagsEx)
     {
         FIXME("Unknown FlagsEx: 0x%08lx\n", DeviceInstallParams->FlagsEx & ~SupportedFlagsEx);
         SetLastError(ERROR_INVALID_FLAGS);
     }
     else if ((DeviceInstallParams->Flags & DI_NOVCP)
         && (DeviceInstallParams->FileQueue == NULL || DeviceInstallParams->FileQueue == (HSPFILEQ)INVALID_HANDLE_VALUE))
         SetLastError(ERROR_INVALID_USER_BUFFER);
     else
     {
         /* FIXME: check Reserved field */
         ret = TRUE;
     }
 
     return ret;
 }

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().

 {
     LPWSTR Section = NULL;
     //LPCWSTR pExtensionPlatform;
     LPCWSTR pExtensionArchitecture;
     LPWSTR Fields[6];
     DWORD i;
     BOOL ret = FALSE;
 
     //static const WCHAR ExtensionPlatformNone[]  = {'.',0};
     static const WCHAR ExtensionPlatformNT[]  = {'.','N','T',0};
     static const WCHAR ExtensionPlatformWindows[]  = {'.','W','i','n',0};
 
     static const WCHAR ExtensionArchitectureNone[]  = {0};
     static const WCHAR ExtensionArchitecturealpha[]  = {'a','l','p','h','a',0};
     static const WCHAR ExtensionArchitectureamd64[]  = {'A','M','D','6','4',0};
     static const WCHAR ExtensionArchitectureia64[]  = {'I','A','6','4',0};
     static const WCHAR ExtensionArchitecturemips[]  = {'m','i','p','s',0};
     static const WCHAR ExtensionArchitectureppc[]  = {'p','p','c',0};
     static const WCHAR ExtensionArchitecturex86[]  = {'x','8','6',0};
 
     TRACE("%s %p 0x%x 0x%x\n",
         debugstr_w(SectionName), PlatformInfo, ProductType, SuiteMask);
 
     *ScorePlatform = *ScoreMajorVersion = *ScoreMinorVersion = *ScoreProductType = *ScoreSuiteMask = 0;
 
     Section = pSetupDuplicateString(SectionName);
     if (!Section)
     {
         TRACE("pSetupDuplicateString() failed\n");
         goto cleanup;
     }
 
     /* Set various extensions values */
     switch (PlatformInfo->Platform)
     {
         case VER_PLATFORM_WIN32_WINDOWS:
             //pExtensionPlatform = ExtensionPlatformWindows;
             break;
         case VER_PLATFORM_WIN32_NT:
             //pExtensionPlatform = ExtensionPlatformNT;
             break;
         default:
             ERR("Unknown platform 0x%lx\n", PlatformInfo->Platform);
             //pExtensionPlatform = ExtensionPlatformNone;
             break;
     }
     switch (PlatformInfo->ProcessorArchitecture)
     {
         case PROCESSOR_ARCHITECTURE_ALPHA:
             pExtensionArchitecture = ExtensionArchitecturealpha;
             break;
         case PROCESSOR_ARCHITECTURE_AMD64:
             pExtensionArchitecture = ExtensionArchitectureamd64;
             break;
         case PROCESSOR_ARCHITECTURE_IA64:
             pExtensionArchitecture = ExtensionArchitectureia64;
             break;
         case PROCESSOR_ARCHITECTURE_INTEL:
             pExtensionArchitecture = ExtensionArchitecturex86;
             break;
         case PROCESSOR_ARCHITECTURE_MIPS:
             pExtensionArchitecture = ExtensionArchitecturemips;
             break;
         case PROCESSOR_ARCHITECTURE_PPC:
             pExtensionArchitecture = ExtensionArchitectureppc;
             break;
         default:
             ERR("Unknown processor architecture 0x%x\n", PlatformInfo->ProcessorArchitecture);
         case PROCESSOR_ARCHITECTURE_UNKNOWN:
             pExtensionArchitecture = ExtensionArchitectureNone;
             break;
     }
 
     /*
      * Field[0] Platform
      * Field[1] Architecture
      * Field[2] Major version
      * Field[3] Minor version
      * Field[4] Product type
      * Field[5] Suite mask
      * Remark: these fields may be NULL if the information is not provided
      */
     Fields[0] = Section;
     if (Fields[0] == NULL)
     {
         TRACE("No extension found\n");
         *ScorePlatform = *ScoreMajorVersion = *ScoreMinorVersion = *ScoreProductType = *ScoreSuiteMask = ULONG_MAX;
         ret = TRUE;
         goto cleanup;
     }
     Fields[1] = Fields[0] + 1;
     Fields[2] = Fields[3] = Fields[4] = Fields[5] = NULL;
     for (i = 2; Fields[i - 1] != NULL && i < 6; i++)
     {
         Fields[i] = wcschr(Fields[i - 1], '.');
         if (Fields[i])
         {
             Fields[i]++;
             *(Fields[i] - 1) = UNICODE_NULL;
         }
     }
     /* Take care of first 2 fields */
     if (strncmpiW(Fields[0], ExtensionPlatformWindows, strlenW(ExtensionPlatformWindows)) == 0)
     {
         if (PlatformInfo->Platform != VER_PLATFORM_WIN32_WINDOWS)
         {
             TRACE("Mismatch on platform field\n");
             goto cleanup;
         }
         Fields[1] += wcslen(ExtensionPlatformWindows) - 1;
     }
     else if (strncmpiW(Fields[0], ExtensionPlatformNT, strlenW(ExtensionPlatformNT)) == 0)
     {
         if (PlatformInfo->Platform != VER_PLATFORM_WIN32_NT)
         {
             TRACE("Mismatch on platform field\n");
             goto cleanup;
         }
         Fields[1] += wcslen(ExtensionPlatformNT) - 1;
     }
     else
     {
         /* No platform specified */
         *ScorePlatform |= 0x02;
     }
     if (strcmpiW(Fields[1], ExtensionArchitectureNone) == 0)
     {
         /* No architecture specified */
         *ScorePlatform |= 0x01;
     }
     else if (strcmpiW(Fields[1], pExtensionArchitecture) != 0)
     {
         TRACE("Mismatch on architecture field ('%s' and '%s')\n",
             debugstr_w(Fields[1]), debugstr_w(pExtensionArchitecture));
         goto cleanup;
     }
 
     /* Check if informations are matching */
     if (Fields[2] && *Fields[2])
     {
         DWORD MajorVersion, MinorVersion = 0;
         MajorVersion = strtoulW(Fields[2], NULL, 0);
         if ((MajorVersion == 0 || MajorVersion == ULONG_MAX) &&
             (errno == ERANGE || errno == EINVAL))
         {
             TRACE("Wrong MajorVersion ('%s')\n", debugstr_w(Fields[2]));
             goto cleanup;
         }
         if (Fields[3] && *Fields[3])
         {
             MinorVersion = strtoulW(Fields[3], NULL, 0);
             if ((MinorVersion == 0 || MinorVersion == ULONG_MAX) &&
                 (errno == ERANGE || errno == EINVAL))
             {
                 TRACE("Wrong MinorVersion ('%s')\n", debugstr_w(Fields[3]));
                 goto cleanup;
             }
         }
         if (PlatformInfo->MajorVersion < MajorVersion ||
             (PlatformInfo->MajorVersion == MajorVersion && PlatformInfo->MinorVersion < MinorVersion))
         {
             TRACE("Mismatch on version field (%lu.%lu and %lu.%lu)\n",
                 MajorVersion, MinorVersion, PlatformInfo->MajorVersion, PlatformInfo->MinorVersion);
             goto cleanup;
         }
         *ScoreMajorVersion = MajorVersion - PlatformInfo->MajorVersion;
         if (MajorVersion == PlatformInfo->MajorVersion)
             *ScoreMinorVersion = MinorVersion - PlatformInfo->MinorVersion;
         else
             *ScoreMinorVersion = MinorVersion;
     }
     else if (Fields[3] && *Fields[3])
     {
         TRACE("Minor version found without major version\n");
         goto cleanup;
     }
     else
     {
         *ScoreMajorVersion = PlatformInfo->MajorVersion;
         *ScoreMinorVersion = PlatformInfo->MinorVersion;
     }
 
     if (Fields[4] && *Fields[4])
     {
         DWORD CurrentProductType;
         CurrentProductType = strtoulW(Fields[4], NULL, 0);
         if ((CurrentProductType == 0 || CurrentProductType == ULONG_MAX) &&
             (errno == ERANGE || errno == EINVAL))
         {
             TRACE("Wrong Product type ('%s')\n", debugstr_w(Fields[4]));
             goto cleanup;
         }
         if (CurrentProductType != ProductType)
         {
             TRACE("Mismatch on product type (0x%08lx and 0x%08x)\n",
                 CurrentProductType, ProductType);
             goto cleanup;
         }
     }
     else
         *ScoreProductType = 1;
 
     if (Fields[5] && *Fields[5])
     {
         DWORD CurrentSuiteMask;
         CurrentSuiteMask = strtoulW(Fields[5], NULL, 0);
         if ((CurrentSuiteMask == 0 || CurrentSuiteMask == ULONG_MAX) &&
             (errno == ERANGE || errno == EINVAL))
         {
             TRACE("Wrong Suite mask ('%s')\n", debugstr_w(Fields[5]));
             goto cleanup;
         }
         if ((CurrentSuiteMask & ~SuiteMask) != 0)
         {
             TRACE("Mismatch on suite mask (0x%08lx and 0x%08x)\n",
                 CurrentSuiteMask, SuiteMask);
             goto cleanup;
         }
         *ScoreSuiteMask = SuiteMask & ~CurrentSuiteMask;
     }
     else
         *ScoreSuiteMask = SuiteMask;
 
     ret = TRUE;
 
 cleanup:
     MyFree(Section);
     return ret;
 }

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().

 {
     DWORD size;
     CONFIGRET cr;
     struct DeviceInfo *deviceInfo;
 
     *pDeviceInfo = NULL;
 
     size = FIELD_OFFSET(struct DeviceInfo, Data) + (strlenW(InstancePath) + 1) * sizeof(WCHAR);
     deviceInfo = HeapAlloc(GetProcessHeap(), 0, size);
     if (!deviceInfo)
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
         return FALSE;
     }
     ZeroMemory(deviceInfo, size);
 
     cr = CM_Locate_DevNode_ExW(&deviceInfo->dnDevInst, (DEVINSTID_W)InstancePath, CM_LOCATE_DEVNODE_PHANTOM, list->hMachine);
     if (cr != CR_SUCCESS)
     {
         SetLastError(GetErrorCodeFromCrCode(cr));
         return FALSE;
     }
 
     deviceInfo->set = list;
     deviceInfo->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
     strcpyW(deviceInfo->Data, InstancePath);
     deviceInfo->instanceId = deviceInfo->Data;
     deviceInfo->UniqueId = strrchrW(deviceInfo->Data, '\\');
     deviceInfo->DeviceDescription = NULL;
     memcpy(&deviceInfo->ClassGuid, pClassGuid, sizeof(GUID));
     deviceInfo->CreationFlags = 0;
     InitializeListHead(&deviceInfo->DriverListHead);
     InitializeListHead(&deviceInfo->InterfaceListHead);
 
     *pDeviceInfo = deviceInfo;
     return TRUE;
 }

static BOOL DestroyClassInstallParams ( struct ClassInstallParams * installParams )

static

Definition at line 571 of file devinst.c.

Referenced by DestroyDeviceInfo(), and DestroyDeviceInfoSet().

 {
     HeapFree(GetProcessHeap(), 0, installParams->PropChangeParams);
     HeapFree(GetProcessHeap(), 0, installParams->AddPropertyPageData);
     return TRUE;
 }

static BOOL DestroyDeviceInfo ( struct DeviceInfo * deviceInfo )

static

Definition at line 579 of file devinst.c.

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

 {
     PLIST_ENTRY ListEntry;
     struct DriverInfoElement *driverInfo;
     struct DeviceInterface *deviceInterface;
 
     while (!IsListEmpty(&deviceInfo->DriverListHead))
     {
         ListEntry = RemoveHeadList(&deviceInfo->DriverListHead);
         driverInfo = CONTAINING_RECORD(ListEntry, struct DriverInfoElement, ListEntry);
         if (!DestroyDriverInfoElement(driverInfo))
             return FALSE;
     }
     while (!IsListEmpty(&deviceInfo->InterfaceListHead))
     {
         ListEntry = RemoveHeadList(&deviceInfo->InterfaceListHead);
         deviceInterface = CONTAINING_RECORD(ListEntry, struct DeviceInterface, ListEntry);
         if (!DestroyDeviceInterface(deviceInterface))
             return FALSE;
     }
     DestroyClassInstallParams(&deviceInfo->ClassInstallParams);
     if (deviceInfo->hmodDevicePropPageProvider)
         FreeLibrary(deviceInfo->hmodDevicePropPageProvider);
     return HeapFree(GetProcessHeap(), 0, deviceInfo);
 }

static BOOL DestroyDeviceInfoSet ( struct DeviceInfoSet * list )

static

Definition at line 606 of file devinst.c.

Referenced by SetupDiDestroyDeviceInfoList().

 {
     PLIST_ENTRY ListEntry;
     struct DeviceInfo *deviceInfo;
 
     while (!IsListEmpty(&list->ListHead))
     {
         ListEntry = RemoveHeadList(&list->ListHead);
         deviceInfo = CONTAINING_RECORD(ListEntry, struct DeviceInfo, ListEntry);
         if (!DestroyDeviceInfo(deviceInfo))
             return FALSE;
     }
     if (list->HKLM != HKEY_LOCAL_MACHINE)
         RegCloseKey(list->HKLM);
     CM_Disconnect_Machine(list->hMachine);
     DestroyClassInstallParams(&list->ClassInstallParams);
     if (list->hmodClassPropPageProvider)
         FreeLibrary(list->hmodClassPropPageProvider);
     return HeapFree(GetProcessHeap(), 0, list);
 }

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().

 {
   switch (cr)
   {
     case CR_ACCESS_DENIED:        return ERROR_ACCESS_DENIED;
     case CR_BUFFER_SMALL:         return ERROR_INSUFFICIENT_BUFFER;
     case CR_CALL_NOT_IMPLEMENTED: return ERROR_CALL_NOT_IMPLEMENTED;
     case CR_FAILURE:              return ERROR_GEN_FAILURE;
     case CR_INVALID_DATA:         return ERROR_INVALID_USER_BUFFER;
     case CR_INVALID_DEVICE_ID:    return ERROR_INVALID_PARAMETER;
     case CR_INVALID_MACHINENAME:  return ERROR_INVALID_COMPUTERNAME;
     case CR_INVALID_DEVNODE:      return ERROR_INVALID_PARAMETER;
     case CR_INVALID_FLAG:         return ERROR_INVALID_FLAGS;
     case CR_INVALID_POINTER:      return ERROR_INVALID_PARAMETER;
     case CR_INVALID_PROPERTY:     return ERROR_INVALID_PARAMETER;
     case CR_NO_SUCH_DEVNODE:      return ERROR_FILE_NOT_FOUND;
     case CR_NO_SUCH_REGISTRY_KEY: return ERROR_FILE_NOT_FOUND;
     case CR_NO_SUCH_VALUE:        return ERROR_FILE_NOT_FOUND;
     case CR_OUT_OF_MEMORY:        return ERROR_NOT_ENOUGH_MEMORY;
     case CR_REGISTRY_ERROR:       return ERROR_GEN_FAILURE;
     case CR_ALREADY_SUCH_DEVINST: return ERROR_DEVINST_ALREADY_EXISTS;
     case CR_SUCCESS:              return ERROR_SUCCESS;
     default:                      return ERROR_GEN_FAILURE;
   }
 
   /* Does not happen */
 }

static BOOL GetSectionCallback	(	IN LPCWSTR	SectionName,
		IN PVOID	Context
	)

static

Definition at line 363 of file devinst.c.

Referenced by SetupDiGetActualSectionToInstallExW().

 {
     struct GetSectionCallbackInfo *info = Context;
     DWORD Score1, Score2, Score3, Score4, Score5;
     BOOL ret;
 
     if (SectionName[info->PrefixLength] != '.')
         return TRUE;
 
     ret = CheckSectionValid(
         &SectionName[info->PrefixLength],
         info->PlatformInfo,
         info->ProductType,
         info->SuiteMask,
         &Score1, &Score2, &Score3, &Score4, &Score5);
     if (!ret)
     {
         TRACE("Section %s not compatible\n", debugstr_w(SectionName));
         return TRUE;
     }
     if (Score1 > info->BestScore1) goto done;
     if (Score1 < info->BestScore1) goto bettersection;
     if (Score2 > info->BestScore2) goto done;
     if (Score2 < info->BestScore2) goto bettersection;
     if (Score3 > info->BestScore3) goto done;
     if (Score3 < info->BestScore3) goto bettersection;
     if (Score4 > info->BestScore4) goto done;
     if (Score4 < info->BestScore4) goto bettersection;
     if (Score5 > info->BestScore5) goto done;
     if (Score5 < info->BestScore5) goto bettersection;
     goto done;
 
 bettersection:
     strcpyW(info->BestSection, SectionName);
     info->BestScore1 = Score1;
     info->BestScore2 = Score2;
     info->BestScore3 = Score3;
     info->BestScore4 = Score4;
     info->BestScore5 = Score5;
 
 done:
     return TRUE;
 }

static BOOL InfIsFromOEMLocation	(	IN PCWSTR	FullName,
		OUT LPBOOL	IsOEMLocation
	)

static

Definition at line 5300 of file devinst.c.

Referenced by SetupDiInstallDevice().

 {
     PWCHAR last;
 
     last = strrchrW(FullName, '\\');
     if (!last)
     {
         /* No directory specified */
         *IsOEMLocation = FALSE;
     }
     else
     {
         LPWSTR Windir;
         UINT ret;
 
         Windir = MyMalloc((MAX_PATH + 1 + strlenW(InfDirectory)) * sizeof(WCHAR));
         if (!Windir)
         {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             return FALSE;
         }
 
         ret = GetSystemWindowsDirectoryW(Windir, MAX_PATH);
         if (ret == 0 || ret > MAX_PATH)
         {
             MyFree(Windir);
             SetLastError(ERROR_GEN_FAILURE);
             return FALSE;
         }
         if (*Windir && Windir[strlenW(Windir) - 1] != '\\')
             strcatW(Windir, BackSlash);
         strcatW(Windir, InfDirectory);
 
         if (strncmpiW(FullName, Windir, last - FullName) == 0)
         {
             /* The path is %SYSTEMROOT%\Inf */
             *IsOEMLocation = FALSE;
         }
         else
         {
             /* The file is in another place */
             *IsOEMLocation = TRUE;
         }
         MyFree(Windir);
     }
     return TRUE;
 }

static BOOL WINAPI IntSetupDiRegisterDeviceInfo	(	IN HDEVINFO	DeviceInfoSet,
		IN OUT PSP_DEVINFO_DATA	DeviceInfoData
	)

static

Definition at line 4019 of file devinst.c.

Referenced by SetupDiCallClassInstaller().

 {
     return SetupDiRegisterDeviceInfo(DeviceInfoSet, DeviceInfoData, 0, NULL, NULL, NULL);
 }

BOOL WINAPI IntSetupDiSetDeviceRegistryPropertyAW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Property,
		const BYTE *	PropertyBuffer,
		DWORD	PropertyBufferSize,
		BOOL	isAnsi
	)

Definition at line 3363 of file devinst.c.

Referenced by SetupDiSetDeviceRegistryPropertyA(), and SetupDiSetDeviceRegistryPropertyW().

 {
     BOOL ret = FALSE;
     struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
     struct DeviceInfo *deviceInfo;
 
     TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
         PropertyBuffer, PropertyBufferSize);
 
     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return FALSE;
     }
     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
     {
         SetLastError(ERROR_INVALID_HANDLE);
         return FALSE;
     }
     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
             || !DeviceInfoData->Reserved)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
 
     deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
     if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
         && PropertyMap[Property].nameW
         && PropertyMap[Property].nameA)
     {
         HKEY hKey;
         LONG l;
         hKey = SETUPDI_OpenDevKey(set->HKLM, deviceInfo, KEY_SET_VALUE);
         if (hKey == INVALID_HANDLE_VALUE)
             return FALSE;
         /* Write new data */
         if (isAnsi)
         {
             l = RegSetValueExA(
                 hKey, PropertyMap[Property].nameA, 0,
                     PropertyMap[Property].regType, PropertyBuffer,
                     PropertyBufferSize);
         } 
         else
         {
             l = RegSetValueExW(
                 hKey, PropertyMap[Property].nameW, 0,
                     PropertyMap[Property].regType, PropertyBuffer,
                     PropertyBufferSize);
         }
         if (!l)
             ret = TRUE;
         else
             SetLastError(l);
         RegCloseKey(hKey);
     }
     else
     {
         ERR("Property 0x%lx not implemented\n", Property);
         SetLastError(ERROR_NOT_SUPPORTED);
     }
 
     TRACE("Returning %d\n", ret);
     return ret;
 }

static BOOL IsDeviceInfoInDeviceInfoSet	(	struct DeviceInfoSet *	deviceInfoSet,
		struct DeviceInfo *	deviceInfo
	)

static

Definition at line 4695 of file devinst.c.

Referenced by SetupDiDeleteDeviceInfo().

 {
     PLIST_ENTRY ListEntry;
 
     ListEntry = deviceInfoSet->ListHead.Flink;
     while (ListEntry != &deviceInfoSet->ListHead)
     {
         if (deviceInfo == CONTAINING_RECORD(ListEntry, struct DeviceInfo, ListEntry))
             return TRUE;
 
         ListEntry = ListEntry->Flink;
     }
 
     return FALSE;
 }

static HKEY OpenHardwareProfileKey	(	IN HKEY	HKLM,
		IN DWORD	HwProfile,
		IN DWORD	samDesired
	)

static

Definition at line 4640 of file devinst.c.

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

 {
     HKEY hHWProfilesKey = NULL;
     HKEY hHWProfileKey = NULL;
     HKEY ret = INVALID_HANDLE_VALUE;
     LONG rc;
 
     rc = RegOpenKeyExW(HKLM,
                        REGSTR_PATH_HWPROFILES,
                        0,
                        READ_CONTROL,
                        &hHWProfilesKey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     if (HwProfile == 0)
     {
         rc = RegOpenKeyExW(hHWProfilesKey,
                            REGSTR_KEY_CURRENT,
                            0,
                            KEY_CREATE_SUB_KEY,
                            &hHWProfileKey);
     }
     else
     {
         WCHAR subKey[5];
         snprintfW(subKey, 4, InstanceKeyFormat, HwProfile);
         subKey[4] = '\0';
         rc = RegOpenKeyExW(hHWProfilesKey,
                            subKey,
                            0,
                            KEY_CREATE_SUB_KEY,
                            &hHWProfileKey);
     }
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     ret = hHWProfileKey;
 
 cleanup:
     if (hHWProfilesKey != NULL)
         RegCloseKey(hHWProfilesKey);
     if (hHWProfileKey != NULL && hHWProfileKey != ret)
         RegCloseKey(hHWProfileKey);
     return ret;
 }

static BOOL ResetDevice	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData
	)

static

Definition at line 5025 of file devinst.c.

 {
 #ifndef __WINESRC__
     struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
     struct DeviceInfo *deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
     CONFIGRET cr;
 
     cr = CM_Enable_DevNode_Ex(deviceInfo->dnDevInst, 0, set->hMachine);
     if (cr != CR_SUCCESS)
     {
         SetLastError(GetErrorCodeFromCrCode(cr));
         return FALSE;
     }
 
     return TRUE;
 #else
     FIXME("Stub: ResetDevice(%p %p)\n", DeviceInfoSet, DeviceInfoData);
     return TRUE;
 #endif
 }

HKEY SETUP_CreateClassKey ( HINF hInf )

Definition at line 3523 of file devinst.c.

Referenced by SetupDiInstallClassExW().

 {
     WCHAR FullBuffer[MAX_PATH];
     WCHAR Buffer[MAX_PATH];
     DWORD RequiredSize;
     HKEY hClassKey;
     DWORD Disposition;
 
     /* Obtain the Class GUID for this class */
     if (!SetupGetLineTextW(NULL,
                            hInf,
                            Version,
                            REGSTR_VAL_CLASSGUID,
                            Buffer,
                            sizeof(Buffer) / sizeof(WCHAR),
                            &RequiredSize))
     {
         return INVALID_HANDLE_VALUE;
     }
 
     /* Build the corresponding registry key name */
     lstrcpyW(FullBuffer, REGSTR_PATH_CLASS_NT);
     lstrcatW(FullBuffer, BackSlash);
     lstrcatW(FullBuffer, Buffer);
 
     /* Obtain the Class name for this class */
     if (!SetupGetLineTextW(NULL,
                            hInf,
                            Version,
                            REGSTR_VAL_CLASS,
                            Buffer,
                            sizeof(Buffer) / sizeof(WCHAR),
                            &RequiredSize))
     {
         return INVALID_HANDLE_VALUE;
     }
 
     /* Try to open or create the registry key */
     TRACE("Opening class key %s\n", debugstr_w(FullBuffer));
 #if 0 // I keep this for reference...
     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                       FullBuffer,
                       0,
                       KEY_SET_VALUE,
                       &hClassKey))
     {
         /* Use RegCreateKeyExW */
     }
 #endif
     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                         FullBuffer,
                         0,
                         NULL,
                         REG_OPTION_NON_VOLATILE,
                         KEY_SET_VALUE,
                         NULL,
                         &hClassKey,
                         &Disposition))
     {
         ERR("RegCreateKeyExW(%s) failed\n", debugstr_w(FullBuffer));
         return INVALID_HANDLE_VALUE;
     }
     if (Disposition == REG_CREATED_NEW_KEY)
         TRACE("The class key %s was successfully created\n", debugstr_w(FullBuffer));
     else
         TRACE("The class key %s was successfully opened\n", debugstr_w(FullBuffer));
 
     TRACE( "setting value %s to %s\n", debugstr_w(REGSTR_VAL_CLASS), debugstr_w(Buffer) );
     if (RegSetValueExW(hClassKey,
                        REGSTR_VAL_CLASS,
                        0,
                        REG_SZ,
                        (LPBYTE)Buffer,
                        RequiredSize * sizeof(WCHAR)))
     {
         RegCloseKey(hClassKey);
         RegDeleteKeyW(HKEY_LOCAL_MACHINE,
                       FullBuffer);
         return INVALID_HANDLE_VALUE;
     }
 
     return hClassKey;
 }

static DWORD SETUPAPI_GetCurrentHwProfile ( IN HDEVINFO DeviceInfoSet )

static

Definition at line 4978 of file devinst.c.

Referenced by SetupDiChangeState().

 {
     HKEY hKey = NULL;
     DWORD dwRegType, dwLength;
     DWORD hwProfile;
     LONG rc;
     DWORD ret = (DWORD)-1;
 
     rc = RegOpenKeyExW(((struct DeviceInfoSet *)DeviceInfoSet)->HKLM,
                        REGSTR_PATH_IDCONFIGDB,
                        0, /* Options */
                        KEY_QUERY_VALUE,
                        &hKey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
 
     dwLength = sizeof(DWORD);
     rc = RegQueryValueExW(hKey,
                           REGSTR_VAL_CURRENTCONFIG,
                           NULL,
                           &dwRegType,
                           (LPBYTE)&hwProfile, &dwLength);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
     {
         SetLastError(ERROR_GEN_FAILURE);
         goto cleanup;
     }
 
     ret = hwProfile;
 
 cleanup:
     if (hKey != NULL)
         RegCloseKey(hKey);
 
     return ret;
 }

HKEY SETUPDI_CreateDevKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5656 of file devinst.c.

Referenced by SetupDiChangeState(), and SetupDiCreateDevRegKeyW().

 {
     HKEY enumKey, key = INVALID_HANDLE_VALUE;
     LONG l;
 
     l = RegCreateKeyExW(RootKey, REGSTR_PATH_SYSTEMENUM, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_CREATE_SUB_KEY, NULL, &enumKey, NULL);
     if (!l)
     {
         l = RegCreateKeyExW(enumKey, devInfo->instanceId, 0, NULL, REG_OPTION_NON_VOLATILE, samDesired, NULL, &key, NULL);
         RegCloseKey(enumKey);
     }
     if (l)
         SetLastError(l);
     return key;
 }

HKEY SETUPDI_CreateDrvKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		UUID *	ClassGuid,
		REGSAM	samDesired
	)

Definition at line 5672 of file devinst.c.

Referenced by SetupDiCreateDevRegKeyW(), SetupDiInstallDevice(), and SetupDiRegisterCoDeviceInstallers().

 {
     HKEY key = INVALID_HANDLE_VALUE;
     LPWSTR lpGuidString = NULL;
     LPWSTR DriverKey = NULL; /* {GUID}\Index */
     LPWSTR pDeviceInstance; /* Points into DriverKey, on the Index field */
     DWORD Index; /* Index used in the DriverKey name */
     DWORD dwSize;
     DWORD Disposition;
     DWORD rc;
     HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
     HKEY hEnumKey = NULL;
     HKEY hClassKey = NULL;
     HKEY hDeviceKey = INVALID_HANDLE_VALUE;
     HKEY hKey = NULL;
 
     /* Open device key, to read Driver value */
     hDeviceKey = SETUPDI_OpenDevKey(RootKey, devInfo, KEY_QUERY_VALUE | KEY_SET_VALUE);
     if (hDeviceKey == INVALID_HANDLE_VALUE)
         goto cleanup;
 
     rc = RegOpenKeyExW(RootKey, REGSTR_PATH_CLASS_NT, 0, KEY_CREATE_SUB_KEY, &hClassKey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
 
     rc = RegQueryValueExW(hDeviceKey, REGSTR_VAL_DRIVER, NULL, NULL, NULL, &dwSize);
     if (rc != ERROR_SUCCESS)
     {
         /* Create a new driver key */
 
         if (UuidToStringW(ClassGuid, &lpGuidString) != RPC_S_OK)
             goto cleanup;
 
         /* The driver key is in \System\CurrentControlSet\Control\Class\{GUID}\Index */
         DriverKey = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpGuidString) + 7) * sizeof(WCHAR) + sizeof(UNICODE_NULL));
         if (!DriverKey)
         {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
 
         DriverKey[0] = '{';
         strcpyW(&DriverKey[1], lpGuidString);
         pDeviceInstance = &DriverKey[strlenW(DriverKey)];
         *pDeviceInstance++ = '}';
         *pDeviceInstance++ = '\\';
 
         /* Try all values for Index between 0 and 9999 */
         Index = 0;
         while (Index <= 9999)
         {
             sprintfW(pDeviceInstance, InstanceKeyFormat, Index);
             rc = RegCreateKeyExW(hClassKey,
                 DriverKey,
                 0,
                 NULL,
                 REG_OPTION_NON_VOLATILE,
 #if _WIN32_WINNT >= 0x502
                 KEY_READ | KEY_WRITE,
 #else
                 KEY_ALL_ACCESS,
 #endif
                 NULL,
                 &hKey,
                 &Disposition);
             if (rc != ERROR_SUCCESS)
             {
                 SetLastError(rc);
                 goto cleanup;
             }
             if (Disposition == REG_CREATED_NEW_KEY)
                 break;
             RegCloseKey(hKey);
             hKey = NULL;
             Index++;
         }
 
         if (Index > 9999)
         {
             /* Unable to create more than 9999 devices within the same class */
             SetLastError(ERROR_GEN_FAILURE);
             goto cleanup;
         }
 
         /* Write the new Driver value */
         rc = RegSetValueExW(hDeviceKey, REGSTR_VAL_DRIVER, 0, REG_SZ, (const BYTE *)DriverKey, (strlenW(DriverKey) + 1) * sizeof(WCHAR));
         if (rc != ERROR_SUCCESS)
         {
             SetLastError(rc);
             goto cleanup;
         }
     }
     else
     {
         /* Open the existing driver key */
 
         DriverKey = HeapAlloc(GetProcessHeap(), 0, dwSize);
         if (!DriverKey)
         {
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
 
         rc = RegQueryValueExW(hDeviceKey, REGSTR_VAL_DRIVER, NULL, NULL, (LPBYTE)DriverKey, &dwSize);
         if (rc != ERROR_SUCCESS)
         {
             SetLastError(rc);
             goto cleanup;
         }
 
         rc = RegCreateKeyExW(hClassKey,
             DriverKey,
             0,
             NULL,
             REG_OPTION_NON_VOLATILE,
 #if _WIN32_WINNT >= 0x502
             KEY_READ | KEY_WRITE,
 #else
             KEY_ALL_ACCESS,
 #endif
             NULL,
             &hKey,
             &Disposition);
         if (rc != ERROR_SUCCESS)
         {
             SetLastError(rc);
             goto cleanup;
         }
     }
 
     key = hKey;
 
 cleanup:
         if (lpGuidString)
             RpcStringFreeW(&lpGuidString);
         HeapFree(GetProcessHeap(), 0, DriverKey);
         if (hHWProfileKey != INVALID_HANDLE_VALUE)
             RegCloseKey(hHWProfileKey);
         if (hEnumKey != NULL)
             RegCloseKey(hEnumKey);
         if (hClassKey != NULL)
             RegCloseKey(hClassKey);
         if (hDeviceKey != INVALID_HANDLE_VALUE)
             RegCloseKey(hDeviceKey);
         if (hKey != NULL && hKey != key)
             RegCloseKey(hKey);
 
     TRACE("Returning 0x%p\n", hKey);
     return hKey;
 }

static BOOL SETUPDI_DeleteDevKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo
	)

static

Definition at line 6003 of file devinst.c.

Referenced by SetupDiDeleteDevRegKey().

 {
     FIXME("\n");
     return FALSE;
 }

static BOOL SETUPDI_DeleteDrvKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo
	)

static

Definition at line 6009 of file devinst.c.

Referenced by SetupDiDeleteDevRegKey().

 {
     FIXME("\n");
     return FALSE;
 }

static void SETUPDI_GuidToString	(	const GUID *	guid,
		LPWSTR	guidStr
	)

static

Definition at line 79 of file devinst.c.

Referenced by SetupDiCreateDeviceInterfaceRegKeyW(), and SetupDiOpenClassRegKeyExW().

 {
     static const WCHAR fmt[] = {'{','%','0','8','X','-','%','0','4','X','-',
         '%','0','4','X','-','%','0','2','X','%','0','2','X','-','%','0','2',
         'X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%',
         '0','2','X','}',0};
 
     sprintfW(guidStr, fmt, guid->Data1, guid->Data2, guid->Data3,
         guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
         guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 }

HKEY SETUPDI_OpenDevKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5826 of file devinst.c.

Referenced by IntSetupDiSetDeviceRegistryPropertyAW(), SETUPDI_CreateDrvKey(), SETUPDI_OpenDrvKey(), SetupDiGetDeviceRegistryPropertyW(), SetupDiInstallDevice(), and SetupDiOpenDevRegKey().

 {
     HKEY enumKey, key = INVALID_HANDLE_VALUE;
     LONG l;
 
     l = RegOpenKeyExW(RootKey, REGSTR_PATH_SYSTEMENUM, 0, READ_CONTROL, &enumKey);
     if (!l)
     {
         l = RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
         RegCloseKey(enumKey);
     }
     if (l)
         SetLastError(l);
     return key;
 }

HKEY SETUPDI_OpenDrvKey	(	HKEY	RootKey,
		struct DeviceInfo *	devInfo,
		REGSAM	samDesired
	)

Definition at line 5842 of file devinst.c.

Referenced by SetupDiBuildDriverInfoList(), SetupDiCallClassInstaller(), SetupDiChangeState(), SetupDiGetClassDevPropertySheetsW(), SetupDiInstallDevice(), SetupDiOpenDevRegKey(), and SetupDiRegisterCoDeviceInstallers().

 {
     LPWSTR DriverKey = NULL;
     DWORD dwLength = 0;
     DWORD dwRegType;
     DWORD rc;
     HKEY hEnumKey = NULL;
     HKEY hKey = NULL;
     HKEY key = INVALID_HANDLE_VALUE;
 
     hKey = SETUPDI_OpenDevKey(RootKey, devInfo, KEY_QUERY_VALUE);
     if (hKey == INVALID_HANDLE_VALUE)
         goto cleanup;
     /* Read the 'Driver' key */
     rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, NULL, &dwLength);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     else if (dwRegType != REG_SZ)
     {
         SetLastError(ERROR_GEN_FAILURE);
         goto cleanup;
     }
     DriverKey = HeapAlloc(GetProcessHeap(), 0, dwLength);
     if (!DriverKey)
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
         goto cleanup;
     }
     rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, (LPBYTE)DriverKey, &dwLength);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     RegCloseKey(hKey);
     hKey = NULL;
     /* Need to open the driver key */
     rc = RegOpenKeyExW(
         RootKey,
         REGSTR_PATH_CLASS_NT,
         0, /* Options */
         READ_CONTROL,
         &hEnumKey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     rc = RegOpenKeyExW(
         hEnumKey,
         DriverKey,
         0, /* Options */
         samDesired,
         &hKey);
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         goto cleanup;
     }
     key = hKey;
 
 cleanup:
     if (hEnumKey != NULL)
         RegCloseKey(hEnumKey);
     if (hKey != NULL && hKey != key)
         RegCloseKey(hKey);
     if (DriverKey)
         HeapFree(GetProcessHeap(), 0, DriverKey);
     return key;
 }

BOOL WINAPI SetupDiBuildClassInfoList	(	DWORD	Flags,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize
	)

Definition at line 643 of file devinst.c.

Referenced by test_SetupDiBuildClassInfoList().

 {
     TRACE("\n");
     return SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
                                         ClassGuidListSize, RequiredSize,
                                         NULL, NULL);
 }

BOOL WINAPI SetupDiBuildClassInfoListExA	(	DWORD	Flags,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize,
		LPCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 673 of file devinst.c.

 {
     LPWSTR MachineNameW = NULL;
     BOOL bResult;
 
     TRACE("0x%lx %p %lu %p %s %p\n", Flags, ClassGuidList,
         ClassGuidListSize, RequiredSize, debugstr_a(MachineName), Reserved);
 
     if (MachineName)
     {
         MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
         if (MachineNameW == NULL) return FALSE;
     }
 
     bResult = SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
                                            ClassGuidListSize, RequiredSize,
                                            MachineNameW, Reserved);
 
     MyFree(MachineNameW);
 
     return bResult;
 }

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().

 {
     WCHAR szKeyName[40];
     HKEY hClassesKey = INVALID_HANDLE_VALUE;
     HKEY hClassKey;
     DWORD dwLength;
     DWORD dwIndex;
     LONG lError;
     DWORD dwGuidListIndex = 0;
 
     TRACE("0x%lx %p %lu %p %s %p\n", Flags, ClassGuidList,
         ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
 
     if (!RequiredSize)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
     else if (!ClassGuidList && ClassGuidListSize > 0)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
 
     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
                                             KEY_ENUMERATE_SUB_KEYS,
                                             DIOCR_INSTALLER,
                                             MachineName,
                                             Reserved);
     if (hClassesKey == INVALID_HANDLE_VALUE)
     {
         return FALSE;
     }
 
     for (dwIndex = 0; ; dwIndex++)
     {
         dwLength = 40;
         lError = RegEnumKeyExW(hClassesKey,
                                dwIndex,
                                szKeyName,
                                &dwLength,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
         TRACE("RegEnumKeyExW() returns %d\n", lError);
         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
         {
             TRACE("Key name: %s\n", debugstr_w(szKeyName));
 
             if (RegOpenKeyExW(hClassesKey,
                               szKeyName,
                               0,
                               KEY_QUERY_VALUE,
                               &hClassKey))
             {
                 RegCloseKey(hClassesKey);
                 return FALSE;
             }
 
             if (!RegQueryValueExW(hClassKey,
                                   REGSTR_VAL_NOUSECLASS,
                                   NULL,
                                   NULL,
                                   NULL,
                                   NULL))
             {
                 TRACE("'NoUseClass' value found!\n");
                 RegCloseKey(hClassKey);
                 continue;
             }
 
             if ((Flags & DIBCI_NOINSTALLCLASS) &&
                 (!RegQueryValueExW(hClassKey,
                                    REGSTR_VAL_NOINSTALLCLASS,
                                    NULL,
                                    NULL,
                                    NULL,
                                    NULL)))
             {
                 TRACE("'NoInstallClass' value found!\n");
                 RegCloseKey(hClassKey);
                 continue;
             }
 
             if ((Flags & DIBCI_NODISPLAYCLASS) &&
                 (!RegQueryValueExW(hClassKey,
                                    REGSTR_VAL_NODISPLAYCLASS,
                                    NULL,
                                    NULL,
                                    NULL,
                                    NULL)))
             {
                 TRACE("'NoDisplayClass' value found!\n");
                 RegCloseKey(hClassKey);
                 continue;
             }
 
             RegCloseKey(hClassKey);
 
             TRACE("Guid: %s\n", debugstr_w(szKeyName));
             if (dwGuidListIndex < ClassGuidListSize)
             {
                 if (szKeyName[0] == '{' && szKeyName[37] == '}')
                 {
                     szKeyName[37] = 0;
                 }
                 TRACE("Guid: %p\n", &szKeyName[1]);
 
                 UuidFromStringW(&szKeyName[1],
                                 &ClassGuidList[dwGuidListIndex]);
             }
 
             dwGuidListIndex++;
         }
 
         if (lError != ERROR_SUCCESS)
             break;
     }
 
     RegCloseKey(hClassesKey);
 
     if (RequiredSize != NULL)
         *RequiredSize = dwGuidListIndex;
 
     if (ClassGuidListSize < dwGuidListIndex)
     {
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         return FALSE;
     }
 
     return TRUE;
 }

BOOL WINAPI SetupDiCallClassInstaller	(	DI_FUNCTION	InstallFunction,
		HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 4029 of file devinst.c.

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

 {
     BOOL ret = FALSE;
 
     TRACE("%u %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
 
     if (!DeviceInfoSet)
         SetLastError(ERROR_INVALID_PARAMETER);
     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
         SetLastError(ERROR_INVALID_HANDLE);
     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
         SetLastError(ERROR_INVALID_HANDLE);
     else if (((struct DeviceInfoSet *)DeviceInfoSet)->HKLM != HKEY_LOCAL_MACHINE)
         SetLastError(ERROR_INVALID_HANDLE);
     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
         SetLastError(ERROR_INVALID_USER_BUFFER);
     else
     {
         SP_DEVINSTALL_PARAMS_W InstallParams;
 #define CLASS_COINSTALLER  0x1
 #define DEVICE_COINSTALLER 0x2
 #define CLASS_INSTALLER    0x4
         UCHAR CanHandle = 0;
         DEFAULT_CLASS_INSTALL_PROC DefaultHandler = NULL;
 
         switch (InstallFunction)
         {
             case DIF_ADDPROPERTYPAGE_ADVANCED:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_ADDREMOTEPROPERTYPAGE_ADVANCED:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_ALLOW_INSTALL:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_DETECT:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_DESTROYPRIVATEDATA:
                 CanHandle = CLASS_INSTALLER;
                 break;
             case DIF_INSTALLDEVICE:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiInstallDevice;
                 break;
             case DIF_INSTALLDEVICEFILES:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiInstallDriverFiles;
                 break;
             case DIF_INSTALLINTERFACES:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiInstallDeviceInterfaces;
                 break;
             case DIF_NEWDEVICEWIZARD_FINISHINSTALL:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_NEWDEVICEWIZARD_POSTANALYZE:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_NEWDEVICEWIZARD_PREANALYZE:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_NEWDEVICEWIZARD_PRESELECT:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_NEWDEVICEWIZARD_SELECT:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_POWERMESSAGEWAKE:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_PROPERTYCHANGE:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiChangeState;
                 break;
             case DIF_REGISTER_COINSTALLERS:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiRegisterCoDeviceInstallers;
                 break;
             case DIF_REGISTERDEVICE:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = IntSetupDiRegisterDeviceInfo;
                 break;
             case DIF_REMOVE:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiRemoveDevice;
                 break;
             case DIF_SELECTBESTCOMPATDRV:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiSelectBestCompatDrv;
                 break;
             case DIF_SELECTDEVICE:
                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiSelectDevice;
                 break;
             case DIF_TROUBLESHOOTER:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 break;
             case DIF_UNREMOVE:
                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
                 DefaultHandler = SetupDiUnremoveDevice;
                 break;
             default:
                 ERR("Install function %u not supported\n", InstallFunction);
                 SetLastError(ERROR_NOT_SUPPORTED);
         }
 
         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
         if (!SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams))
             /* Don't process this call, as a parameter is invalid */
             CanHandle = 0;
 
         if (CanHandle != 0)
         {
             LIST_ENTRY ClassCoInstallersListHead;
             LIST_ENTRY DeviceCoInstallersListHead;
             HMODULE ClassInstallerLibrary = NULL;
             CLASS_INSTALL_PROC ClassInstaller = NULL;
             COINSTALLER_CONTEXT_DATA Context;
             PLIST_ENTRY ListEntry;
             HKEY hKey;
             DWORD dwRegType, dwLength;
             DWORD rc = NO_ERROR;
 
             InitializeListHead(&ClassCoInstallersListHead);
             InitializeListHead(&DeviceCoInstallersListHead);
 
             if (CanHandle & DEVICE_COINSTALLER)
             {
                 hKey = SETUPDI_OpenDrvKey(((struct DeviceInfoSet *)DeviceInfoSet)->HKLM, (struct DeviceInfo *)DeviceInfoData->Reserved, KEY_QUERY_VALUE);
                 if (hKey != INVALID_HANDLE_VALUE)
                 {
                     rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, &dwRegType, NULL, &dwLength);
                     if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
                     {
                         LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
                         if (KeyBuffer != NULL)
                         {
                             rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
                             if (rc == ERROR_SUCCESS)
                             {
                                 LPWSTR ptr;
                                 for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
                                 {
                                     /* Add coinstaller to DeviceCoInstallersListHead list */
                                     struct CoInstallerElement *coinstaller;
                                     TRACE("Got device coinstaller '%s'\n", debugstr_w(ptr));
                                     coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
                                     if (!coinstaller)
                                         continue;
                                     ZeroMemory(coinstaller, sizeof(struct CoInstallerElement));
                                     if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
                                         InsertTailList(&DeviceCoInstallersListHead, &coinstaller->ListEntry);
                                     else
                                         HeapFree(GetProcessHeap(), 0, coinstaller);
                                 }
                             }
                             HeapFree(GetProcessHeap(), 0, KeyBuffer);
                         }
                     }
                     RegCloseKey(hKey);
                 }
             }
             if (CanHandle & CLASS_COINSTALLER)
             {
                 rc = RegOpenKeyExW(
                     HKEY_LOCAL_MACHINE,
                     REGSTR_PATH_CODEVICEINSTALLERS,
                     0, /* Options */
                     KEY_QUERY_VALUE,
                     &hKey);
                 if (rc == ERROR_SUCCESS)
                 {
                     WCHAR szGuidString[40];
                     if (pSetupStringFromGuid(&DeviceInfoData->ClassGuid, szGuidString, ARRAYSIZE(szGuidString)) == ERROR_SUCCESS)
                     {
                         rc = RegQueryValueExW(hKey, szGuidString, NULL, &dwRegType, NULL, &dwLength);
                         if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
                         {
                             LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
                             if (KeyBuffer != NULL)
                             {
                                 rc = RegQueryValueExW(hKey, szGuidString, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
                                 if (rc == ERROR_SUCCESS)
                                 {
                                     LPWSTR ptr;
                                     for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
                                     {
                                         /* Add coinstaller to ClassCoInstallersListHead list */
                                         struct CoInstallerElement *coinstaller;
                                         TRACE("Got class coinstaller '%s'\n", debugstr_w(ptr));
                                         coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
                                         if (!coinstaller)
                                             continue;
                                         ZeroMemory(coinstaller, sizeof(struct CoInstallerElement));
                                         if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
                                             InsertTailList(&ClassCoInstallersListHead, &coinstaller->ListEntry);
                                         else
                                             HeapFree(GetProcessHeap(), 0, coinstaller);
                                     }
                                 }
                                 HeapFree(GetProcessHeap(), 0, KeyBuffer);
                             }
                         }
                     }
                     RegCloseKey(hKey);
                 }
             }
             if ((CanHandle & CLASS_INSTALLER) && !(InstallParams.FlagsEx & DI_FLAGSEX_CI_FAILED))
             {
                 hKey = SetupDiOpenClassRegKey(&DeviceInfoData->ClassGuid, KEY_QUERY_VALUE);
                 if (hKey != INVALID_HANDLE_VALUE)
                 {
                     rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, &dwRegType, NULL, &dwLength);
                     if (rc == ERROR_SUCCESS && dwRegType == REG_SZ)
                     {
                         LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
                         if (KeyBuffer != NULL)
                         {
                             rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
                             if (rc == ERROR_SUCCESS)
                             {
                                 /* Get ClassInstaller function pointer */
                                 TRACE("Got class installer '%s'\n", debugstr_w(KeyBuffer));
                                 if (GetFunctionPointer(KeyBuffer, &ClassInstallerLibrary, (PVOID*)&ClassInstaller) != ERROR_SUCCESS)
                                 {
                                     InstallParams.FlagsEx |= DI_FLAGSEX_CI_FAILED;
                                     SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
                                 }
                             }
                             HeapFree(GetProcessHeap(), 0, KeyBuffer);
                         }
                     }
                     RegCloseKey(hKey);
                 }
             }
 
             /* Call Class co-installers */
             Context.PostProcessing = FALSE;
             rc = NO_ERROR;
             ListEntry = ClassCoInstallersListHead.Flink;
             while (rc == NO_ERROR && ListEntry != &ClassCoInstallersListHead)
             {
                 struct CoInstallerElement *coinstaller;
                 coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
                 rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
                 coinstaller->PrivateData = Context.PrivateData;
                 if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
                 {
                     coinstaller->DoPostProcessing = TRUE;
                     rc = NO_ERROR;
                 }
                 ListEntry = ListEntry->Flink;
             }
 
             /* Call Device co-installers */
             ListEntry = DeviceCoInstallersListHead.Flink;
             while (rc == NO_ERROR && ListEntry != &DeviceCoInstallersListHead)
             {
                 struct CoInstallerElement *coinstaller;
                 coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
                 rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
                 coinstaller->PrivateData = Context.PrivateData;
                 if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
                 {
                     coinstaller->DoPostProcessing = TRUE;
                     rc = NO_ERROR;
                 }
                 ListEntry = ListEntry->Flink;
             }
 
             /* Call Class installer */
             if (ClassInstaller)
             {
                 rc = (*ClassInstaller)(InstallFunction, DeviceInfoSet, DeviceInfoData);
                 FreeFunctionPointer(ClassInstallerLibrary, ClassInstaller);
             }
             else
                 rc = ERROR_DI_DO_DEFAULT;
 
             /* Call default handler */
             if (rc == ERROR_DI_DO_DEFAULT)
             {
                 if (DefaultHandler && !(InstallParams.Flags & DI_NODI_DEFAULTACTION))
                 {
                     if ((*DefaultHandler)(DeviceInfoSet, DeviceInfoData))
                         rc = NO_ERROR;
                     else
                         rc = GetLastError();
                 }
                 else
                     rc = NO_ERROR;
             }
 
             /* Call Class co-installers that required postprocessing */
             Context.PostProcessing = TRUE;
             ListEntry = ClassCoInstallersListHead.Flink;
             while (ListEntry != &ClassCoInstallersListHead)
             {
                 struct CoInstallerElement *coinstaller;
                 coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
                 if (coinstaller->DoPostProcessing)
                 {
                     Context.InstallResult = rc;
                     Context.PrivateData = coinstaller->PrivateData;
                     rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
                 }
                 FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
                 ListEntry = ListEntry->Flink;
             }
 
             /* Call Device co-installers that required postprocessing */
             ListEntry = DeviceCoInstallersListHead.Flink;
             while (ListEntry != &DeviceCoInstallersListHead)
             {
                 struct CoInstallerElement *coinstaller;
                 coinstaller = CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry);
                 if (coinstaller->DoPostProcessing)
                 {
                     Context.InstallResult = rc;
                     Context.PrivateData = coinstaller->PrivateData;
                     rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
                 }
                 FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
                 ListEntry = ListEntry->Flink;
             }
 
             /* Free allocated memory */
             while (!IsListEmpty(&ClassCoInstallersListHead))
             {
                 ListEntry = RemoveHeadList(&ClassCoInstallersListHead);
                 HeapFree(GetProcessHeap(), 0, CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry));
             }
             while (!IsListEmpty(&DeviceCoInstallersListHead))
             {
                 ListEntry = RemoveHeadList(&DeviceCoInstallersListHead);
                 HeapFree(GetProcessHeap(), 0, CONTAINING_RECORD(ListEntry, struct CoInstallerElement, ListEntry));
             }
 
             ret = (rc == NO_ERROR);
         }
     }
 
     TRACE("Returning %d\n", ret);
     return ret;
 }

BOOL WINAPI SetupDiChangeState	(	IN HDEVINFO	DeviceInfoSet,
		IN OUT PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 5060 of file devinst.c.

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

 {
     struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
     struct DeviceInfo *deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
     PSP_PROPCHANGE_PARAMS PropChange;
     HKEY hRootKey = INVALID_HANDLE_VALUE, hKey = INVALID_HANDLE_VALUE;
     LPCWSTR RegistryValueName;
     DWORD dwConfigFlags, dwLength, dwRegType;
     LONG rc;
     BOOL ret = FALSE;
 
     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
 
     if (!DeviceInfoData)
         PropChange = ((struct DeviceInfoSet *)DeviceInfoSet)->ClassInstallParams.PropChangeParams;
     else
         PropChange = ((struct DeviceInfo *)DeviceInfoData->Reserved)->ClassInstallParams.PropChangeParams;
     if (!PropChange)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         goto cleanup;
     }
 
     if (PropChange->Scope == DICS_FLAG_GLOBAL)
         RegistryValueName = REGSTR_VAL_CONFIGFLAGS;
     else
         RegistryValueName = REGSTR_VAL_CSCONFIGFLAGS;
 
     switch (PropChange->StateChange)
     {
         case DICS_ENABLE:
         case DICS_DISABLE:
         {
             if (PropChange->Scope == DICS_FLAG_GLOBAL)
                 hRootKey = set->HKLM;
             else /* PropChange->Scope == DICS_FLAG_CONFIGSPECIFIC */
             {
                 hRootKey = OpenHardwareProfileKey(set->HKLM, PropChange->HwProfile, KEY_CREATE_SUB_KEY);
                 if (hRootKey == INVALID_HANDLE_VALUE)
                     goto cleanup;
             }
 
             /* Enable/disable device in registry */
             hKey = SETUPDI_OpenDrvKey(hRootKey, deviceInfo, KEY_QUERY_VALUE | KEY_SET_VALUE);
             if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
                 hKey = SETUPDI_CreateDevKey(hRootKey, deviceInfo, KEY_QUERY_VALUE | KEY_SET_VALUE);
             if (hKey == INVALID_HANDLE_VALUE)
                 break;
             dwLength = sizeof(DWORD);
             rc = RegQueryValueExW(
                 hKey,
                 RegistryValueName,
                 NULL,
                 &dwRegType,
                 (LPBYTE)&dwConfigFlags, &dwLength);
             if (rc == ERROR_FILE_NOT_FOUND)
                 dwConfigFlags = 0;
             else if (rc != ERROR_SUCCESS)
             {
                 SetLastError(rc);
                 goto cleanup;
             }
             else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
             {
                 SetLastError(ERROR_GEN_FAILURE);
                 goto cleanup;
             }
             if (PropChange->StateChange == DICS_ENABLE)
                 dwConfigFlags &= ~(PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
             else
                 dwConfigFlags |= (PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
             rc = RegSetValueExW(
                 hKey,
                 RegistryValueName,
                 0,
                 REG_DWORD,
                 (LPBYTE)&dwConfigFlags, sizeof(DWORD));
             if (rc != ERROR_SUCCESS)
             {
                 SetLastError(rc);
                 goto cleanup;
             }
 
             /* Enable/disable device if needed */
             if (PropChange->Scope == DICS_FLAG_GLOBAL
                 || PropChange->HwProfile == 0
                 || PropChange->HwProfile == SETUPAPI_GetCurrentHwProfile(DeviceInfoSet))
             {
                 if (PropChange->StateChange == DICS_ENABLE)
                     ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
                 else
                     ret = StopDevice(DeviceInfoSet, DeviceInfoData);
             }
             else
                 ret = TRUE;
             break;
         }
         case DICS_PROPCHANGE:
         {
             ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
             break;
         }
         default:
         {
             ERR("Unknown StateChange 0x%lx\n", PropChange->StateChange);
             SetLastError(ERROR_NOT_SUPPORTED);
         }
     }
 
 cleanup:
     if (hRootKey != INVALID_HANDLE_VALUE && hRootKey != set->HKLM)
         RegCloseKey(hRootKey);
 
     if (hKey != INVALID_HANDLE_VALUE)
         RegCloseKey(hKey);
 
     TRACE("Returning %d\n", ret);
     return ret;
 }

BOOL WINAPI SetupDiClassGuidsFromNameA	(	LPCSTR	ClassName,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize
	)

Definition at line 863 of file devinst.c.

Referenced by test_SetupDiClassGuidsFromNameA().

 {
     return SetupDiClassGuidsFromNameExA(ClassName, ClassGuidList,
                                         ClassGuidListSize, RequiredSize,
                                         NULL, NULL);
 }

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().

 {
     LPWSTR ClassNameW = NULL;
     LPWSTR MachineNameW = NULL;
     BOOL bResult;
 
     TRACE("%s %p %lu %p %s %p\n", debugstr_a(ClassName), ClassGuidList,
         ClassGuidListSize, RequiredSize, debugstr_a(MachineName), Reserved);
 
     if (!ClassName)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
 
     ClassNameW = pSetupMultiByteToUnicode(ClassName, CP_ACP);
     if (ClassNameW == NULL)
         return FALSE;
 
     if (MachineName)
     {
         MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
         if (MachineNameW == NULL)
         {
             MyFree(ClassNameW);
             return FALSE;
         }
     }
 
     bResult = SetupDiClassGuidsFromNameExW(ClassNameW, ClassGuidList,
                                            ClassGuidListSize, RequiredSize,
                                            MachineNameW, Reserved);
 
     MyFree(MachineNameW);
     MyFree(ClassNameW);
 
     return bResult;
 }

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().

 {
     WCHAR szKeyName[40];
     WCHAR szClassName[MAX_CLASS_NAME_LEN];
     HKEY hClassesKey;
     HKEY hClassKey;
     DWORD dwLength;
     DWORD dwIndex;
     LONG lError;
     DWORD dwGuidListIndex = 0;
 
     TRACE("%s %p %lu %p %s %p\n", debugstr_w(ClassName), ClassGuidList,
         ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
 
     if (!ClassName || !RequiredSize)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
     if (!ClassGuidList && ClassGuidListSize > 0)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
     *RequiredSize = 0;
 
     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
                                             KEY_ENUMERATE_SUB_KEYS,
                                             DIOCR_INSTALLER,
                                             MachineName,
                                             Reserved);
     if (hClassesKey == INVALID_HANDLE_VALUE)
     {
         return FALSE;
     }
 
     for (dwIndex = 0; ; dwIndex++)
     {
         dwLength = 40;
         lError = RegEnumKeyExW(hClassesKey,
                                dwIndex,
                                szKeyName,
                                &dwLength,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
         TRACE("RegEnumKeyExW() returns %d\n", lError);
         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
         {
             TRACE("Key name: %p\n", szKeyName);
 
             if (RegOpenKeyExW(hClassesKey,
                               szKeyName,
                               0,
                               KEY_QUERY_VALUE,
                               &hClassKey))
             {
                 RegCloseKey(hClassesKey);
                 return FALSE;
             }
 
             dwLength = MAX_CLASS_NAME_LEN * sizeof(WCHAR);
             if (!RegQueryValueExW(hClassKey,
                                   REGSTR_VAL_CLASS,
                                   NULL,
                                   NULL,
                                   (LPBYTE)szClassName,
                                   &dwLength))
             {
                 TRACE("Class name: %p\n", szClassName);
 
                 if (strcmpiW(szClassName, ClassName) == 0)
                 {
                     TRACE("Found matching class name\n");
 
                     TRACE("Guid: %p\n", szKeyName);
                     if (dwGuidListIndex < ClassGuidListSize)
                     {
                         if (szKeyName[0] == '{' && szKeyName[37] == '}')
                         {
                             szKeyName[37] = 0;
                         }
                         TRACE("Guid: %p\n", &szKeyName[1]);
 
                         UuidFromStringW(&szKeyName[1],
                                         &ClassGuidList[dwGuidListIndex]);
                     }
 
                     dwGuidListIndex++;
                 }
             }
 
             RegCloseKey(hClassKey);
         }
 
         if (lError != ERROR_SUCCESS)
             break;
     }
 
     RegCloseKey(hClassesKey);
 
     if (RequiredSize != NULL)
         *RequiredSize = dwGuidListIndex;
 
     if (ClassGuidListSize < dwGuidListIndex)
     {
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         return FALSE;
     }
 
     return TRUE;
 }

BOOL WINAPI SetupDiClassGuidsFromNameW	(	LPCWSTR	ClassName,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize
	)

Definition at line 877 of file devinst.c.

 {
     return SetupDiClassGuidsFromNameExW(ClassName, ClassGuidList,
                                         ClassGuidListSize, RequiredSize,
                                         NULL, NULL);
 }

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().

 {
     return SetupDiClassNameFromGuidExA(ClassGuid, ClassName,
                                        ClassNameSize, RequiredSize,
                                        NULL, NULL);
 }

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().

 {
     WCHAR ClassNameW[MAX_CLASS_NAME_LEN];
     LPWSTR MachineNameW = NULL;
     BOOL ret;
 
     if (MachineName)
         MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
     ret = SetupDiClassNameFromGuidExW(ClassGuid, ClassNameW, MAX_CLASS_NAME_LEN,
                                       RequiredSize, MachineNameW, Reserved);
     if (ret)
     {
         int len = WideCharToMultiByte(CP_ACP, 0, ClassNameW, -1, ClassName,
                                       ClassNameSize, NULL, NULL);
         if (len == 0 || len > ClassNameSize)
         {
             SetLastError(ERROR_INSUFFICIENT_BUFFER);
             ret = FALSE;
         }
     }
     MyFree(MachineNameW);
     return ret;
 }

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().

 {
     HKEY hKey;
     DWORD dwLength;
     DWORD dwRegType;
     LONG rc;
     PWSTR Buffer;
 
     TRACE("%s %p %lu %p %s %p\n", debugstr_guid(ClassGuid), ClassName,
         ClassNameSize, RequiredSize, debugstr_w(MachineName), Reserved);
 
     /* Make sure there's a GUID */
     if (ClassGuid == NULL)
     {
         SetLastError(ERROR_INVALID_CLASS);  /* On Vista: ERROR_INVALID_USER_BUFFER */
         return FALSE;
     }
 
     /* Make sure there's a real buffer when there's a size */
     if ((ClassNameSize > 0) && (ClassName == NULL))
     {
         SetLastError(ERROR_INVALID_PARAMETER);  /* On Vista: ERROR_INVALID_USER_BUFFER */
         return FALSE;
     }
 
     /* Open the key for the GUID */
     hKey = SetupDiOpenClassRegKeyExW(ClassGuid, KEY_QUERY_VALUE, DIOCR_INSTALLER, MachineName, Reserved);
 
     if (hKey == INVALID_HANDLE_VALUE)
         return FALSE;
 
     /* Retrieve the class name data and close the key */
     rc = QueryRegistryValue(hKey, REGSTR_VAL_CLASS, (LPBYTE *) &Buffer, &dwRegType, &dwLength);
     RegCloseKey(hKey);
 
     /* Make sure we got the data */
     if (rc != ERROR_SUCCESS)
     {
         SetLastError(rc);
         return FALSE;
     }
 
     /* Make sure the data is a string */
     if (dwRegType != REG_SZ)
     {
         MyFree(Buffer);
         SetLastError(ERROR_GEN_FAILURE);
         return FALSE;
     }
 
     /* Determine the length of the class name */
     dwLength /= sizeof(WCHAR);
 
     if ((dwLength == 0) || (Buffer[dwLength - 1] != UNICODE_NULL))
         /* Count the null-terminator */
         dwLength++;
 
     /* Inform the caller about the class name */
     if ((ClassName != NULL) && (dwLength <= ClassNameSize))
     {
         memcpy(ClassName, Buffer, (dwLength - 1) * sizeof(WCHAR));
         ClassName[dwLength - 1] = UNICODE_NULL;
     }
 
     /* Inform the caller about the required size */
     if (RequiredSize != NULL)
         *RequiredSize = dwLength;
 
     /* Clean up the buffer */
     MyFree(Buffer);
 
     /* Make sure the buffer was large enough */
     if ((ClassName == NULL) || (dwLength > ClassNameSize))
     {
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         return FALSE;
     }
 
     return TRUE;
 }

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().

 {
     return SetupDiClassNameFromGuidExW(ClassGuid, ClassName,
                                        ClassNameSize, RequiredSize,
                                        NULL, NULL);
 }

BOOL WINAPI SetupDiCreateDeviceInfoA	(	HDEVINFO	DeviceInfoSet,
		PCSTR	DeviceName,
		CONST GUID *	ClassGuid,
		PCSTR	DeviceDescription,
		HWND	hwndParent,
		DWORD	CreationFlags,
		PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 1537 of file devinst.c.

 {
     BOOL ret;
     LPWSTR DeviceNameW = NULL;
     LPWSTR DeviceDescriptionW = NULL;
 
     TRACE("\n");
 
     if (DeviceName)
     {
         DeviceNameW = pSetupMultiByteToUnicode(DeviceName, CP_ACP);
         if (DeviceNameW == NULL) return FALSE;
     }
     if (DeviceDescription)
     {
         DeviceDescriptionW = pSetupMultiByteToUnicode(DeviceDescription, CP_ACP);
         if (DeviceDescriptionW == NULL)
         {
             MyFree(DeviceNameW);
             return FALSE;
         }
     }
 
     ret = SetupDiCreateDeviceInfoW(DeviceInfoSet, DeviceNameW, ClassGuid, DeviceDescriptionW,
             hwndParent, CreationFlags, DeviceInfoData);
 
     MyFree(DeviceNameW);
     MyFree(DeviceDescriptionW);
 
     return ret;
 }

HDEVINFO WINAPI SetupDiCreateDeviceInfoList	(	const GUID *	ClassGuid,
		HWND	hwndParent
	)

Definition at line 1214 of file devinst.c.

Referenced by InstallSoftwareBusPnpEnumerator(), and SetupDiInstallClassExW().

 {
     return SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent, NULL, NULL);
 }

HDEVINFO WINAPI SetupDiCreateDeviceInfoListExA	(	const GUID *	ClassGuid,
		HWND	hwndParent,
		PCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 1224 of file devinst.c.

 {
     LPWSTR MachineNameW = NULL;
     HDEVINFO hDevInfo;
 
     TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
       debugstr_a(MachineName), Reserved);
 
     if (MachineName)
     {
         MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
         if (MachineNameW == NULL)
             return INVALID_HANDLE_VALUE;
     }
 
     hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent,
                                               MachineNameW, Reserved);
 
     MyFree(MachineNameW);
 
     return hDevInfo;
 }

HDEVINFO WINAPI SetupDiCreateDeviceInfoListExW	(	const GUID *	ClassGuid,
		HWND	hwndParent,
		PCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 1268 of file devinst.c.

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

 {
     struct DeviceInfoSet *list = NULL;
     DWORD size = FIELD_OFFSET(struct DeviceInfoSet, szData);
     DWORD rc;
     CONFIGRET cr;
     HDEVINFO ret = INVALID_HANDLE_VALUE;
 
     TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
       debugstr_w(MachineName), Reserved);
 
     if (MachineName != NULL)
     {
         SIZE_T len = strlenW(MachineName);
         if (len >= SP_MAX_MACHINENAME_LENGTH - 4)
         {
             SetLastError(ERROR_INVALID_MACHINENAME);
             goto cleanup;
         }
         if(len > 0)

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation