cfgmgr.c File Reference

#include "setupapi_private.h"
#include <dbt.h>
#include <pnp_c.h>
#include <winsvc.h>
#include <pseh/pseh2.h>
#include "rpc_private.h"

Include dependency graph for cfgmgr.c:

Go to the source code of this file.

Classes
struct	_MACHINE_INFO
struct	_LOG_CONF_INFO
struct	_NOTIFY_DATA
struct	_INTERNAL_RANGE
struct	_INTERNAL_RANGE_LIST
struct	_CONFLICT_DATA

Macros
#define	LOG_CONF_MAGIC   0x464E434C /* "LCNF" */
#define	NOTIFY_MAGIC   0x44556677
#define	RANGE_LIST_MAGIC   0x33445566
#define	CONFLICT_MAGIC   0x11225588

Typedefs
typedef struct _MACHINE_INFO	MACHINE_INFO
typedef struct _MACHINE_INFO *	PMACHINE_INFO
typedef struct _LOG_CONF_INFO	LOG_CONF_INFO
typedef struct _LOG_CONF_INFO *	PLOG_CONF_INFO
typedef struct _NOTIFY_DATA	NOTIFY_DATA
typedef struct _NOTIFY_DATA *	PNOTIFY_DATA
typedef struct _INTERNAL_RANGE	INTERNAL_RANGE
typedef struct _INTERNAL_RANGE *	PINTERNAL_RANGE
typedef struct _INTERNAL_RANGE_LIST	INTERNAL_RANGE_LIST
typedef struct _INTERNAL_RANGE_LIST *	PINTERNAL_RANGE_LIST
typedef struct _CONFLICT_DATA	CONFLICT_DATA
typedef struct _CONFLICT_DATA *	PCONFLICT_DATA

Functions
DWORD WINAPI	I_ScPnPGetServiceName (IN SERVICE_STATUS_HANDLE hServiceStatus, OUT LPWSTR lpServiceName, IN DWORD cchServiceName)
static BOOL	GuidToString (_In_ LPGUID Guid, _Out_ LPWSTR String)
static CONFIGRET	RpcStatusToCmStatus (_In_ RPC_STATUS Status)
static ULONG	GetRegistryPropertyType (_In_ ULONG ulProperty)
static VOID	SplitDeviceInstanceId (_In_ PWSTR pszDeviceInstanceId, _Out_ PWSTR pszDeviceId, _Out_ PWSTR pszInstanceId)
static CONFIGRET	GetDeviceInstanceKeyPath (_In_ RPC_BINDING_HANDLE BindingHandle, _In_ PWSTR pszDeviceInst, _Out_ PWSTR pszKeyPath, _Out_ PWSTR pszInstancePath, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
BOOL	IsValidRangeList (_In_opt_ PINTERNAL_RANGE_LIST pRangeList)
BOOL	IsValidLogConf (_In_opt_ PLOG_CONF_INFO pLogConfInfo)
BOOL	IsValidConflictData (_In_opt_ PCONFLICT_DATA pConflictData)
CONFIGRET WINAPI	CMP_GetBlockedDriverInfo (_Out_opt_ LPWSTR pszNames, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CMP_GetServerSideDeviceInstallFlags (_Out_ PULONG pulSSDIFlags, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CMP_Init_Detection (_In_ ULONG ulMagic)
CONFIGRET WINAPI	CMP_RegisterNotification (_In_ HANDLE hRecipient, _In_ LPVOID lpvNotificationFilter, _In_ ULONG ulFlags, _Out_ PHDEVNOTIFY phDevNotify)
CONFIGRET WINAPI	CMP_Report_LogOn (_In_ DWORD dwMagic, _In_ DWORD dwProcessId)
CONFIGRET WINAPI	CMP_UnregisterNotification (_In_ HDEVNOTIFY hDevNotify)
DWORD WINAPI	CMP_WaitNoPendingInstallEvents (_In_ DWORD dwTimeout)
CONFIGRET WINAPI	CMP_WaitServicesAvailable (_In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Add_Empty_Log_Conf (_Out_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ PRIORITY Priority, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Add_Empty_Log_Conf_Ex (_Out_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ PRIORITY Priority, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Add_IDA (_In_ DEVINST dnDevInst, _In_ PSTR pszID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Add_IDW (_In_ DEVINST dnDevInst, _In_ PWSTR pszID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Add_ID_ExA (_In_ DEVINST dnDevInst, _In_ PSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Add_ID_ExW (_In_ DEVINST dnDevInst, _In_ PWSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Add_Range (_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Add_Res_Des (_Out_opt_ PRES_DES prdResDes, _In_ LOG_CONF lcLogConf, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Add_Res_Des_Ex (_Out_opt_ PRES_DES prdResDes, _In_ LOG_CONF lcLogConf, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Connect_MachineA (_In_opt_ PCSTR UNCServerName, _Out_ PHMACHINE phMachine)
CONFIGRET WINAPI	CM_Connect_MachineW (_In_opt_ PCWSTR UNCServerName, _Out_ PHMACHINE phMachine)
CONFIGRET WINAPI	CM_Create_DevNodeA (_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_A pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Create_DevNodeW (_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_W pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Create_DevNode_ExA (_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_A pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
CONFIGRET WINAPI	CM_Create_DevNode_ExW (_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_W pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
CONFIGRET WINAPI	CM_Create_Range_List (_Out_ PRANGE_LIST prlh, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Delete_Class_Key (_In_ LPGUID ClassGuid, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Delete_Class_Key_Ex (_In_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
CONFIGRET WINAPI	CM_Delete_DevNode_Key (_In_ DEVINST dnDevInst, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Delete_DevNode_Key_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
CONFIGRET WINAPI	CM_Delete_Range (_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Detect_Resource_Conflict (_In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _Out_ PBOOL pbConflictDetected, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Detect_Resource_Conflict_Ex (_In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _Out_ PBOOL pbConflictDetected, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Disable_DevNode (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Disable_DevNode_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Disconnect_Machine (_In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Dup_Range_List (_In_ RANGE_LIST rlhOld, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Enable_DevNode (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Enable_DevNode_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Enumerate_Classes (_In_ ULONG ulClassIndex, _Out_ LPGUID ClassGuid, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Enumerate_Classes_Ex (_In_ ULONG ulClassIndex, _Out_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Enumerate_EnumeratorsA (_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Enumerate_EnumeratorsW (_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Enumerate_Enumerators_ExA (_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Enumerate_Enumerators_ExW (_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Find_Range (_Out_ PDWORDLONG pullStart, _In_ DWORDLONG ullStart, _In_ ULONG ulLength, _In_ DWORDLONG ullAlignment, _In_ DWORDLONG ullEnd, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_First_Range (_In_ RANGE_LIST rlh, _Out_ PDWORDLONG pullStart, _Out_ PDWORDLONG pullEnd, _Out_ PRANGE_ELEMENT preElement, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Free_Log_Conf (_In_ LOG_CONF lcLogConfToBeFreed, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Free_Log_Conf_Ex (_In_ LOG_CONF lcLogConfToBeFreed, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Free_Log_Conf_Handle (_In_ LOG_CONF lcLogConf)
CONFIGRET WINAPI	CM_Free_Range_List (_In_ RANGE_LIST RangeList, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Free_Res_Des (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Free_Res_Des_Ex (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Free_Res_Des_Handle (_In_ RES_DES rdResDes)
CONFIGRET WINAPI	CM_Free_Resource_Conflict_Handle (_In_ CONFLICT_LIST clConflictList)
CONFIGRET WINAPI	CM_Get_Child (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Child_Ex (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_Key_NameA (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Class_Key_NameW (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPWSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Class_Key_Name_ExA (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_Key_Name_ExW (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPWSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_NameA (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Class_NameW (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Class_Name_ExA (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_Name_ExW (_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_Registry_PropertyA (LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Class_Registry_PropertyW (LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Depth (_Out_ PULONG pulDepth, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Depth_Ex (_Out_ PULONG pulDepth, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_DevNode_Custom_PropertyA (_In_ DEVINST dnDevInst, _In_ PCSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_DevNode_Custom_PropertyW (_In_ DEVINST dnDevInst, _In_ PCWSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_DevNode_Custom_Property_ExA (_In_ DEVINST dnDevInst, _In_ PCSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_DevNode_Custom_Property_ExW (_In_ DEVINST dnDevInst, _In_ PCWSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_DevNode_Registry_PropertyA (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_DevNode_Registry_PropertyW (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_DevNode_Registry_Property_ExA (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_DevNode_Registry_Property_ExW (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_DevNode_Status (_Out_ PULONG pulStatus, _Out_ PULONG pulProblemNumber, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_DevNode_Status_Ex (_Out_ PULONG pulStatus, _Out_ PULONG pulProblemNumber, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_IDA (_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_IDW (_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_ExA (_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_ExW (_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_ListA (_In_ PCSTR pszFilter, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_ListW (_In_ PCWSTR pszFilter, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_List_ExA (_In_ PCSTR pszFilter, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_List_ExW (_In_ PCWSTR pszFilter, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_List_SizeA (_Out_ PULONG pulLen, _In_opt_ PCSTR pszFilter, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_List_SizeW (_Out_ PULONG pulLen, _In_opt_ PCWSTR pszFilter, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_List_Size_ExA (_Out_ PULONG pulLen, _In_opt_ PCSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_List_Size_ExW (_Out_ PULONG pulLen, _In_opt_ PCWSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_ID_Size (_Out_ PULONG pulLen, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_ID_Size_Ex (_Out_ PULONG pulLen, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_AliasA (_In_ LPCSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_AliasW (_In_ LPCWSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_Alias_ExA (_In_ LPCSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_Alias_ExW (_In_ LPCWSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_ListA (_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_ListW (_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_ExA (_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_ExW (_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_SizeA (_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_SizeW (_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_Size_ExA (_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Device_Interface_List_Size_ExW (_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_First_Log_Conf (_Out_opt_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_First_Log_Conf_Ex (_Out_opt_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Global_State (_Out_ PULONG pulState, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Global_State_Ex (_Out_ PULONG pulState, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_HW_Prof_FlagsA (_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_HW_Prof_FlagsW (_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_HW_Prof_Flags_ExA (_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_HW_Prof_Flags_ExW (_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Hardware_Profile_InfoA (_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_A pHWProfileInfo, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Hardware_Profile_InfoW (_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_W pHWProfileInfo, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Hardware_Profile_Info_ExA (_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_A pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Hardware_Profile_Info_ExW (_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_W pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Log_Conf_Priority (_In_ LOG_CONF lcLogConf, _Out_ PPRIORITY pPriority, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Log_Conf_Priority_Ex (_In_ LOG_CONF lcLogConf, _Out_ PPRIORITY pPriority, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Next_Log_Conf (_Out_opt_ PLOG_CONF plcLogConf, _In_ LOG_CONF lcLogConf, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Next_Log_Conf_Ex (_Out_opt_ PLOG_CONF plcLogConf, _In_ LOG_CONF lcLogConf, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Next_Res_Des (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ForResource, _Out_opt_ PRESOURCEID pResourceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Next_Res_Des_Ex (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ForResource, _Out_opt_ PRESOURCEID pResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Parent (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Parent_Ex (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Res_Des_Data (_In_ RES_DES rdResDes, _Out_writes_bytes_(BufferLen) PVOID Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Res_Des_Data_Ex (_In_ RES_DES rdResDes, _Out_writes_bytes_(BufferLen) PVOID Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Res_Des_Data_Size (_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Res_Des_Data_Size_Ex (_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Get_Resource_Conflict_Count (_In_ CONFLICT_LIST clConflictList, _Out_ PULONG pulCount)
CONFIGRET WINAPI	CM_Get_Resource_Conflict_DetailsA (_In_ CONFLICT_LIST clConflictList, _In_ ULONG ulIndex, _Inout_ PCONFLICT_DETAILS_A pConflictDetails)
CONFIGRET WINAPI	CM_Get_Resource_Conflict_DetailsW (_In_ CONFLICT_LIST clConflictList, _In_ ULONG ulIndex, _Inout_ PCONFLICT_DETAILS_W pConflictDetails)
CONFIGRET WINAPI	CM_Get_Sibling (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Get_Sibling_Ex (_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
WORD WINAPI	CM_Get_Version (VOID)
WORD WINAPI	CM_Get_Version_Ex (_In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Intersect_Range_List (_In_ RANGE_LIST rlhOld1, _In_ RANGE_LIST rlhOld2, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Invert_Range_List (_In_ RANGE_LIST rlhOld, _In_ RANGE_LIST rlhNew, _In_ DWORDLONG ullMaxValue, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Is_Dock_Station_Present (_Out_ PBOOL pbPresent)
CONFIGRET WINAPI	CM_Is_Dock_Station_Present_Ex (_Out_ PBOOL pbPresent, _In_opt_ HMACHINE hMachine)
BOOL WINAPI	CM_Is_Version_Available (_In_ WORD wVersion)
BOOL WINAPI	CM_Is_Version_Available_Ex (_In_ WORD wVersion, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Locate_DevNodeA (_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Locate_DevNodeW (_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Locate_DevNode_ExA (_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Locate_DevNode_ExW (_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Merge_Range_List (_In_ RANGE_LIST rlhOld1, _In_ RANGE_LIST rlhOld2, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Modify_Res_Des (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Modify_Res_Des_Ex (_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Move_DevNode (_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Move_DevNode_Ex (_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Next_Range (_Inout_ PRANGE_ELEMENT preElement, _Out_ PDWORDLONG pullStart, _Out_ PDWORDLONG pullEnd, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Open_Class_KeyA (_In_opt_ LPGUID pClassGuid, _In_opt_ LPCSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Open_Class_KeyW (_In_opt_ LPGUID pClassGuid, _In_opt_ LPCWSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Open_Class_Key_ExA (_In_opt_ LPGUID pClassGuid, _In_opt_ LPCSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Open_Class_Key_ExW (_In_opt_ LPGUID pClassGuid, _In_opt_ LPCWSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Open_DevNode_Key (_In_ DEVINST dnDevNode, _In_ REGSAM samDesired, _In_ ULONG ulHardwareProfile, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkDevice, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Open_DevNode_Key_Ex (_In_ DEVINST dnDevNode, _In_ REGSAM samDesired, _In_ ULONG ulHardwareProfile, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkDevice, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_And_Remove_SubTreeA (_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Query_And_Remove_SubTreeW (_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Query_And_Remove_SubTree_ExA (_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_And_Remove_SubTree_ExW (_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_Arbitrator_Free_Data (_Out_writes_bytes_(DataLen) PVOID pData, _In_ ULONG DataLen, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Query_Arbitrator_Free_Data_Ex (_Out_writes_bytes_(DataLen) PVOID pData, _In_ ULONG DataLen, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_Arbitrator_Free_Size (_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Query_Arbitrator_Free_Size_Ex (_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_Remove_SubTree (_In_ DEVINST dnAncestor, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Query_Remove_SubTree_Ex (_In_ DEVINST dnAncestor, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Query_Resource_Conflict_List (_Out_ PCONFLICT_LIST pclConflictList, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Reenumerate_DevNode (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Reenumerate_DevNode_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Register_Device_Driver (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Register_Device_Driver_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Register_Device_InterfaceA (_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCSTR pszReference, _Out_writes_(*pulLength) LPSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Register_Device_InterfaceW (_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCWSTR pszReference, _Out_writes_(*pulLength) LPWSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Register_Device_Interface_ExA (_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCSTR pszReference, _Out_writes_(*pulLength) LPSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Register_Device_Interface_ExW (_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCWSTR pszReference, _Out_writes_(*pulLength) LPWSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Remove_SubTree (_In_ DEVINST dnAncestor, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Remove_SubTree_Ex (_In_ DEVINST dnAncestor, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Request_Device_EjectA (_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Request_Device_EjectW (_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Request_Device_Eject_ExA (_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Request_Device_Eject_ExW (_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Request_Eject_PC (VOID)
CONFIGRET WINAPI	CM_Request_Eject_PC_Ex (_In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Run_Detection (_In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Run_Detection_Ex (_In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_Class_Registry_PropertyA (_In_ LPGUID ClassGuid, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_Class_Registry_PropertyW (_In_ LPGUID ClassGuid, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_DevNode_Problem (_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_DevNode_Problem_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_DevNode_Registry_PropertyA (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_DevNode_Registry_PropertyW (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_DevNode_Registry_Property_ExA (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_DevNode_Registry_Property_ExW (_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_HW_Prof (_In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_HW_Prof_Ex (_In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_HW_Prof_FlagsA (_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_HW_Prof_FlagsW (_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Set_HW_Prof_Flags_ExA (_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Set_HW_Prof_Flags_ExW (_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Setup_DevNode (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Setup_DevNode_Ex (_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Test_Range_Available (_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Uninstall_DevNode (_In_ DEVINST dnPhantom, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Uninstall_DevNode_Ex (_In_ DEVINST dnPhantom, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Unregister_Device_InterfaceA (_In_ LPCSTR pszDeviceInterface, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Unregister_Device_InterfaceW (_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags)
CONFIGRET WINAPI	CM_Unregister_Device_Interface_ExA (_In_ LPCSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
CONFIGRET WINAPI	CM_Unregister_Device_Interface_ExW (_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)

Variables
static const WCHAR	BackslashOpenBrace [] = {'\\', '{', 0}
static const WCHAR	CloseBrace [] = {'}', 0}
static const WCHAR	Class [] = {'C','l','a','s','s',0}
static const WCHAR	ControlClass []
static const WCHAR	DeviceClasses []

Macro Definition Documentation

CONFLICT_MAGIC

#define CONFLICT_MAGIC   0x11225588

Definition at line 106 of file cfgmgr.c.

LOG_CONF_MAGIC

#define LOG_CONF_MAGIC   0x464E434C /* "LCNF" */

Definition at line 71 of file cfgmgr.c.

NOTIFY_MAGIC

#define NOTIFY_MAGIC   0x44556677

Definition at line 80 of file cfgmgr.c.

RANGE_LIST_MAGIC

#define RANGE_LIST_MAGIC   0x33445566

Definition at line 98 of file cfgmgr.c.

Typedef Documentation

CONFLICT_DATA

typedef struct _CONFLICT_DATA CONFLICT_DATA

INTERNAL_RANGE

typedef struct _INTERNAL_RANGE INTERNAL_RANGE

INTERNAL_RANGE_LIST

typedef struct _INTERNAL_RANGE_LIST INTERNAL_RANGE_LIST

LOG_CONF_INFO

typedef struct _LOG_CONF_INFO LOG_CONF_INFO

MACHINE_INFO

typedef struct _MACHINE_INFO MACHINE_INFO

NOTIFY_DATA

typedef struct _NOTIFY_DATA NOTIFY_DATA

PCONFLICT_DATA

typedef struct _CONFLICT_DATA * PCONFLICT_DATA

PINTERNAL_RANGE

typedef struct _INTERNAL_RANGE * PINTERNAL_RANGE

PINTERNAL_RANGE_LIST

typedef struct _INTERNAL_RANGE_LIST * PINTERNAL_RANGE_LIST

PLOG_CONF_INFO

typedef struct _LOG_CONF_INFO * PLOG_CONF_INFO

PMACHINE_INFO

typedef struct _MACHINE_INFO * PMACHINE_INFO

PNOTIFY_DATA

typedef struct _NOTIFY_DATA * PNOTIFY_DATA

Function Documentation

CM_Add_Empty_Log_Conf()

CONFIGRET WINAPI CM_Add_Empty_Log_Conf	(	_Out_ PLOG_CONF	plcLogConf,
		_In_ DEVINST	dnDevInst,
		_In_ PRIORITY	Priority,
		_In_ ULONG	ulFlags
	)

Definition at line 865 of file cfgmgr.c.

{
    TRACE("CM_Add_Empty_Log_Conf(%p %p %lu %lx)\n",
          plcLogConf, dnDevInst, Priority, ulFlags);
 
    return CM_Add_Empty_Log_Conf_Ex(plcLogConf, dnDevInst, Priority,
                                    ulFlags, NULL);
}

CM_Add_Empty_Log_Conf_Ex()

CONFIGRET WINAPI CM_Add_Empty_Log_Conf_Ex	(	_Out_ PLOG_CONF	plcLogConf,
		_In_ DEVINST	dnDevInst,
		_In_ PRIORITY	Priority,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 884 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    ULONG ulLogConfTag = 0;
    LPWSTR lpDevInst;
    PLOG_CONF_INFO pLogConfInfo;
    CONFIGRET ret = CR_SUCCESS;
 
    FIXME("CM_Add_Empty_Log_Conf_Ex(%p %p %lu %lx %p)\n",
          plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    if (plcLogConf == NULL)
        return CR_INVALID_POINTER;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (Priority > 0xFFFF)
        return CR_INVALID_PRIORITY;
 
    if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_AddEmptyLogConf(BindingHandle, lpDevInst, Priority,
                                  &ulLogConfTag, ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (ret == CR_SUCCESS)
    {
        pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
        if (pLogConfInfo == NULL)
        {
            ret = CR_OUT_OF_MEMORY;
        }
        else
        {
            pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
            pLogConfInfo->dnDevInst = dnDevInst;
            pLogConfInfo->ulType = ulFlags;
            pLogConfInfo->ulTag = ulLogConfTag;
 
            *plcLogConf = (LOG_CONF)pLogConfInfo;
 
            ret = CR_SUCCESS;
        }
    }
 
    return ret;
}

Referenced by CM_Add_Empty_Log_Conf().

CM_Add_ID_ExA()

CONFIGRET WINAPI CM_Add_ID_ExA	(	_In_ DEVINST	dnDevInst,
		_In_ PSTR	pszID,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1010 of file cfgmgr.c.

{
    PWSTR pszIDW;
    CONFIGRET ret;
 
    TRACE("CM_Add_ID_ExA(%p %s %lx %p)\n",
          dnDevInst, debugstr_a(pszID), ulFlags, hMachine);
 
    if (pSetupCaptureAndConvertAnsiArg(pszID, &pszIDW))
        return CR_INVALID_DATA;
 
    ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
 
    MyFree(pszIDW);
 
    return ret;
}

Referenced by CM_Add_IDA().

CM_Add_ID_ExW()

CONFIGRET WINAPI CM_Add_ID_ExW	(	_In_ DEVINST	dnDevInst,
		_In_ PWSTR	pszID,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1038 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    CONFIGRET ret;
 
    TRACE("CM_Add_ID_ExW(%p %s %lx %p)\n",
          dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (pszID == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_ADD_ID_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_AddID(BindingHandle,
                        lpDevInst,
                        pszID,
                        ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Add_ID_ExA(), and CM_Add_IDW().

CM_Add_IDA()

CONFIGRET WINAPI CM_Add_IDA	(	_In_ DEVINST	dnDevInst,
		_In_ PSTR	pszID,
		_In_ ULONG	ulFlags
	)

Definition at line 976 of file cfgmgr.c.

{
    TRACE("CM_Add_IDA(%p %s %lx)\n",
          dnDevInst, debugstr_a(pszID), ulFlags);
 
    return CM_Add_ID_ExA(dnDevInst, pszID, ulFlags, NULL);
}

CM_Add_IDW()

CONFIGRET WINAPI CM_Add_IDW	(	_In_ DEVINST	dnDevInst,
		_In_ PWSTR	pszID,
		_In_ ULONG	ulFlags
	)

Definition at line 993 of file cfgmgr.c.

{
    TRACE("CM_Add_IDW(%p %s %lx)\n",
          dnDevInst, debugstr_w(pszID), ulFlags);
 
    return CM_Add_ID_ExW(dnDevInst, pszID, ulFlags, NULL);
}

CM_Add_Range()

CONFIGRET WINAPI CM_Add_Range	(	_In_ DWORDLONG	ullStartValue,
		_In_ DWORDLONG	ullEndValue,
		_In_ RANGE_LIST	rlh,
		_In_ ULONG	ulFlags
	)

Definition at line 1106 of file cfgmgr.c.

{
    PINTERNAL_RANGE_LIST pRangeList;
    PINTERNAL_RANGE pRange;
    CONFIGRET ret = CR_SUCCESS;
 
    FIXME("CM_Add_Range(%I64u %I64u %p %lx)\n",
          ullStartValue, ullEndValue, rlh, ulFlags);
 
    pRangeList = (PINTERNAL_RANGE_LIST)rlh;
 
    if (!IsValidRangeList(pRangeList))
        return CR_INVALID_RANGE_LIST;
 
    if (ulFlags & ~CM_ADD_RANGE_BITS)
        return CR_INVALID_FLAG;
 
    if (ullEndValue < ullStartValue)
        return CR_INVALID_RANGE;
 
    /* Lock the range list */
    WaitForSingleObject(pRangeList->hMutex, INFINITE);
 
    /* Allocate the new range */
    pRange = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERNAL_RANGE));
    if (pRange == NULL)
    {
        ret = CR_OUT_OF_MEMORY;
        goto done;
    }
 
    pRange->pRangeList = pRangeList;
    pRange->ullStart = ullStartValue;
    pRange->ullEnd = ullEndValue;
 
    /* Insert the range */
    if (IsListEmpty(&pRangeList->ListHead))
    {
        InsertTailList(&pRangeList->ListHead, &pRange->ListEntry);
    }
    else
    {
        HeapFree(GetProcessHeap(), 0, pRange);
        UNIMPLEMENTED;
    }
 
done:
    /* Unlock the range list */
    ReleaseMutex(pRangeList->hMutex);
 
    return ret;
}

CM_Add_Res_Des()

CONFIGRET WINAPI CM_Add_Res_Des	(	_Out_opt_ PRES_DES	prdResDes,
		_In_ LOG_CONF	lcLogConf,
		_In_ RESOURCEID	ResourceID,
		_In_reads_bytes_(ResourceLen) PCVOID	ResourceData,
		_In_ ULONG	ResourceLen,
		_In_ ULONG	ulFlags
	)

Definition at line 1169 of file cfgmgr.c.

{
    TRACE("CM_Add_Res_Des(%p %p %lu %p %lu %lx)\n",
          prdResDes, lcLogConf, ResourceID, ResourceData, ResourceLen, ulFlags);
 
    return CM_Add_Res_Des_Ex(prdResDes, lcLogConf, ResourceID, ResourceData,
                             ResourceLen, ulFlags, NULL);
}

CM_Add_Res_Des_Ex()

CONFIGRET WINAPI CM_Add_Res_Des_Ex	(	_Out_opt_ PRES_DES	prdResDes,
		_In_ LOG_CONF	lcLogConf,
		_In_ RESOURCEID	ResourceID,
		_In_reads_bytes_(ResourceLen) PCVOID	ResourceData,
		_In_ ULONG	ResourceLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1190 of file cfgmgr.c.

{
    FIXME("CM_Add_Res_Des_Ex(%p %p %lu %p %lu %lx %p)\n",
          prdResDes, lcLogConf, ResourceID,
          ResourceData, ResourceLen, ulFlags, hMachine);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Add_Res_Des().

CM_Connect_MachineA()

CONFIGRET WINAPI CM_Connect_MachineA	(	_In_opt_ PCSTR	UNCServerName,
		_Out_ PHMACHINE	phMachine
	)

Definition at line 1212 of file cfgmgr.c.

{
    PWSTR pServerNameW;
    CONFIGRET ret;
 
    TRACE("CM_Connect_MachineA(%s %p)\n",
          debugstr_a(UNCServerName), phMachine);
 
    if (UNCServerName == NULL || *UNCServerName == 0)
        return CM_Connect_MachineW(NULL, phMachine);
 
    if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
        return CR_INVALID_DATA;
 
    ret = CM_Connect_MachineW(pServerNameW, phMachine);
 
    MyFree(pServerNameW);
 
    return ret;
}

CM_Connect_MachineW()

CONFIGRET WINAPI CM_Connect_MachineW	(	_In_opt_ PCWSTR	UNCServerName,
		_Out_ PHMACHINE	phMachine
	)

Definition at line 1241 of file cfgmgr.c.

{
    PMACHINE_INFO pMachine;
 
    TRACE("CM_Connect_MachineW(%s %p)\n",
          debugstr_w(UNCServerName), phMachine);
 
    if (phMachine == NULL)
        return CR_INVALID_POINTER;
 
    *phMachine = NULL;
 
    pMachine = HeapAlloc(GetProcessHeap(), 0, sizeof(MACHINE_INFO));
    if (pMachine == NULL)
        return CR_OUT_OF_MEMORY;
 
    if (UNCServerName == NULL || *UNCServerName == 0)
    {
        pMachine->bLocal = TRUE;
 
        /* FIXME: store the computers name in pMachine->szMachineName */
 
        if (!PnpGetLocalHandles(&pMachine->BindingHandle,
                                &pMachine->StringTable))
        {
            HeapFree(GetProcessHeap(), 0, pMachine);
            return CR_FAILURE;
        }
    }
    else
    {
        pMachine->bLocal = FALSE;
        if (wcslen(UNCServerName) >= SP_MAX_MACHINENAME_LENGTH - 1)
        {
            HeapFree(GetProcessHeap(), 0, pMachine);
            return CR_INVALID_MACHINENAME;
        }
        lstrcpyW(pMachine->szMachineName, UNCServerName);
 
        pMachine->StringTable = pSetupStringTableInitialize();
        if (pMachine->StringTable == NULL)
        {
            HeapFree(GetProcessHeap(), 0, pMachine);
            return CR_FAILURE;
        }
 
        pSetupStringTableAddString(pMachine->StringTable, L"PLT", 1);
 
        if (!PnpBindRpc(UNCServerName, &pMachine->BindingHandle))
        {
            pSetupStringTableDestroy(pMachine->StringTable);
            HeapFree(GetProcessHeap(), 0, pMachine);
            return CR_INVALID_MACHINENAME;
        }
    }
 
    *phMachine = (PHMACHINE)pMachine;
 
    return CR_SUCCESS;
}

Referenced by CM_Connect_MachineA(), SetupDiBuildClassInfoListExW(), and SetupDiCreateDeviceInfoListExW().

CM_Create_DevNode_ExA()

CONFIGRET WINAPI CM_Create_DevNode_ExA	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINSTID_A	pDeviceID,
		_In_ DEVINST	dnParent,
		_In_ ULONG	ulFlags,
		_In_opt_ HANDLE	hMachine
	)

Definition at line 1348 of file cfgmgr.c.

{
    DEVINSTID_W pDeviceIDW;
    CONFIGRET ret;
 
    TRACE("CM_Create_DevNode_ExA(%p %s %p %lx %p)\n",
          pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
 
    if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
        return CR_INVALID_DATA;
 
    ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
                                hMachine);
 
    MyFree(pDeviceIDW);
 
    return ret;
}

Referenced by CM_Create_DevNodeA().

CM_Create_DevNode_ExW()

CONFIGRET WINAPI CM_Create_DevNode_ExW	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINSTID_W	pDeviceID,
		_In_ DEVINST	dnParent,
		_In_ ULONG	ulFlags,
		_In_opt_ HANDLE	hMachine
	)

Definition at line 1378 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpParentDevInst;
    CONFIGRET ret = CR_SUCCESS;
    WCHAR szLocalDeviceID[MAX_DEVICE_ID_LEN];
 
    TRACE("CM_Create_DevNode_ExW(%p %s %p %lx %p)\n",
          pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    if (pdnDevInst == NULL)
        return CR_INVALID_POINTER;
 
    if (pDeviceID == NULL || wcslen(pDeviceID) == 0 || wcslen(pDeviceID) >= MAX_DEVICE_ID_LEN)
        return CR_INVALID_DEVICE_ID;
 
    if (dnParent == 0)
        return CR_INVALID_DEVNODE;
 
    if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpParentDevInst = pSetupStringTableStringFromId(StringTable, dnParent);
    if (lpParentDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    wcscpy(szLocalDeviceID, pDeviceID);
 
    RpcTryExcept
    {
        ret = PNP_CreateDevInst(BindingHandle,
                                szLocalDeviceID,
                                lpParentDevInst,
                                MAX_DEVICE_ID_LEN,
                                ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (ret == CR_SUCCESS)
    {
        /* If CM_CREATE_DEVINST_GENERATE_ID was passed in, PNP_CreateDevInst
         * will return the generated device ID in szLocalDeviceID */
        *pdnDevInst = pSetupStringTableAddString(StringTable, szLocalDeviceID, 1);
        if (*pdnDevInst == 0)
            ret = CR_NO_SUCH_DEVNODE;
    }
 
    return ret;
}

Referenced by CM_Create_DevNode_ExA(), and CM_Create_DevNodeW().

CM_Create_DevNodeA()

CONFIGRET WINAPI CM_Create_DevNodeA	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINSTID_A	pDeviceID,
		_In_ DEVINST	dnParent,
		_In_ ULONG	ulFlags
	)

Definition at line 1310 of file cfgmgr.c.

{
    TRACE("CM_Create_DevNodeA(%p %s %p %lx)\n",
          pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags);
 
    return CM_Create_DevNode_ExA(pdnDevInst, pDeviceID, dnParent,
                                 ulFlags, NULL);
}

CM_Create_DevNodeW()

CONFIGRET WINAPI CM_Create_DevNodeW	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINSTID_W	pDeviceID,
		_In_ DEVINST	dnParent,
		_In_ ULONG	ulFlags
	)

Definition at line 1329 of file cfgmgr.c.

{
    TRACE("CM_Create_DevNodeW(%p %s %p %lx)\n",
          pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags);
 
    return CM_Create_DevNode_ExW(pdnDevInst, pDeviceID, dnParent,
                                 ulFlags, NULL);
}

CM_Create_Range_List()

CONFIGRET WINAPI CM_Create_Range_List	(	_Out_ PRANGE_LIST	prlh,
		_In_ ULONG	ulFlags
	)

Definition at line 1463 of file cfgmgr.c.

{
    PINTERNAL_RANGE_LIST pRangeList = NULL;
 
    FIXME("CM_Create_Range_List(%p %lx)\n",
          prlh, ulFlags);
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (prlh == NULL)
        return CR_INVALID_POINTER;
 
    /* Allocate the range list */
    pRangeList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(INTERNAL_RANGE_LIST));
    if (pRangeList == NULL)
        return CR_OUT_OF_MEMORY;
 
    /* Set the magic value */
    pRangeList->ulMagic = RANGE_LIST_MAGIC;
 
    /* Initialize the mutex for synchonized access */
    pRangeList->hMutex = CreateMutex(NULL, FALSE, NULL);
    if (pRangeList->hMutex == NULL)
    {
        HeapFree(GetProcessHeap(), 0, pRangeList);
        return CR_FAILURE;
    }
 
    InitializeListHead(&pRangeList->ListHead);
 
    *prlh = (RANGE_LIST)pRangeList;
 
    return CR_SUCCESS;
}

CM_Delete_Class_Key()

CONFIGRET WINAPI CM_Delete_Class_Key	(	_In_ LPGUID	ClassGuid,
		_In_ ULONG	ulFlags
	)

Definition at line 1507 of file cfgmgr.c.

{
    TRACE("CM_Delete_Class_Key(%p %lx)\n",
          ClassGuid, ulFlags);
 
    return CM_Delete_Class_Key_Ex(ClassGuid, ulFlags, NULL);
}

CM_Delete_Class_Key_Ex()

CONFIGRET WINAPI CM_Delete_Class_Key_Ex	(	_In_ LPGUID	ClassGuid,
		_In_ ULONG	ulFlags,
		_In_opt_ HANDLE	hMachine
	)

Definition at line 1523 of file cfgmgr.c.

{
    WCHAR szGuidString[MAX_GUID_STRING_LEN];
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret;
 
    TRACE("CM_Delete_Class_Key_Ex(%p %lx %p)\n",
          ClassGuid, ulFlags, hMachine);
 
    if (ClassGuid == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_DELETE_CLASS_BITS)
        return CR_INVALID_FLAG;
 
    if (!GuidToString(ClassGuid, szGuidString))
        return CR_INVALID_DATA;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    RpcTryExcept
    {
        ret = PNP_DeleteClassKey(BindingHandle,
                                 szGuidString,
                                 ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Delete_Class_Key().

CM_Delete_DevNode_Key()

CONFIGRET WINAPI CM_Delete_DevNode_Key	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulHardwareProfile,
		_In_ ULONG	ulFlags
	)

Definition at line 1577 of file cfgmgr.c.

{
    TRACE("CM_Delete_DevNode_Key(%p %lu %lx)\n",
          dnDevInst, ulHardwareProfile, ulFlags);
 
    return CM_Delete_DevNode_Key_Ex(dnDevInst, ulHardwareProfile, ulFlags,
                                    NULL);
}

CM_Delete_DevNode_Key_Ex()

CONFIGRET WINAPI CM_Delete_DevNode_Key_Ex	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulHardwareProfile,
		_In_ ULONG	ulFlags,
		_In_opt_ HANDLE	hMachine
	)

Definition at line 1595 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    PWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
    CONFIGRET ret;
 
    FIXME("CM_Delete_DevNode_Key_Ex(%p %lu %lx %p)\n",
          dnDevInst, ulHardwareProfile, ulFlags, hMachine);
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags & ~CM_REGISTRY_BITS)
        return CR_INVALID_FLAG;
 
    if ((ulFlags & CM_REGISTRY_USER) && (ulFlags & CM_REGISTRY_CONFIG))
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (pszDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    TRACE("pszDevInst: %S\n", pszDevInst);
 
    pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
    if (pszKeyPath == NULL)
    {
        ret = CR_OUT_OF_MEMORY;
        goto done;
    }
 
    pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
    if (pszInstancePath == NULL)
    {
        ret = CR_OUT_OF_MEMORY;
        goto done;
    }
 
    ret = GetDeviceInstanceKeyPath(BindingHandle,
                                   pszDevInst,
                                   pszKeyPath,
                                   pszInstancePath,
                                   ulHardwareProfile,
                                   ulFlags);
    if (ret != CR_SUCCESS)
        goto done;
 
    TRACE("pszKeyPath: %S\n", pszKeyPath);
    TRACE("pszInstancePath: %S\n", pszInstancePath);
 
    if (ulFlags & CM_REGISTRY_USER)
    {
        FIXME("The CM_REGISTRY_USER flag is not supported yet!\n");
    }
    else
    {
#if 0
        if (!pSetupIsUserAdmin())
        {
            ret = CR_ACCESS_DENIED;
            goto done;
        }
#endif
 
        if (!(ulFlags & CM_REGISTRY_CONFIG))
            ulHardwareProfile = 0;
 
        RpcTryExcept
        {
            ret = PNP_DeleteRegistryKey(BindingHandle,
                                        pszDevInst,
                                        pszKeyPath,
                                        pszInstancePath,
                                        ulHardwareProfile);
        }
        RpcExcept(EXCEPTION_EXECUTE_HANDLER)
        {
            ret = RpcStatusToCmStatus(RpcExceptionCode());
        }
        RpcEndExcept;
    }
 
done:
    if (pszInstancePath != NULL)
        MyFree(pszInstancePath);
 
    if (pszKeyPath != NULL)
        MyFree(pszKeyPath);
 
    return ret;
}

Referenced by CM_Delete_DevNode_Key().

CM_Delete_Range()

CONFIGRET WINAPI CM_Delete_Range	(	_In_ DWORDLONG	ullStartValue,
		_In_ DWORDLONG	ullEndValue,
		_In_ RANGE_LIST	rlh,
		_In_ ULONG	ulFlags
	)

Definition at line 1714 of file cfgmgr.c.

{
    FIXME("CM_Delete_Range(%I64u %I64u %p %lx)\n",
          ullStartValue, ullEndValue, rlh, ulFlags);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

CM_Detect_Resource_Conflict()

CONFIGRET WINAPI CM_Detect_Resource_Conflict	(	_In_ DEVINST	dnDevInst,
		_In_ RESOURCEID	ResourceID,
		_In_reads_bytes_(ResourceLen) PCVOID	ResourceData,
		_In_ ULONG	ResourceLen,
		_Out_ PBOOL	pbConflictDetected,
		_In_ ULONG	ulFlags
	)

Definition at line 1732 of file cfgmgr.c.

{
    TRACE("CM_Detect_Resource_Conflict(%p %lu %p %lu %p 0x%lx)\n",
          dnDevInst, ResourceID, ResourceData, ResourceLen,
          pbConflictDetected, ulFlags);
 
    return CM_Detect_Resource_Conflict_Ex(dnDevInst,
                                          ResourceID,
                                          ResourceData,
                                          ResourceLen,
                                          pbConflictDetected,
                                          ulFlags,
                                          NULL);
}

CM_Detect_Resource_Conflict_Ex()

CONFIGRET WINAPI CM_Detect_Resource_Conflict_Ex	(	_In_ DEVINST	dnDevInst,
		_In_ RESOURCEID	ResourceID,
		_In_reads_bytes_(ResourceLen) PCVOID	ResourceData,
		_In_ ULONG	ResourceLen,
		_Out_ PBOOL	pbConflictDetected,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1759 of file cfgmgr.c.

{
    FIXME("CM_Detect_Resource_Conflict_Ex(%p %lu %p %lu %p 0x%lx %p)\n",
          dnDevInst, ResourceID, ResourceData, ResourceLen,
          pbConflictDetected, ulFlags, hMachine);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Detect_Resource_Conflict().

CM_Disable_DevNode()

CONFIGRET WINAPI CM_Disable_DevNode	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags
	)

Definition at line 1781 of file cfgmgr.c.

{
    TRACE("CM_Disable_DevNode(%p %lx)\n",
          dnDevInst, ulFlags);
 
    return CM_Disable_DevNode_Ex(dnDevInst, ulFlags, NULL);
}

CM_Disable_DevNode_Ex()

CONFIGRET WINAPI CM_Disable_DevNode_Ex	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1797 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    CONFIGRET ret;
 
    TRACE("CM_Disable_DevNode_Ex(%p %lx %p)\n",
          dnDevInst, ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_DisableDevInst(BindingHandle,
                                 lpDevInst,
                                 NULL,
                                 NULL,
                                 0,
                                 ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Disable_DevNode(), and StopDevice().

CM_Disconnect_Machine()

CONFIGRET WINAPI CM_Disconnect_Machine

(

_In_opt_ HMACHINE

hMachine

)

Definition at line 1863 of file cfgmgr.c.

{
    PMACHINE_INFO pMachine;
 
    TRACE("CM_Disconnect_Machine(%p)\n", hMachine);
 
    pMachine = (PMACHINE_INFO)hMachine;
    if (pMachine == NULL)
        return CR_SUCCESS;
 
    if (pMachine->bLocal == FALSE)
    {
        if (pMachine->StringTable != NULL)
            pSetupStringTableDestroy(pMachine->StringTable);
 
        if (!PnpUnbindRpc(pMachine->BindingHandle))
            return CR_ACCESS_DENIED;
    }
 
    HeapFree(GetProcessHeap(), 0, pMachine);
 
    return CR_SUCCESS;
}

Referenced by DestroyDeviceInfoSet(), DeviceProblemWizardW(), DisplayDeviceAdvancedProperties(), and SetupDiBuildClassInfoListExW().

CM_Dup_Range_List()

CONFIGRET WINAPI CM_Dup_Range_List	(	_In_ RANGE_LIST	rlhOld,
		_In_ RANGE_LIST	rlhNew,
		_In_ ULONG	ulFlags
	)

Definition at line 1894 of file cfgmgr.c.

{
    FIXME("CM_Dup_Range_List(%p %p %lx)\n",
          rlhOld, rlhNew, ulFlags);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

CM_Enable_DevNode()

CONFIGRET WINAPI CM_Enable_DevNode	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags
	)

Definition at line 1911 of file cfgmgr.c.

{
    TRACE("CM_Enable_DevNode(%p %lx)\n",
          dnDevInst, ulFlags);
 
    return CM_Enable_DevNode_Ex(dnDevInst, ulFlags, NULL);
}

CM_Enable_DevNode_Ex()

CONFIGRET WINAPI CM_Enable_DevNode_Ex	(	_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 1927 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    CONFIGRET ret;
 
    TRACE("CM_Enable_DevNode_Ex(%p %lx %p)\n",
          dnDevInst, ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_DeviceInstanceAction(BindingHandle,
                                       PNP_DEVINST_ENABLE,
                                       ulFlags,
                                       lpDevInst,
                                       NULL);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Enable_DevNode(), ResetDevice(), and SetupDiRestartDevices().

CM_Enumerate_Classes()

CONFIGRET WINAPI CM_Enumerate_Classes	(	_In_ ULONG	ulClassIndex,
		_Out_ LPGUID	ClassGuid,
		_In_ ULONG	ulFlags
	)

Definition at line 1992 of file cfgmgr.c.

{
    TRACE("CM_Enumerate_Classes(%lx %p %lx)\n",
          ulClassIndex, ClassGuid, ulFlags);
 
    return CM_Enumerate_Classes_Ex(ulClassIndex, ClassGuid, ulFlags, NULL);
}

Referenced by EnumDeviceClasses(), and CDeviceView::GetNextClass().

CM_Enumerate_Classes_Ex()

CONFIGRET WINAPI CM_Enumerate_Classes_Ex	(	_In_ ULONG	ulClassIndex,
		_Out_ LPGUID	ClassGuid,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2009 of file cfgmgr.c.

{
    WCHAR szBuffer[MAX_GUID_STRING_LEN];
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret = CR_SUCCESS;
    ULONG ulLength = MAX_GUID_STRING_LEN;
 
    TRACE("CM_Enumerate_Classes_Ex(%lx %p %lx %p)\n",
          ulClassIndex, ClassGuid, ulFlags, hMachine);
 
    if (ClassGuid == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    RpcTryExcept
    {
        ret = PNP_EnumerateSubKeys(BindingHandle,
                                   PNP_CLASS_SUBKEYS,
                                   ulClassIndex,
                                   szBuffer,
                                   MAX_GUID_STRING_LEN,
                                   &ulLength,
                                   ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (ret == CR_SUCCESS)
    {
        /* Remove the {} */
        szBuffer[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
 
        /* Convert the buffer to a GUID */
        if (UuidFromStringW(&szBuffer[1], ClassGuid) != RPC_S_OK)
            return CR_FAILURE;
    }
 
    return ret;
}

Referenced by CM_Enumerate_Classes(), and SetupDiBuildClassInfoListExW().

CM_Enumerate_Enumerators_ExA()

CONFIGRET WINAPI CM_Enumerate_Enumerators_ExA	(	_In_ ULONG	ulEnumIndex,
		_Out_writes_ *pulLength PCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2114 of file cfgmgr.c.

{
    WCHAR szBuffer[MAX_DEVICE_ID_LEN];
    ULONG ulOrigLength;
    ULONG ulLength;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Enumerate_Enumerators_ExA(%lu %p %p %lx %p)\n",
          ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
 
    if (Buffer == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    ulOrigLength = *pulLength;
    *pulLength = 0;
 
    ulLength = MAX_DEVICE_ID_LEN;
    ret = CM_Enumerate_Enumerators_ExW(ulEnumIndex, szBuffer, &ulLength,
                                       ulFlags, hMachine);
    if (ret == CR_SUCCESS)
    {
        if (WideCharToMultiByte(CP_ACP,
                                0,
                                szBuffer,
                                ulLength,
                                Buffer,
                                ulOrigLength,
                                NULL,
                                NULL) == 0)
            ret = CR_FAILURE;
        else
            *pulLength = lstrlenA(Buffer) + 1;
    }
 
    return ret;
}

Referenced by CM_Enumerate_EnumeratorsA().

CM_Enumerate_Enumerators_ExW()

CONFIGRET WINAPI CM_Enumerate_Enumerators_ExW	(	_In_ ULONG	ulEnumIndex,
		_Out_writes_ *pulLength PWCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2165 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret;
 
    TRACE("CM_Enumerate_Enumerators_ExW(%lu %p %p %lx %p)\n",
          ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
 
    if (Buffer == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    *Buffer = UNICODE_NULL;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    RpcTryExcept
    {
        ret = PNP_EnumerateSubKeys(BindingHandle,
                                   PNP_ENUMERATOR_SUBKEYS,
                                   ulEnumIndex,
                                   Buffer,
                                   *pulLength,
                                   pulLength,
                                   ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Enumerate_Enumerators_ExA(), and CM_Enumerate_EnumeratorsW().

CM_Enumerate_EnumeratorsA()

CONFIGRET WINAPI CM_Enumerate_EnumeratorsA	(	_In_ ULONG	ulEnumIndex,
		_Out_writes_ *pulLength PCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2076 of file cfgmgr.c.

{
    TRACE("CM_Enumerate_EnumeratorsA(%lu %p %p %lx)\n",
          ulEnumIndex, Buffer, pulLength, ulFlags);
 
    return CM_Enumerate_Enumerators_ExA(ulEnumIndex, Buffer, pulLength,
                                        ulFlags, NULL);
}

CM_Enumerate_EnumeratorsW()

CONFIGRET WINAPI CM_Enumerate_EnumeratorsW	(	_In_ ULONG	ulEnumIndex,
		_Out_writes_ *pulLength PWCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2095 of file cfgmgr.c.

{
    TRACE("CM_Enumerate_EnumeratorsW(%lu %p %p %lx)\n",
          ulEnumIndex, Buffer, pulLength, ulFlags);
 
    return CM_Enumerate_Enumerators_ExW(ulEnumIndex, Buffer, pulLength,
                                        ulFlags, NULL);
}

CM_Find_Range()

CONFIGRET WINAPI CM_Find_Range	(	_Out_ PDWORDLONG	pullStart,
		_In_ DWORDLONG	ullStart,
		_In_ ULONG	ulLength,
		_In_ DWORDLONG	ullAlignment,
		_In_ DWORDLONG	ullEnd,
		_In_ RANGE_LIST	rlh,
		_In_ ULONG	ulFlags
	)

Definition at line 2223 of file cfgmgr.c.

{
    FIXME("CM_Find_Range(%p %I64u %lu %I64u %I64u %p %lx)\n",
          pullStart, ullStart, ulLength, ullAlignment, ullEnd, rlh, ulFlags);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

CM_First_Range()

CONFIGRET WINAPI CM_First_Range	(	_In_ RANGE_LIST	rlh,
		_Out_ PDWORDLONG	pullStart,
		_Out_ PDWORDLONG	pullEnd,
		_Out_ PRANGE_ELEMENT	preElement,
		_In_ ULONG	ulFlags
	)

Definition at line 2244 of file cfgmgr.c.

{
    PINTERNAL_RANGE_LIST pRangeList;
    PINTERNAL_RANGE pRange;
    PLIST_ENTRY ListEntry;
    CONFIGRET ret = CR_SUCCESS;
 
    FIXME("CM_First_Range(%p %p %p %p %lx)\n",
          rlh, pullStart, pullEnd, preElement, ulFlags);
 
    pRangeList = (PINTERNAL_RANGE_LIST)rlh;
 
    if (!IsValidRangeList(pRangeList))
        return CR_INVALID_RANGE_LIST;
 
    if (pullStart == NULL || pullEnd == NULL || preElement == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    /* Lock the range list */
    WaitForSingleObject(pRangeList->hMutex, INFINITE);
 
    /* Fail, if the list is empty */
    if (IsListEmpty(&pRangeList->ListHead))
    {
        ret = CR_FAILURE;
        goto done;
    }
 
    /* Get the first range */
    ListEntry = pRangeList->ListHead.Flink;
    pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
 
    /* Return the range data */
    *pullStart = pRange->ullStart;
    *pullEnd = pRange->ullEnd;
    *preElement = (RANGE_ELEMENT)pRange;
 
done:
    /* Unlock the range list */
    ReleaseMutex(pRangeList->hMutex);
 
    return ret;
}

CM_Free_Log_Conf()

CONFIGRET WINAPI CM_Free_Log_Conf	(	_In_ LOG_CONF	lcLogConfToBeFreed,
		_In_ ULONG	ulFlags
	)

Definition at line 2302 of file cfgmgr.c.

{
    TRACE("CM_Free_Log_Conf(%lx %lx)\n",
          lcLogConfToBeFreed, ulFlags);
 
    return CM_Free_Log_Conf_Ex(lcLogConfToBeFreed, ulFlags, NULL);
}

CM_Free_Log_Conf_Ex()

CONFIGRET WINAPI CM_Free_Log_Conf_Ex	(	_In_ LOG_CONF	lcLogConfToBeFreed,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2318 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    PLOG_CONF_INFO pLogConfInfo;
    CONFIGRET ret;
 
    TRACE("CM_Free_Log_Conf_Ex(%lx %lx %p)\n",
          lcLogConfToBeFreed, ulFlags, hMachine);
 
    if (!pSetupIsUserAdmin())
        return CR_ACCESS_DENIED;
 
    pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
    if (!IsValidLogConf(pLogConfInfo))
        return CR_INVALID_LOG_CONF;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_FreeLogConf(BindingHandle,
                              lpDevInst,
                              pLogConfInfo->ulType,
                              pLogConfInfo->ulTag,
                              0);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Free_Log_Conf().

CM_Free_Log_Conf_Handle()

CONFIGRET WINAPI CM_Free_Log_Conf_Handle

(

_In_ LOG_CONF

lcLogConf

)

Definition at line 2385 of file cfgmgr.c.

{
    PLOG_CONF_INFO pLogConfInfo;
 
    TRACE("CM_Free_Log_Conf_Handle(%lx)\n", lcLogConf);
 
    pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
    if (!IsValidLogConf(pLogConfInfo))
        return CR_INVALID_LOG_CONF;
 
    HeapFree(GetProcessHeap(), 0, pLogConfInfo);
 
    return CR_SUCCESS;
}

CM_Free_Range_List()

CONFIGRET WINAPI CM_Free_Range_List	(	_In_ RANGE_LIST	RangeList,
		_In_ ULONG	ulFlags
	)

Definition at line 2407 of file cfgmgr.c.

{
    PINTERNAL_RANGE_LIST pRangeList;
    PINTERNAL_RANGE pRange;
    PLIST_ENTRY ListEntry;
 
    FIXME("CM_Free_Range_List(%p %lx)\n",
          RangeList, ulFlags);
 
    pRangeList = (PINTERNAL_RANGE_LIST)RangeList;
 
    if (!IsValidRangeList(pRangeList))
        return CR_INVALID_RANGE_LIST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    /* Lock the range list */
    WaitForSingleObject(pRangeList->hMutex, INFINITE);
 
    /* Free the list of ranges */
    while (!IsListEmpty(&pRangeList->ListHead))
    {
        ListEntry = RemoveHeadList(&pRangeList->ListHead);
        pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
        HeapFree(GetProcessHeap(), 0, pRange);
    }
 
    /* Unlock the range list */
    ReleaseMutex(pRangeList->hMutex);
 
    /* Close the mutex */
    CloseHandle(pRangeList->hMutex);
 
    /* Free the range list */
    HeapFree(GetProcessHeap(), 0, pRangeList);
 
    return CR_SUCCESS;
}

CM_Free_Res_Des()

CONFIGRET WINAPI CM_Free_Res_Des	(	_Out_ PRES_DES	prdResDes,
		_In_ RES_DES	rdResDes,
		_In_ ULONG	ulFlags
	)

Definition at line 2455 of file cfgmgr.c.

{
    TRACE("CM_Free_Res_Des(%p %p %lx)\n",
          prdResDes, rdResDes, ulFlags);
 
    return CM_Free_Res_Des_Ex(prdResDes, rdResDes, ulFlags, NULL);
}

CM_Free_Res_Des_Ex()

CONFIGRET WINAPI CM_Free_Res_Des_Ex	(	_Out_ PRES_DES	prdResDes,
		_In_ RES_DES	rdResDes,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2472 of file cfgmgr.c.

{
    FIXME("CM_Free_Res_Des_Ex(%p %p %lx %p)\n",
          prdResDes, rdResDes, ulFlags, hMachine);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Free_Res_Des().

CM_Free_Res_Des_Handle()

CONFIGRET WINAPI CM_Free_Res_Des_Handle

(

_In_ RES_DES

rdResDes

)

Definition at line 2490 of file cfgmgr.c.

{
    FIXME("CM_Free_Res_Des_Handle(%p)\n", rdResDes);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

CM_Free_Resource_Conflict_Handle()

CONFIGRET WINAPI CM_Free_Resource_Conflict_Handle

(

_In_ CONFLICT_LIST

clConflictList

)

Definition at line 2504 of file cfgmgr.c.

{
    PCONFLICT_DATA pConflictData;
 
    FIXME("CM_Free_Resource_Conflict_Handle(%p)\n",
          clConflictList);
 
    pConflictData = (PCONFLICT_DATA)clConflictList;
    if (!IsValidConflictData(pConflictData))
        return CR_INVALID_CONFLICT_LIST;
 
    if (pConflictData->pConflictList != NULL)
        MyFree(pConflictData->pConflictList);
 
    MyFree(pConflictData);
 
    return CR_SUCCESS;
}

CM_Get_Child()

CONFIGRET WINAPI CM_Get_Child	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags
	)

Definition at line 2530 of file cfgmgr.c.

{
    TRACE("CM_Get_Child(%p %p %lx)\n",
          pdnDevInst, dnDevInst, ulFlags);
 
    return CM_Get_Child_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
}

Referenced by CfmListRecursiveInsertSubDevices(), DevTreeRecursiveInsertSubDevices(), CDeviceView::GetChildDevice(), and GetMonitorDevInstID().

CM_Get_Child_Ex()

CONFIGRET WINAPI CM_Get_Child_Ex	(	_Out_ PDEVINST	pdnDevInst,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2547 of file cfgmgr.c.

{
    WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
    CONFIGRET ret;
 
    TRACE("CM_Get_Child_Ex(%p %lx %lx %p)\n",
          pdnDevInst, dnDevInst, ulFlags, hMachine);
 
    if (pdnDevInst == NULL)
        return CR_INVALID_POINTER;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    *pdnDevInst = -1;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_GetRelatedDeviceInstance(BindingHandle,
                                           PNP_GET_CHILD_DEVICE_INSTANCE,
                                           lpDevInst,
                                           szRelatedDevInst,
                                           &dwLength,
                                           0);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (ret != CR_SUCCESS)
        return ret;
 
    TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
 
    dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
    if (dwIndex == -1)
        return CR_FAILURE;
 
    *pdnDevInst = dwIndex;
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Child().

CM_Get_Class_Key_Name_ExA()

CONFIGRET WINAPI CM_Get_Class_Key_Name_ExA	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength LPSTR	pszKeyName,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2667 of file cfgmgr.c.

{
    WCHAR szBuffer[MAX_GUID_STRING_LEN];
    CONFIGRET ret = CR_SUCCESS;
    ULONG ulLength;
    ULONG ulOrigLength;
 
    TRACE("CM_Get_Class_Key_Name_ExA(%p %p %p %lx %p)\n",
          ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
 
    if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    ulOrigLength = *pulLength;
    *pulLength = 0;
 
    ulLength = MAX_GUID_STRING_LEN;
    ret = CM_Get_Class_Key_Name_ExW(ClassGuid, szBuffer, &ulLength,
                                    ulFlags, hMachine);
    if (ret == CR_SUCCESS)
    {
        if (WideCharToMultiByte(CP_ACP,
                                0,
                                szBuffer,
                                ulLength,
                                pszKeyName,
                                ulOrigLength,
                                NULL,
                                NULL) == 0)
            ret = CR_FAILURE;
        else
            *pulLength = lstrlenA(pszKeyName) + 1;
    }
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Class_Key_NameA().

CM_Get_Class_Key_Name_ExW()

CONFIGRET WINAPI CM_Get_Class_Key_Name_ExW	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength LPWSTR	pszKeyName,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2715 of file cfgmgr.c.

{
    TRACE("CM_Get_Class_Key_Name_ExW(%p %p %p %lx %p)\n",
          ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
 
    if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (*pulLength < MAX_GUID_STRING_LEN)
    {
        *pulLength = 0;
        return CR_BUFFER_SMALL;
    }
 
    if (!GuidToString(ClassGuid, pszKeyName))
        return CR_INVALID_DATA;
 
    *pulLength = MAX_GUID_STRING_LEN;
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Class_Key_Name_ExA(), and CM_Get_Class_Key_NameW().

CM_Get_Class_Key_NameA()

CONFIGRET WINAPI CM_Get_Class_Key_NameA	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength LPSTR	pszKeyName,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2629 of file cfgmgr.c.

{
    TRACE("CM_Get_Class_Key_NameA(%p %p %p %lx)\n",
          ClassGuid, pszKeyName, pulLength, ulFlags);
 
    return CM_Get_Class_Key_Name_ExA(ClassGuid, pszKeyName, pulLength,
                                     ulFlags, NULL);
}

CM_Get_Class_Key_NameW()

CONFIGRET WINAPI CM_Get_Class_Key_NameW	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength LPWSTR	pszKeyName,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2648 of file cfgmgr.c.

{
    TRACE("CM_Get_Class_Key_NameW(%p %p %p %lx)\n",
          ClassGuid, pszKeyName, pulLength, ulFlags);
 
    return CM_Get_Class_Key_Name_ExW(ClassGuid, pszKeyName, pulLength,
                                     ulFlags, NULL);
}

CM_Get_Class_Name_ExA()

CONFIGRET WINAPI CM_Get_Class_Name_ExA	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength PCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2789 of file cfgmgr.c.

{
    WCHAR szBuffer[MAX_CLASS_NAME_LEN];
    CONFIGRET ret = CR_SUCCESS;
    ULONG ulLength;
    ULONG ulOrigLength;
 
    TRACE("CM_Get_Class_Name_ExA(%p %p %p %lx %p)\n",
          ClassGuid, Buffer, pulLength, ulFlags, hMachine);
 
    if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    ulOrigLength = *pulLength;
    *pulLength = 0;
 
    ulLength = MAX_CLASS_NAME_LEN;
    ret = CM_Get_Class_Name_ExW(ClassGuid, szBuffer, &ulLength,
                                ulFlags, hMachine);
    if (ret == CR_SUCCESS)
    {
        if (WideCharToMultiByte(CP_ACP,
                                0,
                                szBuffer,
                                ulLength,
                                Buffer,
                                ulOrigLength,
                                NULL,
                                NULL) == 0)
            ret = CR_FAILURE;
        else
            *pulLength = lstrlenA(Buffer) + 1;
    }
 
    return ret;
}

Referenced by CM_Get_Class_NameA().

CM_Get_Class_Name_ExW()

CONFIGRET WINAPI CM_Get_Class_Name_ExW	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength PWCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 2837 of file cfgmgr.c.

{
    WCHAR szGuidString[MAX_GUID_STRING_LEN];
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret;
 
    TRACE("CM_Get_Class_Name_ExW(%p %p %p %lx %p\n",
          ClassGuid, Buffer, pulLength, ulFlags, hMachine);
 
    if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (!GuidToString(ClassGuid, szGuidString))
        return CR_INVALID_DATA;
 
    TRACE("Guid %s\n", debugstr_w(szGuidString));
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    RpcTryExcept
    {
        ret = PNP_GetClassName(BindingHandle,
                               szGuidString,
                               Buffer,
                               pulLength,
                               ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Class_Name_ExA(), and CM_Get_Class_NameW().

CM_Get_Class_NameA()

CONFIGRET WINAPI CM_Get_Class_NameA	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength PCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2751 of file cfgmgr.c.

{
    TRACE("CM_Get_Class_NameA(%p %p %p %lx)\n",
          ClassGuid, Buffer, pulLength, ulFlags);
 
    return CM_Get_Class_Name_ExA(ClassGuid, Buffer, pulLength, ulFlags,
                                 NULL);
}

CM_Get_Class_NameW()

CONFIGRET WINAPI CM_Get_Class_NameW	(	_In_ LPGUID	ClassGuid,
		_Out_writes_opt_ *pulLength PWCHAR	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 2770 of file cfgmgr.c.

{
    TRACE("CM_Get_Class_NameW(%p %p %p %lx)\n",
          ClassGuid, Buffer, pulLength, ulFlags);
 
    return CM_Get_Class_Name_ExW(ClassGuid, Buffer, pulLength, ulFlags,
                                 NULL);
}

CM_Get_Class_Registry_PropertyA()

CONFIGRET WINAPI CM_Get_Class_Registry_PropertyA	(	LPGUID	ClassGuid,
		ULONG	ulProperty,
		PULONG	pulRegDataType,
		PVOID	Buffer,
		PULONG	pulLength,
		ULONG	ulFlags,
		HMACHINE	hMachine
	)

Definition at line 2897 of file cfgmgr.c.

{
    PWSTR BufferW = NULL;
    ULONG ulLength = 0;
    ULONG ulType;
    CONFIGRET ret;
 
    TRACE("CM_Get_Class_Registry_PropertyA(%p %lu %p %p %p %lx %p)\n",
          ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
          ulFlags, hMachine);
 
    if (pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
        return CR_INVALID_PROPERTY;
 
    ulType = GetRegistryPropertyType(ulProperty);
    if (ulType == REG_SZ || ulType == REG_MULTI_SZ)
    {
        /* Get the required buffer size */
        ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
                                              NULL, &ulLength, ulFlags, hMachine);
        if (ret != CR_BUFFER_SMALL)
            return ret;
 
        /* Allocate the unicode buffer */
        BufferW = HeapAlloc(GetProcessHeap(), 0, ulLength);
        if (BufferW == NULL)
            return CR_OUT_OF_MEMORY;
 
        /* Get the property */
        ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
                                              BufferW, &ulLength, ulFlags, hMachine);
        if (ret != CR_SUCCESS)
        {
            HeapFree(GetProcessHeap(), 0, BufferW);
            return ret;
        }
 
        /* Do W->A conversion */
        *pulLength = WideCharToMultiByte(CP_ACP,
                                         0,
                                         BufferW,
                                         ulLength,
                                         Buffer,
                                         *pulLength,
                                         NULL,
                                         NULL);
 
        /* Release the unicode buffer */
        HeapFree(GetProcessHeap(), 0, BufferW);
 
        if (*pulLength == 0)
            ret = CR_FAILURE;
    }
    else
    {
        /* Get the property */
        ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
                                              Buffer, pulLength, ulFlags, hMachine);
    }
 
    return ret;
}

CM_Get_Class_Registry_PropertyW()

CONFIGRET WINAPI CM_Get_Class_Registry_PropertyW	(	LPGUID	ClassGuid,
		ULONG	ulProperty,
		PULONG	pulRegDataType,
		PVOID	Buffer,
		PULONG	pulLength,
		ULONG	ulFlags,
		HMACHINE	hMachine
	)

Definition at line 2976 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
    ULONG ulType = 0;
    ULONG ulTransferLength = 0;
    CONFIGRET ret;
 
    TRACE("CM_Get_Class_Registry_PropertyW(%p %lu %p %p %p %lx %p)\n",
          ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
          ulFlags, hMachine);
 
    if (ClassGuid == NULL || pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (pSetupStringFromGuid(ClassGuid,
                             szGuidString,
                             PNP_MAX_GUID_STRING_LEN) != 0)
        return CR_INVALID_DATA;
 
    if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
        return CR_INVALID_PROPERTY;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    ulTransferLength = *pulLength;
 
    RpcTryExcept
    {
        ret = PNP_GetClassRegProp(BindingHandle,
                                  szGuidString,
                                  ulProperty,
                                  &ulType,
                                  Buffer,
                                  &ulTransferLength,
                                  pulLength,
                                  ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (ret == CR_SUCCESS)
    {
        if (pulRegDataType != NULL)
            *pulRegDataType = ulType;
    }
 
    return ret;
}

Referenced by CM_Get_Class_Registry_PropertyA().

CM_Get_Depth()

CONFIGRET WINAPI CM_Get_Depth	(	_Out_ PULONG	pulDepth,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags
	)

Definition at line 3055 of file cfgmgr.c.

{
    TRACE("CM_Get_Depth(%p %lx %lx)\n",
          pulDepth, dnDevInst, ulFlags);
 
    return CM_Get_Depth_Ex(pulDepth, dnDevInst, ulFlags, NULL);
}

CM_Get_Depth_Ex()

CONFIGRET WINAPI CM_Get_Depth_Ex	(	_Out_ PULONG	pulDepth,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3072 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    CONFIGRET ret;
 
    TRACE("CM_Get_Depth_Ex(%p %lx %lx %p)\n",
          pulDepth, dnDevInst, ulFlags, hMachine);
 
    if (pulDepth == NULL)
        return CR_INVALID_POINTER;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return CR_INVALID_DEVNODE;
 
    RpcTryExcept
    {
        ret = PNP_GetDepth(BindingHandle,
                           lpDevInst,
                           pulDepth,
                           ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Depth().

CM_Get_Device_ID_ExA()

CONFIGRET WINAPI CM_Get_Device_ID_ExA	(	_In_ DEVINST	dnDevInst,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3695 of file cfgmgr.c.

{
    WCHAR szBufferW[MAX_DEVICE_ID_LEN];
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_ID_ExA(%lx %p %lu %lx %p)\n",
          dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
 
    if (Buffer == NULL)
        return CR_INVALID_POINTER;
 
    ret = CM_Get_Device_ID_ExW(dnDevInst,
                               szBufferW,
                               MAX_DEVICE_ID_LEN,
                               ulFlags,
                               hMachine);
    if (ret == CR_SUCCESS)
    {
        if (WideCharToMultiByte(CP_ACP,
                                0,
                                szBufferW,
                                lstrlenW(szBufferW) + 1,
                                Buffer,
                                BufferLen,
                                NULL,
                                NULL) == 0)
            ret = CR_FAILURE;
    }
 
    return ret;
}

Referenced by CM_Get_Device_IDA().

CM_Get_Device_ID_ExW()

CONFIGRET WINAPI CM_Get_Device_ID_ExW	(	_In_ DEVINST	dnDevInst,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3738 of file cfgmgr.c.

{
    HSTRING_TABLE StringTable = NULL;
 
    TRACE("CM_Get_Device_ID_ExW(%lx %p %lu %lx %p)\n",
          dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (Buffer == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(NULL, &StringTable))
            return CR_FAILURE;
    }
 
    if (!pSetupStringTableStringFromIdEx(StringTable,
                                         dnDevInst,
                                         Buffer,
                                         &BufferLen))
        return CR_FAILURE;
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Device_ID_ExA(), and CM_Get_Device_IDW().

CM_Get_Device_ID_List_ExA()

CONFIGRET WINAPI CM_Get_Device_ID_List_ExA	(	_In_ PCSTR	pszFilter,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3824 of file cfgmgr.c.

{
    LPWSTR BufferW = NULL;
    LPWSTR pszFilterW = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_ID_List_ExA(%p %p %lu %lx %p)\n",
          pszFilter, Buffer, BufferLen, ulFlags, hMachine);
 
    BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
    if (BufferW == NULL)
        return CR_OUT_OF_MEMORY;
 
    if (pszFilter == NULL)
    {
        ret = CM_Get_Device_ID_List_ExW(NULL,
                                        BufferW,
                                        BufferLen,
                                        ulFlags,
                                        hMachine);
    }
    else
    {
        if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
        {
            ret = CR_INVALID_DEVICE_ID;
            goto Done;
        }
 
        ret = CM_Get_Device_ID_List_ExW(pszFilterW,
                                        BufferW,
                                        BufferLen,
                                        ulFlags,
                                        hMachine);
 
        MyFree(pszFilterW);
    }
 
    if (WideCharToMultiByte(CP_ACP,
                            0,
                            BufferW,
                            BufferLen,
                            Buffer,
                            BufferLen,
                            NULL,
                            NULL) == 0)
        ret = CR_FAILURE;
 
Done:
    MyFree(BufferW);
 
    return ret;
}

Referenced by CM_Get_Device_ID_ListA().

CM_Get_Device_ID_List_ExW()

CONFIGRET WINAPI CM_Get_Device_ID_List_ExW	(	_In_ PCWSTR	pszFilter,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3889 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret;
 
    TRACE("CM_Get_Device_ID_List_ExW(%p %p %lu %lx %p)\n",
          pszFilter, Buffer, BufferLen, ulFlags, hMachine);
 
    if (Buffer == NULL || BufferLen == 0)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    *Buffer = 0;
 
    RpcTryExcept
    {
        ret = PNP_GetDeviceList(BindingHandle,
                                (LPWSTR)pszFilter,
                                Buffer,
                                &BufferLen,
                                ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Device_ID_List_ExA(), CM_Get_Device_ID_ListW(), DisplayDeviceRelations(), and SETUP_CreateDevicesList().

CM_Get_Device_ID_List_Size_ExA()

CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExA	(	_Out_ PULONG	pulLen,
		_In_opt_ PCSTR	pszFilter,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3979 of file cfgmgr.c.

{
    LPWSTR pszFilterW = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    FIXME("CM_Get_Device_ID_List_Size_ExA(%p %s %lx %p)\n",
          pulLen, debugstr_a(pszFilter), ulFlags, hMachine);
 
    if (pszFilter == NULL)
    {
        ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
                                             NULL,
                                             ulFlags,
                                             hMachine);
    }
    else
    {
        if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
            return CR_INVALID_DEVICE_ID;
 
        ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
                                             pszFilterW,
                                             ulFlags,
                                             hMachine);
 
        MyFree(pszFilterW);
    }
 
    return ret;
}

Referenced by CM_Get_Device_ID_List_SizeA().

CM_Get_Device_ID_List_Size_ExW()

CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExW	(	_Out_ PULONG	pulLen,
		_In_opt_ PCWSTR	pszFilter,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4020 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret;
 
    FIXME("CM_Get_Device_ID_List_Size_ExW(%p %s %lx %p)\n",
          pulLen, debugstr_w(pszFilter), ulFlags, hMachine);
 
    if (pulLen == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    *pulLen = 0;
 
    RpcTryExcept
    {
        ret = PNP_GetDeviceListSize(BindingHandle,
                                    (LPWSTR)pszFilter,
                                    pulLen,
                                    ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Device_ID_List_Size_ExA(), CM_Get_Device_ID_List_SizeW(), and DisplayDeviceRelations().

CM_Get_Device_ID_List_SizeA()

CONFIGRET WINAPI CM_Get_Device_ID_List_SizeA	(	_Out_ PULONG	pulLen,
		_In_opt_ PCSTR	pszFilter,
		_In_ ULONG	ulFlags
	)

Definition at line 3945 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_ID_List_SizeA(%p %s %lx)\n",
          pulLen, debugstr_a(pszFilter), ulFlags);
 
    return CM_Get_Device_ID_List_Size_ExA(pulLen, pszFilter, ulFlags, NULL);
}

CM_Get_Device_ID_List_SizeW()

CONFIGRET WINAPI CM_Get_Device_ID_List_SizeW	(	_Out_ PULONG	pulLen,
		_In_opt_ PCWSTR	pszFilter,
		_In_ ULONG	ulFlags
	)

Definition at line 3962 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_ID_List_SizeW(%p %s %lx)\n",
          pulLen, debugstr_w(pszFilter), ulFlags);
 
    return CM_Get_Device_ID_List_Size_ExW(pulLen, pszFilter, ulFlags, NULL);
}

CM_Get_Device_ID_ListA()

CONFIGRET WINAPI CM_Get_Device_ID_ListA	(	_In_ PCSTR	pszFilter,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 3786 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_ID_ListA(%p %p %lu %lx)\n",
          pszFilter, Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_ID_List_ExA(pszFilter, Buffer, BufferLen,
                                     ulFlags, NULL);
}

CM_Get_Device_ID_ListW()

CONFIGRET WINAPI CM_Get_Device_ID_ListW	(	_In_ PCWSTR	pszFilter,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 3805 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_ID_ListW(%p %p %lu %lx)\n",
          pszFilter, Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_ID_List_ExW(pszFilter, Buffer, BufferLen,
                                     ulFlags, NULL);
}

CM_Get_Device_ID_Size()

CONFIGRET WINAPI CM_Get_Device_ID_Size	(	_Out_ PULONG	pulLen,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags
	)

Definition at line 4074 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_ID_Size(%p %lx %lx)\n",
          pulLen, dnDevInst, ulFlags);
 
    return CM_Get_Device_ID_Size_Ex(pulLen, dnDevInst, ulFlags, NULL);
}

Referenced by GetMonitorDevInstID(), CDeviceNode::SetupNode(), and ShowDeviceProperties().

CM_Get_Device_ID_Size_Ex()

CONFIGRET WINAPI CM_Get_Device_ID_Size_Ex	(	_Out_ PULONG	pulLen,
		_In_ DEVINST	dnDevInst,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4091 of file cfgmgr.c.

{
    HSTRING_TABLE StringTable = NULL;
    LPWSTR DeviceId;
 
    TRACE("CM_Get_Device_ID_Size_Ex(%p %lx %lx %p)\n",
          pulLen, dnDevInst, ulFlags, hMachine);
 
    if (pulLen == NULL)
        return CR_INVALID_POINTER;
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVINST;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(NULL, &StringTable))
            return CR_FAILURE;
    }
 
    DeviceId = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (DeviceId == NULL)
    {
        *pulLen = 0;
        return CR_SUCCESS;
    }
 
    *pulLen = lstrlenW(DeviceId);
 
    return CR_SUCCESS;
}

Referenced by CM_Get_Device_ID_Size().

CM_Get_Device_IDA()

CONFIGRET WINAPI CM_Get_Device_IDA	(	_In_ DEVINST	dnDevInst,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 3659 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_IDA(%lx %p %lu %lx)\n",
          dnDevInst, Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_ID_ExA(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
}

Referenced by test_devnode().

CM_Get_Device_IDW()

CONFIGRET WINAPI CM_Get_Device_IDW	(	_In_ DEVINST	dnDevInst,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 3677 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_IDW(%lx %p %lu %lx)\n",
          dnDevInst, Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_ID_ExW(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
}

Referenced by CDeviceNode::SetupNode(), and ShowDeviceProperties().

CM_Get_Device_Interface_Alias_ExA()

CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExA	(	_In_ LPCSTR	pszDeviceInterface,
		_In_ LPGUID	AliasInterfaceGuid,
		_Out_writes_ *pulLength LPSTR	pszAliasDeviceInterface,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4186 of file cfgmgr.c.

{
    FIXME("CM_Get_Device_Interface_Alias_ExA(%p %p %p %p %lx %p)\n",
          pszDeviceInterface, AliasInterfaceGuid,
          pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
 
    return CR_CALL_NOT_IMPLEMENTED;
}

Referenced by CM_Get_Device_Interface_AliasA().

CM_Get_Device_Interface_Alias_ExW()

CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExW	(	_In_ LPCWSTR	pszDeviceInterface,
		_In_ LPGUID	AliasInterfaceGuid,
		_Out_writes_ *pulLength LPWSTR	pszAliasDeviceInterface,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4207 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    ULONG ulTransferLength;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_Interface_Alias_ExW(%p %p %p %p %lx %p)\n",
          pszDeviceInterface, AliasInterfaceGuid,
          pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
 
    if (pszDeviceInterface == NULL ||
        AliasInterfaceGuid == NULL ||
        pszAliasDeviceInterface == NULL ||
        pulLength == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags != 0)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    ulTransferLength = *pulLength;
 
    RpcTryExcept
    {
        ret = PNP_GetInterfaceDeviceAlias(BindingHandle,
                                          (LPWSTR)pszDeviceInterface,
                                          AliasInterfaceGuid,
                                          pszAliasDeviceInterface,
                                          pulLength,
                                          &ulTransferLength,
                                          0);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Device_Interface_AliasW().

CM_Get_Device_Interface_AliasA()

CONFIGRET WINAPI CM_Get_Device_Interface_AliasA	(	_In_ LPCSTR	pszDeviceInterface,
		_In_ LPGUID	AliasInterfaceGuid,
		_Out_writes_ *pulLength LPSTR	pszAliasDeviceInterface,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 4142 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_AliasA(%p %p %p %p %lx)\n",
          pszDeviceInterface, AliasInterfaceGuid,
          pszAliasDeviceInterface, pulLength, ulFlags);
 
    return CM_Get_Device_Interface_Alias_ExA(pszDeviceInterface,
        AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
        ulFlags, NULL);
}

CM_Get_Device_Interface_AliasW()

CONFIGRET WINAPI CM_Get_Device_Interface_AliasW	(	_In_ LPCWSTR	pszDeviceInterface,
		_In_ LPGUID	AliasInterfaceGuid,
		_Out_writes_ *pulLength LPWSTR	pszAliasDeviceInterface,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags
	)

Definition at line 4164 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_AliasW(%p %p %p %p %lx)\n",
          pszDeviceInterface, AliasInterfaceGuid,
          pszAliasDeviceInterface, pulLength, ulFlags);
 
    return CM_Get_Device_Interface_Alias_ExW(pszDeviceInterface,
        AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
        ulFlags, NULL);
}

CM_Get_Device_Interface_List_ExA()

CONFIGRET WINAPI CM_Get_Device_Interface_List_ExA	(	_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_A	pDeviceID,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4313 of file cfgmgr.c.

{
    DEVINSTID_W pDeviceIdW = NULL;
    PWCHAR BufferW = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_Interface_List_ExA(%s %s %p %lu 0x%08lx %p)\n",
          debugstr_guid(InterfaceClassGuid), debugstr_a(pDeviceID),
          Buffer, BufferLen, ulFlags, hMachine);
 
    if (Buffer == NULL ||
        BufferLen == 0)
        return CR_INVALID_POINTER;
 
    if (pDeviceID != NULL)
    {
        if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
            return CR_INVALID_DEVICE_ID;
    }
 
    BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
    if (BufferW == NULL)
    {
        ret = CR_OUT_OF_MEMORY;
        goto Done;
    }
 
    ret = CM_Get_Device_Interface_List_ExW(InterfaceClassGuid, pDeviceIdW,
                                           BufferW, BufferLen, ulFlags,
                                           hMachine);
    if (ret != CR_SUCCESS)
        goto Done;
 
    if (WideCharToMultiByte(CP_ACP,
                            0,
                            BufferW,
                            BufferLen,
                            Buffer,
                            BufferLen,
                            NULL,
                            NULL) == 0)
        ret = CR_FAILURE;
 
Done:
    if (BufferW != NULL)
        MyFree(BufferW);
 
    if (pDeviceIdW != NULL)
        MyFree(pDeviceIdW);
 
    return ret;
}

Referenced by CM_Get_Device_Interface_ListA().

CM_Get_Device_Interface_List_ExW()

CONFIGRET WINAPI CM_Get_Device_Interface_List_ExW	(	_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_W	pDeviceID,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4378 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    PNP_RPC_BUFFER_SIZE BufferSize = 0;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_Interface_List_ExW(%s %s %p %lu 0x%08lx %p)\n",
          debugstr_guid(InterfaceClassGuid), debugstr_w(pDeviceID),
          Buffer, BufferLen, ulFlags, hMachine);
 
    if (Buffer == NULL ||
        BufferLen == 0)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    *Buffer = 0;
    BufferSize = BufferLen;
 
    RpcTryExcept
    {
        ret = PNP_GetInterfaceDeviceList(BindingHandle,
                                         InterfaceClassGuid,
                                         pDeviceID,
                                         (LPBYTE)Buffer,
                                         &BufferSize,
                                         ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Device_Interface_List_ExA(), and CM_Get_Device_Interface_ListW().

CM_Get_Device_Interface_List_Size_ExA()

CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExA	(	_Out_ PULONG	pulLen,
		_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_A	pDeviceID,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4478 of file cfgmgr.c.

{
    DEVINSTID_W pDeviceIdW = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_Interface_List_Size_ExA(%p %p %s 0x%08lx %p)\n",
          pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags, hMachine);
 
    if (pulLen == NULL)
        return CR_INVALID_POINTER;
 
    if (pDeviceID != NULL)
    {
        if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
            return CR_INVALID_DEVICE_ID;
    }
 
    *pulLen = 0;
 
    ret = CM_Get_Device_Interface_List_Size_ExW(pulLen, InterfaceClassGuid,
                                                pDeviceIdW, ulFlags, hMachine);
 
    if (pDeviceIdW != NULL)
        MyFree(pDeviceIdW);
 
    return ret;
}

Referenced by CM_Get_Device_Interface_List_SizeA().

CM_Get_Device_Interface_List_Size_ExW()

CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExW	(	_Out_ PULONG	pulLen,
		_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_W	pDeviceID,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 4517 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_Device_Interface_List_Size_ExW(%p %p %s 0x%08lx %p)\n",
          pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags, hMachine);
 
    if (pulLen == NULL)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, NULL))
            return CR_FAILURE;
    }
 
    *pulLen = 0;
 
    RpcTryExcept
    {
        ret = PNP_GetInterfaceDeviceListSize(BindingHandle,
                                             pulLen,
                                             InterfaceClassGuid,
                                             pDeviceID,
                                             ulFlags);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = RpcStatusToCmStatus(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return ret;
}

Referenced by CM_Get_Device_Interface_List_Size_ExA(), and CM_Get_Device_Interface_List_SizeW().

CM_Get_Device_Interface_List_SizeA()

CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeA	(	_Out_ PULONG	pulLen,
		_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_A	pDeviceID,
		_In_ ULONG	ulFlags
	)

Definition at line 4440 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_List_SizeA(%p %p %s 0x%08lx)\n",
          pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags);
 
    return CM_Get_Device_Interface_List_Size_ExA(pulLen, InterfaceClassGuid,
                                                 pDeviceID, ulFlags, NULL);
}

CM_Get_Device_Interface_List_SizeW()

CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeW	(	_Out_ PULONG	pulLen,
		_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_W	pDeviceID,
		_In_ ULONG	ulFlags
	)

Definition at line 4459 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_List_SizeW(%p %p %s 0x%08lx)\n",
          pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags);
 
    return CM_Get_Device_Interface_List_Size_ExW(pulLen, InterfaceClassGuid,
                                                 pDeviceID, ulFlags, NULL);
}

CM_Get_Device_Interface_ListA()

CONFIGRET WINAPI CM_Get_Device_Interface_ListA	(	_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_A	pDeviceID,
		_Out_writes_(BufferLen) PCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 4271 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_ListA(%s %s %p %lu 0x%08lx)\n",
          debugstr_guid(InterfaceClassGuid), debugstr_a(pDeviceID),
          Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_Interface_List_ExA(InterfaceClassGuid, pDeviceID,
                                            Buffer, BufferLen, ulFlags, NULL);
}

CM_Get_Device_Interface_ListW()

CONFIGRET WINAPI CM_Get_Device_Interface_ListW	(	_In_ LPGUID	InterfaceClassGuid,
		_In_opt_ DEVINSTID_W	pDeviceID,
		_Out_writes_(BufferLen) PWCHAR	Buffer,
		_In_ ULONG	BufferLen,
		_In_ ULONG	ulFlags
	)

Definition at line 4292 of file cfgmgr.c.

{
    TRACE("CM_Get_Device_Interface_ListW(%s %s %p %lu 0x%08lx)\n",
          debugstr_guid(InterfaceClassGuid), debugstr_w(pDeviceID),
          Buffer, BufferLen, ulFlags);
 
    return CM_Get_Device_Interface_List_ExW(InterfaceClassGuid, pDeviceID,
                                            Buffer, BufferLen, ulFlags, NULL);
}

CM_Get_DevNode_Custom_Property_ExA()

CONFIGRET WINAPI CM_Get_DevNode_Custom_Property_ExA	(	_In_ DEVINST	dnDevInst,
		_In_ PCSTR	pszCustomPropertyName,
		_Out_opt_ PULONG	pulRegDataType,
		_Out_writes_bytes_opt_ *pulLength PVOID	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3183 of file cfgmgr.c.

{
    LPWSTR pszPropertyNameW = NULL;
    PVOID BufferW;
    ULONG ulLengthW;
    ULONG ulDataType = REG_NONE;
    CONFIGRET ret;
 
    TRACE("CM_Get_DevNode_Custom_Property_ExA(%lx %s %p %p %p %lx %p)\n",
          dnDevInst, pszCustomPropertyName, pulRegDataType,
          Buffer, pulLength, ulFlags, hMachine);
 
    if (!pulLength)
        return CR_INVALID_POINTER;
 
    ulLengthW = *pulLength * sizeof(WCHAR);
    BufferW = HeapAlloc(GetProcessHeap(), 0, ulLengthW);
    if (!BufferW)
        return CR_OUT_OF_MEMORY;
 
    pszPropertyNameW = pSetupMultiByteToUnicode(pszCustomPropertyName,
                                                CP_ACP);
    if (pszPropertyNameW == NULL)
    {
        HeapFree(GetProcessHeap(), 0, BufferW);
        return CR_OUT_OF_MEMORY;
    }
 
    ret = CM_Get_DevNode_Custom_Property_ExW(dnDevInst,
                                             pszPropertyNameW,
                                             &ulDataType,
                                             BufferW,
                                             &ulLengthW,
                                             ulFlags,
                                             hMachine);
    if (ret == CR_SUCCESS)
    {
        if (ulDataType == REG_SZ ||
            ulDataType == REG_EXPAND_SZ ||
            ulDataType == REG_MULTI_SZ)
        {
            /* Do W->A conversion */
            *pulLength = WideCharToMultiByte(CP_ACP,
                                             0,
                                             BufferW,
                                             lstrlenW(BufferW) + 1,
                                             Buffer,
                                             *pulLength,
                                             NULL,
                                             NULL);
            if (*pulLength == 0)
                ret = CR_FAILURE;
        }
        else
        {
            /* Directly copy the value */
            if (ulLengthW <= *pulLength)
                memcpy(Buffer, BufferW, ulLengthW);
            else
            {
                *pulLength = ulLengthW;
                ret = CR_BUFFER_SMALL;
            }
        }
    }
 
    if (pulRegDataType)
        *pulRegDataType = ulDataType;
 
    HeapFree(GetProcessHeap(), 0, BufferW);
    MyFree(pszPropertyNameW);
 
    return ret;
}

Referenced by CM_Get_DevNode_Custom_PropertyA().

CM_Get_DevNode_Custom_Property_ExW()

CONFIGRET WINAPI CM_Get_DevNode_Custom_Property_ExW	(	_In_ DEVINST	dnDevInst,
		_In_ PCWSTR	pszCustomPropertyName,
		_Out_opt_ PULONG	pulRegDataType,
		_Out_writes_bytes_opt_ *pulLength PVOID	Buffer,
		_Inout_ PULONG	pulLength,
		_In_ ULONG	ulFlags,
		_In_opt_ HMACHINE	hMachine
	)

Definition at line 3271 of file cfgmgr.c.

{
    RPC_BINDING_HANDLE BindingHandle = NULL;
    HSTRING_TABLE StringTable = NULL;
    LPWSTR lpDevInst;
    ULONG ulDataType = REG_NONE;
    ULONG ulTransferLength;
    CONFIGRET ret = CR_SUCCESS;
 
    TRACE("CM_Get_DevNode_Custom_Property_ExW(%lx %s %p %p %p %lx %p)\n",
          dnDevInst, debugstr_w(pszCustomPropertyName), pulRegDataType,
          Buffer, pulLength, ulFlags, hMachine);
 
    if (dnDevInst == 0)
        return CR_INVALID_DEVNODE;
 
    if (pszCustomPropertyName == NULL ||
        pulLength == NULL ||
        *pulLength == 0)
        return CR_INVALID_POINTER;
 
    if (ulFlags & ~CM_CUSTOMDEVPROP_BITS)
        return CR_INVALID_FLAG;
 
    if (hMachine != NULL)
    {
        BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
        if (BindingHandle == NULL)
            return CR_FAILURE;
 
        StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
        if (StringTable == 0)
            return CR_FAILURE;
    }
    else
    {
        if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
            return CR_FAILURE;
    }
 
    lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
    if (lpDevInst == NULL)
        return