devinst.c File Reference

#include "setupapi_private.h"

Include dependency graph for devinst.c:

Go to the source code of this file.

Classes
struct	CoInstallerElement
struct	GetSectionCallbackInfo
struct	PropertyMapEntry

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

Typedefs
typedef DWORD(CALLBACK *	CLASS_INSTALL_PROC) (IN DI_FUNCTION InstallFunction, IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
typedef BOOL(WINAPI *	DEFAULT_CLASS_INSTALL_PROC) (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)
typedef DWORD(CALLBACK *	COINSTALLER_PROC) (IN DI_FUNCTION InstallFunction, IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, IN OUT PCOINSTALLER_CONTEXT_DATA Context)

Functions
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)
BOOL WINAPI	SetupDiRestartDevices (HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData)

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

CLASS_COINSTALLER

#define CLASS_COINSTALLER   0x1

CLASS_INSTALLER

#define CLASS_INSTALLER   0x4

DEVICE_COINSTALLER

#define DEVICE_COINSTALLER   0x2

Typedef Documentation

CLASS_INSTALL_PROC

typedef DWORD(CALLBACK* CLASS_INSTALL_PROC) (IN DI_FUNCTION InstallFunction, IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)

Definition at line 42 of file devinst.c.

COINSTALLER_PROC

typedef DWORD(CALLBACK* COINSTALLER_PROC) (IN DI_FUNCTION InstallFunction, IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL, IN OUT PCOINSTALLER_CONTEXT_DATA Context)

Definition at line 51 of file devinst.c.

DEFAULT_CLASS_INSTALL_PROC

typedef BOOL(WINAPI* DEFAULT_CLASS_INSTALL_PROC) (IN HDEVINFO DeviceInfoSet, IN OUT PSP_DEVINFO_DATA DeviceInfoData)

Definition at line 47 of file devinst.c.

Function Documentation

CheckDeviceInstallParameters()

static BOOL CheckDeviceInstallParameters ( IN PSP_DEVINSTALL_PARAMS_W  DeviceInstallParams )

static

Definition at line 4504 of file devinst.c.

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

Referenced by SetupDiSetDeviceInstallParamsW().

CheckSectionValid()

static BOOL CheckSectionValid ( IN LPCWSTR  SectionName, IN PSP_ALTPLATFORM_INFO  PlatformInfo, IN BYTE  ProductType, IN WORD  SuiteMask, OUT PDWORD  ScorePlatform, OUT PDWORD  ScoreMajorVersion, OUT PDWORD  ScoreMinorVersion, OUT PDWORD  ScoreProductType, OUT PDWORD  ScoreSuiteMask  )

static

Definition at line 122 of file devinst.c.

{
    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(%s %p 0x%x 0x%x)\n",
        __FUNCTION__, 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;
}

Referenced by GetSectionCallback().

CreateDeviceInfo()

BOOL CreateDeviceInfo	(	IN struct DeviceInfoSet *	list,
		IN LPCWSTR	InstancePath,
		IN LPCGUID	pClassGuid,
		OUT struct DeviceInfo **	pDeviceInfo
	)

Definition at line 526 of file devinst.c.

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

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

DestroyClassInstallParams()

static BOOL DestroyClassInstallParams ( struct ClassInstallParams *  installParams )

static

Definition at line 571 of file devinst.c.

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

Referenced by DestroyDeviceInfo(), and DestroyDeviceInfoSet().

DestroyDeviceInfo()

static BOOL DestroyDeviceInfo ( struct DeviceInfo *  deviceInfo )

static

Definition at line 579 of file devinst.c.

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

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

DestroyDeviceInfoSet()

static BOOL DestroyDeviceInfoSet ( struct DeviceInfoSet *  list )

static

Definition at line 606 of file devinst.c.

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

Referenced by SetupDiDestroyDeviceInfoList().

GetErrorCodeFromCrCode()

static DWORD GetErrorCodeFromCrCode ( const IN CONFIGRET  cr )

static

Definition at line 92 of file devinst.c.

{
  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 */
}

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

GetSectionCallback()

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

static

Definition at line 363 of file devinst.c.

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

Referenced by SetupDiGetActualSectionToInstallExW().

InfIsFromOEMLocation()

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

static

Definition at line 5316 of file devinst.c.

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

Referenced by SetupDiInstallDevice().

IntSetupDiRegisterDeviceInfo()

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

static

Definition at line 4019 of file devinst.c.

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

Referenced by SetupDiCallClassInstaller().

IntSetupDiSetDeviceRegistryPropertyAW()

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.

{
    BOOL ret = FALSE;
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;

    TRACE("%s(%p %p %d %p %d)\n", __FUNCTION__, 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;
}

Referenced by SetupDiSetDeviceRegistryPropertyA(), and SetupDiSetDeviceRegistryPropertyW().

IsDeviceInfoInDeviceInfoSet()

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

static

Definition at line 4695 of file devinst.c.

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

Referenced by SetupDiDeleteDeviceInfo().

OpenHardwareProfileKey()

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

static

Definition at line 4640 of file devinst.c.

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

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

ResetDevice()

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
}

Referenced by SetupDiChangeState(), and SetupDiInstallDevice().

SETUP_CreateClassKey()

HKEY SETUP_CreateClassKey

(

HINF

hInf

)

Definition at line 3523 of file devinst.c.

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

Referenced by SetupDiInstallClassExW().

SETUPAPI_GetCurrentHwProfile()

static DWORD SETUPAPI_GetCurrentHwProfile ( IN HDEVINFO  DeviceInfoSet )

static

Definition at line 4978 of file devinst.c.

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

Referenced by SetupDiChangeState().

SETUPDI_CreateDevKey()

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

Definition at line 5672 of file devinst.c.

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

Referenced by SetupDiChangeState(), and SetupDiCreateDevRegKeyW().

SETUPDI_CreateDrvKey()

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

Definition at line 5688 of file devinst.c.

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

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

SETUPDI_DeleteDevKey()

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

static

Definition at line 6019 of file devinst.c.

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

Referenced by SetupDiDeleteDevRegKey().

SETUPDI_DeleteDrvKey()

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

static

Definition at line 6025 of file devinst.c.

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

Referenced by SetupDiDeleteDevRegKey().

SETUPDI_GuidToString()

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

static

Definition at line 79 of file devinst.c.

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

Referenced by SetupDiCreateDeviceInterfaceRegKeyW(), and SetupDiOpenClassRegKeyExW().

SETUPDI_OpenDevKey()

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

Definition at line 5842 of file devinst.c.

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

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

SETUPDI_OpenDrvKey()

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

Definition at line 5858 of file devinst.c.

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

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

SetupDiBuildClassInfoList()

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

Definition at line 643 of file devinst.c.

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

Referenced by test_SetupDiBuildClassInfoList().

SetupDiBuildClassInfoListExA()

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("%s(0x%lx %p %lu %p %s %p)\n", __FUNCTION__, 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;
}

SetupDiBuildClassInfoListExW()

BOOL WINAPI SetupDiBuildClassInfoListExW	(	DWORD	Flags,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize,
		LPCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 720 of file devinst.c.

{
    WCHAR szKeyName[40];
    HKEY hClassesKey = INVALID_HANDLE_VALUE;
    HKEY hClassKey;
    DWORD dwLength;
    DWORD dwIndex;
    LONG lError;
    DWORD dwGuidListIndex = 0;

    TRACE("%s(0x%lx %p %lu %p %s %p)\n", __FUNCTION__, 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;
}

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

SetupDiCallClassInstaller()

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

Definition at line 4029 of file devinst.c.

{
    BOOL ret = FALSE;

    TRACE("%s(%u %p %p)\n", __FUNCTION__, 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;
}

Referenced by CNetConnection::Disconnect(), CDeviceNode::EnableDevice(), EnableDevice(), EnumerateDrivers(), InstallCurrentDriver(), InstallSoftwareBusPnpEnumerator(), SETUP_CallInstaller(), StartDevice(), CDeviceNode::UninstallDevice(), UninstallDriver(), UpdateDevInfo(), UpdateDriverDetailsDlg(), and WritePortSettings().

SetupDiChangeState()

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

Definition at line 5076 of file devinst.c.

{
    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("%s(%p %p)\n", __FUNCTION__, 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;
}

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

SetupDiClassGuidsFromNameA()

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

Definition at line 863 of file devinst.c.

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

Referenced by test_SetupDiClassGuidsFromNameA().

SetupDiClassGuidsFromNameExA()

BOOL WINAPI SetupDiClassGuidsFromNameExA	(	LPCSTR	ClassName,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize,
		LPCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 891 of file devinst.c.

{
    LPWSTR ClassNameW = NULL;
    LPWSTR MachineNameW = NULL;
    BOOL bResult;

    TRACE("%s(%s %p %lu %p %s %p)\n", __FUNCTION__, 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;
}

Referenced by SetupDiClassGuidsFromNameA().

SetupDiClassGuidsFromNameExW()

BOOL WINAPI SetupDiClassGuidsFromNameExW	(	LPCWSTR	ClassName,
		LPGUID	ClassGuidList,
		DWORD	ClassGuidListSize,
		PDWORD	RequiredSize,
		LPCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 939 of file devinst.c.

{
    WCHAR szKeyName[40];
    WCHAR szClassName[MAX_CLASS_NAME_LEN];
    HKEY hClassesKey;
    HKEY hClassKey;
    DWORD dwLength;
    DWORD dwIndex;
    LONG lError;
    DWORD dwGuidListIndex = 0;

    TRACE("%s(%s %p %lu %p %s %p)\n", __FUNCTION__, 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;
}

Referenced by SetupDiClassGuidsFromNameExA(), and SetupDiClassGuidsFromNameW().

SetupDiClassGuidsFromNameW()

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

SetupDiClassNameFromGuidA()

BOOL WINAPI SetupDiClassNameFromGuidA	(	const GUID *	ClassGuid,
		PSTR	ClassName,
		DWORD	ClassNameSize,
		PDWORD	RequiredSize
	)

Definition at line 1062 of file devinst.c.

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

Referenced by test_SetupDiBuildClassInfoList(), and test_SetupDiClassNameFromGuidA().

SetupDiClassNameFromGuidExA()

BOOL WINAPI SetupDiClassNameFromGuidExA	(	const GUID *	ClassGuid,
		PSTR	ClassName,
		DWORD	ClassNameSize,
		PDWORD	RequiredSize,
		PCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 1090 of file devinst.c.

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

Referenced by SetupDiClassNameFromGuidA().

SetupDiClassNameFromGuidExW()

BOOL WINAPI SetupDiClassNameFromGuidExW	(	const GUID *	ClassGuid,
		PWSTR	ClassName,
		DWORD	ClassNameSize,
		PDWORD	RequiredSize,
		PCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 1123 of file devinst.c.

{
    HKEY hKey;
    DWORD dwLength;
    DWORD dwRegType;
    LONG rc;
    PWSTR Buffer;

    TRACE("%s(%s %p %lu %p %s %p)\n", __FUNCTION__, 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;
}

Referenced by SetupDiClassNameFromGuidExA(), and SetupDiClassNameFromGuidW().

SetupDiClassNameFromGuidW()

BOOL WINAPI SetupDiClassNameFromGuidW	(	const GUID *	ClassGuid,
		PWSTR	ClassName,
		DWORD	ClassNameSize,
		PDWORD	RequiredSize
	)

Definition at line 1076 of file devinst.c.

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

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

SetupDiCreateDeviceInfoA()

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;