devinst.c File Reference

#include "setupapi_private.h"
#include <pseh/pseh2.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)
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)
BOOL WINAPI	SetupDiGetCustomDevicePropertyA (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType OPTIONAL, OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL)
BOOL WINAPI	SetupDiGetCustomDevicePropertyW (IN HDEVINFO DeviceInfoSet, IN PSP_DEVINFO_DATA DeviceInfoData, IN PCWSTR CustomPropertyName, IN DWORD Flags, OUT PDWORD PropertyRegDataType OPTIONAL, OUT PBYTE PropertyBuffer, IN DWORD PropertyBufferSize, OUT PDWORD RequiredSize OPTIONAL)

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 43 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 52 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 48 of file devinst.c.

Function Documentation

CheckDeviceInstallParameters()

static BOOL CheckDeviceInstallParameters ( IN PSP_DEVINSTALL_PARAMS_W  DeviceInstallParams )

static

Definition at line 4543 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 124 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 528 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_CreateDevicesList(), SETUP_CreateInterfaceList(), SetupDiCreateDeviceInfoW(), SetupDiOpenDeviceInfoW(), and SetupDiOpenDeviceInterfaceW().

DestroyClassInstallParams()

static BOOL DestroyClassInstallParams ( struct ClassInstallParams *  installParams )

static

Definition at line 573 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 581 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 608 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()

DWORD GetErrorCodeFromCrCode

(

const IN CONFIGRET

cr

)

Definition at line 94 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(), SETUP_CreateDevicesList(), SetupDiBuildClassInfoListExW(), SetupDiCreateDeviceInfoListExW(), SetupDiCreateDeviceInfoW(), SetupDiGetClassRegistryPropertyA(), SetupDiGetClassRegistryPropertyW(), SetupDiGetCustomDevicePropertyA(), SetupDiGetCustomDevicePropertyW(), SetupDiRestartDevices(), SetupDiSetClassRegistryPropertyA(), SetupDiSetClassRegistryPropertyW(), and StopDevice().

GetSectionCallback()

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

static

Definition at line 365 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 5355 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 4058 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 3402 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 4734 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 4679 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 5064 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 3562 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 5017 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 5715 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 5731 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 6062 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 6068 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 81 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 5885 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 5901 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 645 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 675 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 722 of file devinst.c.

{
    GUID CurrentClassGuid;
    HKEY hClassKey;
    DWORD dwIndex;
    DWORD dwGuidListIndex = 0;
    HMACHINE hMachine = NULL;
    CONFIGRET cr;
 
    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;
    }
 
    if (MachineName)
    {
        cr = CM_Connect_MachineW(MachineName, &hMachine);
        if (cr != CR_SUCCESS)
        {
            SetLastError(GetErrorCodeFromCrCode(cr));
            return FALSE;
        }
    }
 
    for (dwIndex = 0; ; dwIndex++)
    {
        cr = CM_Enumerate_Classes_Ex(dwIndex,
                                     &CurrentClassGuid,
                                     0,
                                     hMachine);
        if (cr == CR_SUCCESS)
        {
            TRACE("Guid: %s\n", debugstr_guid(&CurrentClassGuid));
            if (CM_Open_Class_Key_ExW(&CurrentClassGuid,
                                       NULL,
                                       KEY_QUERY_VALUE,
                                       RegDisposition_OpenExisting,
                                       &hClassKey,
                                       CM_OPEN_CLASS_KEY_INSTALLER,
                                       hMachine) != CR_SUCCESS)
            {
                SetLastError(GetErrorCodeFromCrCode(cr));
                if (hMachine)
                    CM_Disconnect_Machine(hMachine);
                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);
 
            if (dwGuidListIndex < ClassGuidListSize)
            {
                ClassGuidList[dwGuidListIndex] = CurrentClassGuid;
            }
 
            dwGuidListIndex++;
        }
 
        if (cr != ERROR_SUCCESS)
            break;
    }
 
    if (hMachine)
        CM_Disconnect_Machine(hMachine);
 
    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 4068 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(), DisplayDeviceAdvancedProperties(), 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 5115 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 854 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 882 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 930 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 868 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 1053 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 1081 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 1114 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 1067 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 1528 of file devinst.c.

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

Referenced by test_device_iface(), test_device_iface_detail(), test_device_info(), test_device_interface_key(), test_device_key(), test_devnode(), test_get_device_instance_id(), test_register_device_iface(), test_register_device_info(), test_registry_property_a(), and test_registry_property_w().

SetupDiCreateDeviceInfoList()

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

Definition at line 1205 of file devinst.c.

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

Referenced by InstallCompositeBattery(), InstallSoftwareBusPnpEnumerator(), SetupDiInstallClassExW(), test_device_iface(), test_device_iface_detail(), test_device_info(), test_device_key(), test_get_device_instance_id(), and test_register_device_info().

SetupDiCreateDeviceInfoListExA()

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

Definition at line 1215 of file devinst.c.

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

SetupDiCreateDeviceInfoListExW()

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

Definition at line 1259 of file devinst.c.

{
    struct DeviceInfoSet *list = NULL;
    DWORD size = FIELD_OFFSET(struct DeviceInfoSet, szData);
    DWORD rc;
    CONFIGRET cr;
    HDEVINFO ret = INVALID_HANDLE_VALUE;
 
    TRACE("%s(%s %p %s %p)\n", __FUNCTION__, debugstr_guid(ClassGuid), hwndParent,
      debugstr_w(MachineName), Reserved);
 
    if (MachineName != NULL)
    {
        SIZE_T len = strlenW(MachineName);
        if (len >= SP_MAX_MACHINENAME_LENGTH - 4)
        {
            SetLastError(ERROR_INVALID_MACHINENAME);
            goto cleanup;
        }
        if(len > 0)
            size += (len + 3) * sizeof(WCHAR);
        else
            MachineName = NULL;
    }
 
    if (Reserved != NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    list = MyMalloc(size);
    if (!list)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return INVALID_HANDLE_VALUE;
    }
    ZeroMemory(list, FIELD_OFFSET(struct DeviceInfoSet, szData));
 
    list->magic = SETUP_DEVICE_INFO_SET_MAGIC;
    memcpy(&list->ClassGuid,
            ClassGuid ? ClassGuid : &GUID_NULL,
            sizeof(list->ClassGuid));
    list->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
    list->InstallParams.Flags |= DI_CLASSINSTALLPARAMS;
    list->InstallParams.hwndParent = hwndParent;
    if (MachineName)
    {
        rc = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &list->HKLM);
        if (rc != ERROR_SUCCESS)
        {
            SetLastError(ERROR_INVALID_MACHINENAME);
            goto cleanup;
        }
 
        list->szData[0] = list->szData[1] = '\\';
        strcpyW(list->szData + 2, MachineName);
        list->MachineName = list->szData;
    }
    else
    {
        list->HKLM = HKEY_LOCAL_MACHINE;
        list->MachineName = NULL;
    }
    cr = CM_Connect_MachineW(list->MachineName, &list->hMachine);
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        goto cleanup;
    }
    InitializeListHead(&list->DriverListHead);
    InitializeListHead(&list->ListHead);
 
    return (HDEVINFO)list;
 
cleanup:
    if (ret == INVALID_HANDLE_VALUE)
    {
        if (list)
        {
            if (list->HKLM != NULL && list->HKLM != HKEY_LOCAL_MACHINE)
                RegCloseKey(list->HKLM);
            MyFree(list);
        }
    }
    return ret;
}

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

SetupDiCreateDeviceInfoW()

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

Definition at line 1570 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo = NULL;
    BOOL ret = FALSE;
    CONFIGRET cr;
    DEVINST RootDevInst;
    DEVINST DevInst;
    WCHAR GenInstanceId[MAX_DEVICE_ID_LEN];
    DWORD dwFlags;
 
    TRACE("%s(%p %s %s %s %p %x %p)\n", __FUNCTION__, DeviceInfoSet, debugstr_w(DeviceName),
        debugstr_guid(ClassGuid), debugstr_w(DeviceDescription),
        hwndParent, CreationFlags, DeviceInfoData);
 
    if (!DeviceName)
    {
        SetLastError(ERROR_INVALID_DEVINST_NAME);
        return FALSE;
    }
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!ClassGuid)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!IsEqualGUID(&set->ClassGuid, &GUID_NULL) &&
        !IsEqualGUID(ClassGuid, &set->ClassGuid))
    {
        SetLastError(ERROR_CLASS_MISMATCH);
        return FALSE;
    }
    if (CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS))
    {
        TRACE("Unknown flags: 0x%08lx\n", CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS));
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    /* Get the root device instance */
    cr = CM_Locate_DevInst_ExW(&RootDevInst,
                               NULL,
                               CM_LOCATE_DEVINST_NORMAL,
                               set->hMachine);
    if (cr != CR_SUCCESS)
    {
        SetLastError(ERROR_INVALID_DATA);
        return FALSE;
    }
 
    dwFlags = CM_CREATE_DEVINST_PHANTOM;
    if (CreationFlags & DICD_GENERATE_ID)
        dwFlags |= CM_CREATE_DEVINST_GENERATE_ID;
 
    /* Create the new device instance */
    cr = CM_Create_DevInst_ExW(&DevInst,
                               (DEVINSTID)DeviceName,
                               RootDevInst,
                               dwFlags,
                               set->hMachine);
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        return FALSE;
    }
 
    if (CreationFlags & DICD_GENERATE_ID)
    {
        /* Grab the actual instance ID that was created */
        cr = CM_Get_Device_ID_Ex(DevInst,
                                 GenInstanceId,
                                 MAX_DEVICE_ID_LEN,
                                 0,
                                 set->hMachine);
        if (cr != CR_SUCCESS)
        {
            SetLastError(GetErrorCodeFromCrCode(cr));
            return FALSE;
        }
 
        DeviceName = GenInstanceId;
        TRACE("Using generated instance ID: %s\n", debugstr_w(DeviceName));
    }
 
    if (CreateDeviceInfo(set, DeviceName, ClassGuid, &deviceInfo))
    {
        InsertTailList(&set->ListHead, &deviceInfo->ListEntry);
 
        if (!DeviceInfoData)
            ret = TRUE;
        else
        {
            if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
            {
                SetLastError(ERROR_INVALID_USER_BUFFER);
            }
            else
            {
                memcpy(&DeviceInfoData->ClassGuid, ClassGuid, sizeof(GUID));
                DeviceInfoData->DevInst = deviceInfo->dnDevInst;
                DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
                ret = TRUE;
            }
        }
    }
 
    if (ret == FALSE)
    {
        if (deviceInfo != NULL)
        {
            /* Remove deviceInfo from List */
            RemoveEntryList(&deviceInfo->ListEntry);
 
            /* Destroy deviceInfo */
            DestroyDeviceInfo(deviceInfo);
        }
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by InstallCompositeBattery(), InstallSoftwareBusPnpEnumerator(), and SetupDiCreateDeviceInfoA().

SetupDiCreateDeviceInterfaceA()

BOOL WINAPI SetupDiCreateDeviceInterfaceA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		const GUID *	InterfaceClassGuid,
		PCSTR	ReferenceString,
		DWORD	CreationFlags,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData
	)

Definition at line 2501 of file devinst.c.

{
    BOOL ret;
    LPWSTR ReferenceStringW = NULL;
 
    TRACE("%s(%p %p %s %s %08x %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
            debugstr_guid(InterfaceClassGuid), debugstr_a(ReferenceString),
            CreationFlags, DeviceInterfaceData);
 
    if (ReferenceString)
    {
        ReferenceStringW = pSetupMultiByteToUnicode(ReferenceString, CP_ACP);
        if (ReferenceStringW == NULL) return FALSE;
    }
 
    ret = SetupDiCreateDeviceInterfaceW(DeviceInfoSet, DeviceInfoData,
            InterfaceClassGuid, ReferenceStringW, CreationFlags,
            DeviceInterfaceData);
 
    MyFree(ReferenceStringW);
 
    return ret;
}

Referenced by test_device_iface(), test_device_iface_detail(), test_device_interface_key(), and test_register_device_iface().

SetupDiCreateDeviceInterfaceRegKeyA()

HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData,
		DWORD	Reserved,
		REGSAM	samDesired,
		HINF	InfHandle,
		PCSTR	InfSectionName
	)

Definition at line 2579 of file devinst.c.

{
    HKEY key;
    PWSTR InfSectionNameW = NULL;
 
    TRACE("%s(%p %p %d %08x %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInterfaceData, Reserved,
            samDesired, InfHandle, InfSectionName);
    if (InfHandle)
    {
        if (!InfSectionName)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
        InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
        if (!InfSectionNameW)
            return INVALID_HANDLE_VALUE;
    }
    key = SetupDiCreateDeviceInterfaceRegKeyW(DeviceInfoSet,
            DeviceInterfaceData, Reserved, samDesired, InfHandle,
            InfSectionNameW);
    MyFree(InfSectionNameW);
    return key;
}

Referenced by test_device_interface_key().

SetupDiCreateDeviceInterfaceRegKeyW()

HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData,
		DWORD	Reserved,
		REGSAM	samDesired,
		HINF	InfHandle,
		PCWSTR	InfSectionName
	)

Definition at line 2613 of file devinst.c.

{
    HKEY hKey, hDevKey, hRefKey, hDevParamKey;
    LPWSTR SymbolicLink, ReferenceString;
    DWORD Length, RefLength, Index;
    LONG rc;
    WCHAR bracedGuidString[39];
    struct DeviceInterface *DevItf;
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
 
    TRACE("%s(%p %p %d %08x %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInterfaceData, Reserved,
            samDesired, InfHandle, InfSectionName);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
            set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_HANDLE_VALUE;
    }
    if (!DeviceInterfaceData ||
            DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
            !DeviceInterfaceData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    if (InfHandle && !InfSectionName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    hKey = SetupDiOpenClassRegKeyExW(&DeviceInterfaceData->InterfaceClassGuid, samDesired, DIOCR_INTERFACE, NULL, NULL);
    if (hKey == INVALID_HANDLE_VALUE)
    {
        hKey = SetupDiOpenClassRegKeyExW(NULL, samDesired, DIOCR_INTERFACE, NULL, NULL);
        if (hKey == INVALID_HANDLE_VALUE)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
        SETUPDI_GuidToString(&DeviceInterfaceData->InterfaceClassGuid, bracedGuidString);
 
        if (RegCreateKeyExW(hKey, bracedGuidString, 0, NULL, 0, samDesired, NULL, &hDevKey, NULL) != ERROR_SUCCESS)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
        RegCloseKey(hKey);
        hKey = hDevKey;
    }
 
    DevItf = (struct DeviceInterface *)DeviceInterfaceData->Reserved;
 
    Length = (wcslen(DevItf->SymbolicLink)+1) * sizeof(WCHAR);
    SymbolicLink = HeapAlloc(GetProcessHeap(), 0, Length);
    if (!SymbolicLink)
    {
        RegCloseKey(hKey);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return INVALID_HANDLE_VALUE;
    }
 
    wcscpy(SymbolicLink, DevItf->SymbolicLink);
 
    /* Enumerate all characters in symbolic link */
    Index = 0;
    while (SymbolicLink[Index])
    {
        /* Check for a start position of reference string */
        if (SymbolicLink[Index] == L'}' && SymbolicLink[Index + 1] == L'\\')
        {
            /* Found it */
            break;
        }
        /* Replace all '\' backslashes by '#' pounds in symbolic link */
        if (SymbolicLink[Index] == L'\\')
        {
            SymbolicLink[Index] = L'#';
        }
        Index++;
    }
 
    /* Create reference string */
    RefLength = Length - Index * sizeof(WCHAR);
    ReferenceString = HeapAlloc(GetProcessHeap(), 0, RefLength);
    if (!ReferenceString)
    {
        HeapFree(GetProcessHeap(), 0, SymbolicLink);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return INVALID_HANDLE_VALUE;
    }
 
    ReferenceString[0] = L'#';
    wcscpy(ReferenceString + 1, &SymbolicLink[Index + 2]); /* Skip first '\' backslash */
 
    /* Null-terminate symbolic link at the beginning of the reference part,
     * as we don't need a ref part in key name. */
    SymbolicLink[Index + 1] = UNICODE_NULL;
 
    /* Open device instance key */
    rc = RegOpenKeyExW(hKey, SymbolicLink, 0, samDesired, &hDevKey);
    HeapFree(GetProcessHeap(), 0, SymbolicLink);
    RegCloseKey(hKey);
    if (rc != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, ReferenceString);
        SetLastError(rc);
        return INVALID_HANDLE_VALUE;
    }
 
    /* Open reference key */
    rc = RegOpenKeyExW(hDevKey, ReferenceString, 0, samDesired, &hRefKey);
    HeapFree(GetProcessHeap(), 0, ReferenceString);
    RegCloseKey(hDevKey);
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        return INVALID_HANDLE_VALUE;
    }
 
    /* Create/open "Device Parameters" subkey */
    rc = RegCreateKeyExW(hRefKey, L"Device Parameters", 0, NULL, 0, samDesired, NULL, &hDevParamKey, NULL);
    RegCloseKey(hRefKey);
    if (rc == ERROR_SUCCESS)
    {
        if (InfHandle && InfSectionName)
        {
            if (!SetupInstallFromInfSection(NULL /*FIXME */,
                                            InfHandle,
                                            InfSectionName,
                                            SPINST_INIFILES | SPINST_REGISTRY | SPINST_INI2REG | SPINST_FILES | SPINST_BITREG | SPINST_REGSVR | SPINST_UNREGSVR | SPINST_PROFILEITEMS | SPINST_COPYINF,
                                            hDevParamKey,
                                            NULL,
                                            0,
                                            set->SelectedDevice->InstallParams.InstallMsgHandler,
                                            set->SelectedDevice->InstallParams.InstallMsgHandlerContext,
                                            INVALID_HANDLE_VALUE,
                                            NULL))
            {
                RegCloseKey(hDevParamKey);
                return INVALID_HANDLE_VALUE;
            }
        }
    }
 
    SetLastError(rc);
    return hDevParamKey;
}

Referenced by InstallOneInterface(), InstallSoftwareDeviceInterfaceInf(), and SetupDiCreateDeviceInterfaceRegKeyA().

SetupDiCreateDeviceInterfaceW()

BOOL WINAPI SetupDiCreateDeviceInterfaceW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		const GUID *	InterfaceClassGuid,
		PCWSTR	ReferenceString,
		DWORD	CreationFlags,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData
	)

Definition at line 2534 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    TRACE("%s(%p %p %s %s %08x %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
            debugstr_guid(InterfaceClassGuid), debugstr_w(ReferenceString),
            CreationFlags, DeviceInterfaceData);
 
    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;
    }
    if (!InterfaceClassGuid)
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
    FIXME("%p %p %s %s %08x %p\n", DeviceInfoSet, DeviceInfoData,
            debugstr_guid(InterfaceClassGuid), debugstr_w(ReferenceString),
            CreationFlags, DeviceInterfaceData);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

Referenced by SetupDiCreateDeviceInterfaceA().

SetupDiCreateDevRegKeyA()

HKEY WINAPI SetupDiCreateDevRegKeyA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Scope,
		DWORD	HwProfile,
		DWORD	KeyType,
		HINF	InfHandle,
		PCSTR	InfSectionName
	)

Definition at line 1353 of file devinst.c.

{
    PWSTR InfSectionNameW = NULL;
    HKEY key;
 
    TRACE("%s(%p %p %d %d %d %p %s)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, Scope,
            HwProfile, KeyType, InfHandle, debugstr_a(InfSectionName));
 
    if (InfHandle)
    {
        if (!InfSectionName)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return INVALID_HANDLE_VALUE;
        }
        else
        {
            InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
            if (InfSectionNameW == NULL) return INVALID_HANDLE_VALUE;
        }
    }
    key = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, Scope,
            HwProfile, KeyType, InfHandle, InfSectionNameW);
    MyFree(InfSectionNameW);
    return key;
}

SetupDiCreateDevRegKeyW()

HKEY WINAPI SetupDiCreateDevRegKeyW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Scope,
		DWORD	HwProfile,
		DWORD	KeyType,
		HINF	InfHandle,
		PCWSTR	InfSectionName
	)

Definition at line 1396 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;
    HKEY key = INVALID_HANDLE_VALUE;
    DWORD rc;
    HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
    HKEY hKey = NULL;
    HKEY RootKey;
 
    TRACE("%s(%p %p %lu %lu %lu %p %s)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, Scope,
            HwProfile, KeyType, InfHandle, debugstr_w(InfSectionName));
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_HANDLE_VALUE;
    }
    if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_HANDLE_VALUE;
    }
    if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
            || !DeviceInfoData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return INVALID_HANDLE_VALUE;
    }
    if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return INVALID_HANDLE_VALUE;
    }
    if (InfHandle && !InfSectionName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    if (!InfHandle && InfSectionName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
        if (Scope == DICS_FLAG_GLOBAL)
            RootKey = set->HKLM;
        else /* Scope == DICS_FLAG_CONFIGSPECIFIC */
        {
            hHWProfileKey = OpenHardwareProfileKey(set->HKLM, HwProfile, KEY_CREATE_SUB_KEY);
            if (hHWProfileKey == INVALID_HANDLE_VALUE)
                goto cleanup;
            RootKey = hHWProfileKey;
        }
 
        if (KeyType == DIREG_DEV)
        {
#if _WIN32_WINNT >= 0x502
            hKey = SETUPDI_CreateDevKey(RootKey, deviceInfo, KEY_READ | KEY_WRITE);
#else
            hKey = SETUPDI_CreateDevKey(RootKey, deviceInfo, KEY_ALL_ACCESS);
#endif
            if (hKey == INVALID_HANDLE_VALUE)
                goto cleanup;
 
            if (Scope == DICS_FLAG_GLOBAL)
            {
                HKEY hTempKey = hKey;
 
                rc = RegCreateKeyExW(hTempKey,
                                     L"Device Parameters",
                                     0,
                                     NULL,
                                     REG_OPTION_NON_VOLATILE,
#if _WIN32_WINNT >= 0x502
                                     KEY_READ | KEY_WRITE,
#else
                                     KEY_ALL_ACCESS,
#endif
                                     NULL,
                                     &hKey,
                                     NULL);
                if (rc == ERROR_SUCCESS)
                    RegCloseKey(hTempKey);
            }
        }
        else /* KeyType == DIREG_DRV */
        {
#if _WIN32_WINNT >= 0x502
            hKey = SETUPDI_CreateDrvKey(RootKey, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_READ | KEY_WRITE);
#else
            hKey = SETUPDI_CreateDrvKey(RootKey, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_ALL_ACCESS);
#endif
            if (hKey == INVALID_HANDLE_VALUE)
                goto cleanup;
        }
 
        /* Do installation of the specified section */
        if (InfHandle)
        {
            FIXME("Need to install section %s in file %p\n",
                debugstr_w(InfSectionName), InfHandle);
        }
        key = hKey;
 
cleanup:
        if (hHWProfileKey != INVALID_HANDLE_VALUE)
            RegCloseKey(hHWProfileKey);
        if (hKey != NULL && hKey != key)
            RegCloseKey(hKey);
 
    TRACE("Returning 0x%p\n", key);
    return key;
}

Referenced by GetPortType(), InstallDeviceData(), InstallNetDevice(), InstallParallelPort(), InstallSerialPort(), SetupDiCreateDevRegKeyA(), and test_device_key().

SetupDiDeleteDeviceInfo()

BOOL WINAPI SetupDiDeleteDeviceInfo	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 4756 of file devinst.c.

{
    struct DeviceInfoSet *deviceInfoSet;
    struct DeviceInfo *deviceInfo = (struct DeviceInfo *)DeviceInfoData;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((deviceInfoSet = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (!IsDeviceInfoInDeviceInfoSet(deviceInfoSet, deviceInfo))
        SetLastError(ERROR_INVALID_PARAMETER);
    else
    {
        RemoveEntryList(&deviceInfo->ListEntry);
        DestroyDeviceInfo(deviceInfo);
        ret = TRUE;
    }
 
    return ret;
}

Referenced by InstallCompositeBattery(), test_device_info(), and test_register_device_info().

SetupDiDeleteDeviceInterfaceRegKey()

BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData,
		DWORD	Reserved
	)

Definition at line 2772 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p %d)\n", __FUNCTION__, DeviceInfoSet, DeviceInterfaceData, Reserved);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
            set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!DeviceInterfaceData ||
            DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
            !DeviceInterfaceData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    FIXME("%p %p %d\n", DeviceInfoSet, DeviceInterfaceData, Reserved);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return ret;
}

Referenced by test_device_interface_key().

SetupDiDeleteDevRegKey()

BOOL WINAPI SetupDiDeleteDevRegKey	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Scope,
		DWORD	HwProfile,
		DWORD	KeyType
	)

Definition at line 6077 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *devInfo;
    BOOL ret = FALSE;
    HKEY RootKey;
 
    TRACE("%s(%p %p %d %d %d)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, Scope, HwProfile,
            KeyType);
 
    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;
    }
    if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
    if (KeyType != DIREG_DEV && KeyType != DIREG_DRV && KeyType != DIREG_BOTH)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
    devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
    if (devInfo->set != set)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (Scope != DICS_FLAG_GLOBAL)
    {
        RootKey = OpenHardwareProfileKey(set->HKLM, HwProfile, 0);
        if (RootKey == INVALID_HANDLE_VALUE)
            return FALSE;
    }
    else
        RootKey = set->HKLM;
    switch (KeyType)
    {
        case DIREG_DEV:
            ret = SETUPDI_DeleteDevKey(RootKey, devInfo);
            break;
        case DIREG_DRV:
            ret = SETUPDI_DeleteDrvKey(RootKey, devInfo);
            break;
        case DIREG_BOTH:
            ret = SETUPDI_DeleteDevKey(RootKey, devInfo);
            if (ret)
                ret = SETUPDI_DeleteDrvKey(RootKey, devInfo);
            break;
        default:
            WARN("unknown KeyType %d\n", KeyType);
    }
    if (RootKey != set->HKLM)
        RegCloseKey(RootKey);
    return ret;
}

SetupDiDestroyDeviceInfoList()

BOOL WINAPI SetupDiDestroyDeviceInfoList

(

HDEVINFO

devinfo

)

Definition at line 2937 of file devinst.c.

{
    BOOL ret = FALSE;
 
    TRACE("%s(%p)\n", __FUNCTION__, devinfo);
    if (devinfo && devinfo != INVALID_HANDLE_VALUE)
    {
        struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
 
        if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
        {
            ret = DestroyDeviceInfoSet(list);
        }
    }
 
    if (ret == FALSE)
        SetLastError(ERROR_INVALID_HANDLE);
 
    return ret;
}

Referenced by BluetoothFindRadioClose(), check_device_path(), CDeviceNode::Cleanup(), cleanUp(), CloseDeviceList(), DeviceAdvancedPropertiesW(), DeviceProblemWizardW(), DevicePropertiesExW(), DevInstallW(), CNetConnection::Disconnect(), DisplayDeviceAdvancedProperties(), DisplayPageSetDeviceDetails(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumHotpluggedDevices(), fill_pnpentity(), find_devices(), FreeDevicesList(), get_device(), getDeviceInfo(), getDeviceInterfaceDetail(), InitHardWareTypesPage(), InitProbeListPage(), InstallCompositeBattery(), InstallDevInstEx(), InstallSoftwareBusPnpEnumerator(), InstallSoftwareDeviceInterface(), InstallSoftwareDeviceInterfaceInf(), IsSoftwareBusPnpEnumeratorInstalled(), KsOpenDefaultDevice(), CKsProxy::Load(), PowerMeterInfo_UpdateBatteryStats(), ProcessExistingDevices(), CDeviceView::RefreshDeviceList(), run_for_each_device(), SetDeviceDetails(), SetupDiGetClassDevsExW(), SetupDiInstallClassExW(), test_create_device_list_ex(), test_device_iface(), test_device_iface_detail(), test_device_info(), test_device_interface_key(), test_device_key(), test_devnode(), test_get_device_instance_id(), test_register_device_iface(), test_register_device_info(), test_registry_property_a(), test_registry_property_w(), test_SetupDiGetClassDevsA(), test_SetupDiGetClassDevsExW(), TestKs(), testSetupDiGetClassDevsA(), UpdateDevInfo(), UpdateDriverForPlugAndPlayDevicesW(), WdmAudInitUserModeMixer(), and WdmAudOpenSoundDeviceByLegacy().

SetupDiEnumDeviceInfo()

BOOL WINAPI SetupDiEnumDeviceInfo	(	HDEVINFO	devinfo,
		DWORD	index,
		PSP_DEVINFO_DATA	info
	)

Definition at line 1787 of file devinst.c.

{
    BOOL ret = FALSE;
 
    TRACE("%s(%p %d %p)\n", __FUNCTION__, devinfo, index, info);
 
    if(info==NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (devinfo && devinfo != INVALID_HANDLE_VALUE)
    {
        struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
        if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
        {
            if (info->cbSize != sizeof(SP_DEVINFO_DATA))
                SetLastError(ERROR_INVALID_USER_BUFFER);
            else
            {
                PLIST_ENTRY ItemList = list->ListHead.Flink;
                while (ItemList != &list->ListHead && index-- > 0)
                    ItemList = ItemList->Flink;
                if (ItemList == &list->ListHead)
                    SetLastError(ERROR_NO_MORE_ITEMS);
                else
                {
                    struct DeviceInfo *DevInfo = CONTAINING_RECORD(ItemList, struct DeviceInfo, ListEntry);
                    memcpy(&info->ClassGuid,
                        &DevInfo->ClassGuid,
                        sizeof(GUID));
                    info->DevInst = DevInfo->dnDevInst;
                    info->Reserved = (ULONG_PTR)DevInfo;
                    ret = TRUE;
                }
            }
        }
        else
            SetLastError(ERROR_INVALID_HANDLE);
    }
    else
        SetLastError(ERROR_INVALID_HANDLE);
    return ret;
}

Referenced by BuildDevicesList(), check_device_info_(), DisplayPageSetDeviceDetails(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumHotpluggedDevices(), fill_pnpentity(), FindNetworkAdapter(), getDeviceInfo(), InitProbeListPage(), CDeviceView::ListDevicesByType(), pCDevSettings_GetDeviceInstanceId(), CDeviceView::RefreshDeviceList(), SetDeviceDetails(), test_device_info(), test_register_device_info(), test_SetupDiGetClassDevsExW(), testSetupDiGetClassDevsA(), and UpdateDriverForPlugAndPlayDevicesW().

SetupDiEnumDeviceInterfaces()

BOOL WINAPI SetupDiEnumDeviceInterfaces	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		CONST GUID *	InterfaceClassGuid,
		DWORD	MemberIndex,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData
	)

Definition at line 2824 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    BOOL ret = FALSE;
 
    TRACE("%s(%p, %p, %s, %d, %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
     debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
            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;
    }
    if (!DeviceInterfaceData ||
            DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (DeviceInfoData)
    {
        struct DeviceInfo *devInfo =
            (struct DeviceInfo *)DeviceInfoData->Reserved;
        BOOL found = FALSE;
        PLIST_ENTRY InterfaceListEntry = devInfo->InterfaceListHead.Flink;
        while (InterfaceListEntry != &devInfo->InterfaceListHead && !found)
        {
            struct DeviceInterface *DevItf = CONTAINING_RECORD(InterfaceListEntry, struct DeviceInterface, ListEntry);
            if (!IsEqualIID(&DevItf->InterfaceClassGuid, InterfaceClassGuid))
            {
                InterfaceListEntry = InterfaceListEntry->Flink;
                continue;
            }
            if (MemberIndex-- == 0)
            {
                /* return this item */
                memcpy(&DeviceInterfaceData->InterfaceClassGuid,
                    &DevItf->InterfaceClassGuid,
                    sizeof(GUID));
                DeviceInterfaceData->Flags = DevItf->Flags;
                DeviceInterfaceData->Reserved = (ULONG_PTR)DevItf;
                found = TRUE;
                ret = TRUE;
            }
            InterfaceListEntry = InterfaceListEntry->Flink;
        }
        if (!found)
            SetLastError(ERROR_NO_MORE_ITEMS);
    }
    else
    {
        BOOL found = FALSE;
        PLIST_ENTRY ItemList = set->ListHead.Flink;
        while (ItemList != &set->ListHead && !found)
        {
            PLIST_ENTRY InterfaceListEntry;
            struct DeviceInfo *devInfo =
                CONTAINING_RECORD(ItemList, struct DeviceInfo, ListEntry);
            InterfaceListEntry = devInfo->InterfaceListHead.Flink;
            while (InterfaceListEntry != &devInfo->InterfaceListHead && !found)
            {
                struct DeviceInterface *DevItf = CONTAINING_RECORD(InterfaceListEntry, struct DeviceInterface, ListEntry);
                if (!IsEqualIID(&DevItf->InterfaceClassGuid, InterfaceClassGuid))
                {
                    InterfaceListEntry = InterfaceListEntry->Flink;
                    continue;
                }
                if (MemberIndex-- == 0)
                {
                    /* return this item */
                    memcpy(&DeviceInterfaceData->InterfaceClassGuid,
                        &DevItf->InterfaceClassGuid,
                        sizeof(GUID));
                    DeviceInterfaceData->Flags = DevItf->Flags;
                    DeviceInterfaceData->Reserved = (ULONG_PTR)DevItf;
                    found = TRUE;
                    ret = TRUE;
                }
                InterfaceListEntry = InterfaceListEntry->Flink;
            }
            ItemList = ItemList->Flink;
 
        }
        if (!found)
            SetLastError(ERROR_NO_MORE_ITEMS);
    }
    return ret;
}

Referenced by BluetoothFindNextRadio(), check_device_iface_(), check_device_path(), Enum(), find_devices(), get_device(), getDeviceInterfaceDetail(), GetDeviceListInterfaces(), InstallSoftwareDeviceInterface(), InstallSoftwareDeviceInterfaceInf(), IsSoftwareBusPnpEnumeratorInstalled(), KsOpenDefaultDevice(), PowerMeterInfo_UpdateBatteryStats(), ProcessExistingDevices(), run_for_each_device(), test_device_iface(), test_register_device_iface(), TestKs(), and WdmAudOpenSoundDeviceByLegacy().

SetupDiGetActualSectionToInstallA()

BOOL WINAPI SetupDiGetActualSectionToInstallA	(	HINF	InfHandle,
		PCSTR	InfSectionName,
		PSTR	InfSectionWithExt,
		DWORD	InfSectionWithExtSize,
		PDWORD	RequiredSize,
		PSTR *	Extension
	)

Definition at line 1964 of file devinst.c.

{
    return SetupDiGetActualSectionToInstallExA(InfHandle, InfSectionName,
        NULL, InfSectionWithExt, InfSectionWithExtSize, RequiredSize,
        Extension, NULL);
}

SetupDiGetActualSectionToInstallExA()

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
	)

Definition at line 1997 of file devinst.c.

{
    LPWSTR InfSectionNameW = NULL;
    LPWSTR InfSectionWithExtW = NULL;
    PWSTR ExtensionW;
    BOOL bResult = FALSE;
 
    TRACE("%s()\n", __FUNCTION__);
 
    if (InfSectionName)
    {
        InfSectionNameW = pSetupMultiByteToUnicode(InfSectionName, CP_ACP);
        if (InfSectionNameW == NULL)
            goto cleanup;
    }
    if (InfSectionWithExt)
    {
        InfSectionWithExtW = MyMalloc(InfSectionWithExtSize * sizeof(WCHAR));
        if (InfSectionWithExtW == NULL)
            goto cleanup;
    }
 
    bResult = SetupDiGetActualSectionToInstallExW(
        InfHandle, InfSectionNameW, AlternatePlatformInfo,
        InfSectionWithExt ? InfSectionWithExtW : NULL,
        InfSectionWithExtSize,
        RequiredSize,
        Extension ? &ExtensionW : NULL,
        Reserved);
 
    if (bResult && InfSectionWithExt)
    {
         bResult = WideCharToMultiByte(CP_ACP, 0, InfSectionWithExtW, -1, InfSectionWithExt,
             InfSectionWithExtSize, NULL, NULL) != 0;
    }
    if (bResult && Extension)
    {
        if (ExtensionW == NULL)
            *Extension = NULL;
         else
            *Extension = &InfSectionWithExt[ExtensionW - InfSectionWithExtW];
    }
 
cleanup:
    MyFree(InfSectionNameW);
    MyFree(InfSectionWithExtW);
 
    return bResult;
}

Referenced by SetupDiGetActualSectionToInstallA().

SetupDiGetActualSectionToInstallExW()

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
	)

Definition at line 415 of file devinst.c.

{
    BOOL ret = FALSE;
 
    TRACE("%s(%p %s %p %p %lu %p %p %p)\n", __FUNCTION__, InfHandle, debugstr_w(InfSectionName),
        AlternatePlatformInfo, InfSectionWithExt, InfSectionWithExtSize,
        RequiredSize, Extension, Reserved);
 
    if (!InfHandle || InfHandle == (HINF)INVALID_HANDLE_VALUE)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (!InfSectionName)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (AlternatePlatformInfo && AlternatePlatformInfo->cbSize != sizeof(SP_ALTPLATFORM_INFO))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (Reserved != NULL)
        SetLastError(ERROR_INVALID_PARAMETER);
    else
    {
        static SP_ALTPLATFORM_INFO CurrentPlatform = { 0, };
        static BYTE CurrentProductType = 0;
        static WORD CurrentSuiteMask = 0;
        PSP_ALTPLATFORM_INFO pPlatformInfo = &CurrentPlatform;
        struct GetSectionCallbackInfo CallbackInfo;
        DWORD dwFullLength;
        BYTE ProductType;
        WORD SuiteMask;
 
        /* Fill platform info if needed */
        if (AlternatePlatformInfo)
        {
            pPlatformInfo = AlternatePlatformInfo;
            ProductType = 0;
            SuiteMask = 0;
        }
        else
        {
            if (CurrentPlatform.cbSize != sizeof(SP_ALTPLATFORM_INFO))
            {
                /* That's the first time we go here. We need to fill in the structure */
                SYSTEM_INFO SystemInfo;
                GetSystemInfo(&SystemInfo);
                CurrentPlatform.cbSize = sizeof(SP_ALTPLATFORM_INFO);
                CurrentPlatform.Platform = OsVersionInfo.dwPlatformId;
                CurrentPlatform.MajorVersion = OsVersionInfo.dwMajorVersion;
                CurrentPlatform.MinorVersion = OsVersionInfo.dwMinorVersion;
                CurrentPlatform.ProcessorArchitecture = SystemInfo.wProcessorArchitecture;
                CurrentPlatform.Reserved = 0;
                CurrentProductType = OsVersionInfo.wProductType;
                CurrentSuiteMask = OsVersionInfo.wSuiteMask;
            }
            ProductType = CurrentProductType;
            SuiteMask = CurrentSuiteMask;
        }
 
        CallbackInfo.PlatformInfo = pPlatformInfo;
        CallbackInfo.ProductType = ProductType;
        CallbackInfo.SuiteMask = SuiteMask;
        CallbackInfo.PrefixLength = strlenW(InfSectionName);
        CallbackInfo.BestScore1 = ULONG_MAX;
        CallbackInfo.BestScore2 = ULONG_MAX;
        CallbackInfo.BestScore3 = ULONG_MAX;
        CallbackInfo.BestScore4 = ULONG_MAX;
        CallbackInfo.BestScore5 = ULONG_MAX;
        strcpyW(CallbackInfo.BestSection, InfSectionName);
        TRACE("EnumerateSectionsStartingWith(InfSectionName = %S)\n", InfSectionName);
        if (!EnumerateSectionsStartingWith(
            InfHandle,
            InfSectionName,
            GetSectionCallback,
            &CallbackInfo))
        {
            SetLastError(ERROR_GEN_FAILURE);
            goto done;
        }
        TRACE("CallbackInfo.BestSection = %S\n", CallbackInfo.BestSection);
 
        dwFullLength = lstrlenW(CallbackInfo.BestSection);
        if (RequiredSize != NULL)
            *RequiredSize = dwFullLength + 1;
 
        if (InfSectionWithExtSize > 0)
        {
            if (InfSectionWithExtSize < dwFullLength + 1)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                goto done;
            }
            strcpyW(InfSectionWithExt, CallbackInfo.BestSection);
            if (Extension)
            {
                DWORD dwLength = lstrlenW(InfSectionName);
                *Extension = (dwLength == dwFullLength) ? NULL : &InfSectionWithExt[dwLength];
            }
        }
 
        ret = TRUE;
    }
 
done:
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by SetupDiGetActualSectionToInstallExA(), and SetupDiGetActualSectionToInstallW().

SetupDiGetActualSectionToInstallW()

BOOL WINAPI SetupDiGetActualSectionToInstallW	(	HINF	InfHandle,
		PCWSTR	InfSectionName,
		PWSTR	InfSectionWithExt,
		DWORD	InfSectionWithExtSize,
		PDWORD	RequiredSize,
		PWSTR *	Extension
	)

Definition at line 1980 of file devinst.c.

{
    return SetupDiGetActualSectionToInstallExW(InfHandle, InfSectionName,
        NULL, InfSectionWithExt, InfSectionWithExtSize, RequiredSize,
        Extension, NULL);
}

Referenced by get_source_id(), get_src_file_info(), InstallDeviceData(), InstallHinfSectionW(), NetClassInstaller(), SetupDiBuildDriverInfoList(), SetupDiInstallClassExW(), SetupDiInstallDevice(), SetupDiInstallDeviceInterfaces(), SetupDiInstallDriverFiles(), SetupDiRegisterCoDeviceInstallers(), and SetupGetSourceInfoW().

SetupDiGetClassDescriptionA()

BOOL WINAPI SetupDiGetClassDescriptionA	(	const GUID *	ClassGuid,
		PSTR	ClassDescription,
		DWORD	ClassDescriptionSize,
		PDWORD	RequiredSize
	)

Definition at line 2058 of file devinst.c.

{
    return SetupDiGetClassDescriptionExA(ClassGuid, ClassDescription,
                                         ClassDescriptionSize,
                                         RequiredSize, NULL, NULL);
}

Referenced by test_SetupDiGetClassDescriptionA().

SetupDiGetClassDescriptionExA()

BOOL WINAPI SetupDiGetClassDescriptionExA	(	const GUID *	ClassGuid,
		PSTR	ClassDescription,
		DWORD	ClassDescriptionSize,
		PDWORD	RequiredSize,
		PCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 2086 of file devinst.c.

{
    PWCHAR ClassDescriptionW = NULL;
    LPWSTR MachineNameW = NULL;
    BOOL ret = FALSE;
 
    TRACE("%s(%s %p %lu %p %s %p)\n", __FUNCTION__, debugstr_guid(ClassGuid), ClassDescription,
        ClassDescriptionSize, RequiredSize, debugstr_a(MachineName), Reserved);
 
    if (ClassDescriptionSize > 0)
    {
        ClassDescriptionW = MyMalloc(ClassDescriptionSize * sizeof(WCHAR));
        if (!ClassDescriptionW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
    }
 
    if (MachineName)
    {
        MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
        if (!MachineNameW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
    }
 
    ret = SetupDiGetClassDescriptionExW(ClassGuid, ClassDescriptionW,
        ClassDescriptionSize * sizeof(WCHAR), RequiredSize, MachineNameW, Reserved);
    if (ret)
    {
        DWORD len = (DWORD)WideCharToMultiByte(CP_ACP, 0, ClassDescriptionW, -1, ClassDescription,
            ClassDescriptionSize, NULL, NULL);
        if (len == 0 || len > ClassDescriptionSize)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            ret = FALSE;
        }
    }
 
cleanup:
    MyFree(ClassDescriptionW);
    MyFree(MachineNameW);
    return ret;
}

Referenced by SetupDiGetClassDescriptionA().

SetupDiGetClassDescriptionExW()

BOOL WINAPI SetupDiGetClassDescriptionExW	(	const GUID *	ClassGuid,
		PWSTR	ClassDescription,
		DWORD	ClassDescriptionSize,
		PDWORD	RequiredSize,
		PCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 2143 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), ClassDescription,
        ClassDescriptionSize, RequiredSize, debugstr_w(MachineName), Reserved);
 
    /* Make sure there's a GUID */
    if (!ClassGuid)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Make sure there's a real buffer when there's a size */
    if (!ClassDescription && ClassDescriptionSize > 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        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 description data and close the key */
    rc = QueryRegistryValue(hKey, NULL, (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 description */
    dwLength /= sizeof(WCHAR);
 
    /* Count the null-terminator if none is present */
    if ((dwLength == 0) || (Buffer[dwLength - 1] != UNICODE_NULL))
        dwLength++;
 
    /* Inform the caller about the class description */
    if ((ClassDescription != NULL) && (dwLength <= ClassDescriptionSize))
    {
        memcpy(ClassDescription, Buffer, (dwLength - 1) * sizeof(WCHAR));
        ClassDescription[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 ((ClassDescription == NULL) || (dwLength > ClassDescriptionSize))
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by SetupDiGetClassDescriptionExA(), and SetupDiGetClassDescriptionW().

SetupDiGetClassDescriptionW()

BOOL WINAPI SetupDiGetClassDescriptionW	(	const GUID *	ClassGuid,
		PWSTR	ClassDescription,
		DWORD	ClassDescriptionSize,
		PDWORD	RequiredSize
	)

Definition at line 2072 of file devinst.c.

{
    return SetupDiGetClassDescriptionExW(ClassGuid, ClassDescription,
                                         ClassDescriptionSize,
                                         RequiredSize, NULL, NULL);
}

SetupDiGetClassDevsA()

HDEVINFO WINAPI SetupDiGetClassDevsA	(	CONST GUID *	class,
		LPCSTR	enumstr,
		HWND	parent,
		DWORD	flags
	)

Definition at line 2236 of file devinst.c.

{
    return SetupDiGetClassDevsExA(class, enumstr, parent,
                                  flags, NULL, NULL, NULL);
}

Referenced by test_device_interface_key(), test_devnode(), test_register_device_iface(), test_register_device_info(), test_registry_property_a(), test_registry_property_w(), and testSetupDiGetClassDevsA().

SetupDiGetClassDevsExA()

HDEVINFO WINAPI SetupDiGetClassDevsExA	(	const GUID *	class,
		PCSTR	enumstr,
		HWND	parent,
		DWORD	flags,
		HDEVINFO	deviceset,
		PCSTR	machine,
		PVOID	reserved
	)

Definition at line 2249 of file devinst.c.

{
    HDEVINFO ret;
    LPWSTR enumstrW = NULL, machineW = NULL;
 
    if (enumstr)
    {
        enumstrW = pSetupMultiByteToUnicode(enumstr, CP_ACP);
        if (!enumstrW)
        {
            ret = INVALID_HANDLE_VALUE;
            goto end;
        }
    }
    if (machine)
    {
        machineW = pSetupMultiByteToUnicode(machine, CP_ACP);
        if (!machineW)
        {
            MyFree(enumstrW);
            ret = INVALID_HANDLE_VALUE;
            goto end;
        }
    }
    ret = SetupDiGetClassDevsExW(class, enumstrW, parent, flags, deviceset,
            machineW, reserved);
    MyFree(enumstrW);
    MyFree(machineW);
 
end:
    return ret;
}

Referenced by SetupDiGetClassDevsA().

SetupDiGetClassDevsExW()

HDEVINFO WINAPI SetupDiGetClassDevsExW	(	CONST GUID *	class,
		PCWSTR	enumstr,
		HWND	parent,
		DWORD	flags,
		HDEVINFO	deviceset,
		PCWSTR	machine,
		PVOID	reserved
	)

Definition at line 2305 of file devinst.c.

{
    HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
    struct DeviceInfoSet *list;
    CONST GUID *pClassGuid;
    LONG rc;
    HDEVINFO set = INVALID_HANDLE_VALUE;
 
    TRACE("%s(%s %s %p 0x%08x %p %s %p)\n", __FUNCTION__, debugstr_guid(class),
            debugstr_w(enumstr), parent, flags, deviceset, debugstr_w(machine),
            reserved);
 
    if (!(flags & DIGCF_ALLCLASSES) && !class)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
 
    /* Create the deviceset if not set */
    if (deviceset)
    {
        list = (struct DeviceInfoSet *)deviceset;
        if (list->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        {
            SetLastError(ERROR_INVALID_HANDLE);
            goto cleanup;
        }
        hDeviceInfo = deviceset;
    }
    else
    {
         hDeviceInfo = SetupDiCreateDeviceInfoListExW(
             flags & (DIGCF_DEVICEINTERFACE | DIGCF_ALLCLASSES) ? NULL : class,
             NULL, machine, NULL);
         if (hDeviceInfo == INVALID_HANDLE_VALUE)
             goto cleanup;
         list = (struct DeviceInfoSet *)hDeviceInfo;
    }
 
    if (flags & DIGCF_PROFILE)
        FIXME(": flag DIGCF_PROFILE ignored\n");
 
    if (flags & DIGCF_DEVICEINTERFACE)
    {
        if (!class)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            goto cleanup;
        }
        rc = SETUP_CreateInterfaceList(list, machine, class, enumstr, flags & DIGCF_PRESENT);
    }
    else
    {
        /* Determine which class(es) should be included in the deviceset */
        if (flags & DIGCF_ALLCLASSES)
        {
            /* The caller wants all classes. Check if
             * the deviceset limits us to one class */
            if (IsEqualIID(&list->ClassGuid, &GUID_NULL))
                pClassGuid = NULL;
            else
                pClassGuid = &list->ClassGuid;
        }
        else if (class)
        {
            /* The caller wants one class. Check if it matches deviceset class */
            if (IsEqualIID(&list->ClassGuid, class)
             || IsEqualIID(&list->ClassGuid, &GUID_NULL))
            {
                pClassGuid = class;
            }
            else
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                goto cleanup;
            }
        }
        else if (!IsEqualIID(&list->ClassGuid, &GUID_NULL))
        {
            /* No class specified. Try to use the one of the deviceset */
            if (IsEqualIID(&list->ClassGuid, &GUID_NULL))
                pClassGuid = &list->ClassGuid;
            else
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                goto cleanup;
            }
        }
        else
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            goto cleanup;
        }
        rc = SETUP_CreateDevicesList(list, machine, pClassGuid, enumstr);
    }
    if (rc != ERROR_SUCCESS)
    {
        SetLastError(rc);
        goto cleanup;
    }
    set = hDeviceInfo;
 
cleanup:
    if (!deviceset && hDeviceInfo != INVALID_HANDLE_VALUE && hDeviceInfo != set)
        SetupDiDestroyDeviceInfoList(hDeviceInfo);
    return set;
}

Referenced by ProcessExistingDevices(), SetupDiGetClassDevsExA(), SetupDiGetClassDevsW(), and test_SetupDiGetClassDevsExW().

SetupDiGetClassDevsW()

HDEVINFO WINAPI SetupDiGetClassDevsW	(	CONST GUID *	class,
		LPCWSTR	enumstr,
		HWND	parent,
		DWORD	flags
	)

Definition at line 2292 of file devinst.c.

{
    return SetupDiGetClassDevsExW(class, enumstr, parent, flags, NULL, NULL,
            NULL);
}

Referenced by BluetoothFindFirstRadio(), check_device_path(), CNetConnection::Disconnect(), DisplayPageSetDeviceDetails(), fill_pnpentity(), find_devices(), get_device(), CDeviceView::GetNextClass(), InstallSoftwareDeviceInterface(), InstallSoftwareDeviceInterfaceInf(), IsSoftwareBusPnpEnumeratorInstalled(), KsOpenDefaultDevice(), pCDevSettings_GetDeviceInstanceId(), PowerMeterInfo_UpdateBatteryStats(), CDeviceView::RefreshDeviceList(), run_for_each_device(), SetDeviceDetails(), UpdateDriverForPlugAndPlayDevicesW(), and WdmAudOpenSoundDeviceByLegacy().

SetupDiGetCustomDevicePropertyA()

BOOL WINAPI SetupDiGetCustomDevicePropertyA	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData,
		IN PCSTR	CustomPropertyName,
		IN DWORD	Flags,
		OUT PDWORD PropertyRegDataType	OPTIONAL,
		OUT PBYTE	PropertyBuffer,
		IN DWORD	PropertyBufferSize,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 6203 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;
    DWORD ConfigFlags = 0, PropertySize;
    CONFIGRET cr;
 
    TRACE("%s(%p %p %s 0x%lx %p %p %lu %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
        CustomPropertyName, Flags, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize);
 
    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;
    }
    if (Flags & ~DICUSTOMDEVPROP_MERGE_MULTISZ)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
    if (deviceInfo->set != set)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Flags & DICUSTOMDEVPROP_MERGE_MULTISZ)
    {
        ConfigFlags |= CM_CUSTOMDEVPROP_MERGE_MULTISZ;
    }
 
    PropertySize = PropertyBufferSize;
    cr = CM_Get_DevInst_Custom_Property_ExA(deviceInfo->dnDevInst,
                                            CustomPropertyName,
                                            PropertyRegDataType,
                                            PropertyBuffer,
                                            &PropertySize,
                                            ConfigFlags,
                                            set->hMachine);
    if ((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL))
    {
        if (RequiredSize)
            *RequiredSize = PropertySize;
    }
 
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        return FALSE;
    }
 
    return TRUE;
}

SetupDiGetCustomDevicePropertyW()

BOOL WINAPI SetupDiGetCustomDevicePropertyW	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData,
		IN PCWSTR	CustomPropertyName,
		IN DWORD	Flags,
		OUT PDWORD PropertyRegDataType	OPTIONAL,
		OUT PBYTE	PropertyBuffer,
		IN DWORD	PropertyBufferSize,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 6283 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;
    DWORD ConfigFlags = 0, PropertySize;
    CONFIGRET cr;
 
    TRACE("%s(%p %p %s 0x%lx %p %p %lu %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
        debugstr_w(CustomPropertyName), Flags, PropertyRegDataType, PropertyBuffer, PropertyBufferSize, RequiredSize);
 
    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;
    }
    if (Flags & ~DICUSTOMDEVPROP_MERGE_MULTISZ)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
    if (deviceInfo->set != set)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Flags & DICUSTOMDEVPROP_MERGE_MULTISZ)
    {
        ConfigFlags |= CM_CUSTOMDEVPROP_MERGE_MULTISZ;
    }
 
    PropertySize = PropertyBufferSize;
    cr = CM_Get_DevInst_Custom_Property_ExW(deviceInfo->dnDevInst,
                                            CustomPropertyName,
                                            PropertyRegDataType,
                                            PropertyBuffer,
                                            &PropertySize,
                                            ConfigFlags,
                                            set->hMachine);
    if ((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL))
    {
        if (RequiredSize)
            *RequiredSize = PropertySize;
    }
 
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        return FALSE;
    }
 
    return TRUE;
}

SetupDiGetDeviceInfoListClass()

BOOL WINAPI SetupDiGetDeviceInfoListClass	(	IN HDEVINFO	DeviceInfoSet,
		OUT LPGUID	ClassGuid
	)

Definition at line 4465 of file devinst.c.

{
    struct DeviceInfoSet *list;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, ClassGuid);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (IsEqualIID(&list->ClassGuid, &GUID_NULL))
        SetLastError(ERROR_NO_ASSOCIATED_CLASS);
    else
    {
        *ClassGuid = list->ClassGuid;
 
        ret = TRUE;
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

SetupDiGetDeviceInfoListDetailA()

BOOL WINAPI SetupDiGetDeviceInfoListDetailA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_LIST_DETAIL_DATA_A	DevInfoData
	)

Definition at line 2423 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DevInfoData);
 
    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 (!DevInfoData ||
            DevInfoData->cbSize != sizeof(SP_DEVINFO_LIST_DETAIL_DATA_A))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    memcpy(&DevInfoData->ClassGuid, &set->ClassGuid, sizeof(GUID));
    DevInfoData->RemoteMachineHandle = set->hMachine;
    if (set->MachineName)
    {
        FIXME("Stub\n");
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
    else
        DevInfoData->RemoteMachineName[0] = 0;
 
    return TRUE;
}

SetupDiGetDeviceInfoListDetailW()

BOOL WINAPI SetupDiGetDeviceInfoListDetailW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_LIST_DETAIL_DATA_W	DevInfoData
	)

Definition at line 2464 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DevInfoData);
 
    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 (!DevInfoData ||
            DevInfoData->cbSize != sizeof(SP_DEVINFO_LIST_DETAIL_DATA_W))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    memcpy(&DevInfoData->ClassGuid, &set->ClassGuid, sizeof(GUID));
    DevInfoData->RemoteMachineHandle = set->hMachine;
    if (set->MachineName)
        strcpyW(DevInfoData->RemoteMachineName, set->MachineName + 2);
    else
        DevInfoData->RemoteMachineName[0] = 0;
 
    return TRUE;
}

SetupDiGetDeviceInstallParamsA()

BOOL WINAPI SetupDiGetDeviceInstallParamsA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		PSP_DEVINSTALL_PARAMS_A	DeviceInstallParams
	)

Definition at line 4422 of file devinst.c.

{
    SP_DEVINSTALL_PARAMS_W deviceInstallParamsW;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
 
    if (DeviceInstallParams == NULL)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_A))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        deviceInstallParamsW.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
        ret = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &deviceInstallParamsW);
 
        if (ret)
        {
            /* Do W->A conversion */
            memcpy(
                DeviceInstallParams,
                &deviceInstallParamsW,
                FIELD_OFFSET(SP_DEVINSTALL_PARAMS_W, DriverPath));
            if (WideCharToMultiByte(CP_ACP, 0, deviceInstallParamsW.DriverPath, -1,
                DeviceInstallParams->DriverPath, MAX_PATH, NULL, NULL) == 0)
            {
                DeviceInstallParams->DriverPath[0] = '\0';
                ret = FALSE;
            }
        }
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

SetupDiGetDeviceInstallParamsW()

BOOL WINAPI SetupDiGetDeviceInstallParamsW	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA DeviceInfoData	OPTIONAL,
		OUT PSP_DEVINSTALL_PARAMS_W	DeviceInstallParams
	)

Definition at line 4495 of file devinst.c.

{
    struct DeviceInfoSet *list;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (!DeviceInstallParams)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_W))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        PSP_DEVINSTALL_PARAMS_W Source;
 
        if (DeviceInfoData)
            Source = &((struct DeviceInfo *)DeviceInfoData->Reserved)->InstallParams;
        else
            Source = &list->InstallParams;
 
        ret = TRUE;
 
        _SEH2_TRY
        {
            memcpy(DeviceInstallParams, Source, Source->cbSize);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            SetLastError(RtlNtStatusToDosError(_SEH2_GetExceptionCode()));
            ret = FALSE;
        }
        _SEH2_END;
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by BatteryClassInstall(), DisplayDeviceAdvancedProperties(), EnumerateDrivers(), CDeviceNode::GetFlags(), InstallNetDevice(), CDeviceNode::RemoveFlags(), SearchDriver(), CDeviceNode::SetFlags(), SetupDiBuildDriverInfoList(), SetupDiCallClassInstaller(), SetupDiDestroyDriverInfoList(), SetupDiGetDeviceInstallParamsA(), SetupDiGetDriverInstallParamsW(), SetupDiGetSelectedDriverW(), SetupDiInstallClassExW(), SetupDiInstallDevice(), SetupDiInstallDeviceInterfaces(), SetupDiInstallDriverFiles(), SetupDiRegisterCoDeviceInstallers(), SetupDiSetClassInstallParamsW(), SetupInstallFromInfSectionW(), UpdateDevInfo(), and WriteParameterArray().

SetupDiGetDeviceInstanceIdA()

BOOL WINAPI SetupDiGetDeviceInstanceIdA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		PSTR	DeviceInstanceId,
		DWORD	DeviceInstanceIdSize,
		PDWORD	RequiredSize
	)

Definition at line 1838 of file devinst.c.

{
    BOOL ret = FALSE;
    DWORD size;
    PWSTR instanceId;
 
    TRACE("%s(%p %p %p %d %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstanceId,
            DeviceInstanceIdSize, RequiredSize);
 
    if (!DeviceInstanceId && DeviceInstanceIdSize > 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet,
                                DeviceInfoData,
                                NULL,
                                0,
                                &size);
    if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
        return FALSE;
    instanceId = MyMalloc(size * sizeof(WCHAR));
    if (instanceId)
    {
        ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet,
                                          DeviceInfoData,
                                          instanceId,
                                          size,
                                          &size);
        if (ret)
        {
            int len = WideCharToMultiByte(CP_ACP, 0, instanceId, -1,
                                          DeviceInstanceId,
                                          DeviceInstanceIdSize, NULL, NULL);
 
            if (!len)
                ret = FALSE;
            else
            {
                if (len > DeviceInstanceIdSize)
                {
                    SetLastError(ERROR_INSUFFICIENT_BUFFER);
                    ret = FALSE;
                }
                if (RequiredSize)
                    *RequiredSize = len;
            }
        }
        MyFree(instanceId);
    }
    else
    {
        if (RequiredSize)
            *RequiredSize = size;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        ret = FALSE;
    }
    return ret;
}

Referenced by check_device_info_(), test_device_info(), and test_get_device_instance_id().

SetupDiGetDeviceInstanceIdW()

BOOL WINAPI SetupDiGetDeviceInstanceIdW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		PWSTR	DeviceInstanceId,
		DWORD	DeviceInstanceIdSize,
		PDWORD	RequiredSize
	)

Definition at line 1907 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *devInfo;
 
    TRACE("%s(%p %p %p %d %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstanceId,
            DeviceInstanceIdSize, RequiredSize);
 
    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;
    }
    devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
    if (!DeviceInstanceId && DeviceInstanceIdSize > 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (DeviceInstanceId && DeviceInstanceIdSize == 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    TRACE("instance ID: %s\n", debugstr_w(devInfo->instanceId));
    if (DeviceInstanceIdSize < lstrlenW(devInfo->instanceId) + 1)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        if (RequiredSize)
            *RequiredSize = lstrlenW(devInfo->instanceId) + 1;
        return FALSE;
    }
    lstrcpyW(DeviceInstanceId, devInfo->instanceId);
    if (RequiredSize)
        *RequiredSize = lstrlenW(devInfo->instanceId) + 1;
    return TRUE;
}

Referenced by fill_pnpentity(), GetBootResourceList(), InstallNetDevice(), SetupDiGetDeviceInstanceIdA(), and UpdateDriverForPlugAndPlayDevicesW().

SetupDiGetDeviceInterfaceDetailA()

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
	)

Definition at line 2961 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailDataW = NULL;
    DWORD sizeW = 0, bytesNeeded;
    BOOL ret = FALSE;
 
    TRACE("%s(%p, %p, %p, %d, %p, %p)\n", __FUNCTION__, DeviceInfoSet,
     DeviceInterfaceData, DeviceInterfaceDetailData,
     DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
            set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!DeviceInterfaceData ||
            DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
            !DeviceInterfaceData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (DeviceInterfaceDetailData && (DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A)))
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
    if((DeviceInterfaceDetailDataSize != 0) &&
        (DeviceInterfaceDetailDataSize < (FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath) + sizeof(CHAR))))
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
    if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
 
    if (DeviceInterfaceDetailData != NULL)
    {
        sizeW = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)
            + (DeviceInterfaceDetailDataSize - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath)) * sizeof(WCHAR);
        DeviceInterfaceDetailDataW = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)MyMalloc(sizeW);
        if (!DeviceInterfaceDetailDataW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        }
        DeviceInterfaceDetailDataW->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
    }
    if (!DeviceInterfaceDetailData || (DeviceInterfaceDetailData && DeviceInterfaceDetailDataW))
    {
        ret = SetupDiGetDeviceInterfaceDetailW(
            DeviceInfoSet,
            DeviceInterfaceData,
            DeviceInterfaceDetailDataW,
            sizeW,
            &sizeW,
            DeviceInfoData);
        bytesNeeded = (sizeW - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)) / sizeof(WCHAR)
            + FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath);
        if (RequiredSize)
            *RequiredSize = bytesNeeded;
        if (ret && DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize >= bytesNeeded)
        {
            if (!WideCharToMultiByte(
                CP_ACP, 0,
                DeviceInterfaceDetailDataW->DevicePath, -1,
                DeviceInterfaceDetailData->DevicePath, DeviceInterfaceDetailDataSize - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
                NULL, NULL))
            {
                ret = FALSE;
            }
        }
    }
    MyFree(DeviceInterfaceDetailDataW);
 
    return ret;
}

Referenced by check_device_iface_(), test_device_iface(), and test_device_iface_detail().

SetupDiGetDeviceInterfaceDetailW()

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
	)

Definition at line 3055 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    BOOL ret = FALSE;
 
    TRACE("%s(%p, %p, %p, %d, %p, %p)\n", __FUNCTION__, DeviceInfoSet,
     DeviceInterfaceData, DeviceInterfaceDetailData,
     DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
            set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!DeviceInterfaceData ||
            DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
            !DeviceInterfaceData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (DeviceInterfaceDetailData && DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W))
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
    if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
    if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if ((DeviceInterfaceDetailData != NULL)
        && (DeviceInterfaceDetailDataSize < (FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)) + sizeof(WCHAR)))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    else
    {
        struct DeviceInterface *deviceInterface = (struct DeviceInterface *)DeviceInterfaceData->Reserved;
        LPCWSTR devName = deviceInterface->SymbolicLink;
        DWORD sizeRequired = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W) +
            (lstrlenW(devName) + 1) * sizeof(WCHAR);
 
        if (sizeRequired > DeviceInterfaceDetailDataSize)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            if (RequiredSize)
                *RequiredSize = sizeRequired;
        }
        else
        {
            strcpyW(DeviceInterfaceDetailData->DevicePath, devName);
            TRACE("DevicePath is %s\n", debugstr_w(DeviceInterfaceDetailData->DevicePath));
            if (DeviceInfoData)
            {
                memcpy(&DeviceInfoData->ClassGuid,
                    &deviceInterface->DeviceInfo->ClassGuid,
                    sizeof(GUID));
                DeviceInfoData->DevInst = deviceInterface->DeviceInfo->dnDevInst;
                DeviceInfoData->Reserved = (ULONG_PTR)deviceInterface->DeviceInfo;
            }
            ret = TRUE;
        }
    }
    return ret;
}

Referenced by BluetoothFindNextRadio(), check_device_path(), Enum(), find_devices(), get_device(), GetDeviceListInterfaces(), InstallSoftwareDeviceInterface(), IsSoftwareBusPnpEnumeratorInstalled(), KsOpenDefaultDevice(), ProcessExistingDevices(), run_for_each_device(), SetupDiGetDeviceInterfaceDetailA(), test_device_iface_detail(), and WdmAudOpenSoundDeviceByLegacy().

SetupDiGetDeviceRegistryPropertyA()

BOOL WINAPI SetupDiGetDeviceRegistryPropertyA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Property,
		PDWORD	PropertyRegDataType,
		PBYTE	PropertyBuffer,
		DWORD	PropertyBufferSize,
		PDWORD	RequiredSize
	)

Definition at line 3183 of file devinst.c.

{
    BOOL ret;
    BOOL bIsStringProperty;
    DWORD RegType;
    DWORD RequiredSizeA, RequiredSizeW;
    DWORD PropertyBufferSizeW = 0;
    PBYTE PropertyBufferW = NULL;
 
    TRACE("%s(%p %p %d %p %p %d %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
        Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
        RequiredSize);
 
    if (PropertyBufferSize != 0)
    {
        PropertyBufferSizeW = PropertyBufferSize * 2;
        PropertyBufferW = HeapAlloc(GetProcessHeap(), 0, PropertyBufferSizeW);
        if (!PropertyBufferW)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }
 
    ret = SetupDiGetDeviceRegistryPropertyW(DeviceInfoSet,
                                            DeviceInfoData,
                                            Property,
                                            &RegType,
                                            PropertyBufferW,
                                            PropertyBufferSizeW,
                                            &RequiredSizeW);
 
    if (ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        bIsStringProperty = (RegType == REG_SZ || RegType == REG_MULTI_SZ || RegType == REG_EXPAND_SZ);
 
        if (bIsStringProperty)
           RequiredSizeA = RequiredSizeW / sizeof(WCHAR);
        else
            RequiredSizeA = RequiredSizeW;
        if (RequiredSize)
            *RequiredSize = RequiredSizeA;
        if (PropertyRegDataType)
            *PropertyRegDataType = RegType;
    }
 
    if (!ret)
    {
        HeapFree(GetProcessHeap(), 0, PropertyBufferW);
        return ret;
    }
 
    if (RequiredSizeA <= PropertyBufferSize)
    {
        if (bIsStringProperty && PropertyBufferSize > 0)
        {
            if (WideCharToMultiByte(CP_ACP, 0, (LPWSTR)PropertyBufferW, RequiredSizeW / sizeof(WCHAR), (LPSTR)PropertyBuffer, PropertyBufferSize, NULL, NULL) == 0)
            {
                /* Last error is already set by WideCharToMultiByte */
                ret = FALSE;
            }
        }
        else
            memcpy(PropertyBuffer, PropertyBufferW, RequiredSizeA);
    }
    else
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        ret = FALSE;
    }
 
    HeapFree(GetProcessHeap(), 0, PropertyBufferW);
    return ret;
}

Referenced by test_registry_property_a().

SetupDiGetDeviceRegistryPropertyW()

BOOL WINAPI SetupDiGetDeviceRegistryPropertyW	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Property,
		PDWORD	PropertyRegDataType,
		PBYTE	PropertyBuffer,
		DWORD	PropertyBufferSize,
		PDWORD	RequiredSize
	)

Definition at line 3268 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *devInfo;
    CONFIGRET cr;
    LONG lError = ERROR_SUCCESS;
    DWORD size;
 
    TRACE("%s(%p %p %d %p %p %d %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
        Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
        RequiredSize);
 
    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;
    }
 
    if (Property >= SPDRP_MAXIMUM_PROPERTY)
    {
        SetLastError(ERROR_INVALID_REG_PROPERTY);
        return FALSE;
    }
 
    devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
    if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
        && PropertyMap[Property].nameW)
    {
        HKEY hKey;
        size = PropertyBufferSize;
        hKey = SETUPDI_OpenDevKey(set->HKLM, devInfo, KEY_QUERY_VALUE);
        if (hKey == INVALID_HANDLE_VALUE)
            return FALSE;
        lError = RegQueryValueExW(hKey, PropertyMap[Property].nameW,
                 NULL, PropertyRegDataType, PropertyBuffer, &size);
        RegCloseKey(hKey);
 
        if (RequiredSize)
            *RequiredSize = size;
 
        switch (lError)
        {
            case ERROR_SUCCESS:
                if (PropertyBuffer == NULL && size != 0)
                    lError = ERROR_INSUFFICIENT_BUFFER;
                break;
            case ERROR_MORE_DATA:
                lError = ERROR_INSUFFICIENT_BUFFER;
                break;
            default:
                break;
        }
    }
    else if (Property == SPDRP_PHYSICAL_DEVICE_OBJECT_NAME)
    {
        size = (strlenW(devInfo->Data) + 1) * sizeof(WCHAR);
 
        if (PropertyRegDataType)
            *PropertyRegDataType = REG_SZ;
        if (RequiredSize)
            *RequiredSize = size;
        if (PropertyBufferSize >= size)
        {
            strcpyW((LPWSTR)PropertyBuffer, devInfo->Data);
        }
        else
            lError = ERROR_INSUFFICIENT_BUFFER;
    }
    else
    {
        size = PropertyBufferSize;
 
        cr = CM_Get_DevNode_Registry_Property_ExW(devInfo->dnDevInst,
                                                  Property + (CM_DRP_DEVICEDESC - SPDRP_DEVICEDESC),
                                                  PropertyRegDataType,
                                                  PropertyBuffer,
                                                  &size,
                                                  0,
                                                  set->hMachine);
        if ((cr == CR_SUCCESS) || (cr == CR_BUFFER_SMALL))
        {
            if (RequiredSize)
                *RequiredSize = size;
        }
 
        if (cr != CR_SUCCESS)
        {
            switch (cr)
            {
                case CR_INVALID_DEVINST:
                    lError = ERROR_NO_SUCH_DEVINST;
                    break;
 
                case CR_INVALID_PROPERTY:
                    lError = ERROR_INVALID_REG_PROPERTY;
                    break;
 
                case CR_BUFFER_SMALL:
                    lError = ERROR_INSUFFICIENT_BUFFER;
                    break;
 
                default :
                    lError = ERROR_INVALID_DATA;
                    break;
            }
        }
    }
 
    SetLastError(lError);
    return (lError == ERROR_SUCCESS);
}

Referenced by CriticalDeviceCoInstaller(), DevInstallW(), DisplayPageSetDeviceDetails(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), FindNetworkAdapter(), GetHardwareAndCompatibleIDsLists(), InstallDevInstEx(), InstallParallelPort(), InstallSerialPort(), SetDeviceDetails(), SetupDiGetDeviceRegistryPropertyA(), SetupDiInstallDevice(), StorageCoInstaller(), test_registry_property_w(), and UpdateDriverForPlugAndPlayDevicesW().

SetupDiGetSelectedDevice()

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

Definition at line 4947 of file devinst.c.

{
    struct DeviceInfoSet *list;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (list->SelectedDevice == NULL)
        SetLastError(ERROR_NO_DEVICE_SELECTED);
    else if (!DeviceInfoData)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        memcpy(&DeviceInfoData->ClassGuid,
            &list->SelectedDevice->ClassGuid,
            sizeof(GUID));
        DeviceInfoData->DevInst = list->SelectedDevice->dnDevInst;
        DeviceInfoData->Reserved = (ULONG_PTR)list->SelectedDevice;
        ret = TRUE;
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

SetupDiInstallClassA()

BOOL WINAPI SetupDiInstallClassA	(	HWND	hwndParent,
		PCSTR	InfFileName,
		DWORD	Flags,
		HSPFILEQ	FileQueue
	)

Definition at line 3514 of file devinst.c.

{
    return SetupDiInstallClassExA(hwndParent, InfFileName, Flags, FileQueue, NULL, NULL, NULL);
}

Referenced by test_install_class().

SetupDiInstallClassExA()

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
	)

Definition at line 3527 of file devinst.c.

{
    PWSTR InfFileNameW = NULL;
    BOOL Result;
 
    if (!InfFileName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    else
    {
        InfFileNameW = pSetupMultiByteToUnicode(InfFileName, CP_ACP);
        if (InfFileNameW == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }
 
    Result = SetupDiInstallClassExW(hwndParent, InfFileNameW, Flags,
        FileQueue, InterfaceClassGuid, Reserved1, Reserved2);
 
    MyFree(InfFileNameW);
 
    return Result;
}

Referenced by SetupDiInstallClassA(), and test_SetupDiInstallClassExA().

SetupDiInstallClassW()

BOOL WINAPI SetupDiInstallClassW	(	HWND	hwndParent,
		PCWSTR	InfFileName,
		DWORD	Flags,
		HSPFILEQ	FileQueue
	)

Definition at line 3649 of file devinst.c.

{
    return SetupDiInstallClassExW(hwndParent, InfFileName, Flags, FileQueue, NULL, NULL, NULL);
}

Referenced by InstallSysSetupInfDevices().

SetupDiInstallDevice()

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

Definition at line 5409 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;
    SP_DEVINSTALL_PARAMS_W InstallParams;
    struct DriverInfoElement *SelectedDriver;
    SYSTEMTIME DriverDate;
    WCHAR SectionName[MAX_PATH];
    WCHAR Buffer[32];
    DWORD SectionNameLength = 0;
    BOOL Result = FALSE;
    ULONG DoAction;
    DWORD RequiredSize;
    LPWSTR pSectionName = NULL;
    WCHAR ClassName[MAX_CLASS_NAME_LEN];
    GUID ClassGuid;
    LPWSTR lpGuidString = NULL, lpFullGuidString = NULL;
    BOOL RebootRequired = FALSE;
    HKEY hKey = INVALID_HANDLE_VALUE;
    BOOL NeedtoCopyFile;
    LARGE_INTEGER fullVersion;
    LONG rc;
    PVOID Context = NULL;
    BOOL ret = FALSE; /* Return value */
 
    TRACE("%s(%p %p)\n", __FUNCTION__, 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 (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
        Result = TRUE;
 
    if (!Result)
    {
        /* One parameter is bad */
        goto cleanup;
    }
 
    InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
    Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
    if (!Result)
        goto cleanup;
 
    if (InstallParams.FlagsEx & DI_FLAGSEX_SETFAILEDINSTALL)
    {
        /* Set FAILEDINSTALL in ConfigFlags registry value */
        DWORD ConfigFlags, regType;
        Result = SetupDiGetDeviceRegistryPropertyW(
            DeviceInfoSet,
            DeviceInfoData,
            SPDRP_CONFIGFLAGS,
            &regType,
            (PBYTE)&ConfigFlags,
            sizeof(ConfigFlags),
            NULL);
        if (!Result || regType != REG_DWORD)
        {
            SetLastError(ERROR_GEN_FAILURE);
            goto cleanup;
        }
        ConfigFlags |= CONFIGFLAG_FAILEDINSTALL;
        Result = SetupDiSetDeviceRegistryPropertyW(
            DeviceInfoSet,
            DeviceInfoData,
            SPDRP_CONFIGFLAGS,
            (PBYTE)&ConfigFlags,
            sizeof(ConfigFlags));
        if (!Result)
        {
            SetLastError(ERROR_GEN_FAILURE);
            goto cleanup;
        }
 
        ret = TRUE;
        goto cleanup;
    }
 
    SelectedDriver = (struct DriverInfoElement *)InstallParams.ClassInstallReserved;
    if (SelectedDriver == NULL)
    {
        SetLastError(ERROR_NO_DRIVER_SELECTED);
        goto cleanup;
    }
 
    FileTimeToSystemTime(&SelectedDriver->Info.DriverDate, &DriverDate);
 
    Result = SetupDiGetActualSectionToInstallW(
        SelectedDriver->InfFileDetails->hInf,
        SelectedDriver->Details.SectionName,
        SectionName, MAX_PATH, &SectionNameLength, NULL);
    if (!Result || SectionNameLength > MAX_PATH - strlenW(DotServices))
        goto cleanup;
    pSectionName = &SectionName[strlenW(SectionName)];
 
    /* Get information from [Version] section */
    if (!SetupDiGetINFClassW(SelectedDriver->Details.InfFileName, &ClassGuid, ClassName, MAX_CLASS_NAME_LEN, &RequiredSize))
        goto cleanup;
    /* Format ClassGuid to a string */
    if (UuidToStringW((UUID*)&ClassGuid, &lpGuidString) != RPC_S_OK)
        goto cleanup;
    RequiredSize = lstrlenW(lpGuidString);
    lpFullGuidString = HeapAlloc(GetProcessHeap(), 0, (RequiredSize + 3) * sizeof(WCHAR));
    if (!lpFullGuidString)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto cleanup;
    }
    lpFullGuidString[0] = '{';
    memcpy(&lpFullGuidString[1], lpGuidString, RequiredSize * sizeof(WCHAR));
    lpFullGuidString[RequiredSize + 1] = '}';
    lpFullGuidString[RequiredSize + 2] = '\0';
 
    /* Copy .inf file to Inf\ directory (if needed) */
    Result = InfIsFromOEMLocation(SelectedDriver->Details.InfFileName, &NeedtoCopyFile);
    if (!Result)
        goto cleanup;
    if (NeedtoCopyFile)
    {
        WCHAR NewFileName[MAX_PATH];
        struct InfFileDetails *newInfFileDetails;
        Result = SetupCopyOEMInfW(
            SelectedDriver->Details.InfFileName,
            NULL,
            SPOST_NONE,
            SP_COPY_NOOVERWRITE,
            NewFileName, MAX_PATH,
            NULL,
            NULL);
        if (!Result && GetLastError() != ERROR_FILE_EXISTS)
            goto cleanup;
        /* Create a new struct InfFileDetails, and set it to
         * SelectedDriver->InfFileDetails, to release use of
         * current InfFile */
        newInfFileDetails = CreateInfFileDetails(NewFileName);
        if (!newInfFileDetails)
            goto cleanup;
        DereferenceInfFile(SelectedDriver->InfFileDetails);
        SelectedDriver->InfFileDetails = newInfFileDetails;
        strcpyW(SelectedDriver->Details.InfFileName, NewFileName);
    }
 
    deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
    /* Open/Create driver key information */
#if _WIN32_WINNT >= 0x502
    hKey = SETUPDI_OpenDrvKey(set->HKLM, deviceInfo, KEY_READ | KEY_WRITE);
#else
    hKey = SETUPDI_OpenDrvKey(set->HKLM, deviceInfo, KEY_ALL_ACCESS);
#endif
    if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
#if _WIN32_WINNT >= 0x502
        hKey = SETUPDI_CreateDrvKey(set->HKLM, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_READ | KEY_WRITE);
#else
        hKey = SETUPDI_CreateDrvKey(set->HKLM, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_ALL_ACCESS);
#endif
    if (hKey == INVALID_HANDLE_VALUE)
        goto cleanup;
 
    /* Install main section */
    DoAction = 0;
    if (!(InstallParams.FlagsEx & DI_FLAGSEX_NO_DRVREG_MODIFY))
        DoAction |= SPINST_REGISTRY;
    if (!(InstallParams.Flags & DI_NOFILECOPY))
    {
        DoAction |= SPINST_FILES;
        Context = SetupInitDefaultQueueCallback(InstallParams.hwndParent);
        if (!Context)
            goto cleanup;
    }
    *pSectionName = '\0';
    Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
        SelectedDriver->InfFileDetails->hInf, SectionName,
        DoAction, hKey, SelectedDriver->InfFileDetails->DirectoryName, SP_COPY_NEWER,
        SetupDefaultQueueCallbackW, Context,
        DeviceInfoSet, DeviceInfoData);
    if (!Result)
        goto cleanup;
    InstallParams.Flags |= DI_NOFILECOPY;
    SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
 
    /* Write information to driver key */
    *pSectionName = UNICODE_NULL;
    memcpy(&fullVersion, &SelectedDriver->Info.DriverVersion, sizeof(LARGE_INTEGER));
    TRACE("Write information to driver key\n");
    TRACE("DriverDate      : '%u-%u-%u'\n", DriverDate.wMonth, DriverDate.wDay, DriverDate.wYear);
    TRACE("DriverDesc      : '%s'\n", debugstr_w(SelectedDriver->Info.Description));
    TRACE("DriverVersion   : '%ld.%ld.%lu.%ld'\n", fullVersion.HighPart >> 16, fullVersion.HighPart & 0xffff, fullVersion.LowPart >> 16, fullVersion.LowPart & 0xffff);
    TRACE("InfPath         : '%s'\n", debugstr_w(SelectedDriver->InfFileDetails->FileName));
    TRACE("InfSection      : '%s'\n", debugstr_w(SelectedDriver->Details.SectionName));
    TRACE("InfSectionExt   : '%s'\n", debugstr_w(&SectionName[strlenW(SelectedDriver->Details.SectionName)]));
    TRACE("MatchingDeviceId: '%s'\n", debugstr_w(SelectedDriver->MatchingId));
    TRACE("ProviderName    : '%s'\n", debugstr_w(SelectedDriver->Info.ProviderName));
    sprintfW(Buffer, DateFormat, DriverDate.wMonth, DriverDate.wDay, DriverDate.wYear);
    rc = RegSetValueExW(hKey, REGSTR_DRIVER_DATE, 0, REG_SZ, (const BYTE *)Buffer, (strlenW(Buffer) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_DRIVER_DATE_DATA, 0, REG_BINARY, (const BYTE *)&SelectedDriver->Info.DriverDate, sizeof(FILETIME));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_DRVDESC, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.Description, (strlenW(SelectedDriver->Info.Description) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
    {
        sprintfW(Buffer, VersionFormat, fullVersion.HighPart >> 16, fullVersion.HighPart & 0xffff, fullVersion.LowPart >> 16, fullVersion.LowPart & 0xffff);
        rc = RegSetValueExW(hKey, REGSTR_DRIVER_VERSION, 0, REG_SZ, (const BYTE *)Buffer, (strlenW(Buffer) + 1) * sizeof(WCHAR));
    }
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_INFPATH, 0, REG_SZ, (const BYTE *)SelectedDriver->InfFileDetails->FileName, (strlenW(SelectedDriver->InfFileDetails->FileName) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_INFSECTION, 0, REG_SZ, (const BYTE *)SelectedDriver->Details.SectionName, (strlenW(SelectedDriver->Details.SectionName) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_INFSECTIONEXT, 0, REG_SZ, (const BYTE *)&SectionName[strlenW(SelectedDriver->Details.SectionName)], (strlenW(SectionName) - strlenW(SelectedDriver->Details.SectionName) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_MATCHINGDEVID, 0, REG_SZ, (const BYTE *)SelectedDriver->MatchingId, (strlenW(SelectedDriver->MatchingId) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_PROVIDER_NAME, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.ProviderName, (strlenW(SelectedDriver->Info.ProviderName) + 1) * sizeof(WCHAR));
    if (rc != ERROR_SUCCESS)
    {
       SetLastError(rc);
       goto cleanup;
    }
    RegCloseKey(hKey);
    hKey = INVALID_HANDLE_VALUE;
 
    /* FIXME: Process .LogConfigOverride section */
 
    /* Install .Services section */
    strcpyW(pSectionName, DotServices);
    Result = SetupInstallServicesFromInfSectionExW(
        SelectedDriver->InfFileDetails->hInf,
        SectionName,
        0,
        DeviceInfoSet,
        DeviceInfoData,
        NULL,
        NULL);
    if (!Result)
    {
        if (GetLastError() != ERROR_SECTION_NOT_FOUND)
            goto cleanup;
        SetLastError(ERROR_SUCCESS);
    }
    if (GetLastError() == ERROR_SUCCESS_REBOOT_REQUIRED)
        RebootRequired = TRUE;
 
    /* Open device registry key */
    hKey = SETUPDI_OpenDevKey(((struct DeviceInfoSet *)DeviceInfoSet)->HKLM, (struct DeviceInfo *)DeviceInfoData->Reserved, KEY_SET_VALUE);
    if (hKey == INVALID_HANDLE_VALUE)
        goto cleanup;
 
    /* Install .HW section */
    DoAction = 0;
    if (!(InstallParams.FlagsEx & DI_FLAGSEX_NO_DRVREG_MODIFY))
        DoAction |= SPINST_REGISTRY;
    strcpyW(pSectionName, DotHW);
    Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
        SelectedDriver->InfFileDetails->hInf, SectionName,
        DoAction, hKey, NULL, 0,
        NULL, NULL,
        DeviceInfoSet, DeviceInfoData);
    if (!Result)
        goto cleanup;
 
    /* Write information to enum key */
    TRACE("Write information to enum key\n");
    TRACE("Class           : '%s'\n", debugstr_w(ClassName));
    TRACE("ClassGUID       : '%s'\n", debugstr_w(lpFullGuidString));
    TRACE("DeviceDesc      : '%s'\n", debugstr_w(SelectedDriver->Info.Description));
    TRACE("Mfg             : '%s'\n", debugstr_w(SelectedDriver->Info.MfgName));
    rc = RegSetValueExW(hKey, REGSTR_VAL_CLASS, 0, REG_SZ, (const BYTE *)ClassName, (strlenW(ClassName) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_CLASSGUID, 0, REG_SZ, (const BYTE *)lpFullGuidString, (strlenW(lpFullGuidString) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_DEVDESC, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.Description, (strlenW(SelectedDriver->Info.Description) + 1) * sizeof(WCHAR));
    if (rc == ERROR_SUCCESS)
        rc = RegSetValueExW(hKey, REGSTR_VAL_MFG, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.MfgName, (strlenW(SelectedDriver->Info.MfgName) + 1) * sizeof(WCHAR));
    if (rc != ERROR_SUCCESS)
    {
       SetLastError(rc);
       goto cleanup;
    }
 
    /* Start the device */
    if (!RebootRequired && !(InstallParams.Flags & (DI_NEEDRESTART | DI_NEEDREBOOT | DI_DONOTCALLCONFIGMG)))
        ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
    else
        ret = TRUE;
 
cleanup:
    /* End of installation */
    if (hKey != INVALID_HANDLE_VALUE)
        RegCloseKey(hKey);
    if (lpGuidString)
        RpcStringFreeW(&lpGuidString);
    HeapFree(GetProcessHeap(), 0, lpFullGuidString);
    if (Context)
        SetupTermDefaultQueueCallback(Context);
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by DisplayClassInstaller(), InstallCompositeBattery(), InstallNetDevice(), InstallParallelPort(), InstallSerialPort(), and SetupDiCallClassInstaller().

SetupDiOpenClassRegKey()

HKEY WINAPI SetupDiOpenClassRegKey	(	const GUID *	ClassGuid,
		REGSAM	samDesired
	)

Definition at line 3662 of file devinst.c.

{
    return SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
                                     DIOCR_INSTALLER, NULL, NULL);
}

Referenced by DisplayClassProperties(), SETUP_GetClassIconInfo(), SetupDiCallClassInstaller(), START_TEST(), and test_open_class_key().

SetupDiOpenClassRegKeyExA()

HKEY WINAPI SetupDiOpenClassRegKeyExA	(	const GUID *	ClassGuid,
		REGSAM	samDesired,
		DWORD	Flags,
		PCSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 3674 of file devinst.c.

{
    PWSTR MachineNameW = NULL;
    HKEY hKey;
 
    TRACE("%s(%s 0x%lx 0x%lx %s %p)\n", __FUNCTION__, debugstr_guid(ClassGuid), samDesired,
        Flags, debugstr_a(MachineName), Reserved);
 
    if (MachineName)
    {
        MachineNameW = pSetupMultiByteToUnicode(MachineName, CP_ACP);
        if (MachineNameW == NULL)
            return INVALID_HANDLE_VALUE;
    }
 
    hKey = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
                                     Flags, MachineNameW, Reserved);
 
    MyFree(MachineNameW);
 
    return hKey;
}

Referenced by test_open_class_key(), and test_SetupDiOpenClassRegKeyExA().

SetupDiOpenClassRegKeyExW()

HKEY WINAPI SetupDiOpenClassRegKeyExW	(	const GUID *	ClassGuid,
		REGSAM	samDesired,
		DWORD	Flags,
		PCWSTR	MachineName,
		PVOID	Reserved
	)

Definition at line 3706 of file devinst.c.

{
    HKEY HKLM;
    HKEY hClassesKey;
    HKEY key;
    LPCWSTR lpKeyName;
    LONG l;
 
    TRACE("%s(%s 0x%lx 0x%lx %s %p)\n", __FUNCTION__, debugstr_guid(ClassGuid), samDesired,
        Flags, debugstr_w(MachineName), Reserved);
 
    if (MachineName != NULL)
    {
        l = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &HKLM);
        if (l != ERROR_SUCCESS)
        {
            SetLastError(l);
            return INVALID_HANDLE_VALUE;
        }
    }
    else
        HKLM = HKEY_LOCAL_MACHINE;
 
    if (Flags == DIOCR_INSTALLER)
    {
        lpKeyName = REGSTR_PATH_CLASS_NT;
    }
    else if (Flags == DIOCR_INTERFACE)
    {
        lpKeyName = REGSTR_PATH_DEVICE_CLASSES;
    }
    else
    {
        ERR("Invalid Flags parameter!\n");
        SetLastError(ERROR_INVALID_FLAGS);
        if (MachineName != NULL) RegCloseKey(HKLM);
        return INVALID_HANDLE_VALUE;
    }
 
    if (!ClassGuid)
    {
        if ((l = RegOpenKeyExW(HKLM,
                               lpKeyName,
                               0,
                               samDesired,
                               &hClassesKey)))
        {
            SetLastError(ERROR_INVALID_CLASS);
            hClassesKey = INVALID_HANDLE_VALUE;
        }
        if (MachineName != NULL)
            RegCloseKey(HKLM);
        key = hClassesKey;
    }
    else
    {
        WCHAR bracedGuidString[39];
 
        SETUPDI_GuidToString(ClassGuid, bracedGuidString);
 
        if (!(l = RegOpenKeyExW(HKLM,
                                lpKeyName,
                                0,
                                samDesired,
                                &hClassesKey)))
        {
            if (MachineName != NULL)
                RegCloseKey(HKLM);
 
            if ((l = RegOpenKeyExW(hClassesKey,
                                   bracedGuidString,
                                   0,
                                   samDesired,
                                   &key)))
            {
                SetLastError(l);
                key = INVALID_HANDLE_VALUE;
            }
            RegCloseKey(hClassesKey);
        }
        else
        {
            if (MachineName != NULL) RegCloseKey(HKLM);
            SetLastError(l);
            key = INVALID_HANDLE_VALUE;
        }
    }
 
    return key;
}

Referenced by SETUP_CreateInterfaceList(), SetupDiClassGuidsFromNameExW(), SetupDiClassNameFromGuidExW(), SetupDiCreateDeviceInterfaceRegKeyW(), SetupDiGetClassDescriptionExW(), SetupDiGetClassDevPropertySheetsW(), SetupDiInstallClassExW(), SetupDiOpenClassRegKey(), SetupDiOpenClassRegKeyExA(), SetupDiOpenDeviceInterfaceRegKey(), SetupDiOpenDeviceInterfaceW(), and CClassNode::SetupNode().

SetupDiOpenDeviceInfoA()

BOOL WINAPI SetupDiOpenDeviceInfoA	(	IN HDEVINFO	DeviceInfoSet,
		IN PCSTR	DeviceInstanceId,
		IN HWND hwndParent	OPTIONAL,
		IN DWORD	OpenFlags,
		OUT PSP_DEVINFO_DATA DeviceInfoData	OPTIONAL
	)

Definition at line 4789 of file devinst.c.

{
    LPWSTR DeviceInstanceIdW = NULL;
    BOOL bResult;
 
    TRACE("%s(%p %s %p %lx %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInstanceId, hwndParent, OpenFlags, DeviceInfoData);
 
    DeviceInstanceIdW = pSetupMultiByteToUnicode(DeviceInstanceId, CP_ACP);
    if (DeviceInstanceIdW == NULL)
        return FALSE;
 
    bResult = SetupDiOpenDeviceInfoW(DeviceInfoSet,
        DeviceInstanceIdW, hwndParent, OpenFlags, DeviceInfoData);
 
    MyFree(DeviceInstanceIdW);
 
    return bResult;
}

SetupDiOpenDeviceInfoW()

BOOL WINAPI SetupDiOpenDeviceInfoW	(	IN HDEVINFO	DeviceInfoSet,
		IN PCWSTR	DeviceInstanceId,
		IN HWND hwndParent	OPTIONAL,
		IN DWORD	OpenFlags,
		OUT PSP_DEVINFO_DATA DeviceInfoData	OPTIONAL
	)

Definition at line 4818 of file devinst.c.

{
    struct DeviceInfoSet *list;
    HKEY hEnumKey, hKey = NULL;
    DWORD rc, dwSize;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %s %p %lx %p)\n", __FUNCTION__,
        DeviceInfoSet, debugstr_w(DeviceInstanceId),
        hwndParent, OpenFlags, DeviceInfoData);
 
    if (OpenFlags & DIOD_CANCEL_REMOVE)
        FIXME("DIOD_CANCEL_REMOVE flag not implemented\n");
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (!DeviceInstanceId)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (OpenFlags & ~(DIOD_CANCEL_REMOVE | DIOD_INHERIT_CLASSDRVS))
    {
        TRACE("Unknown flags: 0x%08lx\n", OpenFlags & ~(DIOD_CANCEL_REMOVE | DIOD_INHERIT_CLASSDRVS));
        SetLastError(ERROR_INVALID_FLAGS);
    }
    else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        struct DeviceInfo *deviceInfo = NULL;
        /* Search if device already exists in DeviceInfoSet.
         *    If yes, return the existing element
         *    If no, create a new element using information in registry
         */
        PLIST_ENTRY ItemList = list->ListHead.Flink;
        while (ItemList != &list->ListHead)
        {
            deviceInfo = CONTAINING_RECORD(ItemList, struct DeviceInfo, ListEntry);
            if (!wcscmp(deviceInfo->instanceId, DeviceInstanceId))
                break;
            deviceInfo = NULL;
            ItemList = ItemList->Flink;
        }
 
        if (deviceInfo)
        {
            /* good one found */
            ret = TRUE;
        }
        else
        {
            GUID ClassGUID;
            WCHAR szClassGuid[MAX_GUID_STRING_LEN];
 
            /* Open supposed registry key */
            rc = RegOpenKeyExW(
                list->HKLM,
                REGSTR_PATH_SYSTEMENUM,
                0, /* Options */
                READ_CONTROL,
                &hEnumKey);
            if (rc != ERROR_SUCCESS)
            {
                SetLastError(rc);
                goto cleanup;
            }
            rc = RegOpenKeyExW(
                hEnumKey,
                DeviceInstanceId,
                0, /* Options */
                KEY_QUERY_VALUE,
                &hKey);
            RegCloseKey(hEnumKey);
            if (rc != ERROR_SUCCESS)
            {
                if (rc == ERROR_FILE_NOT_FOUND)
                    rc = ERROR_NO_SUCH_DEVINST;
                SetLastError(rc);
                goto cleanup;
            }
 
            ClassGUID = GUID_NULL;
            dwSize = MAX_GUID_STRING_LEN * sizeof(WCHAR);
 
            if (RegQueryValueExW(hKey,
                                 REGSTR_VAL_CLASSGUID,
                                 NULL,
                                 NULL,
                                 (LPBYTE)szClassGuid,
                                 &dwSize) == ERROR_SUCCESS)
            {
                szClassGuid[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
 
                /* Convert a string to a ClassGuid */
                UuidFromStringW(&szClassGuid[1], &ClassGUID);
            }
 
            if (!CreateDeviceInfo(list, DeviceInstanceId, &ClassGUID, &deviceInfo))
                goto cleanup;
 
            InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
 
            ret = TRUE;
        }
 
        if (ret && deviceInfo && DeviceInfoData)
        {
            memcpy(&DeviceInfoData->ClassGuid, &deviceInfo->ClassGuid, sizeof(GUID));
            DeviceInfoData->DevInst = deviceInfo->dnDevInst;
            DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
        }
    }
 
cleanup:
    if (hKey != NULL)
        RegCloseKey(hKey);
    return ret;
}

Referenced by DevInstallW(), InstallDevInstEx(), SetupDiOpenDeviceInfoA(), and CDeviceNode::SetupNode().

SetupDiOpenDeviceInterfaceA()

BOOL WINAPI SetupDiOpenDeviceInterfaceA	(	HDEVINFO	DeviceInfoSet,
		PCSTR	DevicePath,
		DWORD	OpenFlags,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData
	)

Definition at line 4020 of file devinst.c.

{
    LPWSTR DevicePathW = NULL;
    BOOL bResult;
 
    TRACE("%s(%p %s %08lx %p)\n", __FUNCTION__, DeviceInfoSet, debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
 
    DevicePathW = pSetupMultiByteToUnicode(DevicePath, CP_ACP);
    if (DevicePathW == NULL)
        return FALSE;
 
    bResult = SetupDiOpenDeviceInterfaceW(DeviceInfoSet,
        DevicePathW, OpenFlags, DeviceInterfaceData);
 
    MyFree(DevicePathW);
 
    return bResult;
}

SetupDiOpenDeviceInterfaceW()

BOOL WINAPI SetupDiOpenDeviceInterfaceW	(	HDEVINFO	DeviceInfoSet,
		PCWSTR	DevicePath,
		DWORD	OpenFlags,
		PSP_DEVICE_INTERFACE_DATA	DeviceInterfaceData
	)

Definition at line 3805 of file devinst.c.

{
    struct DeviceInfoSet * list;
    PCWSTR pEnd;
    DWORD dwLength, dwError, dwIndex, dwKeyName, dwSubIndex;
    CLSID ClassId;
    WCHAR Buffer[MAX_PATH + 1];
    WCHAR SymBuffer[MAX_PATH + 1];
    WCHAR InstancePath[MAX_PATH + 1];
    HKEY hKey, hDevKey, hSymKey;
    struct DeviceInfo * deviceInfo;
    struct DeviceInterface *deviceInterface;
    BOOL Ret;
    PLIST_ENTRY ItemList;
    PLIST_ENTRY InterfaceListEntry;
 
    TRACE("%s(%p %s %08x %p)\n", __FUNCTION__,
        DeviceInfoSet, debugstr_w(DevicePath), OpenFlags, DeviceInterfaceData);
 
 
    if (DeviceInterfaceData && DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    list = (struct DeviceInfoSet * )DeviceInfoSet;
 
    dwLength = wcslen(DevicePath);
    if (dwLength < 39)
    {
        /* path must be at least a guid length + L'\0' */
        SetLastError(ERROR_BAD_PATHNAME);
        return FALSE;
    }
 
    if (DevicePath[0] != L'\\' ||
        DevicePath[1] != L'\\' ||
        (DevicePath[2] != L'?' && DevicePath[2] != L'.') ||
        DevicePath[3] != L'\\')
    {
        /* invalid formatted path */
        SetLastError(ERROR_BAD_PATHNAME);
        return FALSE;
    }
 
    /* check for reference strings */
    pEnd = wcschr(&DevicePath[4], L'\\');
    if (!pEnd)
    {
        /* no reference string */
        pEnd = DevicePath + dwLength;
    }
 
    /* copy guid */
    wcscpy(Buffer, pEnd - 37);
    Buffer[36] = L'\0';
 
    dwError = UuidFromStringW(Buffer, &ClassId);
    if (dwError != NOERROR)
    {
        /* invalid formatted path */
        SetLastError(ERROR_BAD_PATHNAME);
        return FALSE;
    }
 
    hKey = SetupDiOpenClassRegKeyExW(&ClassId, KEY_READ, DIOCR_INTERFACE, list->MachineName, NULL);
 
    if (hKey == INVALID_HANDLE_VALUE)
    {
        /* invalid device class */
        return FALSE;
    }
 
    ItemList = list->ListHead.Flink;
    while (ItemList != &list->ListHead)
    {
        deviceInfo = CONTAINING_RECORD(ItemList, struct DeviceInfo, ListEntry);
        InterfaceListEntry = deviceInfo->InterfaceListHead.Flink;
        while (InterfaceListEntry != &deviceInfo->InterfaceListHead)
        {
            deviceInterface = CONTAINING_RECORD(InterfaceListEntry, struct DeviceInterface, ListEntry);
            if (!IsEqualIID(&deviceInterface->InterfaceClassGuid, &ClassId))
            {
                InterfaceListEntry = InterfaceListEntry->Flink;
                continue;
            }
 
            if (!wcsicmp(deviceInterface->SymbolicLink, DevicePath))
            {
                if (DeviceInterfaceData)
                {
                    DeviceInterfaceData->Reserved = (ULONG_PTR)deviceInterface;
                    DeviceInterfaceData->Flags = deviceInterface->Flags;
                    CopyMemory(&DeviceInterfaceData->InterfaceClassGuid, &ClassId, sizeof(GUID));
                }
 
                return TRUE;
            }
 
        }
    }
 
 
    dwIndex = 0;
    do
    {
        Buffer[0] = 0;
        dwKeyName = sizeof(Buffer) / sizeof(WCHAR);
        dwError = RegEnumKeyExW(hKey, dwIndex, Buffer, &dwKeyName, NULL, NULL, NULL, NULL);
 
        if (dwError != ERROR_SUCCESS)
            break;
 
        if (RegOpenKeyExW(hKey, Buffer, 0, KEY_READ, &hDevKey) != ERROR_SUCCESS)
            break;
 
        dwSubIndex = 0;
        InstancePath[0] = 0;
        dwKeyName = sizeof(InstancePath);
 
        dwError = RegQueryValueExW(hDevKey, L"DeviceInstance", NULL, NULL, (LPBYTE)InstancePath, &dwKeyName);
 
        while(TRUE)
        {
            Buffer[0] = 0;
            dwKeyName = sizeof(Buffer) / sizeof(WCHAR);
            dwError = RegEnumKeyExW(hDevKey, dwSubIndex, Buffer, &dwKeyName, NULL, NULL, NULL, NULL);
 
            if (dwError != ERROR_SUCCESS)
                break;
 
            dwError = RegOpenKeyExW(hDevKey, Buffer, 0, KEY_READ, &hSymKey);
            if (dwError != ERROR_SUCCESS)
                break;
 
            /* query for symbolic link */
            dwKeyName = sizeof(SymBuffer);
            SymBuffer[0] = L'\0';
            dwError = RegQueryValueExW(hSymKey, L"SymbolicLink", NULL, NULL, (LPBYTE)SymBuffer, &dwKeyName);
 
            if (dwError != ERROR_SUCCESS)
            {
                RegCloseKey(hSymKey);
                break;
            }
 
            if (!wcsicmp(SymBuffer, DevicePath))
            {
                Ret = CreateDeviceInfo(list, InstancePath, &ClassId, &deviceInfo);
                RegCloseKey(hSymKey);
                RegCloseKey(hDevKey);
                RegCloseKey(hKey);
 
                if (Ret)
                {
                    deviceInterface = HeapAlloc(GetProcessHeap(), 0, sizeof(struct DeviceInterface) + (wcslen(SymBuffer) + 1) * sizeof(WCHAR));
                    if (deviceInterface)
                    {
 
                        CopyMemory(&deviceInterface->InterfaceClassGuid, &ClassId, sizeof(GUID));
                        deviceInterface->DeviceInfo = deviceInfo;
                        deviceInterface->Flags = SPINT_ACTIVE; //FIXME
 
                        wcscpy(deviceInterface->SymbolicLink, SymBuffer);
 
                        InsertTailList(&deviceInfo->InterfaceListHead, &deviceInterface->ListEntry);
                        InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
 
 
                        if (DeviceInterfaceData)
                        {
                            DeviceInterfaceData->Reserved = (ULONG_PTR)deviceInterface;
                            DeviceInterfaceData->Flags = deviceInterface->Flags;
                            CopyMemory(&DeviceInterfaceData->InterfaceClassGuid, &ClassId, sizeof(GUID));
                        }
                        else
                        {
                            Ret = FALSE;
                            SetLastError(ERROR_INVALID_USER_BUFFER);
                        }
                    }
                }
                else
                {
                    HeapFree(GetProcessHeap(), 0, deviceInfo);
                    Ret = FALSE;
                }
                return Ret;
        }
        RegCloseKey(hSymKey);
        dwSubIndex++;
    }
 
    RegCloseKey(hDevKey);
    dwIndex++;
    } while(TRUE);
 
    RegCloseKey(hKey);
    return FALSE;
}

Referenced by CKsProxy::Load(), and SetupDiOpenDeviceInterfaceA().

SetupDiOpenDevRegKey()

HKEY WINAPI SetupDiOpenDevRegKey	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Scope,
		DWORD	HwProfile,
		DWORD	KeyType,
		REGSAM	samDesired
	)

Definition at line 5978 of file devinst.c.

{
    struct DeviceInfoSet *set = DeviceInfoSet;
    struct DeviceInfo *devInfo;
    HKEY key = INVALID_HANDLE_VALUE;
    HKEY RootKey;
 
    TRACE("%s(%p %p %d %d %d %x)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData,
          Scope, HwProfile, KeyType, samDesired);
 
    if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_HANDLE_VALUE;
    }
    if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return INVALID_HANDLE_VALUE;
    }
    if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
            || !DeviceInfoData->Reserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return INVALID_HANDLE_VALUE;
    }
    if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return INVALID_HANDLE_VALUE;
    }
    devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
    if (devInfo->set != set)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }
    if (Scope != DICS_FLAG_GLOBAL)
    {
        RootKey = OpenHardwareProfileKey(set->HKLM, HwProfile, 0);
        if (RootKey == INVALID_HANDLE_VALUE)
            return INVALID_HANDLE_VALUE;
    }
    else
        RootKey = set->HKLM;
    switch (KeyType)
    {
        case DIREG_DEV:
            key = SETUPDI_OpenDevKey(RootKey, devInfo, samDesired);
            if (Scope == DICS_FLAG_GLOBAL)
            {
                LONG rc;
                HKEY hTempKey = key;
                rc = RegOpenKeyExW(hTempKey,
                                   L"Device Parameters",
                                   0,
                                   samDesired,
                                   &key);
                if (rc == ERROR_SUCCESS)
                    RegCloseKey(hTempKey);
            }
            break;
        case DIREG_DRV:
            key = SETUPDI_OpenDrvKey(RootKey, devInfo, samDesired);
            break;
        default:
            WARN("unknown KeyType %d\n", KeyType);
    }
    if (RootKey != set->HKLM)
        RegCloseKey(RootKey);
    return key;
}

Referenced by BuildParameterArray(), ChangePortNumber(), CriticalDeviceCoInstaller(), DisplayClassInstaller(), DisplayDeviceCoinstallers(), DisplayMatchingDeviceId(), FindCurrentDriver(), GetDeviceLocationString(), GetDriverDateString(), GetDriverProviderString(), GetDriverVersionString(), InstallNetDevice(), OpenDeviceKey(), PS2MousePropPageProvider(), ReadPortSettings(), RemovePort(), test_device_key(), WriteParameterArray(), and WritePortSettings().

SetupDiRegisterCoDeviceInstallers()

BOOL WINAPI SetupDiRegisterCoDeviceInstallers	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 5255 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *deviceInfo;
    BOOL ret = FALSE; /* Return value */
 
    TRACE("%s(%p %p)\n", __FUNCTION__, 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 (!DeviceInfoData)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        SP_DEVINSTALL_PARAMS_W InstallParams;
        struct DriverInfoElement *SelectedDriver;
        BOOL Result;
        DWORD DoAction;
        WCHAR SectionName[MAX_PATH];
        DWORD SectionNameLength = 0;
        HKEY hKey = INVALID_HANDLE_VALUE;
        PVOID Context = NULL;
 
        InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
        Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
        if (!Result)
            goto cleanup;
 
        SelectedDriver = (struct DriverInfoElement *)InstallParams.ClassInstallReserved;
        if (SelectedDriver == NULL)
        {
            SetLastError(ERROR_NO_DRIVER_SELECTED);
            goto cleanup;
        }
 
        /* Get .CoInstallers section name */
        Result = SetupDiGetActualSectionToInstallW(
            SelectedDriver->InfFileDetails->hInf,
            SelectedDriver->Details.SectionName,
            SectionName, MAX_PATH, &SectionNameLength, NULL);
        if (!Result || SectionNameLength > MAX_PATH - strlenW(DotCoInstallers) - 1)
            goto cleanup;
        lstrcatW(SectionName, DotCoInstallers);
 
        deviceInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
        /* Open/Create driver key information */
#if _WIN32_WINNT >= 0x502
        hKey = SETUPDI_OpenDrvKey(set->HKLM, deviceInfo, KEY_READ | KEY_WRITE);
#else
        hKey = SETUPDI_OpenDrvKey(set->HKLM, deviceInfo, KEY_ALL_ACCESS);
#endif
        if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
#if _WIN32_WINNT >= 0x502
            hKey = SETUPDI_CreateDrvKey(set->HKLM, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_READ | KEY_WRITE);
#else
            hKey = SETUPDI_CreateDrvKey(set->HKLM, deviceInfo, (UUID*)&DeviceInfoData->ClassGuid, KEY_ALL_ACCESS);
#endif
        if (hKey == INVALID_HANDLE_VALUE)
            goto cleanup;
 
        /* Install .CoInstallers section */
        DoAction = SPINST_REGISTRY;
        if (!(InstallParams.Flags & DI_NOFILECOPY))
        {
            DoAction |= SPINST_FILES;
            Context = SetupInitDefaultQueueCallback(InstallParams.hwndParent);
            if (!Context)
                goto cleanup;
        }
        Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
            SelectedDriver->InfFileDetails->hInf, SectionName,
            DoAction, hKey, SelectedDriver->InfFileDetails->DirectoryName, SP_COPY_NEWER,
            SetupDefaultQueueCallbackW, Context,
            DeviceInfoSet, DeviceInfoData);
        if (!Result)
            goto cleanup;
 
        ret = TRUE;
 
cleanup:
        if (Context)
            SetupTermDefaultQueueCallback(Context);
        if (hKey != INVALID_HANDLE_VALUE)
            RegCloseKey(hKey);
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by SetupDiCallClassInstaller().

SetupDiRegisterDeviceInfo()

BOOL WINAPI SetupDiRegisterDeviceInfo	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		DWORD	Flags,
		PSP_DETSIG_CMPPROC	CompareProc,
		PVOID	CompareContext,
		PSP_DEVINFO_DATA	DupDeviceInfoData
	)

Definition at line 1711 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    WCHAR DevInstId[MAX_DEVICE_ID_LEN];
    DEVINST ParentDevInst;
    CONFIGRET cr;
    DWORD dwError = ERROR_SUCCESS;
 
    TRACE("%s(%p %p %08x %p %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, Flags,
            CompareProc, CompareContext, DupDeviceInfoData);
 
    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;
    }
 
    if (Flags & ~SPRDI_FIND_DUPS)
    {
        TRACE("Unknown flags: 0x%08lx\n", Flags & ~SPRDI_FIND_DUPS);
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    if (Flags & SPRDI_FIND_DUPS)
    {
        FIXME("Unimplemented codepath!\n");
    }
 
    CM_Get_Device_ID_Ex(DeviceInfoData->DevInst,
                        DevInstId,
                        MAX_DEVICE_ID_LEN,
                        0,
                        set->hMachine);
 
    CM_Get_Parent_Ex(&ParentDevInst,
                     DeviceInfoData->DevInst,
                     0,
                     set->hMachine);
 
    cr = CM_Create_DevInst_Ex(&DeviceInfoData->DevInst,
                              DevInstId,
                              ParentDevInst,
                              CM_CREATE_DEVINST_NORMAL | CM_CREATE_DEVINST_DO_NOT_INSTALL,
                              set->hMachine);
    if (cr != CR_SUCCESS &&
        cr != CR_ALREADY_SUCH_DEVINST)
    {
        dwError = ERROR_NO_SUCH_DEVINST;
    }
 
    SetLastError(dwError);
 
    return (dwError == ERROR_SUCCESS);
}

Referenced by InstallCompositeBattery(), IntSetupDiRegisterDeviceInfo(), test_device_key(), test_register_device_iface(), and test_register_device_info().

SetupDiRestartDevices()

BOOL WINAPI SetupDiRestartDevices	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 6158 of file devinst.c.

{
    struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
    struct DeviceInfo *devInfo;
    CONFIGRET cr;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData);
 
    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;
    }
 
    devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 
    cr = CM_Enable_DevNode_Ex(devInfo->dnDevInst, 0, set->hMachine);
    if (cr != CR_SUCCESS)
    {
        SetLastError(GetErrorCodeFromCrCode(cr));
        return FALSE;
    }
 
    return TRUE;
}

Referenced by InstallNetDevice().

SetupDiSelectDevice()

BOOL WINAPI SetupDiSelectDevice	(	IN HDEVINFO	DeviceInfoSet,
		IN OUT PSP_DEVINFO_DATA DeviceInfoData	OPTIONAL
	)

Definition at line 5241 of file devinst.c.

{
    FIXME("%p %p\n", DeviceInfoSet, DeviceInfoData);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

Referenced by SetupDiCallClassInstaller().

SetupDiSetClassInstallParamsA()

BOOL WINAPI SetupDiSetClassInstallParamsA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		PSP_CLASSINSTALL_HEADER	ClassInstallParams,
		DWORD	ClassInstallParamsSize
	)

Definition at line 4046 of file devinst.c.

{
    FIXME("%p %p %x %u\n",DeviceInfoSet, DeviceInfoData,
          ClassInstallParams->InstallFunction, ClassInstallParamsSize);
    return FALSE;
}

SetupDiSetDeviceInstallParamsA()

BOOL WINAPI SetupDiSetDeviceInstallParamsA	(	HDEVINFO	DeviceInfoSet,
		PSP_DEVINFO_DATA	DeviceInfoData,
		PSP_DEVINSTALL_PARAMS_A	DeviceInstallParams
	)

Definition at line 4642 of file devinst.c.

{
    SP_DEVINSTALL_PARAMS_W deviceInstallParamsW;
    int len = 0;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
 
    if (DeviceInstallParams == NULL)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInstallParams->cbSize < sizeof(SP_DEVINSTALL_PARAMS_A))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        memcpy(&deviceInstallParamsW, DeviceInstallParams, FIELD_OFFSET(SP_DEVINSTALL_PARAMS_A, DriverPath));
        deviceInstallParamsW.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
        len = MultiByteToWideChar(CP_ACP, 0, DeviceInstallParams->DriverPath, -1, NULL, 0);
        if (!len)
        {
            ERR("DrivePath is NULL\n");
            ret = FALSE;
        }
        else
        {
            MultiByteToWideChar(CP_ACP, 0, DeviceInstallParams->DriverPath, -1, deviceInstallParamsW.DriverPath, len);
            ret = SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &deviceInstallParamsW);
        }
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

SetupDiSetDeviceInstallParamsW()

BOOL WINAPI SetupDiSetDeviceInstallParamsW	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA DeviceInfoData	OPTIONAL,
		IN PSP_DEVINSTALL_PARAMS_W	DeviceInstallParams
	)

Definition at line 4602 of file devinst.c.

{
    struct DeviceInfoSet *list;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (!DeviceInstallParams)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_W))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (CheckDeviceInstallParameters(DeviceInstallParams))
    {
        PSP_DEVINSTALL_PARAMS_W Destination;
 
        if (DeviceInfoData)
            Destination = &((struct DeviceInfo *)DeviceInfoData->Reserved)->InstallParams;
        else
            Destination = &list->InstallParams;
        memcpy(Destination, DeviceInstallParams, DeviceInstallParams->cbSize);
        ret = TRUE;
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

Referenced by DisplayDeviceAdvancedProperties(), EnumerateDrivers(), InstallNetDevice(), CDeviceNode::RemoveFlags(), SearchDriver(), CDeviceNode::SetFlags(), SetupDiBuildDriverInfoList(), SetupDiCallClassInstaller(), SetupDiDestroyDriverInfoList(), SetupDiInstallClassExW(), SetupDiInstallDevice(), SetupDiInstallDriverFiles(), SetupDiSetClassInstallParamsW(), SetupDiSetDeviceInstallParamsA(), and WriteParameterArray().

SetupDiSetDeviceRegistryPropertyA()

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

Definition at line 3478 of file devinst.c.

{
    return IntSetupDiSetDeviceRegistryPropertyAW(DeviceInfoSet,
                                                 DeviceInfoData,
                                                 Property,
                                                 PropertyBuffer,
                                                 PropertyBufferSize,
                                                 TRUE);
}

Referenced by test_registry_property_a().

SetupDiSetDeviceRegistryPropertyW()

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

Definition at line 3496 of file devinst.c.

{
    return IntSetupDiSetDeviceRegistryPropertyAW(DeviceInfoSet,
                                                 DeviceInfoData,
                                                 Property,
                                                 PropertyBuffer,
                                                 PropertyBufferSize,
                                                 FALSE);
}

Referenced by InstallCompositeBattery(), InstallParallelPort(), InstallSerialPort(), InstallSoftwareBusPnpEnumerator(), SetFailedInstall(), SetupDiInstallDevice(), SetupInstallServicesFromInfSectionExW(), StorageCoInstaller(), and test_registry_property_w().

SetupDiSetSelectedDevice()

BOOL WINAPI SetupDiSetSelectedDevice	(	IN HDEVINFO	DeviceInfoSet,
		IN PSP_DEVINFO_DATA	DeviceInfoData
	)

Definition at line 4985 of file devinst.c.

{
    struct DeviceInfoSet *list;
    BOOL ret = FALSE;
 
    TRACE("%s(%p %p)\n", __FUNCTION__, DeviceInfoSet, DeviceInfoData);
 
    if (!DeviceInfoSet)
        SetLastError(ERROR_INVALID_HANDLE);
    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
        SetLastError(ERROR_INVALID_HANDLE);
    else if (!DeviceInfoData)
        SetLastError(ERROR_INVALID_PARAMETER);
    else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else if (DeviceInfoData->Reserved == 0)
        SetLastError(ERROR_INVALID_USER_BUFFER);
    else
    {
        list->SelectedDevice = (struct DeviceInfo *)DeviceInfoData->Reserved;
        ret = TRUE;
    }
 
    TRACE("Returning %d\n", ret);
    return ret;
}

StopDevice()

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

static

Definition at line 5088 of file devinst.c.

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

Referenced by SetupDiChangeState().

Variable Documentation

BackSlash

const WCHAR BackSlash[] = {'\\',0}

static

Definition at line 27 of file devinst.c.

Referenced by InfIsFromOEMLocation(), and SETUP_CreateClassKey().

DateFormat

const WCHAR DateFormat[] = {'%','u','-','%','u','-','%','u',0}

static

Definition at line 28 of file devinst.c.

Referenced by SetupDiInstallDevice().

DotCoInstallers

const WCHAR DotCoInstallers[] = {'.','C','o','I','n','s','t','a','l','l','e','r','s',0}

static

Definition at line 29 of file devinst.c.

Referenced by SetupDiRegisterCoDeviceInstallers().

DotHW

const WCHAR DotHW[] = {'.','H','W',0}

static

Definition at line 30 of file devinst.c.

Referenced by SetupDiInstallDevice().

DotServices

const WCHAR DotServices[] = {'.','S','e','r','v','i','c','e','s',0}

static

Definition at line 31 of file devinst.c.

Referenced by SetupDiInstallDevice().

InfDirectory

const WCHAR InfDirectory[] = {'i','n','f','\\',0}

static

Definition at line 32 of file devinst.c.

Referenced by InfIsFromOEMLocation().

InstanceKeyFormat

const WCHAR InstanceKeyFormat[] = {'%','0','4','l','u',0}

static

Definition at line 33 of file devinst.c.

Referenced by OpenHardwareProfileKey(), and SETUPDI_CreateDrvKey().

PropertyMap

struct PropertyMapEntry PropertyMap[]

static

Definition at line 3142 of file devinst.c.

Referenced by IntSetupDiSetDeviceRegistryPropertyAW(), and SetupDiGetDeviceRegistryPropertyW().

REGSTR_DRIVER_DATE

const WCHAR REGSTR_DRIVER_DATE[] = {'D','r','i','v','e','r','D','a','t','e',0}

static

Definition at line 37 of file devinst.c.

Referenced by SetupDiInstallDevice().

REGSTR_DRIVER_DATE_DATA

const WCHAR REGSTR_DRIVER_DATE_DATA[] = {'D','r','i','v','e','r','D','a','t','e','D','a','t','a',0}

static

Definition at line 38 of file devinst.c.

Referenced by SetupDiInstallDevice().

REGSTR_DRIVER_VERSION

const WCHAR REGSTR_DRIVER_VERSION[] = {'D','r','i','v','e','r','V','e','r','s','i','o','n',0}

static

Definition at line 39 of file devinst.c.

Referenced by SetupDiInstallDevice().

REGSTR_SECURITY

const WCHAR REGSTR_SECURITY[] = {'S','e','c','u','r','i','t','y',0}

static

Definition at line 40 of file devinst.c.

REGSTR_UI_NUMBER_DESC_FORMAT

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

Definition at line 41 of file devinst.c.

Version

const WCHAR Version[] = {'V','e','r','s','i','o','n',0}

static

Definition at line 34 of file devinst.c.

VersionFormat

const WCHAR VersionFormat[] = {'%','u','.','%','u','.','%','u','.','%','u',0}

static

Definition at line 35 of file devinst.c.

Referenced by SetupDiInstallDevice().