ReactOS 0.4.16-dev-1188-gc03d779
cfgmgr.c File Reference
#include "setupapi_private.h"
#include <dbt.h>
#include <pnp_c.h>
#include <winsvc.h>
#include <winsvc_undoc.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  _RES_DES_INFO
 
struct  _NOTIFY_DATA
 
struct  _INTERNAL_RANGE
 
struct  _INTERNAL_RANGE_LIST
 
struct  _CONFLICT_DATA
 

Macros

#define LOG_CONF_MAGIC   0x464E434C /* "LCNF" */
 
#define RES_DES_MAGIC   0x53445352 /* "RSDS" */
 
#define NOTIFY_MAGIC   0x44556677
 
#define RANGE_LIST_MAGIC   0x33445566
 
#define CONFLICT_MAGIC   0x11225588
 

Typedefs

typedef struct _MACHINE_INFO MACHINE_INFO
 
typedef struct _MACHINE_INFOPMACHINE_INFO
 
typedef struct _LOG_CONF_INFO LOG_CONF_INFO
 
typedef struct _LOG_CONF_INFOPLOG_CONF_INFO
 
typedef struct _RES_DES_INFO RES_DES_INFO
 
typedef struct _RES_DES_INFOPRES_DES_INFO
 
typedef struct _NOTIFY_DATA NOTIFY_DATA
 
typedef struct _NOTIFY_DATAPNOTIFY_DATA
 
typedef struct _INTERNAL_RANGE INTERNAL_RANGE
 
typedef struct _INTERNAL_RANGEPINTERNAL_RANGE
 
typedef struct _INTERNAL_RANGE_LIST INTERNAL_RANGE_LIST
 
typedef struct _INTERNAL_RANGE_LISTPINTERNAL_RANGE_LIST
 
typedef struct _CONFLICT_DATA CONFLICT_DATA
 
typedef struct _CONFLICT_DATAPCONFLICT_DATA
 

Functions

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 IsValidResDes (_In_opt_ PRES_DES_INFO pResDesInfo)
 
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 111 of file cfgmgr.c.

◆ LOG_CONF_MAGIC

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

Definition at line 65 of file cfgmgr.c.

◆ NOTIFY_MAGIC

#define NOTIFY_MAGIC   0x44556677

Definition at line 85 of file cfgmgr.c.

◆ RANGE_LIST_MAGIC

#define RANGE_LIST_MAGIC   0x33445566

Definition at line 103 of file cfgmgr.c.

◆ RES_DES_MAGIC

#define RES_DES_MAGIC   0x53445352 /* "RSDS" */

Definition at line 77 of file cfgmgr.c.

Typedef Documentation

◆ CONFLICT_DATA

◆ INTERNAL_RANGE

◆ INTERNAL_RANGE_LIST

◆ LOG_CONF_INFO

◆ MACHINE_INFO

◆ NOTIFY_DATA

◆ PCONFLICT_DATA

◆ PINTERNAL_RANGE

◆ PINTERNAL_RANGE_LIST

◆ PLOG_CONF_INFO

◆ PMACHINE_INFO

◆ PNOTIFY_DATA

◆ PRES_DES_INFO

◆ RES_DES_INFO

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 894 of file cfgmgr.c.

899{
900 TRACE("CM_Add_Empty_Log_Conf(%p %p %lu %lx)\n",
901 plcLogConf, dnDevInst, Priority, ulFlags);
902
903 return CM_Add_Empty_Log_Conf_Ex(plcLogConf, dnDevInst, Priority,
904 ulFlags, NULL);
905}
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: cfgmgr.c:913
#define NULL
Definition: types.h:112
#define TRACE(s)
Definition: solgame.cpp:4
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY _In_ WDF_INTERRUPT_PRIORITY Priority
Definition: wdfinterrupt.h:655

◆ 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 913 of file cfgmgr.c.

919{
921 HSTRING_TABLE StringTable = NULL;
922 ULONG ulLogConfTag = 0;
923 LPWSTR lpDevInst;
924 PLOG_CONF_INFO pLogConfInfo;
926
927 FIXME("CM_Add_Empty_Log_Conf_Ex(%p %p %lu %lx %p)\n",
928 plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
929
930 if (!pSetupIsUserAdmin())
931 return CR_ACCESS_DENIED;
932
933 if (plcLogConf == NULL)
934 return CR_INVALID_POINTER;
935
936 if (dnDevInst == 0)
937 return CR_INVALID_DEVINST;
938
939 if (Priority > 0xFFFF)
940 return CR_INVALID_PRIORITY;
941
942 if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
943 return CR_INVALID_FLAG;
944
945 if (hMachine != NULL)
946 {
947 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
948 if (BindingHandle == NULL)
949 return CR_FAILURE;
950
951 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
952 if (StringTable == 0)
953 return CR_FAILURE;
954 }
955 else
956 {
957 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
958 return CR_FAILURE;
959 }
960
961 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
962 if (lpDevInst == NULL)
963 return CR_INVALID_DEVNODE;
964
966 {
968 &ulLogConfTag, ulFlags);
969 }
971 {
973 }
975
976 if (ret == CR_SUCCESS)
977 {
978 pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
979 if (pLogConfInfo == NULL)
980 {
982 }
983 else
984 {
985 pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
986 pLogConfInfo->dnDevInst = dnDevInst;
987 pLogConfInfo->ulType = ulFlags;
988 pLogConfInfo->ulTag = ulLogConfTag;
989
990 *plcLogConf = (LOG_CONF)pLogConfInfo;
991
992 ret = CR_SUCCESS;
993 }
994 }
995
996 return ret;
997}
DWORD WINAPI PNP_AddEmptyLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulPriority, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4209
#define FIXME(fmt,...)
Definition: precomp.h:53
#define CR_OUT_OF_MEMORY
Definition: cfgmgr32.h:844
#define CR_INVALID_PRIORITY
Definition: cfgmgr32.h:885
DWORD_PTR LOG_CONF
Definition: cfgmgr32.h:90
#define CR_FAILURE
Definition: cfgmgr32.h:865
#define CR_INVALID_DEVINST
Definition: cfgmgr32.h:848
#define LOG_CONF_BITS
Definition: cfgmgr32.h:603
#define PRIORITY_BIT
Definition: cfgmgr32.h:607
#define CR_ACCESS_DENIED
Definition: cfgmgr32.h:897
#define CR_INVALID_FLAG
Definition: cfgmgr32.h:846
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
#define CR_INVALID_POINTER
Definition: cfgmgr32.h:845
#define CR_SUCCESS
Definition: cfgmgr32.h:842
#define CR_INVALID_DEVNODE
Definition: cfgmgr32.h:847
static CONFIGRET RpcStatusToCmStatus(_In_ RPC_STATUS Status)
Definition: cfgmgr.c:141
#define LOG_CONF_MAGIC
Definition: cfgmgr.c:65
struct _MACHINE_INFO * PMACHINE_INFO
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
BOOL WINAPI pSetupIsUserAdmin(VOID)
Definition: misc.c:1817
BOOL PnpGetLocalHandles(RPC_BINDING_HANDLE *BindingHandle, HSTRING_TABLE *StringTable)
Definition: rpc.c:66
LPWSTR WINAPI pSetupStringTableStringFromId(HSTRING_TABLE hStringTable, DWORD dwId)
Definition: stringtable.c:722
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
#define RpcEndExcept
Definition: rpc.h:123
#define RpcTryExcept
Definition: rpc.h:121
#define RpcExcept(expr)
Definition: rpc.h:122
#define RpcExceptionCode()
Definition: rpc.h:127
ULONG ulTag
Definition: cfgmgr.c:62
ULONG ulType
Definition: cfgmgr.c:61
DEVINST dnDevInst
Definition: cfgmgr.c:60
ULONG ulMagic
Definition: cfgmgr.c:59
_In_ ULONG _Out_ HANDLE * BindingHandle
Definition: tdikrnl.h:1147
uint32_t ULONG
Definition: typedefs.h:59
int ret
WCHAR * LPWSTR
Definition: xmlstorage.h:184

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 1039 of file cfgmgr.c.

1044{
1045 PWSTR pszIDW;
1046 CONFIGRET ret;
1047
1048 TRACE("CM_Add_ID_ExA(%p %s %lx %p)\n",
1049 dnDevInst, debugstr_a(pszID), ulFlags, hMachine);
1050
1051 if (pSetupCaptureAndConvertAnsiArg(pszID, &pszIDW))
1052 return CR_INVALID_DATA;
1053
1054 ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
1055
1056 MyFree(pszIDW);
1057
1058 return ret;
1059}
#define CR_INVALID_DATA
Definition: cfgmgr32.h:877
CONFIGRET WINAPI CM_Add_ID_ExW(_In_ DEVINST dnDevInst, _In_ PWSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1067
DWORD WINAPI pSetupCaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
Definition: misc.c:574
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
#define debugstr_a
Definition: kernel32.h:31
uint16_t * PWSTR
Definition: typedefs.h:56

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 1067 of file cfgmgr.c.

1072{
1074 HSTRING_TABLE StringTable = NULL;
1075 LPWSTR lpDevInst;
1076 CONFIGRET ret;
1077
1078 TRACE("CM_Add_ID_ExW(%p %s %lx %p)\n",
1079 dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
1080
1081 if (!pSetupIsUserAdmin())
1082 return CR_ACCESS_DENIED;
1083
1084 if (dnDevInst == 0)
1085 return CR_INVALID_DEVINST;
1086
1087 if (pszID == NULL)
1088 return CR_INVALID_POINTER;
1089
1090 if (ulFlags & ~CM_ADD_ID_BITS)
1091 return CR_INVALID_FLAG;
1092
1093 if (hMachine != NULL)
1094 {
1095 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1096 if (BindingHandle == NULL)
1097 return CR_FAILURE;
1098
1099 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1100 if (StringTable == 0)
1101 return CR_FAILURE;
1102 }
1103 else
1104 {
1105 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1106 return CR_FAILURE;
1107 }
1108
1109 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1110 if (lpDevInst == NULL)
1111 return CR_INVALID_DEVNODE;
1112
1114 {
1116 lpDevInst,
1117 pszID,
1118 ulFlags);
1119 }
1121 {
1123 }
1125
1126 return ret;
1127}
DWORD WINAPI PNP_AddID(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszID, DWORD ulFlags)
Definition: rpcserver.c:3675
#define CM_ADD_ID_BITS
Definition: cfgmgr32.h:616
#define debugstr_w
Definition: kernel32.h:32

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 1005 of file cfgmgr.c.

1009{
1010 TRACE("CM_Add_IDA(%p %s %lx)\n",
1011 dnDevInst, debugstr_a(pszID), ulFlags);
1012
1013 return CM_Add_ID_ExA(dnDevInst, pszID, ulFlags, NULL);
1014}
CONFIGRET WINAPI CM_Add_ID_ExA(_In_ DEVINST dnDevInst, _In_ PSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1039

◆ CM_Add_IDW()

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

Definition at line 1022 of file cfgmgr.c.

1026{
1027 TRACE("CM_Add_IDW(%p %s %lx)\n",
1028 dnDevInst, debugstr_w(pszID), ulFlags);
1029
1030 return CM_Add_ID_ExW(dnDevInst, pszID, ulFlags, NULL);
1031}

◆ CM_Add_Range()

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

Definition at line 1135 of file cfgmgr.c.

1140{
1141 PINTERNAL_RANGE_LIST pRangeList;
1142 PINTERNAL_RANGE pRange;
1144
1145 FIXME("CM_Add_Range(%I64u %I64u %p %lx)\n",
1146 ullStartValue, ullEndValue, rlh, ulFlags);
1147
1148 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
1149
1150 if (!IsValidRangeList(pRangeList))
1151 return CR_INVALID_RANGE_LIST;
1152
1153 if (ulFlags & ~CM_ADD_RANGE_BITS)
1154 return CR_INVALID_FLAG;
1155
1156 if (ullEndValue < ullStartValue)
1157 return CR_INVALID_RANGE;
1158
1159 /* Lock the range list */
1160 WaitForSingleObject(pRangeList->hMutex, INFINITE);
1161
1162 /* Allocate the new range */
1163 pRange = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERNAL_RANGE));
1164 if (pRange == NULL)
1165 {
1167 goto done;
1168 }
1169
1170 pRange->pRangeList = pRangeList;
1171 pRange->ullStart = ullStartValue;
1172 pRange->ullEnd = ullEndValue;
1173
1174 /* Insert the range */
1175 if (IsListEmpty(&pRangeList->ListHead))
1176 {
1177 InsertTailList(&pRangeList->ListHead, &pRange->ListEntry);
1178 }
1179 else
1180 {
1181 HeapFree(GetProcessHeap(), 0, pRange);
1183 }
1184
1185done:
1186 /* Unlock the range list */
1187 ReleaseMutex(pRangeList->hMutex);
1188
1189 return ret;
1190}
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
#define CM_ADD_RANGE_BITS
Definition: cfgmgr32.h:594
#define CR_INVALID_RANGE
Definition: cfgmgr32.h:864
#define CR_INVALID_RANGE_LIST
Definition: cfgmgr32.h:863
struct _INTERNAL_RANGE_LIST * PINTERNAL_RANGE_LIST
BOOL IsValidRangeList(_In_opt_ PINTERNAL_RANGE_LIST pRangeList)
Definition: cfgmgr.c:395
#define HeapFree(x, y, z)
Definition: compat.h:735
#define INFINITE
Definition: serial.h:102
#define InsertTailList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
LIST_ENTRY ListHead
Definition: cfgmgr.c:100
DWORDLONG ullEnd
Definition: cfgmgr.c:93
DWORDLONG ullStart
Definition: cfgmgr.c:92
struct _INTERNAL_RANGE_LIST * pRangeList
Definition: cfgmgr.c:91
LIST_ENTRY ListEntry
Definition: cfgmgr.c:90
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseMutex(IN HANDLE hMutex)
Definition: synch.c:618

◆ 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 1198 of file cfgmgr.c.

1205{
1206 TRACE("CM_Add_Res_Des(%p %p %lu %p %lu %lx)\n",
1207 prdResDes, lcLogConf, ResourceID, ResourceData, ResourceLen, ulFlags);
1208
1209 return CM_Add_Res_Des_Ex(prdResDes, lcLogConf, ResourceID, ResourceData,
1210 ResourceLen, ulFlags, NULL);
1211}
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: cfgmgr.c:1219

◆ 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 1219 of file cfgmgr.c.

1227{
1228 FIXME("CM_Add_Res_Des_Ex(%p %p %lu %p %lu %lx %p)\n",
1229 prdResDes, lcLogConf, ResourceID,
1230 ResourceData, ResourceLen, ulFlags, hMachine);
1231
1233}
#define CR_CALL_NOT_IMPLEMENTED
Definition: cfgmgr32.h:898

Referenced by CM_Add_Res_Des().

◆ CM_Connect_MachineA()

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

Definition at line 1241 of file cfgmgr.c.

1244{
1245 PWSTR pServerNameW;
1246 CONFIGRET ret;
1247
1248 TRACE("CM_Connect_MachineA(%s %p)\n",
1249 debugstr_a(UNCServerName), phMachine);
1250
1251 if (UNCServerName == NULL || *UNCServerName == 0)
1252 return CM_Connect_MachineW(NULL, phMachine);
1253
1254 if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
1255 return CR_INVALID_DATA;
1256
1257 ret = CM_Connect_MachineW(pServerNameW, phMachine);
1258
1259 MyFree(pServerNameW);
1260
1261 return ret;
1262}
CONFIGRET WINAPI CM_Connect_MachineW(_In_opt_ PCWSTR UNCServerName, _Out_ PHMACHINE phMachine)
Definition: cfgmgr.c:1270

Referenced by SetupDiGetClassRegistryPropertyA(), and SetupDiSetClassRegistryPropertyA().

◆ CM_Connect_MachineW()

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

Definition at line 1270 of file cfgmgr.c.

1273{
1274 PMACHINE_INFO pMachine;
1275
1276 TRACE("CM_Connect_MachineW(%s %p)\n",
1277 debugstr_w(UNCServerName), phMachine);
1278
1279 if (phMachine == NULL)
1280 return CR_INVALID_POINTER;
1281
1282 *phMachine = NULL;
1283
1284 pMachine = HeapAlloc(GetProcessHeap(), 0, sizeof(MACHINE_INFO));
1285 if (pMachine == NULL)
1286 return CR_OUT_OF_MEMORY;
1287
1288 if (UNCServerName == NULL || *UNCServerName == 0)
1289 {
1290 pMachine->bLocal = TRUE;
1291
1292 /* FIXME: store the computers name in pMachine->szMachineName */
1293
1294 if (!PnpGetLocalHandles(&pMachine->BindingHandle,
1295 &pMachine->StringTable))
1296 {
1297 HeapFree(GetProcessHeap(), 0, pMachine);
1298 return CR_FAILURE;
1299 }
1300 }
1301 else
1302 {
1303 pMachine->bLocal = FALSE;
1304 if (wcslen(UNCServerName) >= SP_MAX_MACHINENAME_LENGTH - 1)
1305 {
1306 HeapFree(GetProcessHeap(), 0, pMachine);
1308 }
1309 lstrcpyW(pMachine->szMachineName, UNCServerName);
1310
1312 if (pMachine->StringTable == NULL)
1313 {
1314 HeapFree(GetProcessHeap(), 0, pMachine);
1315 return CR_FAILURE;
1316 }
1317
1318 pSetupStringTableAddString(pMachine->StringTable, L"PLT", 1);
1319
1320 if (!PnpBindRpc(UNCServerName, &pMachine->BindingHandle))
1321 {
1323 HeapFree(GetProcessHeap(), 0, pMachine);
1325 }
1326 }
1327
1328 *phMachine = (PHMACHINE)pMachine;
1329
1330 return CR_SUCCESS;
1331}
HMACHINE * PHMACHINE
Definition: cfgmgr32.h:109
#define CR_INVALID_MACHINENAME
Definition: cfgmgr32.h:893
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define lstrcpyW
Definition: compat.h:749
RPC_STATUS PnpBindRpc(LPCWSTR pszMachine, RPC_BINDING_HANDLE *BindingHandle)
Definition: rpc.c:28
HSTRING_TABLE WINAPI pSetupStringTableInitialize(VOID)
Definition: stringtable.c:54
DWORD WINAPI pSetupStringTableAddString(HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags)
Definition: stringtable.c:196
VOID WINAPI pSetupStringTableDestroy(HSTRING_TABLE hStringTable)
Definition: stringtable.c:145
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define L(x)
Definition: ntvdm.h:50
#define SP_MAX_MACHINENAME_LENGTH
Definition: setupapi.h:27
WCHAR szMachineName[SP_MAX_MACHINENAME_LENGTH]
Definition: cfgmgr.c:50
HSTRING_TABLE StringTable
Definition: cfgmgr.c:52
RPC_BINDING_HANDLE BindingHandle
Definition: cfgmgr.c:51
BOOL bLocal
Definition: cfgmgr.c:53

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

◆ 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 1377 of file cfgmgr.c.

1383{
1384 DEVINSTID_W pDeviceIDW;
1385 CONFIGRET ret;
1386
1387 TRACE("CM_Create_DevNode_ExA(%p %s %p %lx %p)\n",
1388 pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
1389
1390 if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
1391 return CR_INVALID_DATA;
1392
1393 ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
1394 hMachine);
1395
1396 MyFree(pDeviceIDW);
1397
1398 return ret;
1399}
_Null_terminated_ WCHAR * DEVINSTID_W
Definition: cfgmgr32.h:80
CONFIGRET WINAPI CM_Create_DevNode_ExW(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_W pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1407

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 1407 of file cfgmgr.c.

1413{
1415 HSTRING_TABLE StringTable = NULL;
1416 LPWSTR lpParentDevInst;
1418 WCHAR szLocalDeviceID[MAX_DEVICE_ID_LEN];
1419
1420 TRACE("CM_Create_DevNode_ExW(%p %s %p %lx %p)\n",
1421 pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
1422
1423 if (!pSetupIsUserAdmin())
1424 return CR_ACCESS_DENIED;
1425
1426 if (pdnDevInst == NULL)
1427 return CR_INVALID_POINTER;
1428
1429 if (pDeviceID == NULL || wcslen(pDeviceID) == 0 || wcslen(pDeviceID) >= MAX_DEVICE_ID_LEN)
1430 return CR_INVALID_DEVICE_ID;
1431
1432 if (dnParent == 0)
1433 return CR_INVALID_DEVNODE;
1434
1435 if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
1436 return CR_INVALID_FLAG;
1437
1438 if (hMachine != NULL)
1439 {
1440 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1441 if (BindingHandle == NULL)
1442 return CR_FAILURE;
1443
1444 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1445 if (StringTable == 0)
1446 return CR_FAILURE;
1447 }
1448 else
1449 {
1450 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1451 return CR_FAILURE;
1452 }
1453
1454 lpParentDevInst = pSetupStringTableStringFromId(StringTable, dnParent);
1455 if (lpParentDevInst == NULL)
1456 return CR_INVALID_DEVNODE;
1457
1458 wcscpy(szLocalDeviceID, pDeviceID);
1459
1461 {
1463 szLocalDeviceID,
1464 lpParentDevInst,
1466 ulFlags);
1467 }
1469 {
1471 }
1473
1474 if (ret == CR_SUCCESS)
1475 {
1476 /* If CM_CREATE_DEVINST_GENERATE_ID was passed in, PNP_CreateDevInst
1477 * will return the generated device ID in szLocalDeviceID */
1478 *pdnDevInst = pSetupStringTableAddString(StringTable, szLocalDeviceID, 1);
1479 if (*pdnDevInst == 0)
1481 }
1482
1483 return ret;
1484}
DWORD WINAPI PNP_CreateDevInst(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentDeviceID, PNP_RPC_STRING_LEN ulLength, DWORD ulFlags)
Definition: rpcserver.c:3174
#define CR_INVALID_DEVICE_ID
Definition: cfgmgr32.h:876
#define CR_NO_SUCH_DEVNODE
Definition: cfgmgr32.h:857
#define CM_CREATE_DEVNODE_BITS
Definition: cfgmgr32.h:624
wcscpy
#define MAX_DEVICE_ID_LEN
Definition: devaction.c:40
__wchar_t WCHAR
Definition: xmlstorage.h:180

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 1339 of file cfgmgr.c.

1344{
1345 TRACE("CM_Create_DevNodeA(%p %s %p %lx)\n",
1346 pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags);
1347
1348 return CM_Create_DevNode_ExA(pdnDevInst, pDeviceID, dnParent,
1349 ulFlags, NULL);
1350}
CONFIGRET WINAPI CM_Create_DevNode_ExA(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_A pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1377

◆ CM_Create_DevNodeW()

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

Definition at line 1358 of file cfgmgr.c.

1363{
1364 TRACE("CM_Create_DevNodeW(%p %s %p %lx)\n",
1365 pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags);
1366
1367 return CM_Create_DevNode_ExW(pdnDevInst, pDeviceID, dnParent,
1368 ulFlags, NULL);
1369}

◆ CM_Create_Range_List()

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

Definition at line 1492 of file cfgmgr.c.

1495{
1496 PINTERNAL_RANGE_LIST pRangeList;
1497
1498 FIXME("CM_Create_Range_List(%p %lx)\n",
1499 prlh, ulFlags);
1500
1501 if (ulFlags != 0)
1502 return CR_INVALID_FLAG;
1503
1504 if (prlh == NULL)
1505 return CR_INVALID_POINTER;
1506
1507 /* Allocate the range list */
1509 if (pRangeList == NULL)
1510 return CR_OUT_OF_MEMORY;
1511
1512 /* Set the magic value */
1513 pRangeList->ulMagic = RANGE_LIST_MAGIC;
1514
1515 /* Initialize the mutex for synchonized access */
1516 pRangeList->hMutex = CreateMutex(NULL, FALSE, NULL);
1517 if (pRangeList->hMutex == NULL)
1518 {
1519 HeapFree(GetProcessHeap(), 0, pRangeList);
1520 return CR_FAILURE;
1521 }
1522
1523 InitializeListHead(&pRangeList->ListHead);
1524
1525 *prlh = (RANGE_LIST)pRangeList;
1526
1527 return CR_SUCCESS;
1528}
DWORD_PTR RANGE_LIST
Definition: cfgmgr32.h:102
#define RANGE_LIST_MAGIC
Definition: cfgmgr.c:103
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define CreateMutex
Definition: winbase.h:3788

◆ CM_Delete_Class_Key()

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

Definition at line 1536 of file cfgmgr.c.

1539{
1540 TRACE("CM_Delete_Class_Key(%p %lx)\n",
1541 ClassGuid, ulFlags);
1542
1543 return CM_Delete_Class_Key_Ex(ClassGuid, ulFlags, NULL);
1544}
CONFIGRET WINAPI CM_Delete_Class_Key_Ex(_In_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1552

◆ 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 1552 of file cfgmgr.c.

1556{
1557 WCHAR szGuidString[MAX_GUID_STRING_LEN];
1559 CONFIGRET ret;
1560
1561 TRACE("CM_Delete_Class_Key_Ex(%p %lx %p)\n",
1562 ClassGuid, ulFlags, hMachine);
1563
1564 if (ClassGuid == NULL)
1565 return CR_INVALID_POINTER;
1566
1567 if (ulFlags & ~CM_DELETE_CLASS_BITS)
1568 return CR_INVALID_FLAG;
1569
1570 if (!GuidToString(ClassGuid, szGuidString))
1571 return CR_INVALID_DATA;
1572
1573 if (hMachine != NULL)
1574 {
1575 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1576 if (BindingHandle == NULL)
1577 return CR_FAILURE;
1578 }
1579 else
1580 {
1582 return CR_FAILURE;
1583 }
1584
1586 {
1588 szGuidString,
1589 ulFlags);
1590 }
1592 {
1594 }
1596
1597 return ret;
1598}
DWORD WINAPI PNP_DeleteClassKey(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulFlags)
Definition: rpcserver.c:2600
#define CM_DELETE_CLASS_BITS
Definition: cfgmgr32.h:639
static BOOL GuidToString(_In_ LPGUID Guid, _Out_ LPWSTR String)
Definition: cfgmgr.c:118
#define MAX_GUID_STRING_LEN
Definition: apphelp.c:29

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 1606 of file cfgmgr.c.

1610{
1611 TRACE("CM_Delete_DevNode_Key(%p %lu %lx)\n",
1612 dnDevInst, ulHardwareProfile, ulFlags);
1613
1614 return CM_Delete_DevNode_Key_Ex(dnDevInst, ulHardwareProfile, ulFlags,
1615 NULL);
1616}
CONFIGRET WINAPI CM_Delete_DevNode_Key_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1624

◆ 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 1624 of file cfgmgr.c.

1629{
1631 HSTRING_TABLE StringTable = NULL;
1632 PWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
1633 CONFIGRET ret;
1634
1635 FIXME("CM_Delete_DevNode_Key_Ex(%p %lu %lx %p)\n",
1636 dnDevInst, ulHardwareProfile, ulFlags, hMachine);
1637
1638 if (dnDevInst == 0)
1639 return CR_INVALID_DEVINST;
1640
1641 if (ulFlags & ~CM_REGISTRY_BITS)
1642 return CR_INVALID_FLAG;
1643
1644 if ((ulFlags & CM_REGISTRY_USER) && (ulFlags & CM_REGISTRY_CONFIG))
1645 return CR_INVALID_FLAG;
1646
1647 if (hMachine != NULL)
1648 {
1649 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1650 if (BindingHandle == NULL)
1651 return CR_FAILURE;
1652
1653 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1654 if (StringTable == 0)
1655 return CR_FAILURE;
1656 }
1657 else
1658 {
1659 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1660 return CR_FAILURE;
1661 }
1662
1663 pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1664 if (pszDevInst == NULL)
1665 return CR_INVALID_DEVNODE;
1666
1667 TRACE("pszDevInst: %S\n", pszDevInst);
1668
1669 pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
1670 if (pszKeyPath == NULL)
1671 {
1673 goto done;
1674 }
1675
1676 pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
1677 if (pszInstancePath == NULL)
1678 {
1680 goto done;
1681 }
1682
1684 pszDevInst,
1685 pszKeyPath,
1686 pszInstancePath,
1687 ulHardwareProfile,
1688 ulFlags);
1689 if (ret != CR_SUCCESS)
1690 goto done;
1691
1692 TRACE("pszKeyPath: %S\n", pszKeyPath);
1693 TRACE("pszInstancePath: %S\n", pszInstancePath);
1694
1695 if (ulFlags & CM_REGISTRY_USER)
1696 {
1697 FIXME("The CM_REGISTRY_USER flag is not supported yet!\n");
1698 }
1699 else
1700 {
1701#if 0
1702 if (!pSetupIsUserAdmin())
1703 {
1705 goto done;
1706 }
1707#endif
1708
1709 if (!(ulFlags & CM_REGISTRY_CONFIG))
1710 ulHardwareProfile = 0;
1711
1713 {
1715 pszDevInst,
1716 pszKeyPath,
1717 pszInstancePath,
1718 ulHardwareProfile);
1719 }
1721 {
1723 }
1725 }
1726
1727done:
1728 if (pszInstancePath != NULL)
1729 MyFree(pszInstancePath);
1730
1731 if (pszKeyPath != NULL)
1732 MyFree(pszKeyPath);
1733
1734 return ret;
1735}
DWORD WINAPI PNP_DeleteRegistryKey(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentKey, LPWSTR pszChildKey, DWORD ulFlags)
Definition: rpcserver.c:2482
#define CM_REGISTRY_BITS
Definition: cfgmgr32.h:804
#define CM_REGISTRY_USER
Definition: cfgmgr32.h:802
#define CM_REGISTRY_CONFIG
Definition: cfgmgr32.h:803
static CONFIGRET GetDeviceInstanceKeyPath(_In_ RPC_BINDING_HANDLE BindingHandle, _In_ PWSTR pszDeviceInst, _Out_ PWSTR pszKeyPath, _Out_ PWSTR pszInstancePath, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
Definition: cfgmgr.c:229
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147

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 1743 of file cfgmgr.c.

1748{
1749 FIXME("CM_Delete_Range(%I64u %I64u %p %lx)\n",
1750 ullStartValue, ullEndValue, rlh, ulFlags);
1751
1753}

◆ 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 1761 of file cfgmgr.c.

1768{
1769 TRACE("CM_Detect_Resource_Conflict(%p %lu %p %lu %p 0x%lx)\n",
1770 dnDevInst, ResourceID, ResourceData, ResourceLen,
1771 pbConflictDetected, ulFlags);
1772
1773 return CM_Detect_Resource_Conflict_Ex(dnDevInst,
1774 ResourceID,
1775 ResourceData,
1776 ResourceLen,
1777 pbConflictDetected,
1778 ulFlags,
1779 NULL);
1780}
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: cfgmgr.c:1788

◆ 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 1788 of file cfgmgr.c.

1796{
1797 FIXME("CM_Detect_Resource_Conflict_Ex(%p %lu %p %lu %p 0x%lx %p)\n",
1798 dnDevInst, ResourceID, ResourceData, ResourceLen,
1799 pbConflictDetected, ulFlags, hMachine);
1800
1802}

Referenced by CM_Detect_Resource_Conflict().

◆ CM_Disable_DevNode()

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

Definition at line 1810 of file cfgmgr.c.

1813{
1814 TRACE("CM_Disable_DevNode(%p %lx)\n",
1815 dnDevInst, ulFlags);
1816
1817 return CM_Disable_DevNode_Ex(dnDevInst, ulFlags, NULL);
1818}
CONFIGRET WINAPI CM_Disable_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1826

◆ CM_Disable_DevNode_Ex()

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

Definition at line 1826 of file cfgmgr.c.

1830{
1832 HSTRING_TABLE StringTable = NULL;
1833 LPWSTR lpDevInst;
1834 CONFIGRET ret;
1835
1836 TRACE("CM_Disable_DevNode_Ex(%p %lx %p)\n",
1837 dnDevInst, ulFlags, hMachine);
1838
1839 if (!pSetupIsUserAdmin())
1840 return CR_ACCESS_DENIED;
1841
1842 if (dnDevInst == 0)
1843 return CR_INVALID_DEVINST;
1844
1845 if (ulFlags != 0)
1846 return CR_INVALID_FLAG;
1847
1848 if (hMachine != NULL)
1849 {
1850 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1851 if (BindingHandle == NULL)
1852 return CR_FAILURE;
1853
1854 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1855 if (StringTable == 0)
1856 return CR_FAILURE;
1857 }
1858 else
1859 {
1860 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1861 return CR_FAILURE;
1862 }
1863
1864 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1865 if (lpDevInst == NULL)
1866 return CR_INVALID_DEVNODE;
1867
1869 {
1871 lpDevInst,
1872 NULL,
1873 NULL,
1874 0,
1875 ulFlags);
1876 }
1878 {
1880 }
1882
1883 return ret;
1884}
DWORD WINAPI PNP_DisableDevInst(handle_t hBinding, LPWSTR pDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3590

Referenced by CM_Disable_DevNode(), and StopDevice().

◆ CM_Disconnect_Machine()

CONFIGRET WINAPI CM_Disconnect_Machine ( _In_opt_ HMACHINE  hMachine)

Definition at line 1892 of file cfgmgr.c.

1894{
1895 PMACHINE_INFO pMachine;
1896
1897 TRACE("CM_Disconnect_Machine(%p)\n", hMachine);
1898
1899 pMachine = (PMACHINE_INFO)hMachine;
1900 if (pMachine == NULL)
1901 return CR_SUCCESS;
1902
1903 if (pMachine->bLocal == FALSE)
1904 {
1905 if (pMachine->StringTable != NULL)
1907
1908 if (!PnpUnbindRpc(pMachine->BindingHandle))
1909 return CR_ACCESS_DENIED;
1910 }
1911
1912 HeapFree(GetProcessHeap(), 0, pMachine);
1913
1914 return CR_SUCCESS;
1915}
RPC_STATUS PnpUnbindRpc(RPC_BINDING_HANDLE *BindingHandle)
Definition: rpc.c:53

Referenced by DestroyDeviceInfoSet(), DeviceProblemWizardW(), DisplayDeviceAdvancedProperties(), SetupDiBuildClassInfoListExW(), SetupDiGetClassRegistryPropertyA(), SetupDiGetClassRegistryPropertyW(), SetupDiSetClassRegistryPropertyA(), and SetupDiSetClassRegistryPropertyW().

◆ CM_Dup_Range_List()

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

Definition at line 1923 of file cfgmgr.c.

1927{
1928 PINTERNAL_RANGE_LIST pOldRangeList, pNewRangeList;
1929 PINTERNAL_RANGE pOldRange, pNewRange;
1930 PLIST_ENTRY ListEntry;
1932
1933 FIXME("CM_Dup_Range_List(%p %p %lx)\n",
1934 rlhOld, rlhNew, ulFlags);
1935
1936 pOldRangeList = (PINTERNAL_RANGE_LIST)rlhOld;
1937 pNewRangeList = (PINTERNAL_RANGE_LIST)rlhNew;
1938
1939 if (!IsValidRangeList(pOldRangeList))
1940 return CR_INVALID_RANGE_LIST;
1941
1942 if (!IsValidRangeList(pNewRangeList))
1943 return CR_INVALID_RANGE_LIST;
1944
1945 if (ulFlags != 0)
1946 return CR_INVALID_FLAG;
1947
1948 /* Lock the range lists */
1949 WaitForSingleObject(pOldRangeList->hMutex, INFINITE);
1950 WaitForSingleObject(pNewRangeList->hMutex, INFINITE);
1951
1952 /* Delete the new range list, if ist is not empty */
1953 while (!IsListEmpty(&pNewRangeList->ListHead))
1954 {
1955 ListEntry = RemoveHeadList(&pNewRangeList->ListHead);
1956 pNewRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
1957 HeapFree(GetProcessHeap(), 0, pNewRange);
1958 }
1959
1960 /* Copy the old range list into the new range list */
1961 ListEntry = &pOldRangeList->ListHead;
1962 while (ListEntry->Flink == &pOldRangeList->ListHead)
1963 {
1964 pOldRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
1965
1966 pNewRange = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERNAL_RANGE));
1967 if (pNewRange == NULL)
1968 {
1970 goto done;
1971 }
1972
1973 pNewRange->pRangeList = pNewRangeList;
1974 pNewRange->ullStart = pOldRange->ullStart;
1975 pNewRange->ullEnd = pOldRange->ullEnd;
1976
1977 InsertTailList(&pNewRangeList->ListHead, &pNewRange->ListEntry);
1978
1979 ListEntry = ListEntry->Flink;
1980 }
1981
1982done:
1983 /* Unlock the range lists */
1984 ReleaseMutex(pNewRangeList->hMutex);
1985 ReleaseMutex(pOldRangeList->hMutex);
1986
1987 return ret;
1988}
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

◆ CM_Enable_DevNode()

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

Definition at line 1996 of file cfgmgr.c.

1999{
2000 TRACE("CM_Enable_DevNode(%p %lx)\n",
2001 dnDevInst, ulFlags);
2002
2003 return CM_Enable_DevNode_Ex(dnDevInst, ulFlags, NULL);
2004}
CONFIGRET WINAPI CM_Enable_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2012

◆ CM_Enable_DevNode_Ex()

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

Definition at line 2012 of file cfgmgr.c.

2016{
2018 HSTRING_TABLE StringTable = NULL;
2019 LPWSTR lpDevInst;
2020 CONFIGRET ret;
2021
2022 TRACE("CM_Enable_DevNode_Ex(%p %lx %p)\n",
2023 dnDevInst, ulFlags, hMachine);
2024
2025 if (!pSetupIsUserAdmin())
2026 return CR_ACCESS_DENIED;
2027
2028 if (dnDevInst == 0)
2029 return CR_INVALID_DEVINST;
2030
2031 if (ulFlags != 0)
2032 return CR_INVALID_FLAG;
2033
2034 if (hMachine != NULL)
2035 {
2036 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2037 if (BindingHandle == NULL)
2038 return CR_FAILURE;
2039
2040 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2041 if (StringTable == 0)
2042 return CR_FAILURE;
2043 }
2044 else
2045 {
2046 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2047 return CR_FAILURE;
2048 }
2049
2050 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
2051 if (lpDevInst == NULL)
2052 return CR_INVALID_DEVNODE;
2053
2055 {
2057 PNP_DEVINST_ENABLE,
2058 ulFlags,
2059 lpDevInst,
2060 NULL);
2061 }
2063 {
2065 }
2067
2068 return ret;
2069}
DWORD WINAPI PNP_DeviceInstanceAction(handle_t hBinding, DWORD ulMajorAction, DWORD ulMinorAction, LPWSTR pszDeviceInstance1, LPWSTR pszDeviceInstance2)
Definition: rpcserver.c:3414

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 2077 of file cfgmgr.c.

2081{
2082 TRACE("CM_Enumerate_Classes(%lx %p %lx)\n",
2083 ulClassIndex, ClassGuid, ulFlags);
2084
2085 return CM_Enumerate_Classes_Ex(ulClassIndex, ClassGuid, ulFlags, NULL);
2086}
CONFIGRET WINAPI CM_Enumerate_Classes_Ex(_In_ ULONG ulClassIndex, _Out_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2094

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 2094 of file cfgmgr.c.

2099{
2100 WCHAR szBuffer[MAX_GUID_STRING_LEN];
2103 ULONG ulLength = MAX_GUID_STRING_LEN;
2104
2105 TRACE("CM_Enumerate_Classes_Ex(%lx %p %lx %p)\n",
2106 ulClassIndex, ClassGuid, ulFlags, hMachine);
2107
2108 if (ClassGuid == NULL)
2109 return CR_INVALID_POINTER;
2110
2111 if (ulFlags != 0)
2112 return CR_INVALID_FLAG;
2113
2114 if (hMachine != NULL)
2115 {
2116 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2117 if (BindingHandle == NULL)
2118 return CR_FAILURE;
2119 }
2120 else
2121 {
2123 return CR_FAILURE;
2124 }
2125
2127 {
2129 PNP_CLASS_SUBKEYS,
2130 ulClassIndex,
2131 szBuffer,
2133 &ulLength,
2134 ulFlags);
2135 }
2137 {
2139 }
2141
2142 if (ret == CR_SUCCESS)
2143 {
2144 /* Remove the {} */
2145 szBuffer[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
2146
2147 /* Convert the buffer to a GUID */
2148 if (UuidFromStringW(&szBuffer[1], ClassGuid) != RPC_S_OK)
2149 return CR_FAILURE;
2150 }
2151
2152 return ret;
2153}
DWORD WINAPI PNP_EnumerateSubKeys(handle_t hBinding, DWORD ulBranch, DWORD ulIndex, LPWSTR Buffer, PNP_RPC_STRING_LEN ulLength, PNP_RPC_STRING_LEN *pulRequiredLen, DWORD ulFlags)
Definition: rpcserver.c:973
#define UNICODE_NULL
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:614

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 2199 of file cfgmgr.c.

2205{
2206 WCHAR szBuffer[MAX_DEVICE_ID_LEN];
2207 ULONG ulOrigLength;
2208 ULONG ulLength;
2210
2211 TRACE("CM_Enumerate_Enumerators_ExA(%lu %p %p %lx %p)\n",
2212 ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
2213
2214 if (Buffer == NULL || pulLength == NULL)
2215 return CR_INVALID_POINTER;
2216
2217 if (ulFlags != 0)
2218 return CR_INVALID_FLAG;
2219
2220 ulOrigLength = *pulLength;
2221 *pulLength = 0;
2222
2223 ulLength = MAX_DEVICE_ID_LEN;
2224 ret = CM_Enumerate_Enumerators_ExW(ulEnumIndex, szBuffer, &ulLength,
2225 ulFlags, hMachine);
2226 if (ret == CR_SUCCESS)
2227 {
2229 0,
2230 szBuffer,
2231 ulLength,
2232 Buffer,
2233 ulOrigLength,
2234 NULL,
2235 NULL) == 0)
2236 ret = CR_FAILURE;
2237 else
2238 *pulLength = lstrlenA(Buffer) + 1;
2239 }
2240
2241 return ret;
2242}
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: cfgmgr.c:2250
Definition: bufpool.h:45
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145

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 2250 of file cfgmgr.c.

2256{
2258 CONFIGRET ret;
2259
2260 TRACE("CM_Enumerate_Enumerators_ExW(%lu %p %p %lx %p)\n",
2261 ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
2262
2263 if (Buffer == NULL || pulLength == NULL)
2264 return CR_INVALID_POINTER;
2265
2266 if (ulFlags != 0)
2267 return CR_INVALID_FLAG;
2268
2270
2271 if (hMachine != NULL)
2272 {
2273 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2274 if (BindingHandle == NULL)
2275 return CR_FAILURE;
2276 }
2277 else
2278 {
2280 return CR_FAILURE;
2281 }
2282
2284 {
2286 PNP_ENUMERATOR_SUBKEYS,
2287 ulEnumIndex,
2288 Buffer,
2289 *pulLength,
2290 pulLength,
2291 ulFlags);
2292 }
2294 {
2296 }
2298
2299 return ret;
2300}

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 2161 of file cfgmgr.c.

2166{
2167 TRACE("CM_Enumerate_EnumeratorsA(%lu %p %p %lx)\n",
2168 ulEnumIndex, Buffer, pulLength, ulFlags);
2169
2170 return CM_Enumerate_Enumerators_ExA(ulEnumIndex, Buffer, pulLength,
2171 ulFlags, NULL);
2172}
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: cfgmgr.c:2199

◆ 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 2180 of file cfgmgr.c.

2185{
2186 TRACE("CM_Enumerate_EnumeratorsW(%lu %p %p %lx)\n",
2187 ulEnumIndex, Buffer, pulLength, ulFlags);
2188
2189 return CM_Enumerate_Enumerators_ExW(ulEnumIndex, Buffer, pulLength,
2190 ulFlags, NULL);
2191}

◆ 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 2308 of file cfgmgr.c.

2316{
2317 FIXME("CM_Find_Range(%p %I64u %lu %I64u %I64u %p %lx)\n",
2318 pullStart, ullStart, ulLength, ullAlignment, ullEnd, rlh, ulFlags);
2319
2321}

◆ 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 2329 of file cfgmgr.c.

2335{
2336 PINTERNAL_RANGE_LIST pRangeList;
2337 PINTERNAL_RANGE pRange;
2338 PLIST_ENTRY ListEntry;
2340
2341 FIXME("CM_First_Range(%p %p %p %p %lx)\n",
2342 rlh, pullStart, pullEnd, preElement, ulFlags);
2343
2344 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
2345
2346 if (!IsValidRangeList(pRangeList))
2347 return CR_INVALID_RANGE_LIST;
2348
2349 if (pullStart == NULL || pullEnd == NULL || preElement == NULL)
2350 return CR_INVALID_POINTER;
2351
2352 if (ulFlags != 0)
2353 return CR_INVALID_FLAG;
2354
2355 /* Lock the range list */
2356 WaitForSingleObject(pRangeList->hMutex, INFINITE);
2357
2358 /* Fail, if the list is empty */
2359 if (IsListEmpty(&pRangeList->ListHead))
2360 {
2361 ret = CR_FAILURE;
2362 goto done;
2363 }
2364
2365 /* Get the first range */
2366 ListEntry = pRangeList->ListHead.Flink;
2367 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
2368
2369 /* Return the range data */
2370 *pullStart = pRange->ullStart;
2371 *pullEnd = pRange->ullEnd;
2372 *preElement = (RANGE_ELEMENT)pRange;
2373
2374done:
2375 /* Unlock the range list */
2376 ReleaseMutex(pRangeList->hMutex);
2377
2378 return ret;
2379}
DWORD_PTR RANGE_ELEMENT
Definition: cfgmgr32.h:105

◆ CM_Free_Log_Conf()

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

Definition at line 2387 of file cfgmgr.c.

2390{
2391 TRACE("CM_Free_Log_Conf(%lx %lx)\n",
2392 lcLogConfToBeFreed, ulFlags);
2393
2394 return CM_Free_Log_Conf_Ex(lcLogConfToBeFreed, ulFlags, NULL);
2395}
CONFIGRET WINAPI CM_Free_Log_Conf_Ex(_In_ LOG_CONF lcLogConfToBeFreed, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2403

◆ 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 2403 of file cfgmgr.c.

2407{
2409 HSTRING_TABLE StringTable = NULL;
2410 LPWSTR lpDevInst;
2411 PLOG_CONF_INFO pLogConfInfo;
2412 CONFIGRET ret;
2413
2414 TRACE("CM_Free_Log_Conf_Ex(%lx %lx %p)\n",
2415 lcLogConfToBeFreed, ulFlags, hMachine);
2416
2417 if (!pSetupIsUserAdmin())
2418 return CR_ACCESS_DENIED;
2419
2420 pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
2421 if (!IsValidLogConf(pLogConfInfo))
2422 return CR_INVALID_LOG_CONF;
2423
2424 if (ulFlags != 0)
2425 return CR_INVALID_FLAG;
2426
2427 if (hMachine != NULL)
2428 {
2429 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2430 if (BindingHandle == NULL)
2431 return CR_FAILURE;
2432
2433 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2434 if (StringTable == 0)
2435 return CR_FAILURE;
2436 }
2437 else
2438 {
2439 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2440 return CR_FAILURE;
2441 }
2442
2443 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
2444 if (lpDevInst == NULL)
2445 return CR_INVALID_DEVNODE;
2446
2448 {
2450 lpDevInst,
2451 pLogConfInfo->ulType,
2452 pLogConfInfo->ulTag,
2453 0);
2454 }
2456 {
2458 }
2460
2461 return ret;
2462}
DWORD WINAPI PNP_FreeLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4394
#define CR_INVALID_LOG_CONF
Definition: cfgmgr32.h:850
BOOL IsValidLogConf(_In_opt_ PLOG_CONF_INFO pLogConfInfo)
Definition: cfgmgr.c:419
struct _LOG_CONF_INFO * PLOG_CONF_INFO

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 2470 of file cfgmgr.c.

2472{
2473 PLOG_CONF_INFO pLogConfInfo;
2474
2475 TRACE("CM_Free_Log_Conf_Handle(%lx)\n", lcLogConf);
2476
2477 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
2478 if (!IsValidLogConf(pLogConfInfo))
2479 return CR_INVALID_LOG_CONF;
2480
2481 HeapFree(GetProcessHeap(), 0, pLogConfInfo);
2482
2483 return CR_SUCCESS;
2484}

◆ CM_Free_Range_List()

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

Definition at line 2492 of file cfgmgr.c.

2495{
2496 PINTERNAL_RANGE_LIST pRangeList;
2497 PINTERNAL_RANGE pRange;
2498 PLIST_ENTRY ListEntry;
2499
2500 FIXME("CM_Free_Range_List(%p %lx)\n",
2501 RangeList, ulFlags);
2502
2503 pRangeList = (PINTERNAL_RANGE_LIST)RangeList;
2504
2505 if (!IsValidRangeList(pRangeList))
2506 return CR_INVALID_RANGE_LIST;
2507
2508 if (ulFlags != 0)
2509 return CR_INVALID_FLAG;
2510
2511 /* Lock the range list */
2512 WaitForSingleObject(pRangeList->hMutex, INFINITE);
2513
2514 /* Free the list of ranges */
2515 while (!IsListEmpty(&pRangeList->ListHead))
2516 {
2517 ListEntry = RemoveHeadList(&pRangeList->ListHead);
2518 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
2519 HeapFree(GetProcessHeap(), 0, pRange);
2520 }
2521
2522 /* Unlock the range list */
2523 ReleaseMutex(pRangeList->hMutex);
2524
2525 /* Close the mutex */
2526 CloseHandle(pRangeList->hMutex);
2527
2528 /* Free the range list */
2529 HeapFree(GetProcessHeap(), 0, pRangeList);
2530
2531 return CR_SUCCESS;
2532}
#define CloseHandle
Definition: compat.h:739

◆ CM_Free_Res_Des()

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

Definition at line 2540 of file cfgmgr.c.

2544{
2545 TRACE("CM_Free_Res_Des(%p %p %lx)\n",
2546 prdResDes, rdResDes, ulFlags);
2547
2548 return CM_Free_Res_Des_Ex(prdResDes, rdResDes, ulFlags, NULL);
2549}
CONFIGRET WINAPI CM_Free_Res_Des_Ex(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2557

◆ 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 2557 of file cfgmgr.c.

2562{
2563 FIXME("CM_Free_Res_Des_Ex(%p %p %lx %p)\n",
2564 prdResDes, rdResDes, ulFlags, hMachine);
2565
2567}

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 2575 of file cfgmgr.c.

2577{
2578 PRES_DES_INFO pResDesInfo;
2579
2580 FIXME("CM_Free_Res_Des_Handle(%p)\n", rdResDes);
2581
2582 pResDesInfo = (PRES_DES_INFO)rdResDes;
2583 if (!IsValidResDes(pResDesInfo))
2584 return CR_INVALID_RES_DES;
2585
2586 HeapFree(GetProcessHeap(), 0, pResDesInfo);
2587
2588 return CR_SUCCESS;
2589}
#define CR_INVALID_RES_DES
Definition: cfgmgr32.h:849
BOOL IsValidResDes(_In_opt_ PRES_DES_INFO pResDesInfo)
Definition: cfgmgr.c:443
struct _RES_DES_INFO * PRES_DES_INFO

◆ CM_Free_Resource_Conflict_Handle()

CONFIGRET WINAPI CM_Free_Resource_Conflict_Handle ( _In_ CONFLICT_LIST  clConflictList)

Definition at line 2597 of file cfgmgr.c.

2599{
2600 PCONFLICT_DATA pConflictData;
2601
2602 FIXME("CM_Free_Resource_Conflict_Handle(%p)\n",
2603 clConflictList);
2604
2605 pConflictData = (PCONFLICT_DATA)clConflictList;
2606 if (!IsValidConflictData(pConflictData))
2608
2609 if (pConflictData->pConflictList != NULL)
2610 MyFree(pConflictData->pConflictList);
2611
2612 MyFree(pConflictData);
2613
2614 return CR_SUCCESS;
2615}
#define CR_INVALID_CONFLICT_LIST
Definition: cfgmgr32.h:903
BOOL IsValidConflictData(_In_opt_ PCONFLICT_DATA pConflictData)
Definition: cfgmgr.c:467
struct _CONFLICT_DATA * PCONFLICT_DATA
PPNP_CONFLICT_LIST pConflictList
Definition: cfgmgr.c:108

◆ CM_Get_Child()

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

Definition at line 2623 of file cfgmgr.c.

2627{
2628 TRACE("CM_Get_Child(%p %p %lx)\n",
2629 pdnDevInst, dnDevInst, ulFlags);
2630
2631 return CM_Get_Child_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
2632}
CONFIGRET WINAPI CM_Get_Child_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2640

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 2640 of file cfgmgr.c.

2645{
2646 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
2648 HSTRING_TABLE StringTable = NULL;
2649 LPWSTR lpDevInst;
2650 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
2651 CONFIGRET ret;
2652
2653 TRACE("CM_Get_Child_Ex(%p %lx %lx %p)\n",
2654 pdnDevInst, dnDevInst, ulFlags, hMachine);
2655
2656 if (pdnDevInst == NULL)
2657 return CR_INVALID_POINTER;
2658
2659 if (dnDevInst == 0)
2660 return CR_INVALID_DEVINST;
2661
2662 if (ulFlags != 0)
2663 return CR_INVALID_FLAG;
2664
2665 *pdnDevInst = -1;
2666
2667 if (hMachine != NULL)
2668 {
2669 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2670 if (BindingHandle == NULL)
2671 return CR_FAILURE;
2672
2673 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2674 if (StringTable == 0)
2675 return CR_FAILURE;
2676 }
2677 else
2678 {
2679 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2680 return CR_FAILURE;
2681 }
2682
2683 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
2684 if (lpDevInst == NULL)
2685 return CR_INVALID_DEVNODE;
2686
2688 {
2690 PNP_GET_CHILD_DEVICE_INSTANCE,
2691 lpDevInst,
2692 szRelatedDevInst,
2693 &dwLength,
2694 0);
2695 }
2697 {
2699 }
2701
2702 if (ret != CR_SUCCESS)
2703 return ret;
2704
2705 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
2706
2707 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
2708 if (dwIndex == -1)
2709 return CR_FAILURE;
2710
2711 *pdnDevInst = dwIndex;
2712
2713 return CR_SUCCESS;
2714}
DWORD WINAPI PNP_GetRelatedDeviceInstance(handle_t hBinding, DWORD ulRelationship, LPWSTR pDeviceID, LPWSTR pRelatedDeviceId, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:895
static DWORD DWORD * dwLength
Definition: fusion.c:86
unsigned long DWORD
Definition: ntddk_ex.h:95

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 2760 of file cfgmgr.c.

2766{
2767 WCHAR szBuffer[MAX_GUID_STRING_LEN];
2769 ULONG ulLength;
2770 ULONG ulOrigLength;
2771
2772 TRACE("CM_Get_Class_Key_Name_ExA(%p %p %p %lx %p)\n",
2773 ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
2774
2775 if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
2776 return CR_INVALID_POINTER;
2777
2778 ulOrigLength = *pulLength;
2779 *pulLength = 0;
2780
2781 ulLength = MAX_GUID_STRING_LEN;
2782 ret = CM_Get_Class_Key_Name_ExW(ClassGuid, szBuffer, &ulLength,
2783 ulFlags, hMachine);
2784 if (ret == CR_SUCCESS)
2785 {
2787 0,
2788 szBuffer,
2789 ulLength,
2790 pszKeyName,
2791 ulOrigLength,
2792 NULL,
2793 NULL) == 0)
2794 ret = CR_FAILURE;
2795 else
2796 *pulLength = lstrlenA(pszKeyName) + 1;
2797 }
2798
2799 return CR_SUCCESS;
2800}
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: cfgmgr.c:2808

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 2808 of file cfgmgr.c.

2814{
2815 TRACE("CM_Get_Class_Key_Name_ExW(%p %p %p %lx %p)\n",
2816 ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
2817
2818 if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
2819 return CR_INVALID_POINTER;
2820
2821 if (ulFlags != 0)
2822 return CR_INVALID_FLAG;
2823
2824 if (*pulLength < MAX_GUID_STRING_LEN)
2825 {
2826 *pulLength = 0;
2827 return CR_BUFFER_SMALL;
2828 }
2829
2830 if (!GuidToString(ClassGuid, pszKeyName))
2831 return CR_INVALID_DATA;
2832
2833 *pulLength = MAX_GUID_STRING_LEN;
2834
2835 return CR_SUCCESS;
2836}
#define CR_BUFFER_SMALL
Definition: cfgmgr32.h:872

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 2722 of file cfgmgr.c.

2727{
2728 TRACE("CM_Get_Class_Key_NameA(%p %p %p %lx)\n",
2729 ClassGuid, pszKeyName, pulLength, ulFlags);
2730
2731 return CM_Get_Class_Key_Name_ExA(ClassGuid, pszKeyName, pulLength,
2732 ulFlags, NULL);
2733}
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: cfgmgr.c:2760

◆ 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 2741 of file cfgmgr.c.

2746{
2747 TRACE("CM_Get_Class_Key_NameW(%p %p %p %lx)\n",
2748 ClassGuid, pszKeyName, pulLength, ulFlags);
2749
2750 return CM_Get_Class_Key_Name_ExW(ClassGuid, pszKeyName, pulLength,
2751 ulFlags, NULL);
2752}

◆ 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 2882 of file cfgmgr.c.

2888{
2889 WCHAR szBuffer[MAX_CLASS_NAME_LEN];
2891 ULONG ulLength;
2892 ULONG ulOrigLength;
2893
2894 TRACE("CM_Get_Class_Name_ExA(%p %p %p %lx %p)\n",
2895 ClassGuid, Buffer, pulLength, ulFlags, hMachine);
2896
2897 if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
2898 return CR_INVALID_POINTER;
2899
2900 ulOrigLength = *pulLength;
2901 *pulLength = 0;
2902
2903 ulLength = MAX_CLASS_NAME_LEN;
2904 ret = CM_Get_Class_Name_ExW(ClassGuid, szBuffer, &ulLength,
2905 ulFlags, hMachine);
2906 if (ret == CR_SUCCESS)
2907 {
2909 0,
2910 szBuffer,
2911 ulLength,
2912 Buffer,
2913 ulOrigLength,
2914 NULL,
2915 NULL) == 0)
2916 ret = CR_FAILURE;
2917 else
2918 *pulLength = lstrlenA(Buffer) + 1;
2919 }
2920
2921 return ret;
2922}
#define MAX_CLASS_NAME_LEN
Definition: cfgmgr32.h:52
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: cfgmgr.c:2930

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 2930 of file cfgmgr.c.

2936{
2937 WCHAR szGuidString[MAX_GUID_STRING_LEN];
2939 CONFIGRET ret;
2940
2941 TRACE("CM_Get_Class_Name_ExW(%p %p %p %lx %p\n",
2942 ClassGuid, Buffer, pulLength, ulFlags, hMachine);
2943
2944 if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
2945 return CR_INVALID_POINTER;
2946
2947 if (ulFlags != 0)
2948 return CR_INVALID_FLAG;
2949
2950 if (!GuidToString(ClassGuid, szGuidString))
2951 return CR_INVALID_DATA;
2952
2953 TRACE("Guid %s\n", debugstr_w(szGuidString));
2954
2955 if (hMachine != NULL)
2956 {
2957 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2958 if (BindingHandle == NULL)
2959 return CR_FAILURE;
2960 }
2961 else
2962 {
2964 return CR_FAILURE;
2965 }
2966
2968 {
2970 szGuidString,
2971 Buffer,
2972 pulLength,
2973 ulFlags);
2974 }
2976 {
2978 }
2980
2981 return ret;
2982}
DWORD WINAPI PNP_GetClassName(handle_t hBinding, LPWSTR pszClassGuid, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2542

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 2844 of file cfgmgr.c.

2849{
2850 TRACE("CM_Get_Class_NameA(%p %p %p %lx)\n",
2851 ClassGuid, Buffer, pulLength, ulFlags);
2852
2853 return CM_Get_Class_Name_ExA(ClassGuid, Buffer, pulLength, ulFlags,
2854 NULL);
2855}
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: cfgmgr.c:2882

◆ 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 2863 of file cfgmgr.c.

2868{
2869 TRACE("CM_Get_Class_NameW(%p %p %p %lx)\n",
2870 ClassGuid, Buffer, pulLength, ulFlags);
2871
2872 return CM_Get_Class_Name_ExW(ClassGuid, Buffer, pulLength, ulFlags,
2873 NULL);
2874}

◆ 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 2990 of file cfgmgr.c.

2998{
2999 PWSTR BufferW;
3000 ULONG ulLength = 0;
3001 ULONG ulType;
3002 CONFIGRET ret;
3003
3004 TRACE("CM_Get_Class_Registry_PropertyA(%p %lu %p %p %p %lx %p)\n",
3005 ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
3006 ulFlags, hMachine);
3007
3008 if (pulLength == NULL)
3009 return CR_INVALID_POINTER;
3010
3011 if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
3012 return CR_INVALID_PROPERTY;
3013
3014 ulType = GetRegistryPropertyType(ulProperty);
3015 if (ulType == REG_SZ || ulType == REG_MULTI_SZ)
3016 {
3017 /* Get the required buffer size */
3018 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3019 NULL, &ulLength, ulFlags, hMachine);
3020 if (ret != CR_BUFFER_SMALL)
3021 return ret;
3022
3023 /* Allocate the unicode buffer */
3024 BufferW = HeapAlloc(GetProcessHeap(), 0, ulLength);
3025 if (BufferW == NULL)
3026 return CR_OUT_OF_MEMORY;
3027
3028 /* Get the property */
3029 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3030 BufferW, &ulLength, ulFlags, hMachine);
3031 if (ret != CR_SUCCESS)
3032 {
3033 HeapFree(GetProcessHeap(), 0, BufferW);
3034 return ret;
3035 }
3036
3037 /* Do W->A conversion */
3038 *pulLength = WideCharToMultiByte(CP_ACP,
3039 0,
3040 BufferW,
3041 ulLength,
3042 Buffer,
3043 *pulLength,
3044 NULL,
3045 NULL);
3046
3047 /* Release the unicode buffer */
3048 HeapFree(GetProcessHeap(), 0, BufferW);
3049
3050 if (*pulLength == 0)
3051 ret = CR_FAILURE;
3052 }
3053 else
3054 {
3055 /* Get the property */
3056 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3057 Buffer, pulLength, ulFlags, hMachine);
3058 }
3059
3060 return ret;
3061}
#define CR_INVALID_PROPERTY
Definition: cfgmgr32.h:899
#define CM_CRP_MAX
Definition: cfgmgr32.h:733
CONFIGRET WINAPI CM_Get_Class_Registry_PropertyW(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
Definition: cfgmgr.c:3069
static ULONG GetRegistryPropertyType(_In_ ULONG ulProperty)
Definition: cfgmgr.c:150
#define REG_SZ
Definition: layer.c:22
#define REG_MULTI_SZ
Definition: nt_native.h:1501
_In_z_ PCWSTR _In_ ULONG ulType
Definition: ntuser.h:43

Referenced by SetupDiGetClassRegistryPropertyA().

◆ 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 3069 of file cfgmgr.c.

3077{
3079 WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
3080 ULONG ulType = 0;
3081 ULONG ulTransferLength = 0;
3082 CONFIGRET ret;
3083
3084 TRACE("CM_Get_Class_Registry_PropertyW(%p %lu %p %p %p %lx %p)\n",
3085 ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
3086 ulFlags, hMachine);
3087
3088 if (ClassGuid == NULL || pulLength == NULL)
3089 return CR_INVALID_POINTER;
3090
3091 if (ulFlags != 0)
3092 return CR_INVALID_FLAG;
3093
3094 if (pSetupStringFromGuid(ClassGuid,
3095 szGuidString,
3097 return CR_INVALID_DATA;
3098
3099 if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
3100 return CR_INVALID_PROPERTY;
3101
3102 if (hMachine != NULL)
3103 {
3104 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3105 if (BindingHandle == NULL)
3106 return CR_FAILURE;
3107 }
3108 else
3109 {
3111 return CR_FAILURE;
3112 }
3113
3114 ulTransferLength = *pulLength;
3115
3117 {
3119 szGuidString,
3120 ulProperty,
3121 &ulType,
3122 Buffer,
3123 &ulTransferLength,
3124 pulLength,
3125 ulFlags);
3126 }
3128 {
3130 }
3132
3133 if (ret == CR_SUCCESS)
3134 {
3135 if (pulRegDataType != NULL)
3136 *pulRegDataType = ulType;
3137 }
3138
3139 return ret;
3140}
DWORD WINAPI PNP_GetClassRegProp(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2775
DWORD WINAPI pSetupStringFromGuid(LPGUID lpGUID, PWSTR pString, DWORD dwStringLen)
Definition: misc.c:1775
const unsigned long PNP_MAX_GUID_STRING_LEN
Definition: pnp.idl:12

Referenced by CM_Get_Class_Registry_PropertyA(), and SetupDiGetClassRegistryPropertyW().

◆ CM_Get_Depth()

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

Definition at line 3148 of file cfgmgr.c.

3152{
3153 TRACE("CM_Get_Depth(%p %lx %lx)\n",
3154 pulDepth, dnDevInst, ulFlags);
3155
3156 return CM_Get_Depth_Ex(pulDepth, dnDevInst, ulFlags, NULL);
3157}
CONFIGRET WINAPI CM_Get_Depth_Ex(_Out_ PULONG pulDepth, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3165

◆ 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 3165 of file cfgmgr.c.

3170{
3172 HSTRING_TABLE StringTable = NULL;
3173 LPWSTR lpDevInst;
3174 CONFIGRET ret;
3175
3176 TRACE("CM_Get_Depth_Ex(%p %lx %lx %p)\n",
3177 pulDepth, dnDevInst, ulFlags, hMachine);
3178
3179 if (pulDepth == NULL)
3180 return CR_INVALID_POINTER;
3181
3182 if (dnDevInst == 0)
3183 return CR_INVALID_DEVINST;
3184
3185 if (ulFlags != 0)
3186 return CR_INVALID_FLAG;
3187
3188 if (hMachine != NULL)
3189 {
3190 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3191 if (BindingHandle == NULL)
3192 return CR_FAILURE;
3193
3194 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3195 if (StringTable == 0)
3196 return CR_FAILURE;
3197 }
3198 else
3199 {
3200 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3201 return CR_FAILURE;
3202 }
3203
3204 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3205 if (lpDevInst == NULL)
3206 return CR_INVALID_DEVNODE;
3207
3209 {
3211 lpDevInst,
3212 pulDepth,
3213 ulFlags);
3214 }
3216 {
3218 }
3220
3221 return ret;
3222}
DWORD WINAPI PNP_GetDepth(handle_t hBinding, LPWSTR pszDeviceID, DWORD *pulDepth, DWORD ulFlags)
Definition: rpcserver.c:1840

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 3787 of file cfgmgr.c.

3793{
3794 WCHAR szBufferW[MAX_DEVICE_ID_LEN];
3796
3797 TRACE("CM_Get_Device_ID_ExA(%lx %p %lu %lx %p)\n",
3798 dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
3799
3800 if (Buffer == NULL)
3801 return CR_INVALID_POINTER;
3802
3803 ret = CM_Get_Device_ID_ExW(dnDevInst,
3804 szBufferW,
3806 ulFlags,
3807 hMachine);
3808 if (ret == CR_SUCCESS)
3809 {
3811 0,
3812 szBufferW,
3813 lstrlenW(szBufferW) + 1,
3814 Buffer,
3815 BufferLen,
3816 NULL,
3817 NULL) == 0)
3818 ret = CR_FAILURE;
3819 }
3820
3821 return ret;
3822}
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: cfgmgr.c:3830
#define lstrlenW
Definition: compat.h:750

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 3830 of file cfgmgr.c.

3836{
3837 HSTRING_TABLE StringTable = NULL;
3838
3839 TRACE("CM_Get_Device_ID_ExW(%lx %p %lu %lx %p)\n",
3840 dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
3841
3842 if (dnDevInst == 0)
3843 return CR_INVALID_DEVINST;
3844
3845 if (Buffer == NULL)
3846 return CR_INVALID_POINTER;
3847
3848 if (ulFlags != 0)
3849 return CR_INVALID_FLAG;
3850
3851 if (hMachine != NULL)
3852 {
3853 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3854 if (StringTable == NULL)
3855 return CR_FAILURE;
3856 }
3857 else
3858 {
3859 if (!PnpGetLocalHandles(NULL, &StringTable))
3860 return CR_FAILURE;
3861 }
3862
3863 if (!pSetupStringTableStringFromIdEx(StringTable,
3864 dnDevInst,
3865 Buffer,
3866 &BufferLen))
3867 return CR_FAILURE;
3868
3869 return CR_SUCCESS;
3870}
BOOL WINAPI pSetupStringTableStringFromIdEx(HSTRING_TABLE hStringTable, DWORD dwId, LPWSTR lpBuffer, LPDWORD lpBufferLength)
Definition: stringtable.c:760

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 3916 of file cfgmgr.c.

3922{
3923 LPWSTR BufferW = NULL;
3924 LPWSTR pszFilterW = NULL;
3926
3927 TRACE("CM_Get_Device_ID_List_ExA(%p %p %lu %lx %p)\n",
3928 pszFilter, Buffer, BufferLen, ulFlags, hMachine);
3929
3930 BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
3931 if (BufferW == NULL)
3932 return CR_OUT_OF_MEMORY;
3933
3934 if (pszFilter == NULL)
3935 {
3937 BufferW,
3938 BufferLen,
3939 ulFlags,
3940 hMachine);
3941 }
3942 else
3943 {
3944 if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
3945 {
3947 goto Done;
3948 }
3949
3950 ret = CM_Get_Device_ID_List_ExW(pszFilterW,
3951 BufferW,
3952 BufferLen,
3953 ulFlags,
3954 hMachine);
3955
3956 MyFree(pszFilterW);
3957 }
3958
3960 0,
3961 BufferW,
3962 BufferLen,
3963 Buffer,
3964 BufferLen,
3965 NULL,
3966 NULL) == 0)
3967 ret = CR_FAILURE;
3968
3969Done:
3970 MyFree(BufferW);
3971
3972 return ret;
3973}
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: cfgmgr.c:3981

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 3981 of file cfgmgr.c.

3987{
3989 CONFIGRET ret;
3990
3991 TRACE("CM_Get_Device_ID_List_ExW(%p %p %lu %lx %p)\n",
3992 pszFilter, Buffer, BufferLen, ulFlags, hMachine);
3993
3994 if (Buffer == NULL || BufferLen == 0)
3995 return CR_INVALID_POINTER;
3996
3997 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
3998 return CR_INVALID_FLAG;
3999
4000 if (hMachine != NULL)
4001 {
4002 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4003 if (BindingHandle == NULL)
4004 return CR_FAILURE;
4005 }
4006 else
4007 {
4009 return CR_FAILURE;
4010 }
4011
4012 *Buffer = 0;
4013
4015 {
4017 (LPWSTR)pszFilter,
4018 Buffer,
4019 &BufferLen,
4020 ulFlags);
4021 }
4023 {
4025 }
4027
4028 return ret;
4029}
DWORD WINAPI PNP_GetDeviceList(handle_t hBinding, LPWSTR pszFilter, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1394
#define CM_GETIDLIST_FILTER_BITS
Definition: cfgmgr32.h:669

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 4071 of file cfgmgr.c.

4076{
4077 LPWSTR pszFilterW = NULL;
4079
4080 FIXME("CM_Get_Device_ID_List_Size_ExA(%p %s %lx %p)\n",
4081 pulLen, debugstr_a(pszFilter), ulFlags, hMachine);
4082
4083 if (pszFilter == NULL)
4084 {
4086 NULL,
4087 ulFlags,
4088 hMachine);
4089 }
4090 else
4091 {
4092 if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
4093 return CR_INVALID_DEVICE_ID;
4094
4096 pszFilterW,
4097 ulFlags,
4098 hMachine);
4099
4100 MyFree(pszFilterW);
4101 }
4102
4103 return ret;
4104}
CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExW(_Out_ PULONG pulLen, _In_opt_ PCWSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4112

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 4112 of file cfgmgr.c.

4117{
4119 CONFIGRET ret;
4120
4121 FIXME("CM_Get_Device_ID_List_Size_ExW(%p %s %lx %p)\n",
4122 pulLen, debugstr_w(pszFilter), ulFlags, hMachine);
4123
4124 if (pulLen == NULL)
4125 return CR_INVALID_POINTER;
4126
4127 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
4128 return CR_INVALID_FLAG;
4129
4130 if (hMachine != NULL)
4131 {
4132 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4133 if (BindingHandle == NULL)
4134 return CR_FAILURE;
4135 }
4136 else
4137 {
4139 return CR_FAILURE;
4140 }
4141
4142 *pulLen = 0;
4143
4145 {
4147 (LPWSTR)pszFilter,
4148 pulLen,
4149 ulFlags);
4150 }
4152 {
4154 }
4156
4157 return ret;
4158}
DWORD WINAPI PNP_GetDeviceListSize(handle_t hBinding, LPWSTR pszFilter, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1765

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 4037 of file cfgmgr.c.

4041{
4042 TRACE("CM_Get_Device_ID_List_SizeA(%p %s %lx)\n",
4043 pulLen, debugstr_a(pszFilter), ulFlags);
4044
4045 return CM_Get_Device_ID_List_Size_ExA(pulLen, pszFilter, ulFlags, NULL);
4046}
CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExA(_Out_ PULONG pulLen, _In_opt_ PCSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4071

◆ 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 4054 of file cfgmgr.c.

4058{
4059 TRACE("CM_Get_Device_ID_List_SizeW(%p %s %lx)\n",
4060 pulLen, debugstr_w(pszFilter), ulFlags);
4061
4062 return CM_Get_Device_ID_List_Size_ExW(pulLen, pszFilter, ulFlags, NULL);
4063}

◆ 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 3878 of file cfgmgr.c.

3883{
3884 TRACE("CM_Get_Device_ID_ListA(%p %p %lu %lx)\n",
3885 pszFilter, Buffer, BufferLen, ulFlags);
3886
3887 return CM_Get_Device_ID_List_ExA(pszFilter, Buffer, BufferLen,
3888 ulFlags, NULL);
3889}
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: cfgmgr.c:3916

◆ 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 3897 of file cfgmgr.c.

3902{
3903 TRACE("CM_Get_Device_ID_ListW(%p %p %lu %lx)\n",
3904 pszFilter, Buffer, BufferLen, ulFlags);
3905
3906 return CM_Get_Device_ID_List_ExW(pszFilter, Buffer, BufferLen,
3907 ulFlags, NULL);
3908}

◆ CM_Get_Device_ID_Size()

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

Definition at line 4166 of file cfgmgr.c.

4170{
4171 TRACE("CM_Get_Device_ID_Size(%p %lx %lx)\n",
4172 pulLen, dnDevInst, ulFlags);
4173
4174 return CM_Get_Device_ID_Size_Ex(pulLen, dnDevInst, ulFlags, NULL);
4175}
CONFIGRET WINAPI CM_Get_Device_ID_Size_Ex(_Out_ PULONG pulLen, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4183

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 4183 of file cfgmgr.c.

4188{
4189 HSTRING_TABLE StringTable = NULL;
4190 LPWSTR DeviceId;
4191
4192 TRACE("CM_Get_Device_ID_Size_Ex(%p %lx %lx %p)\n",
4193 pulLen, dnDevInst, ulFlags, hMachine);
4194
4195 if (pulLen == NULL)
4196 return CR_INVALID_POINTER;
4197
4198 if (dnDevInst == 0)
4199 return CR_INVALID_DEVINST;
4200
4201 if (ulFlags != 0)
4202 return CR_INVALID_FLAG;
4203
4204 if (hMachine != NULL)
4205 {
4206 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4207 if (StringTable == NULL)
4208 return CR_FAILURE;
4209 }
4210 else
4211 {
4212 if (!PnpGetLocalHandles(NULL, &StringTable))
4213 return CR_FAILURE;
4214 }
4215
4216 DeviceId = pSetupStringTableStringFromId(StringTable, dnDevInst);
4217 if (DeviceId == NULL)
4218 {
4219 *pulLen = 0;
4220 return CR_SUCCESS;
4221 }
4222
4223 *pulLen = lstrlenW(DeviceId);
4224
4225 return CR_SUCCESS;
4226}

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 3751 of file cfgmgr.c.

3756{
3757 TRACE("CM_Get_Device_IDA(%lx %p %lu %lx)\n",
3758 dnDevInst, Buffer, BufferLen, ulFlags);
3759
3760 return CM_Get_Device_ID_ExA(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
3761}
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: cfgmgr.c:3787

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 3769 of file cfgmgr.c.

3774{
3775 TRACE("CM_Get_Device_IDW(%lx %p %lu %lx)\n",
3776 dnDevInst, Buffer, BufferLen, ulFlags);
3777
3778 return CM_Get_Device_ID_ExW(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
3779}

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 4278 of file cfgmgr.c.

4285{
4286 FIXME("CM_Get_Device_Interface_Alias_ExA(%p %p %p %p %lx %p)\n",
4287 pszDeviceInterface, AliasInterfaceGuid,
4288 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4289
4291}

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 4299 of file cfgmgr.c.

4306{
4308 ULONG ulTransferLength;
4310
4311 TRACE("CM_Get_Device_Interface_Alias_ExW(%p %p %p %p %lx %p)\n",
4312 pszDeviceInterface, AliasInterfaceGuid,
4313 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4314
4315 if (pszDeviceInterface == NULL ||
4316 AliasInterfaceGuid == NULL ||
4317 pszAliasDeviceInterface == NULL ||
4318 pulLength == NULL)
4319 return CR_INVALID_POINTER;
4320
4321 if (ulFlags != 0)
4322 return CR_INVALID_FLAG;
4323
4324 if (hMachine != NULL)
4325 {
4326 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4327 if (BindingHandle == NULL)
4328 return CR_FAILURE;
4329 }
4330 else
4331 {
4333 return CR_FAILURE;
4334 }
4335
4336 ulTransferLength = *pulLength;
4337
4339 {
4341 (LPWSTR)pszDeviceInterface,
4342 AliasInterfaceGuid,
4343 pszAliasDeviceInterface,
4344 pulLength,
4345 &ulTransferLength,
4346 0);
4347 }
4349 {
4351 }
4353
4354 return ret;
4355}
DWORD WINAPI PNP_GetInterfaceDeviceAlias(handle_t hBinding, LPWSTR pszInterfaceDevice, GUID *AliasInterfaceGuid, LPWSTR pszAliasInterfaceDevice, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
Definition: rpcserver.c:2632

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 4234 of file cfgmgr.c.

4240{
4241 TRACE("CM_Get_Device_Interface_AliasA(%p %p %p %p %lx)\n",
4242 pszDeviceInterface, AliasInterfaceGuid,
4243 pszAliasDeviceInterface, pulLength, ulFlags);
4244
4245 return CM_Get_Device_Interface_Alias_ExA(pszDeviceInterface,
4246 AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
4247 ulFlags, NULL);
4248}
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: cfgmgr.c:4278

◆ 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 4256 of file cfgmgr.c.

4262{
4263 TRACE("CM_Get_Device_Interface_AliasW(%p %p %p %p %lx)\n",
4264 pszDeviceInterface, AliasInterfaceGuid,
4265 pszAliasDeviceInterface, pulLength, ulFlags);
4266
4267 return CM_Get_Device_Interface_Alias_ExW(pszDeviceInterface,
4268 AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
4269 ulFlags, NULL);
4270}
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: cfgmgr.c:4299

◆ 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 4405 of file cfgmgr.c.

4412{
4413 DEVINSTID_W pDeviceIdW = NULL;
4414 PWCHAR BufferW = NULL;
4416
4417 TRACE("CM_Get_Device_Interface_List_ExA(%s %s %p %lu 0x%08lx %p)\n",
4419 Buffer, BufferLen, ulFlags, hMachine);
4420
4421 if (Buffer == NULL ||
4422 BufferLen == 0)
4423 return CR_INVALID_POINTER;
4424
4425 if (pDeviceID != NULL)
4426 {
4427 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4428 return CR_INVALID_DEVICE_ID;
4429 }
4430
4431 BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
4432 if (BufferW == NULL)
4433 {
4435 goto Done;
4436 }
4437
4439 BufferW, BufferLen, ulFlags,
4440 hMachine);
4441 if (ret != CR_SUCCESS)
4442 goto Done;
4443
4445 0,
4446 BufferW,
4447 BufferLen,
4448 Buffer,
4449 BufferLen,
4450 NULL,
4451 NULL) == 0)
4452 ret = CR_FAILURE;
4453
4454Done:
4455 if (BufferW != NULL)
4456 MyFree(BufferW);
4457
4458 if (pDeviceIdW != NULL)
4459 MyFree(pDeviceIdW);
4460
4461 return ret;
4462}
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: cfgmgr.c:4470
#define debugstr_guid
Definition: kernel32.h:35
uint16_t * PWCHAR
Definition: typedefs.h:56
_In_ CONST GUID * InterfaceClassGuid
Definition: iofuncs.h:1136

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 4470 of file cfgmgr.c.

4477{
4481
4482 TRACE("CM_Get_Device_Interface_List_ExW(%s %s %p %lu 0x%08lx %p)\n",
4484 Buffer, BufferLen, ulFlags, hMachine);
4485
4486 if (Buffer == NULL ||
4487 BufferLen == 0)
4488 return CR_INVALID_POINTER;
4489
4490 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4491 return CR_INVALID_FLAG;
4492
4493 if (hMachine != NULL)
4494 {
4495 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4496 if (BindingHandle == NULL)
4497 return CR_FAILURE;
4498 }
4499 else
4500 {
4502 return CR_FAILURE;
4503 }
4504
4505 *Buffer = 0;
4506 BufferSize = BufferLen;
4507
4509 {
4512 pDeviceID,
4513 (LPBYTE)Buffer,
4514 &BufferSize,
4515 ulFlags);
4516 }
4518 {
4520 }
4522
4523 return ret;
4524}
DWORD WINAPI PNP_GetInterfaceDeviceList(handle_t hBinding, GUID *InterfaceGuid, LPWSTR pszDeviceID, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2649
#define CM_GET_DEVICE_INTERFACE_LIST_BITS
Definition: cfgmgr32.h:674
unsigned long PNP_RPC_BUFFER_SIZE
Definition: pnp.idl:34
unsigned char * LPBYTE
Definition: typedefs.h:53
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254

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 4570 of file cfgmgr.c.

4576{
4577 DEVINSTID_W pDeviceIdW = NULL;
4579
4580 TRACE("CM_Get_Device_Interface_List_Size_ExA(%p %p %s 0x%08lx %p)\n",
4581 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags, hMachine);
4582
4583 if (pulLen == NULL)
4584 return CR_INVALID_POINTER;
4585
4586 if (pDeviceID != NULL)
4587 {
4588 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4589 return CR_INVALID_DEVICE_ID;
4590 }
4591
4592 *pulLen = 0;
4593
4595 pDeviceIdW, ulFlags, hMachine);
4596
4597 if (pDeviceIdW != NULL)
4598 MyFree(pDeviceIdW);
4599
4600 return ret;
4601}
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: cfgmgr.c:4609

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 4609 of file cfgmgr.c.

4615{
4618
4619 TRACE("CM_Get_Device_Interface_List_Size_ExW(%p %p %s 0x%08lx %p)\n",
4620 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags, hMachine);
4621
4622 if (pulLen == NULL)
4623 return CR_INVALID_POINTER;
4624
4625 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4626 return CR_INVALID_FLAG;
4627
4628 if (hMachine != NULL)
4629 {
4630 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4631 if (BindingHandle == NULL)
4632 return CR_FAILURE;
4633 }
4634 else
4635 {
4637 return CR_FAILURE;
4638 }
4639
4640 *pulLen = 0;
4641
4643 {
4645 pulLen,
4647 pDeviceID,
4648 ulFlags);
4649 }
4651 {
4653 }
4655
4656 return ret;
4657}
DWORD WINAPI PNP_GetInterfaceDeviceListSize(handle_t hBinding, PNP_RPC_BUFFER_SIZE *pulLen, GUID *InterfaceGuid, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:2697

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 4532 of file cfgmgr.c.

4537{
4538 TRACE("CM_Get_Device_Interface_List_SizeA(%p %p %s 0x%08lx)\n",
4539 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags);
4540
4542 pDeviceID, ulFlags, NULL);
4543}
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: cfgmgr.c:4570

◆ 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 4551 of file cfgmgr.c.

4556{
4557 TRACE("CM_Get_Device_Interface_List_SizeW(%p %p %s 0x%08lx)\n",
4558 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags);
4559
4561 pDeviceID, ulFlags, NULL);
4562}

◆ 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 4363 of file cfgmgr.c.

4369{
4370 TRACE("CM_Get_Device_Interface_ListA(%s %s %p %lu 0x%08lx)\n",
4372 Buffer, BufferLen, ulFlags);
4373
4375 Buffer, BufferLen, ulFlags, NULL);
4376}
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: cfgmgr.c:4405

◆ 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 4384 of file cfgmgr.c.

4390{
4391 TRACE("CM_Get_Device_Interface_ListW(%s %s %p %lu 0x%08lx)\n",
4393 Buffer, BufferLen, ulFlags);
4394
4396 Buffer, BufferLen, ulFlags, NULL);
4397}

◆ 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 3276 of file cfgmgr.c.

3284{
3285 LPWSTR pszPropertyNameW;
3286 PVOID BufferW;
3287 ULONG ulLengthW;
3288 ULONG ulDataType = REG_NONE;
3289 CONFIGRET ret;
3290
3291 TRACE("CM_Get_DevNode_Custom_Property_ExA(%lx %s %p %p %p %lx %p)\n",
3292 dnDevInst, pszCustomPropertyName, pulRegDataType,
3293 Buffer, pulLength, ulFlags, hMachine);
3294
3295 if (!pulLength)
3296 return CR_INVALID_POINTER;
3297
3298 ulLengthW = *pulLength * sizeof(WCHAR);
3299 BufferW = HeapAlloc(GetProcessHeap(), 0, ulLengthW);
3300 if (!BufferW)
3301 return CR_OUT_OF_MEMORY;
3302
3303 pszPropertyNameW = pSetupMultiByteToUnicode(pszCustomPropertyName,
3304 CP_ACP);
3305 if (pszPropertyNameW == NULL)
3306 {
3307 HeapFree(GetProcessHeap(), 0, BufferW);
3308 return CR_OUT_OF_MEMORY;
3309 }
3310
3312 pszPropertyNameW,
3313 &ulDataType,
3314 BufferW,
3315 &ulLengthW,
3316 ulFlags,
3317 hMachine);
3318 if (ret == CR_SUCCESS)
3319 {
3320 if (ulDataType == REG_SZ ||
3321 ulDataType == REG_EXPAND_SZ ||
3322 ulDataType == REG_MULTI_SZ)
3323 {
3324 /* Do W->A conversion */
3325 *pulLength = WideCharToMultiByte(CP_ACP,
3326 0,
3327 BufferW,
3328 lstrlenW(BufferW) + 1,
3329 Buffer,
3330 *pulLength,
3331 NULL,
3332 NULL);
3333 if (*pulLength == 0)
3334 ret = CR_FAILURE;
3335 }
3336 else
3337 {
3338 /* Directly copy the value */
3339 if (ulLengthW <= *pulLength)
3340 memcpy(Buffer, BufferW, ulLengthW);
3341 else
3342 {
3343 *pulLength = ulLengthW;
3345 }
3346 }
3347 }
3348
3349 if (pulRegDataType)
3350 *pulRegDataType = ulDataType;
3351
3352 HeapFree(GetProcessHeap(), 0, BufferW);
3353 MyFree(pszPropertyNameW);
3354
3355 return ret;
3356}
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: cfgmgr.c:3364
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define REG_NONE
Definition: nt_native.h:1492
#define REG_EXPAND_SZ
Definition: nt_native.h:1494

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 3364 of file cfgmgr.c.

3372{
3374 HSTRING_TABLE StringTable = NULL;
3375 LPWSTR lpDevInst;
3376 ULONG ulDataType = REG_NONE;
3377 ULONG ulTransferLength;
3379
3380 TRACE("CM_Get_DevNode_Custom_Property_ExW(%lx %s %p %p %p %lx %p)\n",
3381 dnDevInst, debugstr_w(pszCustomPropertyName), pulRegDataType,
3382 Buffer, pulLength, ulFlags, hMachine);
3383
3384 if (dnDevInst == 0)
3385 return CR_INVALID_DEVNODE;
3386
3387 if (pszCustomPropertyName == NULL ||
3388 pulLength == NULL ||
3389 *pulLength == 0)
3390 return CR_INVALID_POINTER;
3391
3392 if (ulFlags & ~CM_CUSTOMDEVPROP_BITS)
3393 return CR_INVALID_FLAG;
3394
3395 if (hMachine != NULL)
3396 {
3397 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3398 if (BindingHandle == NULL)
3399 return CR_FAILURE;
3400
3401 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3402 if (StringTable == 0)
3403 return CR_FAILURE;
3404 }
3405 else
3406 {
3407 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3408 return CR_FAILURE;
3409 }
3410
3411 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3412 if (lpDevInst == NULL)
3413 return CR_INVALID_DEVNODE;
3414
3415 ulTransferLength = *pulLength;
3416
3418 {
3420 lpDevInst,
3421 (LPWSTR)pszCustomPropertyName,
3422 &ulDataType,
3423 Buffer,
3424 &ulTransferLength,
3425 pulLength,
3426 ulFlags);
3427 }
3429 {
3431 }
3433
3434 if (ret == CR_SUCCESS)
3435 {
3436 if (pulRegDataType != NULL)
3437 *pulRegDataType = ulDataType;
3438 }
3439
3440 return ret;
3441}
DWORD WINAPI PNP_GetCustomDevProp(handle_t hBinding, LPWSTR pDeviceID, LPWSTR CustomPropName, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:5188
#define CM_CUSTOMDEVPROP_BITS
Definition: cfgmgr32.h:836

Referenced by CM_Get_DevNode_Custom_Property_ExA(), and CM_Get_DevNode_Custom_PropertyW().

◆ CM_Get_DevNode_Custom_PropertyA()

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 
)

Definition at line 3230 of file cfgmgr.c.

3237{
3238 TRACE("CM_Get_DevNode_Custom_PropertyA(%lx %s %p %p %p %lx)\n",
3239 dnDevInst, pszCustomPropertyName, pulRegDataType,
3240 Buffer, pulLength, ulFlags);
3241
3242 return CM_Get_DevNode_Custom_Property_ExA(dnDevInst, pszCustomPropertyName,
3243 pulRegDataType, Buffer,
3244 pulLength, ulFlags, NULL);
3245}
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: cfgmgr.c:3276

◆ CM_Get_DevNode_Custom_PropertyW()

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 
)

Definition at line 3253 of file cfgmgr.c.

3260{
3261 TRACE("CM_Get_DevNode_Custom_PropertyW(%lx %s %p %p %p %lx)\n",
3262 dnDevInst, debugstr_w(pszCustomPropertyName), pulRegDataType,
3263 Buffer, pulLength, ulFlags);
3264
3265 return CM_Get_DevNode_Custom_Property_ExW(dnDevInst, pszCustomPropertyName,
3266 pulRegDataType, Buffer,
3267 pulLength, ulFlags, NULL);
3268}

◆ CM_Get_DevNode_Registry_Property_ExA()

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 
)

Definition at line 3493 of file cfgmgr.c.

3501{
3502 PVOID BufferW;
3503 ULONG LengthW;
3504 ULONG ulDataType = REG_NONE;
3505 CONFIGRET ret;
3506
3507 TRACE("CM_Get_DevNode_Registry_Property_ExA(%lx %lu %p %p %p %lx %p)\n",
3508 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
3509 ulFlags, hMachine);
3510
3511 if (!pulLength)
3512 return CR_INVALID_POINTER;
3513
3514 LengthW = *pulLength * sizeof(WCHAR);
3515 BufferW = HeapAlloc(GetProcessHeap(), 0, LengthW);
3516 if (!BufferW)
3517 return CR_OUT_OF_MEMORY;
3518
3520 ulProperty,
3521 &ulDataType,
3522 BufferW,
3523 &LengthW,
3524 ulFlags,
3525 hMachine);
3526
3527 if (ret == CR_SUCCESS)
3528 {
3529 if (ulDataType == REG_SZ ||
3530 ulDataType == REG_EXPAND_SZ ||
3531 ulDataType == REG_MULTI_SZ)
3532 {
3533 /* Do W->A conversion */
3534 *pulLength = WideCharToMultiByte(CP_ACP,
3535 0,
3536 BufferW,
3537 lstrlenW(BufferW) + 1,
3538 Buffer,
3539 *pulLength,
3540 NULL,
3541 NULL);
3542 if (*pulLength == 0)
3543 ret = CR_FAILURE;
3544 }
3545 else
3546 {
3547 /* Directly copy the value */
3548 if (LengthW <= *pulLength)
3549 memcpy(Buffer, BufferW, LengthW);
3550 else
3551 {
3552 *pulLength = LengthW;
3554 }
3555 }
3556 }
3557
3558 if (pulRegDataType)
3559 *pulRegDataType = ulDataType;
3560
3561 HeapFree(GetProcessHeap(), 0, BufferW);
3562
3563 return ret;
3564}
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)
Definition: cfgmgr.c:3572

Referenced by CM_Get_DevNode_Registry_PropertyA().

◆ CM_Get_DevNode_Registry_Property_ExW()

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 
)

Definition at line 3572 of file cfgmgr.c.

3580{
3582 HSTRING_TABLE StringTable = NULL;
3584 LPWSTR lpDevInst;
3585 ULONG ulDataType = REG_NONE;
3586 ULONG ulTransferLength = 0;
3587
3588 TRACE("CM_Get_DevNode_Registry_Property_ExW(%lx %lu %p %p %p %lx %p)\n",
3589 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
3590 ulFlags, hMachine);
3591
3592 if (dnDevInst == 0)
3593 return CR_INVALID_DEVNODE;
3594
3595 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
3596 return CR_INVALID_PROPERTY;
3597
3598 /* pulRegDataType is optional */
3599
3600 /* Buffer is optional */
3601
3602 if (pulLength == NULL)
3603 return CR_INVALID_POINTER;
3604
3605 if (*pulLength == 0)
3606 return CR_INVALID_POINTER;
3607
3608 if (ulFlags != 0)
3609 return CR_INVALID_FLAG;
3610
3611 if (hMachine != NULL)
3612 {
3613 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3614 if (BindingHandle == NULL)
3615 return CR_FAILURE;
3616
3617 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3618 if (StringTable == 0)
3619 return CR_FAILURE;
3620 }
3621 else
3622 {
3623 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3624 return CR_FAILURE;
3625 }
3626
3627 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3628 if (lpDevInst == NULL)
3629 return CR_INVALID_DEVNODE;
3630
3631 ulTransferLength = *pulLength;
3632
3634 {
3636 lpDevInst,
3637 ulProperty,
3638 &ulDataType,
3639 Buffer,
3640 &ulTransferLength,
3641 pulLength,
3642 ulFlags);
3643 }
3645 {
3647 }
3649
3650 if (ret == CR_SUCCESS)
3651 {
3652 if (pulRegDataType != NULL)
3653 *pulRegDataType = ulDataType;
3654 }
3655
3656 return ret;
3657}
DWORD WINAPI PNP_GetDeviceRegProp(handle_t hBinding, LPWSTR pDeviceID, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_PROP_SIZE *pulTransferLen, PNP_PROP_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1883
#define CM_DRP_MAX
Definition: cfgmgr32.h:732

Referenced by CM_Get_DevNode_Registry_Property_ExA(), CM_Get_DevNode_Registry_PropertyW(), DisplayDevNodeEnumerator(), SETUP_CreateDevicesList(), and SetupDiGetDeviceRegistryPropertyW().

◆ CM_Get_DevNode_Registry_PropertyA()

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 
)

Definition at line 3449 of file cfgmgr.c.

3456{
3457 TRACE("CM_Get_DevNode_Registry_PropertyA(%lx %lu %p %p %p %lx)\n",
3458 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
3459
3460 return CM_Get_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
3461 pulRegDataType, Buffer,
3462 pulLength, ulFlags, NULL);
3463}
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)
Definition: cfgmgr.c:3493

◆ CM_Get_DevNode_Registry_PropertyW()

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 
)

Definition at line 3471 of file cfgmgr.c.

3478{
3479 TRACE("CM_Get_DevNode_Registry_PropertyW(%lx %lu %p %p %p %lx)\n",
3480 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
3481
3482 return CM_Get_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
3483 pulRegDataType, Buffer,
3484 pulLength, ulFlags, NULL);
3485}

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

◆ CM_Get_DevNode_Status()

CONFIGRET WINAPI CM_Get_DevNode_Status ( _Out_ PULONG  pulStatus,
_Out_ PULONG  pulProblemNumber,
_In_ DEVINST  dnDevInst,
_In_ ULONG  ulFlags 
)

Definition at line 3665 of file cfgmgr.c.

3670{
3671 TRACE("CM_Get_DevNode_Status(%p %p %lx %lx)\n",
3672 pulStatus, pulProblemNumber, dnDevInst, ulFlags);
3673
3674 return CM_Get_DevNode_Status_Ex(pulStatus, pulProblemNumber, dnDevInst,
3675 ulFlags, NULL);
3676}
CONFIGRET WINAPI CM_Get_DevNode_Status_Ex(_Out_ PULONG pulStatus, _Out_ PULONG pulProblemNumber, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3684

Referenced by EnumHotpluggedDevices(), and StorageCoInstaller().

◆ CM_Get_DevNode_Status_Ex()

CONFIGRET WINAPI CM_Get_DevNode_Status_Ex ( _Out_ PULONG  pulStatus,
_Out_ PULONG  pulProblemNumber,
_In_ DEVINST  dnDevInst,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 3684 of file cfgmgr.c.

3690{
3692 HSTRING_TABLE StringTable = NULL;
3693 LPWSTR lpDevInst;
3694 CONFIGRET ret;
3695
3696 TRACE("CM_Get_DevNode_Status_Ex(%p %p %lx %lx %p)\n",
3697 pulStatus, pulProblemNumber, dnDevInst, ulFlags, hMachine);
3698
3699 if (pulStatus == NULL || pulProblemNumber == NULL)
3700 return CR_INVALID_POINTER;
3701
3702 if (dnDevInst == 0)
3703 return CR_INVALID_DEVINST;
3704
3705 if (ulFlags != 0)
3706 return CR_INVALID_FLAG;
3707
3708 if (hMachine != NULL)
3709 {
3710 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3711 if (BindingHandle == NULL)
3712 return CR_FAILURE;
3713
3714 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3715 if (StringTable == 0)
3716 return CR_FAILURE;
3717 }
3718 else
3719 {
3720 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3721 return CR_FAILURE;
3722 }
3723
3724 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3725 if (lpDevInst == NULL)
3726 return CR_INVALID_DEVNODE;
3727
3729 {
3731 lpDevInst,
3732 pulStatus,
3733 pulProblemNumber,
3734 ulFlags);
3735 }
3737 {
3739 }
3741
3742 return ret;
3743}
DWORD WINAPI PNP_GetDeviceStatus(handle_t hBinding, LPWSTR pDeviceID, DWORD *pulStatus, DWORD *pulProblem, DWORD ulFlags)
Definition: rpcserver.c:3459

Referenced by CDeviceNode::CanDisable(), CanDisableDevice(), CDeviceNode::CanUninstall(), CM_Get_DevNode_Status(), DisplayDevNodeFlags(), GetDeviceStatusString(), CDeviceNode::HasProblem(), InitProbeListPage(), IsDeviceHidden(), IsDeviceStarted(), CDeviceNode::IsDisabled(), IsDriverInstalled(), CDeviceNode::IsHidden(), CDeviceNode::IsInstalled(), CDeviceNode::IsStarted(), ShowDeviceProblemWizard(), UpdateDevInfo(), and UpdateDriverDlg().

◆ CM_Get_First_Log_Conf()

CONFIGRET WINAPI CM_Get_First_Log_Conf ( _Out_opt_ PLOG_CONF  plcLogConf,
_In_ DEVINST  dnDevInst,
_In_ ULONG  ulFlags 
)

Definition at line 4665 of file cfgmgr.c.

4669{
4670 TRACE("CM_Get_First_Log_Conf(%p %lx %lx)\n",
4671 plcLogConf, dnDevInst, ulFlags);
4672
4673 return CM_Get_First_Log_Conf_Ex(plcLogConf, dnDevInst, ulFlags, NULL);
4674}
CONFIGRET WINAPI CM_Get_First_Log_Conf_Ex(_Out_opt_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4682

◆ CM_Get_First_Log_Conf_Ex()

CONFIGRET WINAPI CM_Get_First_Log_Conf_Ex ( _Out_opt_ PLOG_CONF  plcLogConf,
_In_ DEVINST  dnDevInst,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 4682 of file cfgmgr.c.

4687{
4689 HSTRING_TABLE StringTable = NULL;
4690 LPWSTR lpDevInst = NULL;
4692 ULONG ulTag;
4693 PLOG_CONF_INFO pLogConfInfo;
4694
4695 FIXME("CM_Get_First_Log_Conf_Ex(%p %lx %lx %p)\n",
4696 plcLogConf, dnDevInst, ulFlags, hMachine);
4697
4698 if (dnDevInst == 0)
4699 return CR_INVALID_DEVINST;
4700
4701 if (ulFlags & ~LOG_CONF_BITS)
4702 return CR_INVALID_FLAG;
4703
4704 if (plcLogConf)
4705 *plcLogConf = 0;
4706
4707 if (hMachine != NULL)
4708 {
4709 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4710 if (BindingHandle == NULL)
4711 return CR_FAILURE;
4712
4713 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4714 if (StringTable == 0)
4715 return CR_FAILURE;
4716 }
4717 else
4718 {
4719 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4720 return CR_FAILURE;
4721 }
4722
4723 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4724 if (lpDevInst == NULL)
4725 return CR_INVALID_DEVNODE;
4726
4728 {
4730 lpDevInst,
4731 ulFlags,
4732 &ulTag,
4733 ulFlags);
4734 }
4736 {
4738 }
4740
4741 if (ret != CR_SUCCESS)
4742 return ret;
4743
4744 if (plcLogConf)
4745 {
4746 pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
4747 if (pLogConfInfo == NULL)
4748 return CR_OUT_OF_MEMORY;
4749
4750 pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
4751 pLogConfInfo->dnDevInst = dnDevInst;
4752 pLogConfInfo->ulType = ulFlags;
4753 pLogConfInfo->ulTag = ulTag;
4754
4755 *plcLogConf = (LOG_CONF)pLogConfInfo;
4756 }
4757
4758 return CR_SUCCESS;
4759}
DWORD WINAPI PNP_GetFirstLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4488
_In_ ULONG _In_ ULONG ulTag
Definition: winddi.h:3942

Referenced by CM_Get_First_Log_Conf().

◆ CM_Get_Global_State()

CONFIGRET WINAPI CM_Get_Global_State ( _Out_ PULONG  pulState,
_In_ ULONG  ulFlags 
)

Definition at line 4767 of file cfgmgr.c.

4770{
4771 TRACE("CM_Get_Global_State(%p %lx)\n",
4772 pulState, ulFlags);
4773
4774 return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
4775}
CONFIGRET WINAPI CM_Get_Global_State_Ex(_Out_ PULONG pulState, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4783

◆ CM_Get_Global_State_Ex()

CONFIGRET WINAPI CM_Get_Global_State_Ex ( _Out_ PULONG  pulState,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 4783 of file cfgmgr.c.

4787{
4789 CONFIGRET ret;
4790
4791 TRACE("CM_Get_Global_State_Ex(%p %lx %p)\n",
4792 pulState, ulFlags, hMachine);
4793
4794 if (pulState == NULL)
4795 return CR_INVALID_POINTER;
4796
4797 if (ulFlags != 0)
4798 return CR_INVALID_FLAG;
4799
4800 if (hMachine != NULL)
4801 {
4802 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4803 if (BindingHandle == NULL)
4804 return CR_FAILURE;
4805 }
4806 else
4807 {
4809 return CR_FAILURE;
4810 }
4811
4813 {
4814 ret = PNP_GetGlobalState(BindingHandle, pulState, ulFlags);
4815 }
4817 {
4819 }
4821
4822 return ret;
4823}
DWORD WINAPI PNP_GetGlobalState(handle_t hBinding, DWORD *pulState, DWORD ulFlags)
Definition: rpcserver.c:720

Referenced by CM_Get_Global_State().

◆ CM_Get_Hardware_Profile_Info_ExA()

CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExA ( _In_ ULONG  ulIndex,
_Out_ PHWPROFILEINFO_A  pHWProfileInfo,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 4992 of file cfgmgr.c.

4997{
4998 HWPROFILEINFO_W LocalProfileInfo;
4999 CONFIGRET ret;
5000
5001 TRACE("CM_Get_Hardware_Profile_Info_ExA(%lu %p %lx %p)\n",
5002 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5003
5004 if (pHWProfileInfo == NULL)
5005 return CR_INVALID_POINTER;
5006
5007 ret = CM_Get_Hardware_Profile_Info_ExW(ulIndex, &LocalProfileInfo,
5008 ulFlags, hMachine);
5009 if (ret == CR_SUCCESS)
5010 {
5011 pHWProfileInfo->HWPI_ulHWProfile = LocalProfileInfo.HWPI_ulHWProfile;
5012 pHWProfileInfo->HWPI_dwFlags = LocalProfileInfo.HWPI_dwFlags;
5013
5015 0,
5016 LocalProfileInfo.HWPI_szFriendlyName,
5017 lstrlenW(LocalProfileInfo.HWPI_szFriendlyName) + 1,
5018 pHWProfileInfo->HWPI_szFriendlyName,
5020 NULL,
5021 NULL) == 0)
5022 ret = CR_FAILURE;
5023 }
5024
5025 return ret;
5026}
#define MAX_PROFILE_LEN
Definition: cfgmgr32.h:54
CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExW(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_W pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5034
ULONG HWPI_ulHWProfile
Definition: cfgmgr32.h:560
DWORD HWPI_dwFlags
Definition: cfgmgr32.h:562
WCHAR HWPI_szFriendlyName[MAX_PROFILE_LEN]
Definition: cfgmgr32.h:561

Referenced by CM_Get_Hardware_Profile_InfoA().

◆ CM_Get_Hardware_Profile_Info_ExW()

CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExW ( _In_ ULONG  ulIndex,
_Out_ PHWPROFILEINFO_W  pHWProfileInfo,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5034 of file cfgmgr.c.

5039{
5041 CONFIGRET ret;
5042
5043 TRACE("CM_Get_Hardware_Profile_Info_ExW(%lu %p %lx %p)\n",
5044 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5045
5046 if (pHWProfileInfo == NULL)
5047 return CR_INVALID_POINTER;
5048
5049 if (ulFlags != 0)
5050 return CR_INVALID_FLAG;
5051
5052 if (hMachine != NULL)
5053 {
5054 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5055 if (BindingHandle == NULL)
5056 return CR_FAILURE;
5057 }
5058 else
5059 {
5061 return CR_FAILURE;
5062 }
5063
5065 {
5066 ret = PNP_GetHwProfInfo(BindingHandle, ulIndex, pHWProfileInfo,
5067 sizeof(HWPROFILEINFO_W), 0);
5068 }
5070 {
5072 }
5074
5075 return ret;
5076}
DWORD WINAPI PNP_GetHwProfInfo(handle_t hBinding, DWORD ulIndex, HWPROFILEINFO *pHWProfileInfo, DWORD ulProfileInfoSize, DWORD ulFlags)
Definition: rpcserver.c:4074

Referenced by CM_Get_Hardware_Profile_Info_ExA(), and CM_Get_Hardware_Profile_InfoW().

◆ CM_Get_Hardware_Profile_InfoA()

CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoA ( _In_ ULONG  ulIndex,
_Out_ PHWPROFILEINFO_A  pHWProfileInfo,
_In_ ULONG  ulFlags 
)

Definition at line 4956 of file cfgmgr.c.

4960{
4961 TRACE("CM_Get_Hardware_Profile_InfoA(%lu %p %lx)\n",
4962 ulIndex, pHWProfileInfo, ulFlags);
4963
4964 return CM_Get_Hardware_Profile_Info_ExA(ulIndex, pHWProfileInfo,
4965 ulFlags, NULL);
4966}
CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExA(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_A pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4992

◆ CM_Get_Hardware_Profile_InfoW()

CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoW ( _In_ ULONG  ulIndex,
_Out_ PHWPROFILEINFO_W  pHWProfileInfo,
_In_ ULONG  ulFlags 
)

Definition at line 4974 of file cfgmgr.c.

4978{
4979 TRACE("CM_Get_Hardware_Profile_InfoW(%lu %p %lx)\n",
4980 ulIndex, pHWProfileInfo, ulFlags);
4981
4982 return CM_Get_Hardware_Profile_Info_ExW(ulIndex, pHWProfileInfo,
4983 ulFlags, NULL);
4984}

◆ CM_Get_HW_Prof_Flags_ExA()

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 
)

Definition at line 4869 of file cfgmgr.c.

4875{
4876 DEVINSTID_W pszDevIdW = NULL;
4878
4879 TRACE("CM_Get_HW_Prof_Flags_ExA(%s %lu %p %lx %p)\n",
4880 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4881
4882 if (szDevInstName != NULL)
4883 {
4884 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
4885 return CR_INVALID_DEVICE_ID;
4886 }
4887
4888 ret = CM_Get_HW_Prof_Flags_ExW(pszDevIdW, ulHardwareProfile,
4889 pulValue, ulFlags, hMachine);
4890
4891 if (pszDevIdW != NULL)
4892 MyFree(pszDevIdW);
4893
4894 return ret;
4895}
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)
Definition: cfgmgr.c:4903

Referenced by CM_Get_HW_Prof_FlagsA().

◆ CM_Get_HW_Prof_Flags_ExW()

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 
)

Definition at line 4903 of file cfgmgr.c.

4909{
4911 CONFIGRET ret;
4912
4913 FIXME("CM_Get_HW_Prof_Flags_ExW(%s %lu %p %lx %p)\n",
4914 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4915
4916 if ((szDevInstName == NULL) || (pulValue == NULL))
4917 return CR_INVALID_POINTER;
4918
4919 if (ulFlags != 0)
4920 return CR_INVALID_FLAG;
4921
4922 /* FIXME: Check whether szDevInstName is valid */
4923
4924 if (hMachine != NULL)
4925 {
4926 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4927 if (BindingHandle == NULL)
4928 return CR_FAILURE;
4929 }
4930 else
4931 {
4933 return CR_FAILURE;
4934 }
4935
4937 {
4938 ret = PNP_HwProfFlags(BindingHandle, PNP_GET_HWPROFFLAGS, szDevInstName,
4939 ulHardwareProfile, pulValue, NULL, NULL, 0, 0);
4940 }
4942 {
4944 }
4946
4947 return ret;
4948}
DWORD WINAPI PNP_HwProfFlags(handle_t hBinding, DWORD ulAction, LPWSTR pDeviceID, DWORD ulConfig, DWORD *pulValue, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3990

Referenced by CM_Get_HW_Prof_Flags_ExA(), and CM_Get_HW_Prof_FlagsW().

◆ CM_Get_HW_Prof_FlagsA()

CONFIGRET WINAPI CM_Get_HW_Prof_FlagsA ( _In_ DEVINSTID_A  szDevInstName,
_In_ ULONG  ulHardwareProfile,
_Out_ PULONG  pulValue,
_In_ ULONG  ulFlags 
)

Definition at line 4831 of file cfgmgr.c.

4836{
4837 TRACE("CM_Get_HW_Prof_FlagsA(%s %lu %p %lx)\n",
4838 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4839
4840 return CM_Get_HW_Prof_Flags_ExA(szDevInstName, ulHardwareProfile,
4841 pulValue, ulFlags, NULL);
4842}
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)
Definition: cfgmgr.c:4869

◆ CM_Get_HW_Prof_FlagsW()

CONFIGRET WINAPI CM_Get_HW_Prof_FlagsW ( _In_ DEVINSTID_W  szDevInstName,
_In_ ULONG  ulHardwareProfile,
_Out_ PULONG  pulValue,
_In_ ULONG  ulFlags 
)

Definition at line 4850 of file cfgmgr.c.

4855{
4856 TRACE("CM_Get_HW_Prof_FlagsW(%s %lu %p %lx)\n",
4857 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4858
4859 return CM_Get_HW_Prof_Flags_ExW(szDevInstName, ulHardwareProfile,
4860 pulValue, ulFlags, NULL);
4861}

◆ CM_Get_Log_Conf_Priority()

CONFIGRET WINAPI CM_Get_Log_Conf_Priority ( _In_ LOG_CONF  lcLogConf,
_Out_ PPRIORITY  pPriority,
_In_ ULONG  ulFlags 
)

Definition at line 5084 of file cfgmgr.c.

5088{
5089 TRACE("CM_Get_Log_Conf_Priority(%p %p %lx)\n",
5090 lcLogConf, pPriority, ulFlags);
5091
5092 return CM_Get_Log_Conf_Priority_Ex(lcLogConf, pPriority, ulFlags, NULL);
5093}
CONFIGRET WINAPI CM_Get_Log_Conf_Priority_Ex(_In_ LOG_CONF lcLogConf, _Out_ PPRIORITY pPriority, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5101

◆ CM_Get_Log_Conf_Priority_Ex()

CONFIGRET WINAPI CM_Get_Log_Conf_Priority_Ex ( _In_ LOG_CONF  lcLogConf,
_Out_ PPRIORITY  pPriority,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5101 of file cfgmgr.c.

5106{
5108 HSTRING_TABLE StringTable = NULL;
5109 PLOG_CONF_INFO pLogConfInfo;
5110 LPWSTR lpDevInst;
5111 CONFIGRET ret;
5112
5113 FIXME("CM_Get_Log_Conf_Priority_Ex(%p %p %lx %p)\n",
5114 lcLogConf, pPriority, ulFlags, hMachine);
5115
5116 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5117 if (!IsValidLogConf(pLogConfInfo))
5118 return CR_INVALID_LOG_CONF;
5119
5120 if (pPriority == NULL)
5121 return CR_INVALID_POINTER;
5122
5123 if (ulFlags != 0)
5124 return CR_INVALID_FLAG;
5125
5126 if (hMachine != NULL)
5127 {
5128 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5129 if (BindingHandle == NULL)
5130 return CR_FAILURE;
5131
5132 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5133 if (StringTable == 0)
5134 return CR_FAILURE;
5135 }
5136 else
5137 {
5138 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5139 return CR_FAILURE;
5140 }
5141
5142 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5143 if (lpDevInst == NULL)
5144 return CR_INVALID_DEVNODE;
5145
5147 {
5149 lpDevInst,
5150 pLogConfInfo->ulType,
5151 pLogConfInfo->ulTag,
5152 pPriority,
5153 0);
5154 }
5156 {
5158 }
5160
5161 return ret;
5162}
DWORD WINAPI PNP_GetLogConfPriority(handle_t hBinding, LPWSTR pDeviceID, DWORD ulType, DWORD ulTag, DWORD *pPriority, DWORD ulFlags)
Definition: rpcserver.c:4708

Referenced by CM_Get_Log_Conf_Priority().

◆ CM_Get_Next_Log_Conf()

CONFIGRET WINAPI CM_Get_Next_Log_Conf ( _Out_opt_ PLOG_CONF  plcLogConf,
_In_ LOG_CONF  lcLogConf,
_In_ ULONG  ulFlags 
)

Definition at line 5170 of file cfgmgr.c.

5174{
5175 TRACE("CM_Get_Next_Log_Conf(%p %p %lx)\n",
5176 plcLogConf, lcLogConf, ulFlags);
5177
5178 return CM_Get_Next_Log_Conf_Ex(plcLogConf, lcLogConf, ulFlags, NULL);
5179}
CONFIGRET WINAPI CM_Get_Next_Log_Conf_Ex(_Out_opt_ PLOG_CONF plcLogConf, _In_ LOG_CONF lcLogConf, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5187

◆ CM_Get_Next_Log_Conf_Ex()

CONFIGRET WINAPI CM_Get_Next_Log_Conf_Ex ( _Out_opt_ PLOG_CONF  plcLogConf,
_In_ LOG_CONF  lcLogConf,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5187 of file cfgmgr.c.

5192{
5194 HSTRING_TABLE StringTable = NULL;
5195 PLOG_CONF_INFO pLogConfInfo;
5196 PLOG_CONF_INFO pNewLogConfInfo;
5197 ULONG ulNewTag;
5198 LPWSTR lpDevInst;
5199 CONFIGRET ret;
5200
5201 FIXME("CM_Get_Next_Log_Conf_Ex(%p %p %lx %p)\n",
5202 plcLogConf, lcLogConf, ulFlags, hMachine);
5203
5204 if (plcLogConf)
5205 *plcLogConf = 0;
5206
5207 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5208 if (!IsValidLogConf(pLogConfInfo))
5209 return CR_INVALID_LOG_CONF;
5210
5211 if (ulFlags != 0)
5212 return CR_INVALID_FLAG;
5213
5214 if (hMachine != NULL)
5215 {
5216 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5217 if (BindingHandle == NULL)
5218 return CR_FAILURE;
5219
5220 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5221 if (StringTable == 0)
5222 return CR_FAILURE;
5223 }
5224 else
5225 {
5226 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5227 return CR_FAILURE;
5228 }
5229
5230 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5231 if (lpDevInst == NULL)
5232 return CR_INVALID_DEVNODE;
5233
5235 {
5237 lpDevInst,
5238 pLogConfInfo->ulType,
5239 pLogConfInfo->ulTag,
5240 &ulNewTag,
5241 0);
5242 }
5244 {
5246 }
5248
5249 if (ret != CR_SUCCESS)
5250 return ret;
5251
5252 if (plcLogConf)
5253 {
5254 pNewLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
5255 if (pNewLogConfInfo == NULL)
5256 return CR_OUT_OF_MEMORY;
5257
5258 pNewLogConfInfo->ulMagic = LOG_CONF_MAGIC;
5259 pNewLogConfInfo->dnDevInst = pLogConfInfo->dnDevInst;
5260 pNewLogConfInfo->ulType = pLogConfInfo->ulType;
5261 pNewLogConfInfo->ulTag = ulNewTag;
5262
5263 *plcLogConf = (LOG_CONF)pNewLogConfInfo;
5264 }
5265
5266 return CR_SUCCESS;
5267}
DWORD WINAPI PNP_GetNextLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulCurrentTag, DWORD *pulNextTag, DWORD ulFlags)
Definition: rpcserver.c:4589

Referenced by CM_Get_Next_Log_Conf().

◆ CM_Get_Next_Res_Des()

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 
)

Definition at line 5275 of file cfgmgr.c.

5281{
5282 TRACE("CM_Get_Next_Res_Des(%p %p %lu %p %lx)\n",
5283 prdResDes, rdResDes, ForResource, pResourceID, ulFlags);
5284
5285 return CM_Get_Next_Res_Des_Ex(prdResDes, rdResDes, ForResource,
5286 pResourceID, ulFlags, NULL);
5287}
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)
Definition: cfgmgr.c:5295

◆ CM_Get_Next_Res_Des_Ex()

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 
)

Definition at line 5295 of file cfgmgr.c.

5302{
5304 HSTRING_TABLE StringTable = NULL;
5305 PRES_DES_INFO pNewResDesInfo = NULL;
5306 ULONG ulLogConfTag, ulLogConfType, ulResDesTag;
5307 ULONG ulNextResDesType = 0, ulNextResDesTag = 0;
5308 LPWSTR lpDevInst;
5309 DEVINST dnDevInst;
5310 CONFIGRET ret;
5311
5312 FIXME("CM_Get_Next_Res_Des_Ex(%p %p %lu %p %lx %p)\n",
5313 prdResDes, rdResDes, ForResource, pResourceID, ulFlags, hMachine);
5314
5315 if (prdResDes == NULL)
5316 return CR_INVALID_POINTER;
5317
5318 if (IsValidLogConf((PLOG_CONF_INFO)rdResDes))
5319 {
5320 FIXME("LogConf found!\n");
5321 dnDevInst = ((PLOG_CONF_INFO)rdResDes)->dnDevInst;
5322 ulLogConfTag = ((PLOG_CONF_INFO)rdResDes)->ulTag;
5323 ulLogConfType = ((PLOG_CONF_INFO)rdResDes)->ulType;
5324 ulResDesTag = (ULONG)-1;
5325 }
5326 else if (IsValidResDes((PRES_DES_INFO)rdResDes))
5327 {
5328 FIXME("ResDes found!\n");
5329 dnDevInst = ((PRES_DES_INFO)rdResDes)->dnDevInst;
5330 ulLogConfTag = ((PRES_DES_INFO)rdResDes)->ulLogConfTag;
5331 ulLogConfType = ((PRES_DES_INFO)rdResDes)->ulLogConfType;
5332 ulResDesTag = ((PRES_DES_INFO)rdResDes)->ulResDesTag;
5333 }
5334 else
5335 {
5336 return CR_INVALID_RES_DES;
5337 }
5338
5339 if ((ForResource == ResType_All) && (pResourceID == NULL))
5340 return CR_INVALID_POINTER;
5341
5342 if (ulFlags != 0)
5343 return CR_INVALID_FLAG;
5344
5345 if (hMachine != NULL)
5346 {
5347 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5348 if (BindingHandle == NULL)
5349 return CR_FAILURE;
5350
5351 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5352 if (StringTable == 0)
5353 return CR_FAILURE;
5354 }
5355 else
5356 {
5357 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5358 return CR_FAILURE;
5359 }
5360
5361 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5362 if (lpDevInst == NULL)
5363 return CR_INVALID_DEVNODE;
5364
5366 {
5368 lpDevInst,
5369 ulLogConfTag,
5370 ulLogConfType,
5371 ForResource,
5372 ulResDesTag,
5373 &ulNextResDesTag,
5374 &ulNextResDesType,
5375 0);
5376 }
5378 {
5380 }
5382
5383 if (ret != CR_SUCCESS)
5384 return ret;
5385
5386 if (ForResource == ResType_All)
5387 *pResourceID = ulNextResDesType;
5388
5389 if (prdResDes)
5390 {
5391 pNewResDesInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(RES_DES_INFO));
5392 if (pNewResDesInfo == NULL)
5393 return CR_OUT_OF_MEMORY;
5394
5395 pNewResDesInfo->ulMagic = LOG_CONF_MAGIC;
5396 pNewResDesInfo->dnDevInst = dnDevInst;
5397 pNewResDesInfo->ulLogConfType = ulLogConfType;
5398 pNewResDesInfo->ulLogConfTag = ulLogConfTag;
5399 pNewResDesInfo->ulResDesType = ulNextResDesType;
5400 pNewResDesInfo->ulResDesTag = ulNextResDesTag;
5401
5402 *prdResDes = (RES_DES)pNewResDesInfo;
5403 }
5404
5405 return CR_SUCCESS;
5406}
DWORD WINAPI PNP_GetNextResDes(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulNextResType, DWORD *pulNextResTag, DWORD ulFlags)
Definition: rpcserver.c:4762
DWORD_PTR RES_DES
Definition: cfgmgr32.h:93
#define ResType_All
Definition: cfgmgr32.h:575
DWORD DEVINST
Definition: cfgmgr32.h:76
ULONG ulLogConfTag
Definition: cfgmgr.c:72
DEVINST dnDevInst
Definition: cfgmgr.c:70
ULONG ulResDesType
Definition: cfgmgr.c:73
ULONG ulResDesTag
Definition: cfgmgr.c:74
ULONG ulLogConfType
Definition: cfgmgr.c:71
ULONG ulMagic
Definition: cfgmgr.c:69

Referenced by CM_Get_Next_Res_Des().

◆ CM_Get_Parent()

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

Definition at line 5414 of file cfgmgr.c.

5418{
5419 TRACE("CM_Get_Parent(%p %p %lx)\n",
5420 pdnDevInst, dnDevInst, ulFlags);
5421
5422 return CM_Get_Parent_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5423}
CONFIGRET WINAPI CM_Get_Parent_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5431

◆ CM_Get_Parent_Ex()

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

Definition at line 5431 of file cfgmgr.c.

5436{
5437 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5439 HSTRING_TABLE StringTable = NULL;
5440 LPWSTR lpDevInst;
5441 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5442 CONFIGRET ret;
5443
5444 TRACE("CM_Get_Parent_Ex(%p %lx %lx %p)\n",
5445 pdnDevInst, dnDevInst, ulFlags, hMachine);
5446
5447 if (pdnDevInst == NULL)
5448 return CR_INVALID_POINTER;
5449
5450 if (dnDevInst == 0)
5451 return CR_INVALID_DEVINST;
5452
5453 if (ulFlags != 0)
5454 return CR_INVALID_FLAG;
5455
5456 *pdnDevInst = -1;
5457
5458 if (hMachine != NULL)
5459 {
5460 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5461 if (BindingHandle == NULL)
5462 return CR_FAILURE;
5463
5464 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5465 if (StringTable == 0)
5466 return CR_FAILURE;
5467 }
5468 else
5469 {
5470 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5471 return CR_FAILURE;
5472 }
5473
5474 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5475 if (lpDevInst == NULL)
5476 return CR_INVALID_DEVNODE;
5477
5479 {
5481 PNP_GET_PARENT_DEVICE_INSTANCE,
5482 lpDevInst,
5483 szRelatedDevInst,
5484 &dwLength,
5485 0);
5486 }
5488 {
5490 }
5492
5493 if (ret != CR_SUCCESS)
5494 return ret;
5495
5496 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5497
5498 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5499 if (dwIndex == -1)
5500 return CR_FAILURE;
5501
5502 *pdnDevInst = dwIndex;
5503
5504 return CR_SUCCESS;
5505}

Referenced by CM_Get_Parent(), SetupDiRegisterDeviceInfo(), and UpdateDevInfo().

◆ CM_Get_Res_Des_Data()

CONFIGRET WINAPI CM_Get_Res_Des_Data ( _In_ RES_DES  rdResDes,
_Out_writes_bytes_(BufferLen) PVOID  Buffer,
_In_ ULONG  BufferLen,
_In_ ULONG  ulFlags 
)

Definition at line 5513 of file cfgmgr.c.

5518{
5519 TRACE("CM_Get_Res_Des_Data(%p %p %lu %lx)\n",
5520 rdResDes, Buffer, BufferLen, ulFlags);
5521
5522 return CM_Get_Res_Des_Data_Ex(rdResDes, Buffer, BufferLen, ulFlags, NULL);
5523}
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)
Definition: cfgmgr.c:5531

◆ CM_Get_Res_Des_Data_Ex()

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 
)

Definition at line 5531 of file cfgmgr.c.

5537{
5538 FIXME("CM_Get_Res_Des_Data_Ex(%p %p %lu %lx %p)\n",
5539 rdResDes, Buffer, BufferLen, ulFlags, hMachine);
5540
5542}

Referenced by CM_Get_Res_Des_Data().

◆ CM_Get_Res_Des_Data_Size()

CONFIGRET WINAPI CM_Get_Res_Des_Data_Size ( _Out_ PULONG  pulSize,
_In_ RES_DES  rdResDes,
_In_ ULONG  ulFlags 
)

Definition at line 5550 of file cfgmgr.c.

5554{
5555 TRACE("CM_Get_Res_Des_Data_Size(%p %p %lx)\n",
5556 pulSize, rdResDes, ulFlags);
5557
5558 return CM_Get_Res_Des_Data_Size_Ex(pulSize, rdResDes, ulFlags, NULL);
5559}
CONFIGRET WINAPI CM_Get_Res_Des_Data_Size_Ex(_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5567
_Check_return_ _Out_ PULONG pulSize
Definition: winddi.h:2120

◆ CM_Get_Res_Des_Data_Size_Ex()

CONFIGRET WINAPI CM_Get_Res_Des_Data_Size_Ex ( _Out_ PULONG  pulSize,
_In_ RES_DES  rdResDes,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5567 of file cfgmgr.c.

5572{
5573 TRACE("CM_Get_Res_Des_Data_Size_Ex(%p %p %lx %p)\n",
5574 pulSize, rdResDes, ulFlags, hMachine);
5575
5577}

Referenced by CM_Get_Res_Des_Data_Size().

◆ CM_Get_Resource_Conflict_Count()

CONFIGRET WINAPI CM_Get_Resource_Conflict_Count ( _In_ CONFLICT_LIST  clConflictList,
_Out_ PULONG  pulCount 
)

Definition at line 5585 of file cfgmgr.c.

5588{
5589 PCONFLICT_DATA pConflictData;
5590
5591 FIXME("CM_Get_Resource_Conflict_Count(%p %p)\n",
5592 clConflictList, pulCount);
5593
5594 pConflictData = (PCONFLICT_DATA)clConflictList;
5595 if (!IsValidConflictData(pConflictData))
5597
5598 if (pulCount == NULL)
5599 return CR_INVALID_POINTER;
5600
5601 *pulCount = pConflictData->pConflictList->ConflictsListed;
5602
5603 return CR_SUCCESS;
5604}
DWORD ConflictsListed
Definition: pnp.idl:240

◆ CM_Get_Resource_Conflict_DetailsA()

CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsA ( _In_ CONFLICT_LIST  clConflictList,
_In_ ULONG  ulIndex,
_Inout_ PCONFLICT_DETAILS_A  pConflictDetails 
)

Definition at line 5612 of file cfgmgr.c.

5616{
5617 FIXME("CM_Get_Resource_Conflict_CountA(%p %lu %p)\n",
5618 clConflictList, ulIndex, pConflictDetails);
5619
5621}

◆ CM_Get_Resource_Conflict_DetailsW()

CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsW ( _In_ CONFLICT_LIST  clConflictList,
_In_ ULONG  ulIndex,
_Inout_ PCONFLICT_DETAILS_W  pConflictDetails 
)

Definition at line 5629 of file cfgmgr.c.

5633{
5634 FIXME("CM_Get_Resource_Conflict_CountW(%p %lu %p)\n",
5635 clConflictList, ulIndex, pConflictDetails);
5636
5638}

◆ CM_Get_Sibling()

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

Definition at line 5646 of file cfgmgr.c.

5650{
5651 TRACE("CM_Get_Sibling(%p %p %lx)\n",
5652 pdnDevInst, dnDevInst, ulFlags);
5653
5654 return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5655}
CONFIGRET WINAPI CM_Get_Sibling_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5663

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

◆ CM_Get_Sibling_Ex()

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

Definition at line 5663 of file cfgmgr.c.

5668{
5669 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5671 HSTRING_TABLE StringTable = NULL;
5672 LPWSTR lpDevInst;
5673 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5674 CONFIGRET ret;
5675
5676 TRACE("CM_Get_Sibling_Ex(%p %lx %lx %p)\n",
5677 pdnDevInst, dnDevInst, ulFlags, hMachine);
5678
5679 if (pdnDevInst == NULL)
5680 return CR_INVALID_POINTER;
5681
5682 if (dnDevInst == 0)
5683 return CR_INVALID_DEVINST;
5684
5685 if (ulFlags != 0)
5686 return CR_INVALID_FLAG;
5687
5688 *pdnDevInst = -1;
5689
5690 if (hMachine != NULL)
5691 {
5692 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5693 if (BindingHandle == NULL)
5694 return CR_FAILURE;
5695
5696 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5697 if (StringTable == 0)
5698 return CR_FAILURE;
5699 }
5700 else
5701 {
5702 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5703 return CR_FAILURE;
5704 }
5705
5706 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5707 if (lpDevInst == NULL)
5708 return CR_INVALID_DEVNODE;
5709
5711 {
5713 PNP_GET_SIBLING_DEVICE_INSTANCE,
5714 lpDevInst,
5715 szRelatedDevInst,
5716 &dwLength,
5717 0);
5718 }
5720 {
5722 }
5724
5725 if (ret != CR_SUCCESS)
5726 return ret;
5727
5728 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5729
5730 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5731 if (dwIndex == -1)
5732 return CR_FAILURE;
5733
5734 *pdnDevInst = dwIndex;
5735
5736 return CR_SUCCESS;
5737}

Referenced by CM_Get_Sibling().

◆ CM_Get_Version()

WORD WINAPI CM_Get_Version ( VOID  )

Definition at line 5745 of file cfgmgr.c.

5746{
5747 TRACE("CM_Get_Version()\n");
5748
5749 return CM_Get_Version_Ex(NULL);
5750}
WORD WINAPI CM_Get_Version_Ex(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5758

Referenced by test_CM_Get_Version().

◆ CM_Get_Version_Ex()

WORD WINAPI CM_Get_Version_Ex ( _In_opt_ HMACHINE  hMachine)

Definition at line 5758 of file cfgmgr.c.

5760{
5762 WORD Version = 0;
5763 CONFIGRET ret;
5764
5765 TRACE("CM_Get_Version_Ex(%p)\n", hMachine);
5766
5767 if (hMachine != NULL)
5768 {
5769 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5770 if (BindingHandle == NULL)
5771 return 0;
5772 }
5773 else
5774 {
5776 return CR_FAILURE;
5777 }
5778
5780 {
5782 }
5784 {
5786 }
5788
5789 if (ret != CR_SUCCESS)
5790 return 0;
5791
5792 return Version;
5793}
DWORD WINAPI PNP_GetVersion(handle_t hBinding, WORD *pVersion)
Definition: rpcserver.c:702
unsigned short WORD
Definition: ntddk_ex.h:93
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469

Referenced by CM_Get_Version().

◆ CM_Intersect_Range_List()

CONFIGRET WINAPI CM_Intersect_Range_List ( _In_ RANGE_LIST  rlhOld1,
_In_ RANGE_LIST  rlhOld2,
_In_ RANGE_LIST  rlhNew,
_In_ ULONG  ulFlags 
)

Definition at line 5801 of file cfgmgr.c.

5806{
5807 FIXME("CM_Intersect_Range_List(%p %p %p %lx)\n",
5808 rlhOld1, rlhOld2, rlhNew, ulFlags);
5809
5811}

◆ CM_Invert_Range_List()

CONFIGRET WINAPI CM_Invert_Range_List ( _In_ RANGE_LIST  rlhOld,
_In_ RANGE_LIST  rlhNew,
_In_ DWORDLONG  ullMaxValue,
_In_ ULONG  ulFlags 
)

Definition at line 5819 of file cfgmgr.c.

5824{
5825 FIXME("CM_Invert_Range_List(%p %p %I64u %lx)\n",
5826 rlhOld, rlhNew, ullMaxValue, ulFlags);
5827
5829}

◆ CM_Is_Dock_Station_Present()

CONFIGRET WINAPI CM_Is_Dock_Station_Present ( _Out_ PBOOL  pbPresent)

Definition at line 5837 of file cfgmgr.c.

5839{
5840 TRACE("CM_Is_Dock_Station_Present(%p)\n",
5841 pbPresent);
5842
5843 return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
5844}
CONFIGRET WINAPI CM_Is_Dock_Station_Present_Ex(_Out_ PBOOL pbPresent, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5852

◆ CM_Is_Dock_Station_Present_Ex()

CONFIGRET WINAPI CM_Is_Dock_Station_Present_Ex ( _Out_ PBOOL  pbPresent,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5852 of file cfgmgr.c.

5855{
5857 CONFIGRET ret;
5858
5859 TRACE("CM_Is_Dock_Station_Present_Ex(%p %p)\n",
5860 pbPresent, hMachine);
5861
5862 if (pbPresent == NULL)
5863 return CR_INVALID_POINTER;
5864
5865 *pbPresent = FALSE;
5866
5867 if (hMachine != NULL)
5868 {
5869 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5870 if (BindingHandle == NULL)
5871 return CR_FAILURE;
5872 }
5873 else
5874 {
5876 return CR_FAILURE;
5877 }
5878
5880 {
5882 pbPresent);
5883 }
5885 {
5887 }
5889
5890 return ret;
5891}
CONFIGRET WINAPI PNP_IsDockStationPresent(handle_t hBinding, BOOL *Present)
Definition: rpcserver.c:3902

Referenced by CM_Is_Dock_Station_Present().

◆ CM_Is_Version_Available()

BOOL WINAPI CM_Is_Version_Available ( _In_ WORD  wVersion)

Definition at line 5899 of file cfgmgr.c.

5901{
5902 TRACE("CM_Is_Version_Available(%hu)\n",
5903 wVersion);
5904
5905 return CM_Is_Version_Available_Ex(wVersion, NULL);
5906}
BOOL WINAPI CM_Is_Version_Available_Ex(_In_ WORD wVersion, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5914

◆ CM_Is_Version_Available_Ex()

BOOL WINAPI CM_Is_Version_Available_Ex ( _In_ WORD  wVersion,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5914 of file cfgmgr.c.

5917{
5919 WORD wServerVersion;
5920 CONFIGRET ret;
5921
5922 TRACE("CM_Is_Version_Available_Ex(%hu %p)\n",
5923 wVersion, hMachine);
5924
5925 if (wVersion <= 0x400)
5926 return TRUE;
5927
5928 if (hMachine != NULL)
5929 {
5930 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5931 if (BindingHandle == NULL)
5932 return FALSE;
5933 }
5934 else
5935 {
5937 return FALSE;
5938 }
5939
5941 {
5942 ret = PNP_GetVersion(BindingHandle, &wServerVersion);
5943 }
5945 {
5947 }
5949
5950 if (ret != CR_SUCCESS)
5951 return FALSE;
5952
5953 return (wServerVersion >= wVersion);
5954}

Referenced by CM_Is_Version_Available().

◆ CM_Locate_DevNode_ExA()

CONFIGRET WINAPI CM_Locate_DevNode_ExA ( _Out_ PDEVINST  pdnDevInst,
_In_opt_ DEVINSTID_A  pDeviceID,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 5996 of file cfgmgr.c.

6001{
6002 DEVINSTID_W pDevIdW = NULL;
6004
6005 TRACE("CM_Locate_DevNode_ExA(%p %s %lx %p)\n",
6006 pdnDevInst, debugstr_a(pDeviceID), ulFlags, hMachine);
6007
6008 if (pDeviceID != NULL)
6009 {
6010 if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
6011 return CR_INVALID_DEVICE_ID;
6012 }
6013
6014 ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
6015
6016 if (pDevIdW != NULL)
6017 MyFree(pDevIdW);
6018
6019 return ret;
6020}
CONFIGRET WINAPI CM_Locate_DevNode_ExW(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6028

Referenced by CM_Locate_DevNodeA().

◆ CM_Locate_DevNode_ExW()

CONFIGRET WINAPI CM_Locate_DevNode_ExW ( _Out_ PDEVINST  pdnDevInst,
_In_opt_ DEVINSTID_W  pDeviceID,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 6028 of file cfgmgr.c.

6033{
6034 WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
6036 HSTRING_TABLE StringTable = NULL;
6038
6039 TRACE("CM_Locate_DevNode_ExW(%p %s %lx %p)\n",
6040 pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
6041
6042 if (pdnDevInst == NULL)
6043 return CR_INVALID_POINTER;
6044
6045 if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
6046 return CR_INVALID_FLAG;
6047
6048 if (hMachine != NULL)
6049 {
6050 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6051 if (BindingHandle == NULL)
6052 return CR_FAILURE;
6053
6054 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6055 if (StringTable == 0)
6056 return CR_FAILURE;
6057 }
6058 else
6059 {
6060 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6061 return CR_FAILURE;
6062 }
6063
6064 if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
6065 {
6066 lstrcpyW(DeviceIdBuffer, pDeviceID);
6067
6069 {
6070 /* Validate the device ID */
6072 DeviceIdBuffer,
6073 ulFlags);
6074 }
6076 {
6078 }
6080 }
6081 else
6082 {
6084 {
6085 /* Get the root device ID */
6087 DeviceIdBuffer,
6089 }
6091 {
6093 }
6095 }
6096
6097 TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
6098
6099 if (ret == CR_SUCCESS)
6100 {
6101 *pdnDevInst = pSetupStringTableAddString(StringTable, DeviceIdBuffer, 1);
6102 if (*pdnDevInst == -1)
6103 ret = CR_FAILURE;
6104 }
6105
6106 return ret;
6107}
DWORD WINAPI PNP_GetRootDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:858
DWORD WINAPI PNP_ValidateDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:815
#define CM_LOCATE_DEVNODE_BITS
Definition: cfgmgr32.h:764

Referenced by CM_Locate_DevNode_ExA(), CM_Locate_DevNodeW(), and CreateDeviceInfo().

◆ CM_Locate_DevNodeA()

CONFIGRET WINAPI CM_Locate_DevNodeA ( _Out_ PDEVINST  pdnDevInst,
_In_opt_ DEVINSTID_A  pDeviceID,
_In_ ULONG  ulFlags 
)

Definition at line 5962 of file cfgmgr.c.

5966{
5967 TRACE("CM_Locate_DevNodeA(%p %s %lx)\n",
5968 pdnDevInst, debugstr_a(pDeviceID), ulFlags);
5969
5970 return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
5971}
CONFIGRET WINAPI CM_Locate_DevNode_ExA(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5996

◆ CM_Locate_DevNodeW()

CONFIGRET WINAPI CM_Locate_DevNodeW ( _Out_ PDEVINST  pdnDevInst,
_In_opt_ DEVINSTID_W  pDeviceID,
_In_ ULONG  ulFlags 
)

Definition at line 5979 of file cfgmgr.c.

5983{
5984 TRACE("CM_Locate_DevNodeW(%p %s %lx)\n",
5985 pdnDevInst, debugstr_w(pDeviceID), ulFlags);
5986
5987 return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
5988}

Referenced by CRootNode::SetupNode().

◆ CM_Merge_Range_List()

CONFIGRET WINAPI CM_Merge_Range_List ( _In_ RANGE_LIST  rlhOld1,
_In_ RANGE_LIST  rlhOld2,
_In_ RANGE_LIST  rlhNew,
_In_ ULONG  ulFlags 
)

Definition at line 6115 of file cfgmgr.c.

6120{
6121 FIXME("CM_Merge_Range_List(%p %p %p %lx)\n",
6122 rlhOld1, rlhOld2, rlhNew, ulFlags);
6123
6125}

◆ CM_Modify_Res_Des()

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 
)

Definition at line 6133 of file cfgmgr.c.

6140{
6141 TRACE("CM_Modify_Res_Des(%p %p %lx %p %lu %lx)\n",
6142 prdResDes, rdResDes, ResourceID, ResourceData,
6143 ResourceLen, ulFlags);
6144
6145 return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
6146 ResourceLen, ulFlags, NULL);
6147}
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)
Definition: cfgmgr.c:6155

◆ CM_Modify_Res_Des_Ex()

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 
)

Definition at line 6155 of file cfgmgr.c.

6163{
6164 FIXME("CM_Modify_Res_Des_Ex(%p %p %lx %p %lu %lx %p)\n",
6165 prdResDes, rdResDes, ResourceID, ResourceData,
6166 ResourceLen, ulFlags, hMachine);
6167
6169}

Referenced by CM_Modify_Res_Des().

◆ CM_Move_DevNode()

CONFIGRET WINAPI CM_Move_DevNode ( _In_ DEVINST  dnFromDevInst,
_In_ DEVINST  dnToDevInst,
_In_ ULONG  ulFlags 
)

Definition at line 6177 of file cfgmgr.c.

6181{
6182 TRACE("CM_Move_DevNode(%lx %lx %lx)\n",
6183 dnFromDevInst, dnToDevInst, ulFlags);
6184
6185 return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
6186}
CONFIGRET WINAPI CM_Move_DevNode_Ex(_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6194

◆ CM_Move_DevNode_Ex()

CONFIGRET WINAPI CM_Move_DevNode_Ex ( _In_ DEVINST  dnFromDevInst,
_In_ DEVINST  dnToDevInst,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 6194 of file cfgmgr.c.

6199{
6201 HSTRING_TABLE StringTable = NULL;
6202 LPWSTR lpFromDevInst;
6203 LPWSTR lpToDevInst;
6204 CONFIGRET ret;
6205
6206 FIXME("CM_Move_DevNode_Ex(%lx %lx %lx %p)\n",
6207 dnFromDevInst, dnToDevInst, ulFlags, hMachine);
6208
6209 if (!pSetupIsUserAdmin())
6210 return CR_ACCESS_DENIED;
6211
6212 if (dnFromDevInst == 0 || dnToDevInst == 0)
6213 return CR_INVALID_DEVNODE;
6214
6215 if (ulFlags != 0)
6216 return CR_INVALID_FLAG;
6217
6218 if (hMachine != NULL)
6219 {
6220 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6221 if (BindingHandle == NULL)
6222 return CR_FAILURE;
6223
6224 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6225 if (StringTable == 0)
6226 return CR_FAILURE;
6227 }
6228 else
6229 {
6230 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6231 return CR_FAILURE;
6232 }
6233
6234 lpFromDevInst = pSetupStringTableStringFromId(StringTable, dnFromDevInst);
6235 if (lpFromDevInst == NULL)
6236 return CR_INVALID_DEVNODE;
6237
6238 lpToDevInst = pSetupStringTableStringFromId(StringTable, dnToDevInst);
6239 if (lpToDevInst == NULL)
6240 return CR_INVALID_DEVNODE;
6241
6243 {
6245 PNP_DEVINST_MOVE,
6246 ulFlags,
6247 lpFromDevInst,
6248 lpToDevInst);
6249 }
6251 {
6253 }
6255
6256 return ret;
6257}

Referenced by CM_Move_DevNode().

◆ CM_Next_Range()

CONFIGRET WINAPI CM_Next_Range ( _Inout_ PRANGE_ELEMENT  preElement,
_Out_ PDWORDLONG  pullStart,
_Out_ PDWORDLONG  pullEnd,
_In_ ULONG  ulFlags 
)

Definition at line 6265 of file cfgmgr.c.

6270{
6271 PINTERNAL_RANGE_LIST pRangeList;
6272 PINTERNAL_RANGE pRange;
6273 PLIST_ENTRY ListEntry;
6275
6276 FIXME("CM_Next_Range(%p %p %p %lx)\n",
6277 preElement, pullStart, pullEnd, ulFlags);
6278
6279 pRange = (PINTERNAL_RANGE)preElement;
6280
6281 if (pRange == NULL || pRange->pRangeList == NULL)
6282 return CR_FAILURE;
6283
6284 if (pullStart == NULL || pullEnd == NULL)
6285 return CR_INVALID_POINTER;
6286
6287 if (ulFlags != 0)
6288 return CR_INVALID_FLAG;
6289
6290 pRangeList = pRange->pRangeList;
6291
6292 /* Lock the range list */
6293 WaitForSingleObject(pRangeList->hMutex, INFINITE);
6294
6295 /* Fail, if we reached the end of the list */
6296 if (pRange->ListEntry.Flink == &pRangeList->ListHead)
6297 {
6298 ret = CR_FAILURE;
6299 goto done;
6300 }
6301
6302 /* Get the next range */
6303 ListEntry = pRangeList->ListHead.Flink;
6304 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
6305
6306 /* Return the range data */
6307 *pullStart = pRange->ullStart;
6308 *pullEnd = pRange->ullEnd;
6309 *preElement = (RANGE_ELEMENT)pRange;
6310
6311done:
6312 /* Unlock the range list */
6313 ReleaseMutex(pRangeList->hMutex);
6314
6315 return ret;
6316}
struct _INTERNAL_RANGE * PINTERNAL_RANGE

◆ CM_Open_Class_Key_ExA()

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 
)

Definition at line 6368 of file cfgmgr.c.

6376{
6377 LPWSTR pszClassNameW = NULL;
6378 CONFIGRET ret;
6379
6380 TRACE("CM_Open_Class_Key_ExA(%p %s %lx %lx %p %lx %p)\n",
6381 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6382 samDesired, Disposition, phkClass, ulFlags, hMachine);
6383
6384 if (pszClassName != NULL)
6385 {
6386 if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
6387 return CR_INVALID_DATA;
6388 }
6389
6390 ret = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
6391 Disposition, phkClass, ulFlags, hMachine);
6392
6393 if (pszClassNameW != NULL)
6394 MyFree(pszClassNameW);
6395
6396 return ret;
6397}
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)
Definition: cfgmgr.c:6405
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56

Referenced by CM_Open_Class_KeyA().

◆ CM_Open_Class_Key_ExW()

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 
)

Definition at line 6405 of file cfgmgr.c.

6413{
6414 WCHAR szKeyName[MAX_PATH];
6415 LPWSTR lpGuidString;
6416 DWORD dwDisposition;
6417 DWORD dwError;
6418 HKEY hKey;
6419
6420 TRACE("CM_Open_Class_Key_ExW(%p %s %lx %lx %p %lx %p)\n",
6421 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6422 samDesired, Disposition, phkClass, ulFlags, hMachine);
6423
6424 /* Check Disposition and ulFlags */
6426 (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
6427 return CR_INVALID_FLAG;
6428
6429 /* Check phkClass */
6430 if (phkClass == NULL)
6431 return CR_INVALID_POINTER;
6432
6433 *phkClass = NULL;
6434
6435 if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
6436 pszClassName != NULL)
6437 return CR_INVALID_DATA;
6438
6439 if (hMachine == NULL)
6440 {
6442 }
6443 else
6444 {
6445 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6447 &hKey))
6448 return CR_REGISTRY_ERROR;
6449 }
6450
6451 if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
6452 {
6453 lstrcpyW(szKeyName, DeviceClasses);
6454 }
6455 else
6456 {
6457 lstrcpyW(szKeyName, ControlClass);
6458 }
6459
6460 if (pClassGuid != NULL)
6461 {
6462 if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
6463 {
6465 return CR_INVALID_DATA;
6466 }
6467
6468 lstrcatW(szKeyName, BackslashOpenBrace);
6469 lstrcatW(szKeyName, lpGuidString);
6470 lstrcatW(szKeyName, CloseBrace);
6471 }
6472
6474 {
6475 dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
6476 NULL, phkClass, &dwDisposition);
6477 }
6478 else
6479 {
6480 dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
6481 }
6482
6484
6485 if (pClassGuid != NULL)
6486 RpcStringFreeW(&lpGuidString);
6487
6488 if (dwError != ERROR_SUCCESS)
6489 {
6490 *phkClass = NULL;
6492 }
6493
6494 if (pszClassName != NULL)
6495 {
6496 RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
6497 (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
6498 }
6499
6500 return CR_SUCCESS;
6501}
#define RegCloseKey(hKey)
Definition: registry.h:49
#define CM_OPEN_CLASS_KEY_INTERFACE
Definition: cfgmgr32.h:773
#define RegDisposition_Bits
Definition: cfgmgr32.h:611
#define CM_OPEN_CLASS_KEY_BITS
Definition: cfgmgr32.h:774
#define RegDisposition_OpenAlways
Definition: cfgmgr32.h:609
#define CR_NO_SUCH_REGISTRY_KEY
Definition: cfgmgr32.h:892
#define CR_REGISTRY_ERROR
Definition: cfgmgr32.h:875
static const WCHAR ControlClass[]
Definition: cfgmgr.c:38
static const WCHAR BackslashOpenBrace[]
Definition: cfgmgr.c:34
static const WCHAR DeviceClasses[]
Definition: cfgmgr.c:43
static const WCHAR CloseBrace[]
Definition: cfgmgr.c:35
#define ERROR_SUCCESS
Definition: deptool.c:10
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegConnectRegistryW(LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult)
Definition: reg.c:874
#define MAX_PATH
Definition: compat.h:34
FxAutoRegKey hKey
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR *StringUuid)
Definition: rpcrt4_main.c:540
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by CM_Open_Class_Key_ExA(), CM_Open_Class_KeyW(), and SetupDiBuildClassInfoListExW().

◆ CM_Open_Class_KeyA()

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 
)

Definition at line 6324 of file cfgmgr.c.

6331{
6332 TRACE("CM_Open_Class_KeyA(%p %s %lx %lx %p %lx)\n",
6333 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6334 samDesired, Disposition, phkClass, ulFlags);
6335
6336 return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
6337 Disposition, phkClass, ulFlags, NULL);
6338}
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)
Definition: cfgmgr.c:6368

◆ CM_Open_Class_KeyW()

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 
)

Definition at line 6346 of file cfgmgr.c.

6353{
6354 TRACE("CM_Open_Class_KeyW(%p %s %lx %lx %p %lx)\n",
6355 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6356 samDesired, Disposition, phkClass, ulFlags);
6357
6358 return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
6359 Disposition, phkClass, ulFlags, NULL);
6360}

◆ CM_Open_DevNode_Key()

CONFIGRET WINAPI CM_Open_DevNode_Key ( _In_ DEVINST  dnDevNode,
_In_ REGSAM  samDesired,
_In_ ULONG  ulHardwareProfile,
_In_ REGDISPOSITION  Disposition,
_Out_ PHKEY  phkDevice,
_In_ ULONG  ulFlags 
)

Definition at line 6509 of file cfgmgr.c.

6516{
6517 TRACE("CM_Open_DevNode_Key(%lx %lx %lu %lx %p %lx)\n",
6518 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags);
6519
6520 return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
6521 Disposition, phkDevice, ulFlags, NULL);
6522}
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)
Definition: cfgmgr.c:6530

◆ CM_Open_DevNode_Key_Ex()

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 
)

Definition at line 6530 of file cfgmgr.c.

6538{
6540 HSTRING_TABLE StringTable = NULL;
6541 LPWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
6542 LONG lError;
6543 DWORD dwDisposition;
6544 HKEY hRootKey = NULL;
6546
6547 TRACE("CM_Open_DevNode_Key_Ex(%lx %lx %lu %lx %p %lx %p)\n",
6548 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
6549
6550 if (phkDevice == NULL)
6551 return CR_INVALID_POINTER;
6552
6553 *phkDevice = NULL;
6554
6555 if (dnDevNode == 0)
6556 return CR_INVALID_DEVNODE;
6557
6558 if (ulFlags & ~CM_REGISTRY_BITS)
6559 return CR_INVALID_FLAG;
6560
6562 return CR_INVALID_DATA;
6563
6564 if (hMachine != NULL)
6565 {
6566 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6567 if (BindingHandle == NULL)
6568 return CR_FAILURE;
6569
6570 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6571 if (StringTable == 0)
6572 return CR_FAILURE;
6573 }
6574 else
6575 {
6576 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6577 return CR_FAILURE;
6578 }
6579
6580 pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevNode);
6581 if (pszDevInst == NULL)
6582 return CR_INVALID_DEVNODE;
6583
6584 TRACE("pszDevInst: %S\n", pszDevInst);
6585
6586 pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
6587 if (pszKeyPath == NULL)
6588 {
6590 goto done;
6591 }
6592
6593 pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
6594 if (pszInstancePath == NULL)
6595 {
6597 goto done;
6598 }
6599
6601 pszDevInst,
6602 pszKeyPath,
6603 pszInstancePath,
6604 ulHardwareProfile,
6605 ulFlags);
6606 if (ret != CR_SUCCESS)
6607 goto done;
6608
6609 TRACE("pszKeyPath: %S\n", pszKeyPath);
6610 TRACE("pszInstancePath: %S\n", pszInstancePath);
6611
6612 wcscat(pszKeyPath, L"\\");
6613 wcscat(pszKeyPath, pszInstancePath);
6614
6615 TRACE("pszKeyPath: %S\n", pszKeyPath);
6616
6617 if (hMachine == NULL)
6618 {
6619 hRootKey = HKEY_LOCAL_MACHINE;
6620 }
6621 else
6622 {
6623 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6625 &hRootKey))
6626 {
6628 goto done;
6629 }
6630 }
6631
6633 {
6634 lError = RegCreateKeyExW(hRootKey,
6635 pszKeyPath,
6636 0,
6637 NULL,
6638 0,
6639 samDesired,
6640 NULL,
6641 phkDevice,
6642 &dwDisposition);
6643 }
6644 else
6645 {
6646 lError = RegOpenKeyExW(hRootKey,
6647 pszKeyPath,
6648 0,
6649 samDesired,
6650 phkDevice);
6651 }
6652
6653 if (lError != ERROR_SUCCESS)
6654 {
6655 *phkDevice = NULL;
6657 }
6658
6659done:
6660 if ((hRootKey != NULL) && (hRootKey != HKEY_LOCAL_MACHINE))
6661 RegCloseKey(hRootKey);
6662
6663 if (pszInstancePath != NULL)
6664 MyFree(pszInstancePath);
6665
6666 if (pszKeyPath != NULL)
6667 MyFree(pszKeyPath);
6668
6669 return ret;
6670}
wcscat
long LONG
Definition: pedump.c:60

Referenced by CM_Open_DevNode_Key().

◆ CM_Query_And_Remove_SubTree_ExA()

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 
)

Definition at line 6718 of file cfgmgr.c.

6725{
6726 LPWSTR lpLocalVetoName;
6727 CONFIGRET ret;
6728
6729 TRACE("CM_Query_And_Remove_SubTree_ExA(%lx %p %p %lu %lx %p)\n",
6730 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6731 ulFlags, hMachine);
6732
6733 if (pszVetoName == NULL && ulNameLength == 0)
6734 return CR_INVALID_POINTER;
6735
6736 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
6737 if (lpLocalVetoName == NULL)
6738 return CR_OUT_OF_MEMORY;
6739
6740 ret = CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, lpLocalVetoName,
6741 ulNameLength, ulFlags, hMachine);
6742 if (ret == CR_REMOVE_VETOED)
6743 {
6745 0,
6746 lpLocalVetoName,
6747 ulNameLength,
6748 pszVetoName,
6749 ulNameLength,
6750 NULL,
6751 NULL) == 0)
6752 ret = CR_FAILURE;
6753 }
6754
6755 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
6756
6757 return ret;
6758}
#define CR_REMOVE_VETOED
Definition: cfgmgr32.h:869
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)
Definition: cfgmgr.c:6766

Referenced by CM_Query_And_Remove_SubTreeA().

◆ CM_Query_And_Remove_SubTree_ExW()

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 
)

Definition at line 6766 of file cfgmgr.c.

6773{
6775 HSTRING_TABLE StringTable = NULL;
6776 LPWSTR lpDevInst;
6777 CONFIGRET ret;
6778
6779 TRACE("CM_Query_And_Remove_SubTree_ExW(%lx %p %p %lu %lx %p)\n",
6780 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6781 ulFlags, hMachine);
6782
6783 if (dnAncestor == 0)
6784 return CR_INVALID_DEVNODE;
6785
6786 if (ulFlags & ~CM_REMOVE_BITS)
6787 return CR_INVALID_FLAG;
6788
6789 if (pszVetoName == NULL && ulNameLength == 0)
6790 return CR_INVALID_POINTER;
6791
6792 if (hMachine != NULL)
6793 {
6794 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6795 if (BindingHandle == NULL)
6796 return CR_FAILURE;
6797
6798 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6799 if (StringTable == 0)
6800 return CR_FAILURE;
6801 }
6802 else
6803 {
6804 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6805 return CR_FAILURE;
6806 }
6807
6808 lpDevInst = pSetupStringTableStringFromId(StringTable, dnAncestor);
6809 if (lpDevInst == NULL)
6810 return CR_INVALID_DEVNODE;
6811
6813 {
6815 lpDevInst,
6816 pVetoType,
6817 pszVetoName,
6818 ulNameLength,
6819 ulFlags);
6820 }
6822 {
6824 }
6826
6827 return ret;
6828}
DWORD WINAPI PNP_QueryRemove(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3805
#define CM_REMOVE_BITS
Definition: cfgmgr32.h:780

Referenced by CM_Query_And_Remove_SubTree_ExA(), and CM_Query_And_Remove_SubTreeW().

◆ CM_Query_And_Remove_SubTreeA()

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 
)

Definition at line 6678 of file cfgmgr.c.

6684{
6685 TRACE("CM_Query_And_Remove_SubTreeA(%lx %p %p %lu %lx)\n",
6686 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6687
6688 return CM_Query_And_Remove_SubTree_ExA(dnAncestor, pVetoType, pszVetoName,
6689 ulNameLength, ulFlags, NULL);
6690}
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)
Definition: cfgmgr.c:6718

◆ CM_Query_And_Remove_SubTreeW()

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 
)

Definition at line 6698 of file cfgmgr.c.

6704{
6705 TRACE("CM_Query_And_Remove_SubTreeW(%lx %p %p %lu %lx)\n",
6706 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6707
6708 return CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, pszVetoName,
6709 ulNameLength, ulFlags, NULL);
6710}

◆ CM_Query_Arbitrator_Free_Data()

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 
)

Definition at line 6836 of file cfgmgr.c.

6842{
6843 TRACE("CM_Query_Arbitrator_Free_Data(%p %lu %lx %lu 0x%08lx)\n",
6844 pData, DataLen, dnDevInst, ResourceID, ulFlags);
6845
6846 return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
6847 ResourceID, ulFlags, NULL);
6848}
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)
Definition: cfgmgr.c:6856
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830

◆ CM_Query_Arbitrator_Free_Data_Ex()

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 
)

Definition at line 6856 of file cfgmgr.c.

6863{
6865 HSTRING_TABLE StringTable = NULL;
6866 LPWSTR lpDevInst;
6867 CONFIGRET ret;
6868
6869 TRACE("CM_Query_Arbitrator_Free_Data_Ex(%p %lu %lx %lu 0x%08lx %p)\n",
6870 pData, DataLen, dnDevInst, ResourceID, ulFlags, hMachine);
6871
6872 if (pData == NULL || DataLen == 0)
6873 return CR_INVALID_POINTER;
6874
6875 if (dnDevInst == 0)
6876 return CR_INVALID_DEVINST;
6877
6878 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6879 return CR_INVALID_FLAG;
6880
6881 if (hMachine != NULL)
6882 {
6883 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6884 if (BindingHandle == NULL)
6885 return CR_FAILURE;
6886
6887 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6888 if (StringTable == 0)
6889 return CR_FAILURE;
6890 }
6891 else
6892 {
6893 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6894 return CR_FAILURE;
6895 }
6896
6897 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6898 if (lpDevInst == NULL)
6899 return CR_INVALID_DEVNODE;
6900
6902 {
6904 pData,
6905 DataLen,
6906 lpDevInst,
6907 ResourceID,
6908 ulFlags);
6909 }
6911 {
6913 }
6915
6916 return ret;
6917}
DWORD WINAPI PNP_QueryArbitratorFreeData(handle_t hBinding, BYTE *pData, DWORD DataLen, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4967
#define CM_QUERY_ARBITRATOR_BITS
Definition: cfgmgr32.h:832

Referenced by CM_Query_Arbitrator_Free_Data().

◆ CM_Query_Arbitrator_Free_Size()

CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size ( _Out_ PULONG  pulSize,
_In_ DEVINST  dnDevInst,
_In_ RESOURCEID  ResourceID,
_In_ ULONG  ulFlags 
)

Definition at line 6925 of file cfgmgr.c.

6930{
6931 TRACE("CM_Query_Arbitrator_Free_Size(%p %lu %lx 0x%08lx)\n",
6932 pulSize, dnDevInst,ResourceID, ulFlags);
6933
6934 return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
6935 ulFlags, NULL);
6936}
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size_Ex(_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6944

◆ CM_Query_Arbitrator_Free_Size_Ex()

CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size_Ex ( _Out_ PULONG  pulSize,
_In_ DEVINST  dnDevInst,
_In_ RESOURCEID  ResourceID,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 6944 of file cfgmgr.c.

6950{
6952 HSTRING_TABLE StringTable = NULL;
6953 LPWSTR lpDevInst;
6954 CONFIGRET ret;
6955
6956 TRACE("CM_Query_Arbitrator_Free_Size_Ex(%p %lu %lx 0x%08lx %p)\n",
6957 pulSize, dnDevInst,ResourceID, ulFlags, hMachine);
6958
6959 if (pulSize == NULL)
6960 return CR_INVALID_POINTER;
6961
6962 if (dnDevInst == 0)
6963 return CR_INVALID_DEVINST;
6964
6965 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6966 return CR_INVALID_FLAG;
6967
6968 if (hMachine != NULL)
6969 {
6970 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6971 if (BindingHandle == NULL)
6972 return CR_FAILURE;
6973
6974 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6975 if (StringTable == 0)
6976 return CR_FAILURE;
6977 }
6978 else
6979 {
6980 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6981 return CR_FAILURE;
6982 }
6983
6984 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6985 if (lpDevInst == NULL)
6986 return CR_INVALID_DEVNODE;
6987
6989 {
6991 pulSize,
6992 lpDevInst,
6993 ResourceID,
6994 ulFlags);
6995 }
6997 {
6999 }
7001
7002 return ret;
7003}
DWORD WINAPI PNP_QueryArbitratorFreeSize(handle_t hBinding, DWORD *pulSize, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4982

Referenced by CM_Query_Arbitrator_Free_Size().

◆ CM_Query_Remove_SubTree()

CONFIGRET WINAPI CM_Query_Remove_SubTree ( _In_ DEVINST  dnAncestor,
_In_ ULONG  ulFlags 
)

Definition at line 7013 of file cfgmgr.c.

7016{
7017 TRACE("CM_Query_Remove_SubTree(%lx %lx)\n",
7018 dnAncestor, ulFlags);
7019
7021}

◆ CM_Query_Remove_SubTree_Ex()

CONFIGRET WINAPI CM_Query_Remove_SubTree_Ex ( _In_ DEVINST  dnAncestor,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 7031 of file cfgmgr.c.

7035{
7036 TRACE("CM_Query_Remove_SubTree_Ex(%lx %lx %p)\n",
7037 dnAncestor, ulFlags, hMachine);
7038
7040}

◆ CM_Query_Resource_Conflict_List()

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 
)

Definition at line 7048 of file cfgmgr.c.

7056{
7058 HSTRING_TABLE StringTable = NULL;
7059 PPNP_CONFLICT_LIST pConflictBuffer = NULL;
7060 PCONFLICT_DATA pConflictData = NULL;
7061 ULONG ulBufferLength;
7062 LPWSTR lpDevInst;
7063 CONFIGRET ret;
7064
7065 FIXME("CM_Query_Resource_Conflict_List(%p %lx %lu %p %lu %lx %p)\n",
7066 pclConflictList, dnDevInst, ResourceID, ResourceData,
7067 ResourceLen, ulFlags, hMachine);
7068
7069 if (dnDevInst == 0)
7070 return CR_INVALID_DEVNODE;
7071
7072 if (ulFlags & ~CM_RESDES_WIDTH_BITS)
7073 return CR_INVALID_FLAG;
7074
7075 if (pclConflictList == NULL ||
7076 ResourceData == NULL ||
7077 ResourceLen == 0)
7078 return CR_INVALID_POINTER;
7079
7080 if (ResourceID == 0)
7081 return CR_INVALID_RESOURCEID;
7082
7083 *pclConflictList = 0;
7084
7085 if (hMachine != NULL)
7086 {
7087 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7088 if (BindingHandle == NULL)
7089 return CR_FAILURE;
7090
7091 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7092 if (StringTable == 0)
7093 return CR_FAILURE;
7094 }
7095 else
7096 {
7097 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7098 return CR_FAILURE;
7099 }
7100
7101 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7102 if (lpDevInst == NULL)
7103 return CR_INVALID_DEVNODE;
7104
7105 pConflictData = MyMalloc(sizeof(CONFLICT_DATA));
7106 if (pConflictData == NULL)
7107 {
7109 goto done;
7110 }
7111
7112 ulBufferLength = sizeof(PNP_CONFLICT_LIST) +
7113 sizeof(PNP_CONFLICT_STRINGS) +
7114 (sizeof(wchar_t) * 200);
7115 pConflictBuffer = MyMalloc(ulBufferLength);
7116 if (pConflictBuffer == NULL)
7117 {
7119 goto done;
7120 }
7121
7123 {
7125 lpDevInst,
7126 ResourceID,
7127 (PBYTE)ResourceData,
7128 ResourceLen,
7129 (PBYTE)pConflictBuffer,
7130 ulBufferLength,
7131 ulFlags);
7132 }
7134 {
7136 }
7138
7139 if (ret != CR_SUCCESS)
7140 goto done;
7141
7142 pConflictData->ulMagic = CONFLICT_MAGIC;
7143 pConflictData->pConflictList = pConflictBuffer;
7144
7145 *pclConflictList = (CONFLICT_LIST)pConflictData;
7146
7147done:
7148 if (ret != CR_SUCCESS)
7149 {
7150 if (pConflictBuffer != NULL)
7151 MyFree(pConflictBuffer);
7152
7153 if (pConflictData != NULL)
7154 MyFree(pConflictData);
7155 }
7156
7157 return ret;
7158}
DWORD WINAPI PNP_QueryResConfList(handle_t hBinding, LPWSTR pDeviceID, RESOURCEID ResourceID, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, BYTE *Buffer, PNP_RPC_BUFFER_SIZE BufferLen, DWORD ulFlags)
Definition: rpcserver.c:4937
ULONG_PTR CONFLICT_LIST
Definition: cfgmgr32.h:111
#define CR_INVALID_RESOURCEID
Definition: cfgmgr32.h:855
#define CM_RESDES_WIDTH_BITS
Definition: cfgmgr32.h:402
#define CONFLICT_MAGIC
Definition: cfgmgr.c:111
BYTE * PBYTE
Definition: pedump.c:66
struct _PNP_CONFLICT_LIST PNP_CONFLICT_LIST
ULONG ulMagic
Definition: cfgmgr.c:107
#define wchar_t
Definition: wchar.h:102

◆ CM_Reenumerate_DevNode()

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

Definition at line 7166 of file cfgmgr.c.

7169{
7170 TRACE("CM_Reenumerate_DevNode(%lx %lx)\n",
7171 dnDevInst, ulFlags);
7172
7173 return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
7174}
CONFIGRET WINAPI CM_Reenumerate_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7181

◆ CM_Reenumerate_DevNode_Ex()

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

Definition at line 7181 of file cfgmgr.c.

7185{
7187 HSTRING_TABLE StringTable = NULL;
7188 LPWSTR lpDevInst;
7189 CONFIGRET ret;
7190
7191 FIXME("CM_Reenumerate_DevNode_Ex(%lx %lx %p)\n",
7192 dnDevInst, ulFlags, hMachine);
7193
7194 if (dnDevInst == 0)
7195 return CR_INVALID_DEVNODE;
7196
7197 if (ulFlags & ~CM_REENUMERATE_BITS)
7198 return CR_INVALID_FLAG;
7199
7200 if (hMachine != NULL)
7201 {
7202 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7203 if (BindingHandle == NULL)
7204 return CR_FAILURE;
7205
7206 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7207 if (StringTable == 0)
7208 return CR_FAILURE;
7209 }
7210 else
7211 {
7212 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7213 return CR_FAILURE;
7214 }
7215
7216 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7217 if (lpDevInst == NULL)
7218 return CR_INVALID_DEVNODE;
7219
7221 {
7223 PNP_DEVINST_REENUMERATE,
7224 ulFlags,
7225 lpDevInst,
7226 NULL);
7227 }
7229 {
7231 }
7233
7234 return ret;
7235}
#define CM_REENUMERATE_BITS
Definition: cfgmgr32.h:793

Referenced by CM_Reenumerate_DevNode().

◆ CM_Register_Device_Driver()

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

Definition at line 7243 of file cfgmgr.c.

7246{
7247 TRACE("CM_Register_Device_Driver(%lx 0x%08lx)\n",
7248 dnDevInst, ulFlags);
7249
7250 return CM_Register_Device_Driver_Ex(dnDevInst, ulFlags, NULL);
7251}
CONFIGRET WINAPI CM_Register_Device_Driver_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7259

◆ CM_Register_Device_Driver_Ex()

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

Definition at line 7259 of file cfgmgr.c.

7263{
7265 HSTRING_TABLE StringTable = NULL;
7266 LPWSTR lpDevInst;
7267 CONFIGRET ret;
7268
7269 TRACE("CM_Register_Device_Driver_Ex(%lx 0x%08lx %p)\n",
7270 dnDevInst, ulFlags, hMachine);
7271
7272 if (dnDevInst == 0)
7273 return CR_INVALID_DEVNODE;
7274
7275 if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
7276 return CR_INVALID_FLAG;
7277
7278 if (hMachine != NULL)
7279 {
7280 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7281 if (BindingHandle == NULL)
7282 return CR_FAILURE;
7283
7284 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7285 if (StringTable == 0)
7286 return CR_FAILURE;
7287 }
7288 else
7289 {
7290 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7291 return CR_FAILURE;
7292 }
7293
7294 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7295 if (lpDevInst == NULL)
7296 return CR_INVALID_DEVNODE;
7297
7299 {
7301 lpDevInst,
7302 ulFlags);
7303 }
7305 {
7307 }
7309
7310 return ret;
7311}
DWORD WINAPI PNP_RegisterDriver(handle_t hBinding, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3782
#define CM_REGISTER_DEVICE_DRIVER_BITS
Definition: cfgmgr32.h:798

Referenced by CM_Register_Device_Driver().

◆ CM_Register_Device_Interface_ExA()

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 
)

Definition at line 7365 of file cfgmgr.c.

7373{
7374 LPWSTR pszReferenceW = NULL;
7375 LPWSTR pszDeviceInterfaceW;
7376 ULONG ulLength;
7377 CONFIGRET ret;
7378
7379 TRACE("CM_Register_Device_Interface_ExA(%lx %s %s %p %p %lx %p)\n",
7380 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_a(pszReference),
7381 pszDeviceInterface, pulLength, ulFlags, hMachine);
7382
7383 if (pulLength == NULL || pszDeviceInterface == NULL)
7384 return CR_INVALID_POINTER;
7385
7386 if (pszReference != NULL)
7387 {
7388 if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
7389 return CR_INVALID_DATA;
7390 }
7391
7392 ulLength = *pulLength;
7393
7394 pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
7395 if (pszDeviceInterfaceW == NULL)
7396 {
7398 goto Done;
7399 }
7400
7403 pszReferenceW,
7404 pszDeviceInterfaceW,
7405 &ulLength,
7406 ulFlags,
7407 hMachine);
7408 if (ret == CR_SUCCESS)
7409 {
7411 0,
7412 pszDeviceInterfaceW,
7413 ulLength,
7414 pszDeviceInterface,
7415 *pulLength,
7416 NULL,
7417 NULL) == 0)
7418 ret = CR_FAILURE;
7419 }
7420
7421 *pulLength = ulLength;
7422
7423Done:
7424 if (pszDeviceInterfaceW != NULL)
7425 HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
7426
7427 if (pszReferenceW != NULL)
7428 MyFree(pszReferenceW);
7429
7430 return ret;
7431}
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)
Definition: cfgmgr.c:7439

Referenced by CM_Register_Device_InterfaceA().

◆ CM_Register_Device_Interface_ExW()

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 
)

Definition at line 7439 of file cfgmgr.c.

7447{
7449 HSTRING_TABLE StringTable = NULL;
7450 LPWSTR lpDevInst;
7451 ULONG ulTransferLength;
7452 CONFIGRET ret;
7453
7454 TRACE("CM_Register_Device_Interface_ExW(%lx %s %s %p %p %lx %p)\n",
7455 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_w(pszReference),
7456 pszDeviceInterface, pulLength, ulFlags, hMachine);
7457
7458 if (dnDevInst == 0)
7459 return CR_INVALID_DEVNODE;
7460
7461 if (InterfaceClassGuid == NULL ||
7462 pszDeviceInterface == NULL ||
7463 pulLength == NULL)
7464 return CR_INVALID_POINTER;
7465
7466 if (ulFlags != 0)
7467 return CR_INVALID_FLAG;
7468
7469 if (hMachine != NULL)
7470 {
7471 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7472 if (BindingHandle == NULL)
7473 return CR_FAILURE;
7474
7475 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7476 if (StringTable == 0)
7477 return CR_FAILURE;
7478 }
7479 else
7480 {
7481 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7482 return CR_FAILURE;
7483 }
7484
7485 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7486 if (lpDevInst == NULL)
7487 return CR_INVALID_DEVNODE;
7488
7489 ulTransferLength = *pulLength;
7490
7492 {
7494 lpDevInst,
7496 (LPWSTR)pszReference,
7497 pszDeviceInterface,
7498 pulLength,
7499 &ulTransferLength,
7500 0);
7501 }
7503 {
7505 }
7507
7508 return ret;
7509}
DWORD WINAPI PNP_RegisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszDeviceID, GUID *InterfaceGuid, LPWSTR pszReference, LPWSTR pszSymLink, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
Definition: rpcserver.c:2744

Referenced by CM_Register_Device_Interface_ExA(), and CM_Register_Device_InterfaceW().

◆ CM_Register_Device_InterfaceA()

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 
)

Definition at line 7319 of file cfgmgr.c.

7326{
7327 TRACE("CM_Register_Device_InterfaceA(%lx %s %s %p %p %lx)\n",
7329 pszReference, pszDeviceInterface, pulLength, ulFlags);
7330
7332 pszReference, pszDeviceInterface,
7333 pulLength, ulFlags, NULL);
7334}
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)
Definition: cfgmgr.c:7365

◆ CM_Register_Device_InterfaceW()

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 
)

Definition at line 7342 of file cfgmgr.c.

7349{
7350 TRACE("CM_Register_Device_InterfaceW(%lx %s %s %p %p %lx)\n",
7352 debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
7353
7355 pszReference, pszDeviceInterface,
7356 pulLength, ulFlags, NULL);
7357}

◆ CM_Remove_SubTree()

CONFIGRET WINAPI CM_Remove_SubTree ( _In_ DEVINST  dnAncestor,
_In_ ULONG  ulFlags 
)

Definition at line 7519 of file cfgmgr.c.

7522{
7523 TRACE("CM_Remove_SubTree(%lx %lx)\n",
7524 dnAncestor, ulFlags);
7525
7527}

◆ CM_Remove_SubTree_Ex()

CONFIGRET WINAPI CM_Remove_SubTree_Ex ( _In_ DEVINST  dnAncestor,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 7537 of file cfgmgr.c.

7541{
7542 TRACE("CM_Remove_SubTree_Ex(%lx %lx %p)\n",
7543 dnAncestor, ulFlags, hMachine);
7544
7546}

◆ CM_Request_Device_Eject_ExA()

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 
)

Definition at line 7594 of file cfgmgr.c.

7601{
7602 LPWSTR lpLocalVetoName = NULL;
7603 CONFIGRET ret;
7604
7605 TRACE("CM_Request_Device_Eject_ExA(%lx %p %p %lu %lx %p)\n",
7606 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7607
7608 if (ulNameLength != 0)
7609 {
7610 if (pszVetoName == NULL)
7611 return CR_INVALID_POINTER;
7612
7613 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
7614 if (lpLocalVetoName == NULL)
7615 return CR_OUT_OF_MEMORY;
7616 }
7617
7618 ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
7619 ulNameLength, ulFlags, hMachine);
7620 if (ret == CR_REMOVE_VETOED && ulNameLength != 0)
7621 {
7623 0,
7624 lpLocalVetoName,
7625 ulNameLength,
7626 pszVetoName,
7627 ulNameLength,
7628 NULL,
7629 NULL) == 0)
7630 ret = CR_FAILURE;
7631 }
7632
7633 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
7634
7635 return ret;
7636}
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)
Definition: cfgmgr.c:7644

Referenced by CM_Request_Device_EjectA().

◆ CM_Request_Device_Eject_ExW()

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 
)

Definition at line 7644 of file cfgmgr.c.

7651{
7653 HSTRING_TABLE StringTable = NULL;
7654 LPWSTR lpDevInst;
7655 CONFIGRET ret;
7656
7657 TRACE("CM_Request_Device_Eject_ExW(%lx %p %p %lu %lx %p)\n",
7658 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7659
7660 if (dnDevInst == 0)
7661 return CR_INVALID_DEVNODE;
7662
7663 if (ulFlags != 0)
7664 return CR_INVALID_FLAG;
7665
7666 if (pszVetoName == NULL && ulNameLength != 0)
7667 return CR_INVALID_POINTER;
7668
7669 /* Windows 2003 SP2 ignores pszVetoName when ulNameLength is zero
7670 * and behaves like when pszVetoName is NULL */
7671 if (ulNameLength == 0)
7672 pszVetoName = NULL;
7673
7674 if (hMachine != NULL)
7675 {
7676 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7677 if (BindingHandle == NULL)
7678 return CR_FAILURE;
7679
7680 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7681 if (StringTable == 0)
7682 return CR_FAILURE;
7683 }
7684 else
7685 {
7686 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7687 return CR_FAILURE;
7688 }
7689
7690 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7691 if (lpDevInst == NULL)
7692 return CR_INVALID_DEVNODE;
7693
7695 {
7697 lpDevInst,
7698 pVetoType,
7699 pszVetoName,
7700 ulNameLength,
7701 ulFlags);
7702 }
7704 {
7706 }
7708
7709 return ret;
7710}
DWORD WINAPI PNP_RequestDeviceEject(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3854

Referenced by CM_Request_Device_Eject_ExA(), and CM_Request_Device_EjectW().

◆ CM_Request_Device_EjectA()

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 
)

Definition at line 7554 of file cfgmgr.c.

7560{
7561 TRACE("CM_Request_Device_EjectA(%lx %p %p %lu %lx)\n",
7562 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7563
7564 return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
7565 ulNameLength, ulFlags, NULL);
7566}
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)
Definition: cfgmgr.c:7594

◆ CM_Request_Device_EjectW()

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 
)

Definition at line 7574 of file cfgmgr.c.

7580{
7581 TRACE("CM_Request_Device_EjectW(%lx %p %p %lu %lx)\n",
7582 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7583
7584 return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
7585 ulNameLength, ulFlags, NULL);
7586}

Referenced by SafeRemoveDevice().

◆ CM_Request_Eject_PC()

CONFIGRET WINAPI CM_Request_Eject_PC ( VOID  )

Definition at line 7718 of file cfgmgr.c.

7719{
7720 TRACE("CM_Request_Eject_PC()\n");
7721
7723}
CONFIGRET WINAPI CM_Request_Eject_PC_Ex(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7731

◆ CM_Request_Eject_PC_Ex()

CONFIGRET WINAPI CM_Request_Eject_PC_Ex ( _In_opt_ HMACHINE  hMachine)

Definition at line 7731 of file cfgmgr.c.

7733{
7735 CONFIGRET ret;
7736
7737 TRACE("CM_Request_Eject_PC_Ex(%p)\n", hMachine);
7738
7739 if (hMachine != NULL)
7740 {
7741 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7742 if (BindingHandle == NULL)
7743 return CR_FAILURE;
7744 }
7745 else
7746 {
7748 return CR_FAILURE;
7749 }
7750
7752 {
7754 }
7756 {
7758 }
7760
7761 return ret;
7762}
DWORD WINAPI PNP_RequestEjectPC(handle_t hBinding)
Definition: rpcserver.c:3958

Referenced by CM_Request_Eject_PC().

◆ CM_Run_Detection()

CONFIGRET WINAPI CM_Run_Detection ( _In_ ULONG  ulFlags)

Definition at line 7770 of file cfgmgr.c.

7772{
7773 TRACE("CM_Run_Detection(%lx)\n", ulFlags);
7774
7775 return CM_Run_Detection_Ex(ulFlags, NULL);
7776}
CONFIGRET WINAPI CM_Run_Detection_Ex(_In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7784

◆ CM_Run_Detection_Ex()

CONFIGRET WINAPI CM_Run_Detection_Ex ( _In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 7784 of file cfgmgr.c.

7787{
7789 CONFIGRET ret;
7790
7791 TRACE("CM_Run_Detection_Ex(%lx %p)\n",
7792 ulFlags, hMachine);
7793
7794 if (!pSetupIsUserAdmin())
7795 return CR_ACCESS_DENIED;
7796
7797 if (ulFlags & ~CM_DETECT_BITS)
7798 return CR_INVALID_FLAG;
7799
7800 if (hMachine != NULL)
7801 {
7802 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7803 if (BindingHandle == NULL)
7804 return CR_FAILURE;
7805 }
7806 else
7807 {
7809 return CR_FAILURE;
7810 }
7811
7813 {
7815 ulFlags);
7816 }
7818 {
7820 }
7822
7823 return ret;
7824}
CONFIGRET WINAPI PNP_RunDetection(handle_t hBinding, DWORD ulFlags)
Definition: rpcserver.c:4999
#define CM_DETECT_BITS
Definition: cfgmgr32.h:646

Referenced by CM_Run_Detection().

◆ CM_Set_Class_Registry_PropertyA()

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 
)

Definition at line 7832 of file cfgmgr.c.

7839{
7841 ULONG ulType;
7842 CONFIGRET ret;
7843
7844 TRACE("CM_Set_Class_Registry_PropertyA(%p %lx %p %lu %lx %p)\n",
7845 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7846
7847 if (ClassGuid == NULL)
7848 return CR_INVALID_POINTER;
7849
7850 if ((Buffer == NULL) && (ulLength != 0))
7851 return CR_INVALID_POINTER;
7852
7853 if (ulFlags != 0)
7854 return CR_INVALID_FLAG;
7855
7856 if (Buffer == NULL)
7857 {
7859 ulProperty,
7860 Buffer,
7861 ulLength,
7862 ulFlags,
7863 hMachine);
7864 }
7865 else
7866 {
7867 /* Get property type */
7868 ulType = GetRegistryPropertyType(ulProperty);
7869
7870 /* Allocate buffer if needed */
7871 if ((ulType == REG_SZ) || (ulType == REG_MULTI_SZ))
7872 {
7873 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
7874 if (lpBuffer == NULL)
7875 {
7877 }
7878 else
7879 {
7881 ulLength, lpBuffer, ulLength))
7882 {
7884 ret = CR_FAILURE;
7885 }
7886 else
7887 {
7889 ulProperty,
7890 lpBuffer,
7891 ulLength * sizeof(WCHAR),
7892 ulFlags,
7893 hMachine);
7895 }
7896 }
7897 }
7898 else
7899 {
7901 ulProperty,
7902 Buffer,
7903 ulLength,
7904 ulFlags,
7905 hMachine);
7906 }
7907
7908 }
7909
7910 return ret;
7911}
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)
Definition: cfgmgr.c:7919
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define MultiByteToWideChar
Definition: compat.h:110

Referenced by SetupDiSetClassRegistryPropertyA().

◆ CM_Set_Class_Registry_PropertyW()

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 
)

Definition at line 7919 of file cfgmgr.c.

7926{
7928 WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
7929 ULONG ulType = 0;
7930 PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
7931 ULONG SecurityDescriptorSize = 0;
7932 CONFIGRET ret;
7933
7934 TRACE("CM_Set_Class_Registry_PropertyW(%p %lx %p %lu %lx %p)\n",
7935 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7936
7937 if (ClassGuid == NULL)
7938 return CR_INVALID_POINTER;
7939
7940 if ((Buffer == NULL) && (ulLength != 0))
7941 return CR_INVALID_POINTER;
7942
7943 if (ulFlags != 0)
7944 return CR_INVALID_FLAG;
7945
7946 if (pSetupStringFromGuid(ClassGuid,
7947 szGuidString,
7949 return CR_INVALID_DATA;
7950
7951 if ((ulProperty < CM_CRP_MIN) || (ulProperty > CM_CRP_MAX))
7952 return CR_INVALID_PROPERTY;
7953
7954 if (hMachine != NULL)
7955 {
7956 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7957 if (BindingHandle == NULL)
7958 return CR_FAILURE;
7959 }
7960 else
7961 {
7963 return CR_FAILURE;
7964 }
7965
7966 ulType = GetRegistryPropertyType(ulProperty);
7967 if ((ulType == REG_DWORD) && (ulLength != sizeof(DWORD)))
7968 return CR_INVALID_DATA;
7969
7970 if (ulProperty == CM_CRP_SECURITY_SDS)
7971 {
7972 if (ulLength != 0)
7973 {
7976 &pSecurityDescriptor,
7977 &SecurityDescriptorSize))
7978 {
7979 ERR("ConvertStringSecurityDescriptorToSecurityDescriptorW() failed (Error %lu)\n", GetLastError());
7980 return CR_INVALID_DATA;
7981 }
7982
7983 Buffer = (PCVOID)pSecurityDescriptor;
7984 ulLength = SecurityDescriptorSize;
7985 }
7986
7987 ulProperty = CM_CRP_SECURITY;
7989 }
7990
7992 {
7994 szGuidString,
7995 ulProperty,
7996 ulType,
7997 (LPBYTE)Buffer,
7998 ulLength,
7999 ulFlags);
8000 }
8002 {
8004 }
8006
8007 if (pSecurityDescriptor)
8008 LocalFree(pSecurityDescriptor);
8009
8010 return ret;
8011}
DWORD WINAPI PNP_SetClassRegProp(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:2901
#define ERR(fmt,...)
Definition: precomp.h:57
#define CM_CRP_SECURITY_SDS
Definition: cfgmgr32.h:708
#define CM_CRP_MIN
Definition: cfgmgr32.h:731
#define CM_CRP_SECURITY
Definition: cfgmgr32.h:706
CONST VOID * PCVOID
Definition: cfgmgr32.h:44
BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(LPCWSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize)
Definition: security.c:3062
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
#define REG_BINARY
Definition: nt_native.h:1496
#define REG_DWORD
Definition: sdbapi.c:596
#define SDDL_REVISION_1
Definition: sddl.h:30
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by CM_Set_Class_Registry_PropertyA(), and SetupDiSetClassRegistryPropertyW().

◆ CM_Set_DevNode_Problem()

CONFIGRET WINAPI CM_Set_DevNode_Problem ( _In_ DEVINST  dnDevInst,
_In_ ULONG  ulProblem,
_In_ ULONG  ulFlags 
)

Definition at line 8019 of file cfgmgr.c.

8023{
8024 TRACE("CM_Set_DevNode_Problem(%lx %lx %lx)\n",
8025 dnDevInst, ulProblem, ulFlags);
8026
8027 return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
8028}
CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8036

Referenced by SetFailedInstall().

◆ CM_Set_DevNode_Problem_Ex()

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

Definition at line 8036 of file cfgmgr.c.

8041{
8043 HSTRING_TABLE StringTable = NULL;
8044 LPWSTR lpDevInst;
8045 CONFIGRET ret;
8046
8047 TRACE("CM_Set_DevNode_Problem_Ex(%lx %lx %lx %p)\n",
8048 dnDevInst, ulProblem, ulFlags, hMachine);
8049
8050 if (dnDevInst == 0)
8051 return CR_INVALID_DEVNODE;
8052
8053 if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
8054 return CR_INVALID_FLAG;
8055
8056 if (hMachine != NULL)
8057 {
8058 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8059 if (BindingHandle == NULL)
8060 return CR_FAILURE;
8061
8062 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8063 if (StringTable == 0)
8064 return CR_FAILURE;
8065 }
8066 else
8067 {
8068 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8069 return CR_FAILURE;
8070 }
8071
8072 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8073 if (lpDevInst == NULL)
8074 return CR_INVALID_DEVNODE;
8075
8077 {
8079 lpDevInst,
8080 ulProblem,
8081 ulFlags);
8082 }
8084 {
8086 }
8088
8089 return ret;
8090}
DWORD WINAPI PNP_SetDeviceProblem(handle_t hBinding, LPWSTR pDeviceID, DWORD ulProblem, DWORD ulFlags)
Definition: rpcserver.c:3537
#define CM_SET_DEVNODE_PROBLEM_BITS
Definition: cfgmgr32.h:808

Referenced by CM_Set_DevNode_Problem().

◆ CM_Set_DevNode_Registry_Property_ExA()

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 
)

Definition at line 8140 of file cfgmgr.c.

8147{
8150 ULONG ulType;
8151
8152 FIXME("CM_Set_DevNode_Registry_Property_ExA(%lx %lu %p %lx %lx %p)\n",
8153 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8154
8155 if (Buffer == NULL && ulLength != 0)
8156 return CR_INVALID_POINTER;
8157
8158 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8159 return CR_INVALID_PROPERTY;
8160
8161 if (Buffer == NULL)
8162 {
8164 ulProperty,
8165 NULL,
8166 0,
8167 ulFlags,
8168 hMachine);
8169 }
8170 else
8171 {
8172 /* Get property type */
8173 ulType = GetRegistryPropertyType(ulProperty);
8174
8175 /* Allocate buffer if needed */
8176 if (ulType == REG_SZ ||
8178 {
8179 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
8180 if (lpBuffer == NULL)
8181 {
8183 }
8184 else
8185 {
8187 ulLength, lpBuffer, ulLength))
8188 {
8190 ret = CR_FAILURE;
8191 }
8192 else
8193 {
8195 ulProperty,
8196 lpBuffer,
8197 ulLength * sizeof(WCHAR),
8198 ulFlags,
8199 hMachine);
8201 }
8202 }
8203 }
8204 else
8205 {
8207 ulProperty,
8208 Buffer,
8209 ulLength,
8210 ulFlags,
8211 hMachine);
8212 }
8213
8215 }
8216
8217 return ret;
8218}
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)
Definition: cfgmgr.c:8226

Referenced by CM_Set_DevNode_Registry_PropertyA().

◆ CM_Set_DevNode_Registry_Property_ExW()

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 
)

Definition at line 8226 of file cfgmgr.c.

8233{
8235 HSTRING_TABLE StringTable = NULL;
8236 LPWSTR lpDevInst;
8237 ULONG ulType;
8238 CONFIGRET ret;
8239
8240 TRACE("CM_Set_DevNode_Registry_Property_ExW(%lx %lu %p %lx %lx %p)\n",
8241 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8242
8243 if (dnDevInst == 0)
8244 return CR_INVALID_DEVNODE;
8245
8246 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8247 return CR_INVALID_PROPERTY;
8248
8249 if (Buffer != NULL && ulLength == 0)
8250 return CR_INVALID_POINTER;
8251
8252 if (ulFlags != 0)
8253 return CR_INVALID_FLAG;
8254
8255 if (hMachine != NULL)
8256 {
8257 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8258 if (BindingHandle == NULL)
8259 return CR_FAILURE;
8260
8261 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8262 if (StringTable == 0)
8263 return CR_FAILURE;
8264 }
8265 else
8266 {
8267 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8268 return CR_FAILURE;
8269 }
8270
8271 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8272 if (lpDevInst == NULL)
8273 return CR_INVALID_DEVNODE;
8274
8275 /* Get property type */
8276 ulType = GetRegistryPropertyType(ulProperty);
8277
8279 {
8281 lpDevInst,
8282 ulProperty,
8283 ulType,
8284 (BYTE *)Buffer,
8285 ulLength,
8286 ulFlags);
8287 }
8289 {
8291 }
8293
8294 return ret;
8295}
DWORD WINAPI PNP_SetDeviceRegProp(handle_t hBinding, LPWSTR pDeviceId, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:2160
unsigned char BYTE
Definition: xxhash.c:193

Referenced by CM_Set_DevNode_Registry_Property_ExA(), and CM_Set_DevNode_Registry_PropertyW().

◆ CM_Set_DevNode_Registry_PropertyA()

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 
)

Definition at line 8098 of file cfgmgr.c.

8104{
8105 TRACE("CM_Set_DevNode_Registry_PropertyA(%lx %lu %p %lx %lx)\n",
8106 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8107
8108 return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
8109 Buffer, ulLength,
8110 ulFlags, NULL);
8111}
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)
Definition: cfgmgr.c:8140

◆ CM_Set_DevNode_Registry_PropertyW()

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 
)

Definition at line 8119 of file cfgmgr.c.

8125{
8126 TRACE("CM_Set_DevNode_Registry_PropertyW(%lx %lu %p %lx %lx)\n",
8127 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8128
8129 return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
8130 Buffer, ulLength,
8131 ulFlags, NULL);
8132}

◆ CM_Set_HW_Prof()

CONFIGRET WINAPI CM_Set_HW_Prof ( _In_ ULONG  ulHardwareProfile,
_In_ ULONG  ulFlags 
)

Definition at line 8303 of file cfgmgr.c.

8306{
8307 TRACE("CM_Set_HW_Prof(%lu %lx)\n",
8308 ulHardwareProfile, ulFlags);
8309
8310 return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
8311}
CONFIGRET WINAPI CM_Set_HW_Prof_Ex(_In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8319

◆ CM_Set_HW_Prof_Ex()

CONFIGRET WINAPI CM_Set_HW_Prof_Ex ( _In_ ULONG  ulHardwareProfile,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 8319 of file cfgmgr.c.

8323{
8325 CONFIGRET ret;
8326
8327 TRACE("CM_Set_HW_Prof_Ex(%lu %lx %p)\n",
8328 ulHardwareProfile, ulFlags, hMachine);
8329
8330 if (!pSetupIsUserAdmin())
8331 return CR_ACCESS_DENIED;
8332
8333 if (ulFlags != 0)
8334 return CR_INVALID_FLAG;
8335
8336 if (hMachine != NULL)
8337 {
8338 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8339 if (BindingHandle == NULL)
8340 return CR_FAILURE;
8341 }
8342 else
8343 {
8345 return CR_FAILURE;
8346 }
8347
8349 {
8350 ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
8351 }
8353 {
8355 }
8357
8358 return ret;
8359}
DWORD WINAPI PNP_SetHwProf(handle_t hBinding, DWORD ulHardwareProfile, DWORD ulFlags)
Definition: rpcserver.c:4955

Referenced by CM_Set_HW_Prof().

◆ CM_Set_HW_Prof_Flags_ExA()

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 
)

Definition at line 8405 of file cfgmgr.c.

8411{
8412 DEVINSTID_W pszDevIdW = NULL;
8414
8415 TRACE("CM_Set_HW_Prof_Flags_ExA(%s %lu %lu %lx %p)\n",
8416 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8417
8418 if (szDevInstName != NULL)
8419 {
8420 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
8421 return CR_INVALID_DEVICE_ID;
8422 }
8423
8424 ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
8425 ulFlags, hMachine);
8426
8427 if (pszDevIdW != NULL)
8428 MyFree(pszDevIdW);
8429
8430 return ret;
8431}
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)
Definition: cfgmgr.c:8439

Referenced by CM_Set_HW_Prof_FlagsA().

◆ CM_Set_HW_Prof_Flags_ExW()

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 
)

Definition at line 8439 of file cfgmgr.c.

8445{
8447 CONFIGRET ret;
8448
8449 FIXME("CM_Set_HW_Prof_Flags_ExW(%s %lu %lu %lx %p)\n",
8450 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8451
8452 if (szDevInstName == NULL)
8453 return CR_INVALID_POINTER;
8454
8455 if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
8456 return CR_INVALID_FLAG;
8457
8458 /* FIXME: Check whether szDevInstName is valid */
8459
8460 if (hMachine != NULL)
8461 {
8462 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8463 if (BindingHandle == NULL)
8464 return CR_FAILURE;
8465 }
8466 else
8467 {
8469 return CR_FAILURE;
8470 }
8471
8473 {
8474 ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
8475 ulConfig, &ulValue, NULL, NULL, 0, 0);
8476 }
8478 {
8480 }
8482
8483 return ret;
8484}
#define CM_SET_HW_PROF_FLAGS_BITS
Definition: cfgmgr32.h:816

Referenced by CM_Set_HW_Prof_Flags_ExA(), and CM_Set_HW_Prof_FlagsW().

◆ CM_Set_HW_Prof_FlagsA()

CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA ( _In_ DEVINSTID_A  szDevInstName,
_In_ ULONG  ulConfig,
_In_ ULONG  ulValue,
_In_ ULONG  ulFlags 
)

Definition at line 8367 of file cfgmgr.c.

8372{
8373 TRACE("CM_Set_HW_Prof_FlagsA(%s %lu %lu %lx)\n",
8374 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags);
8375
8376 return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
8377 ulFlags, NULL);
8378}
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)
Definition: cfgmgr.c:8405

◆ CM_Set_HW_Prof_FlagsW()

CONFIGRET WINAPI CM_Set_HW_Prof_FlagsW ( _In_ DEVINSTID_W  szDevInstName,
_In_ ULONG  ulConfig,
_In_ ULONG  ulValue,
_In_ ULONG  ulFlags 
)

Definition at line 8386 of file cfgmgr.c.

8391{
8392 TRACE("CM_Set_HW_Prof_FlagsW(%s %lu %lu %lx)\n",
8393 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags);
8394
8395 return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
8396 ulFlags, NULL);
8397}

◆ CM_Setup_DevNode()

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

Definition at line 8492 of file cfgmgr.c.

8495{
8496 TRACE("CM_Setup_DevNode(%lx %lx)\n",
8497 dnDevInst, ulFlags);
8498
8499 return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
8500}
CONFIGRET WINAPI CM_Setup_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8508

◆ CM_Setup_DevNode_Ex()

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

Definition at line 8508 of file cfgmgr.c.

8512{
8514 HSTRING_TABLE StringTable = NULL;
8515 LPWSTR lpDevInst;
8516 CONFIGRET ret;
8517
8518 FIXME("CM_Setup_DevNode_Ex(%lx %lx %p)\n",
8519 dnDevInst, ulFlags, hMachine);
8520
8521 if (!pSetupIsUserAdmin())
8522 return CR_ACCESS_DENIED;
8523
8524 if (dnDevInst == 0)
8525 return CR_INVALID_DEVNODE;
8526
8527 if (ulFlags & ~CM_SETUP_BITS)
8528 return CR_INVALID_FLAG;
8529
8530 if (hMachine != NULL)
8531 {
8532 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8533 if (BindingHandle == NULL)
8534 return CR_FAILURE;
8535
8536 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8537 if (StringTable == 0)
8538 return CR_FAILURE;
8539 }
8540 else
8541 {
8542 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8543 return CR_FAILURE;
8544 }
8545
8546 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8547 if (lpDevInst == NULL)
8548 return CR_INVALID_DEVNODE;
8549
8551 {
8553 PNP_DEVINST_SETUP,
8554 ulFlags,
8555 lpDevInst,
8556 NULL);
8557 }
8559 {
8561 }
8563
8564 return ret;
8565}
#define CM_SETUP_BITS
Definition: cfgmgr32.h:828

Referenced by CM_Setup_DevNode().

◆ CM_Test_Range_Available()

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

Definition at line 8573 of file cfgmgr.c.

8578{
8579 PINTERNAL_RANGE_LIST pRangeList;
8580 PINTERNAL_RANGE pRange;
8581 PLIST_ENTRY ListEntry;
8583
8584 FIXME("CM_Test_Range_Available(%I64u %I64u %p %lx)\n",
8585 ullStartValue, ullEndValue, rlh, ulFlags);
8586
8587 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
8588
8589 if (!IsValidRangeList(pRangeList))
8590 return CR_INVALID_RANGE_LIST;
8591
8592 if (ulFlags != 0)
8593 return CR_INVALID_FLAG;
8594
8595 if (ullStartValue > ullEndValue)
8596 return CR_INVALID_RANGE;
8597
8598 /* Lock the range list */
8599 WaitForSingleObject(pRangeList->hMutex, INFINITE);
8600
8601 /* Check the ranges */
8602 ListEntry = &pRangeList->ListHead;
8603 while (ListEntry->Flink == &pRangeList->ListHead)
8604 {
8605 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
8606
8607 /* Check if the start value is within the current range */
8608 if ((ullStartValue >= pRange->ullStart) && (ullStartValue <= pRange->ullEnd))
8609 {
8610 ret = CR_FAILURE;
8611 break;
8612 }
8613
8614 /* Check if the end value is within the current range */
8615 if ((ullEndValue >= pRange->ullStart) && (ullEndValue <= pRange->ullEnd))
8616 {
8617 ret = CR_FAILURE;
8618 break;
8619 }
8620
8621 /* Check if the current range lies inside of the start-end interval */
8622 if ((ullStartValue <= pRange->ullStart) && (ullEndValue >= pRange->ullEnd))
8623 {
8624 ret = CR_FAILURE;
8625 break;
8626 }
8627
8628 ListEntry = ListEntry->Flink;
8629 }
8630
8631 /* Unlock the range list */
8632 ReleaseMutex(pRangeList->hMutex);
8633
8634 return ret;
8635}

◆ CM_Uninstall_DevNode()

CONFIGRET WINAPI CM_Uninstall_DevNode ( _In_ DEVINST  dnPhantom,
_In_ ULONG  ulFlags 
)

Definition at line 8643 of file cfgmgr.c.

8646{
8647 TRACE("CM_Uninstall_DevNode(%lx %lx)\n",
8648 dnPhantom, ulFlags);
8649
8650 return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
8651}
CONFIGRET WINAPI CM_Uninstall_DevNode_Ex(_In_ DEVINST dnPhantom, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8659

◆ CM_Uninstall_DevNode_Ex()

CONFIGRET WINAPI CM_Uninstall_DevNode_Ex ( _In_ DEVINST  dnPhantom,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 8659 of file cfgmgr.c.

8663{
8665 HSTRING_TABLE StringTable = NULL;
8666 LPWSTR lpDevInst;
8667 CONFIGRET ret;
8668
8669 TRACE("CM_Uninstall_DevNode_Ex(%lx %lx %p)\n",
8670 dnPhantom, ulFlags, hMachine);
8671
8672 if (dnPhantom == 0)
8673 return CR_INVALID_DEVNODE;
8674
8675 if (ulFlags != 0)
8676 return CR_INVALID_FLAG;
8677
8678 if (hMachine != NULL)
8679 {
8680 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8681 if (BindingHandle == NULL)
8682 return CR_FAILURE;
8683
8684 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8685 if (StringTable == 0)
8686 return CR_FAILURE;
8687 }
8688 else
8689 {
8690 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8691 return CR_FAILURE;
8692 }
8693
8694 lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
8695 if (lpDevInst == NULL)
8696 return CR_INVALID_DEVNODE;
8697
8699 {
8701 lpDevInst,
8702 ulFlags);
8703 }
8705 {
8707 }
8709
8710 return ret;
8711}
DWORD WINAPI PNP_UninstallDevInst(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3620

Referenced by CM_Uninstall_DevNode().

◆ CM_Unregister_Device_Interface_ExA()

CONFIGRET WINAPI CM_Unregister_Device_Interface_ExA ( _In_ LPCSTR  pszDeviceInterface,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 8753 of file cfgmgr.c.

8757{
8758 LPWSTR pszDeviceInterfaceW = NULL;
8759 CONFIGRET ret;
8760
8761 TRACE("CM_Unregister_Device_Interface_ExA(%s %lx %p)\n",
8762 debugstr_a(pszDeviceInterface), ulFlags, hMachine);
8763
8764 if (pszDeviceInterface == NULL)
8765 return CR_INVALID_POINTER;
8766
8767 if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
8768 return CR_INVALID_DATA;
8769
8770 ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
8771 ulFlags, hMachine);
8772
8773 if (pszDeviceInterfaceW != NULL)
8774 MyFree(pszDeviceInterfaceW);
8775
8776 return ret;
8777}
CONFIGRET WINAPI CM_Unregister_Device_Interface_ExW(_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8785

Referenced by CM_Unregister_Device_InterfaceA().

◆ CM_Unregister_Device_Interface_ExW()

CONFIGRET WINAPI CM_Unregister_Device_Interface_ExW ( _In_ LPCWSTR  pszDeviceInterface,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 8785 of file cfgmgr.c.

8789{
8791 CONFIGRET ret;
8792
8793 TRACE("CM_Unregister_Device_Interface_ExW(%s %lx %p)\n",
8794 debugstr_w(pszDeviceInterface), ulFlags, hMachine);
8795
8796 if (pszDeviceInterface == NULL)
8797 return CR_INVALID_POINTER;
8798
8799 if (ulFlags != 0)
8800 return CR_INVALID_FLAG;
8801
8802 if (hMachine != NULL)
8803 {
8804 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8805 if (BindingHandle == NULL)
8806 return CR_FAILURE;
8807 }
8808 else
8809 {
8811 return CR_FAILURE;
8812 }
8813
8815 {
8817 (LPWSTR)pszDeviceInterface,
8818 ulFlags);
8819 }
8821 {
8823 }
8825
8826 return ret;
8827}
DWORD WINAPI PNP_UnregisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszInterfaceDevice, DWORD ulFlags)
Definition: rpcserver.c:2762

Referenced by CM_Unregister_Device_Interface_ExA(), and CM_Unregister_Device_InterfaceW().

◆ CM_Unregister_Device_InterfaceA()

CONFIGRET WINAPI CM_Unregister_Device_InterfaceA ( _In_ LPCSTR  pszDeviceInterface,
_In_ ULONG  ulFlags 
)

Definition at line 8719 of file cfgmgr.c.

8722{
8723 TRACE("CM_Unregister_Device_InterfaceA(%s %lx)\n",
8724 debugstr_a(pszDeviceInterface), ulFlags);
8725
8726 return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
8727 ulFlags, NULL);
8728}
CONFIGRET WINAPI CM_Unregister_Device_Interface_ExA(_In_ LPCSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8753

◆ CM_Unregister_Device_InterfaceW()

CONFIGRET WINAPI CM_Unregister_Device_InterfaceW ( _In_ LPCWSTR  pszDeviceInterface,
_In_ ULONG  ulFlags 
)

Definition at line 8736 of file cfgmgr.c.

8739{
8740 TRACE("CM_Unregister_Device_InterfaceW(%s %lx)\n",
8741 debugstr_w(pszDeviceInterface), ulFlags);
8742
8743 return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
8744 ulFlags, NULL);
8745}

◆ CMP_GetBlockedDriverInfo()

CONFIGRET WINAPI CMP_GetBlockedDriverInfo ( _Out_opt_ LPWSTR  pszNames,
_Inout_ PULONG  pulLength,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 495 of file cfgmgr.c.

500{
502 ULONG ulTransferLength;
504
505 TRACE("CMP_GetBlockedDriverInfo(%p %p %lx %p)\n",
506 pszNames, pulLength, ulFlags, hMachine);
507
508 if (hMachine != NULL)
509 {
510 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
511 if (BindingHandle == NULL)
512 return CR_FAILURE;
513 }
514 else
515 {
517 return CR_FAILURE;
518 }
519
520 ulTransferLength = *pulLength;
521
523 {
525 (PBYTE)pszNames,
526 &ulTransferLength,
527 pulLength,
528 ulFlags);
529 }
531 {
533 }
535
536 return ret;
537}
DWORD WINAPI PNP_GetBlockedDriverInfo(handle_t hBinding, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulTransferLen, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:5301

◆ CMP_GetServerSideDeviceInstallFlags()

CONFIGRET WINAPI CMP_GetServerSideDeviceInstallFlags ( _Out_ PULONG  pulSSDIFlags,
_In_ ULONG  ulFlags,
_In_opt_ HMACHINE  hMachine 
)

Definition at line 545 of file cfgmgr.c.

549{
552
553 TRACE("CMP_GetServerSideDeviceInstallFlags(%p %lx %p)\n",
554 pulSSDIFlags, ulFlags, hMachine);
555
556 if (pulSSDIFlags == NULL)
557 return CR_INVALID_POINTER;
558
559 if (ulFlags != 0)
560 return CR_INVALID_FLAG;
561
562 if (hMachine != NULL)
563 {
564 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
565 if (BindingHandle == NULL)
566 return CR_FAILURE;
567 }
568 else
569 {
571 return CR_FAILURE;
572 }
573
575 {
577 pulSSDIFlags,
578 ulFlags);
579 }
581 {
583 }
585
586 return ret;
587}
DWORD WINAPI PNP_GetServerSideDeviceInstallFlags(handle_t hBinding, DWORD *pulSSDIFlags, DWORD ulFlags)
Definition: rpcserver.c:5316

◆ CMP_Init_Detection()

CONFIGRET WINAPI CMP_Init_Detection ( _In_ ULONG  ulMagic)

Definition at line 595 of file cfgmgr.c.

597{
600
601 TRACE("CMP_Init_Detection(%lu)\n", ulMagic);
602
603 if (ulMagic != CMP_MAGIC)
604 return CR_INVALID_DATA;
605
607 return CR_FAILURE;
608
610 {
612 }
614 {
616 }
618
619 return ret;
620}
DWORD WINAPI PNP_InitDetection(handle_t hBinding)
Definition: rpcserver.c:745
#define CMP_MAGIC
Definition: userinit.c:29

◆ CMP_RegisterNotification()

CONFIGRET WINAPI CMP_RegisterNotification ( _In_ HANDLE  hRecipient,
_In_ LPVOID  lpvNotificationFilter,
_In_ ULONG  ulFlags,
_Out_ PHDEVNOTIFY  phDevNotify 
)

Definition at line 628 of file cfgmgr.c.

633{
635 PNOTIFY_DATA pNotifyData;
636 WCHAR szNameBuffer[256];
637 INT nLength;
638 DWORD ulUnknown9 = 0;
639 DWORD dwError;
641
642 FIXME("CMP_RegisterNotification(%p %p %lu %p)\n",
643 hRecipient, lpvNotificationFilter, ulFlags, phDevNotify);
644
645 if ((hRecipient == NULL) ||
646 (lpvNotificationFilter == NULL) ||
647 (phDevNotify == NULL))
648 return CR_INVALID_POINTER;
649
650 if (ulFlags & ~0x7)
651 return CR_INVALID_FLAG;
652
653 if (((PDEV_BROADCAST_HDR)lpvNotificationFilter)->dbch_size < sizeof(DEV_BROADCAST_HDR))
654 return CR_INVALID_DATA;
655
657 return CR_FAILURE;
658
659 pNotifyData = HeapAlloc(GetProcessHeap(),
661 sizeof(NOTIFY_DATA));
662 if (pNotifyData == NULL)
663 return CR_OUT_OF_MEMORY;
664
665 pNotifyData->ulMagic = NOTIFY_MAGIC;
666 pNotifyData->hNotifyHandle = NULL;
667
668 ZeroMemory(szNameBuffer, sizeof(szNameBuffer));
669
670 if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_WINDOW_HANDLE)
671 {
672 FIXME("Register a window\n");
673
674 nLength = GetWindowTextW((HWND)hRecipient,
675 szNameBuffer,
676 ARRAYSIZE(szNameBuffer));
677 if (nLength == 0)
678 {
679 szNameBuffer[0] = UNICODE_NULL;
680 }
681
682 FIXME("Register window: %S\n", szNameBuffer);
683 }
684 else if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_SERVICE_HANDLE)
685 {
686 FIXME("Register a service\n");
687
688 dwError = I_ScPnPGetServiceName((SERVICE_STATUS_HANDLE)hRecipient,
689 szNameBuffer,
690 ARRAYSIZE(szNameBuffer));
691 if (dwError != ERROR_SUCCESS)
692 {
693 HeapFree(GetProcessHeap(), 0, pNotifyData);
694 return CR_INVALID_DATA;
695 }
696
697 FIXME("Register service: %S\n", szNameBuffer);
698 }
699
701 {
703 (DWORD_PTR)hRecipient,
704 szNameBuffer,
705 (BYTE*)lpvNotificationFilter,
706 ((DEV_BROADCAST_HDR*)lpvNotificationFilter)->dbch_size,
707 ulFlags,
708 &pNotifyData->hNotifyHandle,
710 &ulUnknown9); /* ??? */
711 }
713 {
715 }
717
718 if (ret == CR_SUCCESS)
719 {
720 TRACE("hNotifyHandle: %p\n", pNotifyData->hNotifyHandle);
721 *phDevNotify = (HDEVNOTIFY)pNotifyData;
722 }
723 else
724 {
725 HeapFree(GetProcessHeap(), 0, pNotifyData);
726
727 *phDevNotify = (HDEVNOTIFY)NULL;
728 }
729
730 return ret;
731}
static SERVICE_STATUS_HANDLE(WINAPI *pRegisterServiceCtrlHandlerExA)(LPCSTR
DWORD WINAPI PNP_RegisterNotification(handle_t hBinding, DWORD_PTR hRecipient, LPWSTR pszName, BYTE *pNotificationFilter, DWORD ulNotificationFilterSize, DWORD ulFlags, PNP_NOTIFY_HANDLE *pNotifyHandle, DWORD ulProcessId, DWORD *pulUnknown9)
Definition: rpcserver.c:5010
#define NOTIFY_MAGIC
Definition: cfgmgr.c:85
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
DWORD WINAPI I_ScPnPGetServiceName(IN SERVICE_STATUS_HANDLE hServiceStatus, OUT LPWSTR lpServiceName, IN DWORD cchServiceName)
Definition: sctrl.c:877
ULONG ulMagic
Definition: cfgmgr.c:81
PVOID hNotifyHandle
Definition: cfgmgr.c:82
uint32_t DWORD_PTR
Definition: typedefs.h:65
int32_t INT
Definition: typedefs.h:58
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1382
#define ZeroMemory
Definition: winbase.h:1744
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
_In_ DWORD nLength
Definition: wincon.h:473

◆ CMP_Report_LogOn()

CONFIGRET WINAPI CMP_Report_LogOn ( _In_ DWORD  dwMagic,
_In_ DWORD  dwProcessId 
)

Definition at line 739 of file cfgmgr.c.

742{
745 BOOL bAdmin;
746 DWORD i;
747
748 TRACE("CMP_Report_LogOn(%lu %lu)\n", dwMagic, dwProcessId);
749
750 if (dwMagic != CMP_MAGIC)
751 return CR_INVALID_DATA;
752
754 return CR_FAILURE;
755
756 bAdmin = pSetupIsUserAdmin();
757
758 for (i = 0; i < 30; i++)
759 {
761 {
763 bAdmin,
764 dwProcessId);
765 }
767 {
769 }
771
772 if (ret == CR_SUCCESS)
773 break;
774
775 Sleep(5000);
776 }
777
778 return ret;
779}
DWORD WINAPI PNP_ReportLogOn(handle_t hBinding, BOOL Admin, DWORD ProcessId)
Definition: rpcserver.c:760
unsigned int BOOL
Definition: ntddk_ex.h:94
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790

Referenced by NotifyLogon().

◆ CMP_UnregisterNotification()

CONFIGRET WINAPI CMP_UnregisterNotification ( _In_ HDEVNOTIFY  hDevNotify)

Definition at line 787 of file cfgmgr.c.

789{
791 PNOTIFY_DATA pNotifyData;
793
794 TRACE("CMP_UnregisterNotification(%p)\n", hDevNotify);
795
796 pNotifyData = (PNOTIFY_DATA)hDevNotify;
797
798 if ((pNotifyData == NULL) ||
799 (pNotifyData->ulMagic != NOTIFY_MAGIC))
800 return CR_INVALID_POINTER;
801
803 return CR_FAILURE;
804
806 {
808 &pNotifyData->hNotifyHandle);
809 }
811 {
813 }
815
816 if (ret == CR_SUCCESS)
817 {
818 pNotifyData->hNotifyHandle = NULL;
819 HeapFree(GetProcessHeap(), 0, pNotifyData);
820 }
821
822 return ret;
823}
DWORD WINAPI PNP_UnregisterNotification(handle_t hBinding, PNP_NOTIFY_HANDLE *pNotifyHandle)
Definition: rpcserver.c:5159
struct _NOTIFY_DATA * PNOTIFY_DATA

◆ CMP_WaitNoPendingInstallEvents()

DWORD WINAPI CMP_WaitNoPendingInstallEvents ( _In_ DWORD  dwTimeout)

Definition at line 831 of file cfgmgr.c.

833{
835 DWORD ret;
836
837 TRACE("CMP_WaitNoPendingInstallEvents(%lu)\n", dwTimeout);
838
839 hEvent = OpenEventW(SYNCHRONIZE, FALSE, L"Global\\PnP_No_Pending_Install_Events");
840 if (hEvent == NULL)
841 return WAIT_FAILED;
842
845 return ret;
846}
static HANDLE hEvent
Definition: comm.c:54
#define SYNCHRONIZE
Definition: nt_native.h:61
HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN LPCWSTR lpName)
Definition: synch.c:682
#define WAIT_FAILED
Definition: winbase.h:440
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD dwTimeout
Definition: wincrypt.h:6081

Referenced by CommonInstall().

◆ CMP_WaitServicesAvailable()

CONFIGRET WINAPI CMP_WaitServicesAvailable ( _In_opt_ HMACHINE  hMachine)

Definition at line 854 of file cfgmgr.c.

856{
860
861 TRACE("CMP_WaitServicesAvailable(%p)\n", hMachine);
862
863 if (hMachine != NULL)
864 {
865 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
866 if (BindingHandle == NULL)
867 return CR_FAILURE;
868 }
869 else
870 {
872 return CR_FAILURE;
873 }
874
876 {
878 }
880 {
882 }
884
885 return ret;
886}

◆ GetDeviceInstanceKeyPath()

static CONFIGRET GetDeviceInstanceKeyPath ( _In_ RPC_BINDING_HANDLE  BindingHandle,
_In_ PWSTR  pszDeviceInst,
_Out_ PWSTR  pszKeyPath,
_Out_ PWSTR  pszInstancePath,
_In_ ULONG  ulHardwareProfile,
_In_ ULONG  ulFlags 
)
static

Definition at line 229 of file cfgmgr.c.

236{
237 PWSTR pszBuffer = NULL;
238 ULONG ulType = 0;
239 ULONG ulTransferLength, ulLength;
241
242 TRACE("GetDeviceInstanceKeyPath()\n");
243
244 /* Allocate a buffer for the device id */
245 pszBuffer = MyMalloc(300 * sizeof(WCHAR));
246 if (pszBuffer == NULL)
247 {
248 ERR("MyMalloc() failed\n");
249 return CR_OUT_OF_MEMORY;
250 }
251
252 if (ulFlags & CM_REGISTRY_SOFTWARE)
253 {
254 /* Software Key Path */
255
256 ulTransferLength = 300 * sizeof(WCHAR);
257 ulLength = 300 * sizeof(WCHAR);
258
260 {
262 pszDeviceInst,
264 &ulType,
265 (PVOID)pszBuffer,
266 &ulTransferLength,
267 &ulLength,
268 0);
269 }
271 {
273 }
275
276 if (ret != CR_SUCCESS)
277 {
279 {
281 pszDeviceInst,
282 (PVOID)pszBuffer,
283 300);
284 }
286 {
288 }
290
291 if (ret != CR_SUCCESS)
292 {
293 goto done;
294 }
295 }
296
297 TRACE("szBuffer: %S\n", pszBuffer);
298
299 SplitDeviceInstanceId(pszBuffer,
300 pszBuffer,
301 pszInstancePath);
302
303 TRACE("szBuffer: %S\n", pszBuffer);
304
305 if (ulFlags & CM_REGISTRY_CONFIG)
306 {
307 if (ulHardwareProfile == 0)
308 {
309 wsprintfW(pszKeyPath,
310 L"%s\\%s\\%s\\%s",
311 L"System\\CurrentControlSet\\Hardware Profiles",
312 L"Current",
313 L"System\\CurrentControlSet\\Control\\Class",
314 pszBuffer);
315 }
316 else
317 {
318 wsprintfW(pszKeyPath,
319 L"%s\\%04lu\\%s\\%s",
320 L"System\\CurrentControlSet\\Hardware Profiles",
321 ulHardwareProfile,
322 L"System\\CurrentControlSet\\Control\\Class",
323 pszBuffer);
324 }
325 }
326 else
327 {
328 wsprintfW(pszKeyPath,
329 L"%s\\%s",
330 L"System\\CurrentControlSet\\Control\\Class",
331 pszBuffer);
332 }
333 }
334 else
335 {
336 /* Hardware Key Path */
337
338 if (ulFlags & CM_REGISTRY_CONFIG)
339 {
340 SplitDeviceInstanceId(pszDeviceInst,
341 pszBuffer,
342 pszInstancePath);
343
344 if (ulHardwareProfile == 0)
345 {
346 wsprintfW(pszKeyPath,
347 L"%s\\%s\\%s\\%s",
348 L"System\\CurrentControlSet\\Hardware Profiles",
349 L"Current",
350 L"System\\CurrentControlSet\\Enum",
351 pszBuffer);
352 }
353 else
354 {
355 wsprintfW(pszKeyPath,
356 L"%s\\%04lu\\%s\\%s",
357 L"System\\CurrentControlSet\\Hardware Profiles",
358 ulHardwareProfile,
359 L"System\\CurrentControlSet\\Enum",
360 pszBuffer);
361 }
362 }
363 else if (ulFlags & CM_REGISTRY_USER)
364 {
365 wsprintfW(pszKeyPath,
366 L"%s\\%s",
367 L"System\\CurrentControlSet\\Enum",
368 pszDeviceInst);
369
370 wcscpy(pszInstancePath,
371 L"Device Parameters");
372 }
373 else
374 {
375 SplitDeviceInstanceId(pszDeviceInst,
376 pszBuffer,
377 pszInstancePath);
378
379 wsprintfW(pszKeyPath,
380 L"%s\\%s",
381 L"System\\CurrentControlSet\\Enum",
382 pszBuffer);
383 }
384 }
385
386done:
387 if (pszBuffer != NULL)
388 MyFree(pszBuffer);
389
390 return ret;
391}
DWORD WINAPI PNP_GetClassInstance(handle_t hBinding, LPWSTR pDeviceId, LPWSTR pszClassInstance, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:2302
#define CM_DRP_DRIVER
Definition: cfgmgr32.h:685
#define CM_REGISTRY_SOFTWARE
Definition: cfgmgr32.h:801
static VOID SplitDeviceInstanceId(_In_ PWSTR pszDeviceInstanceId, _Out_ PWSTR pszDeviceId, _Out_ PWSTR pszInstanceId)
Definition: cfgmgr.c:203
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)

Referenced by CM_Delete_DevNode_Key_Ex(), and CM_Open_DevNode_Key_Ex().

◆ GetRegistryPropertyType()

static ULONG GetRegistryPropertyType ( _In_ ULONG  ulProperty)
static

Definition at line 150 of file cfgmgr.c.

152{
153 switch (ulProperty)
154 {
156 case CM_DRP_SERVICE:
157 case CM_DRP_CLASS:
158 case CM_DRP_CLASSGUID:
159 case CM_DRP_DRIVER:
160 case CM_DRP_MFG:
167 return REG_SZ;
168
173 return REG_MULTI_SZ;
174
177 case CM_DRP_UI_NUMBER:
179 case CM_DRP_BUSNUMBER:
180 case CM_DRP_DEVTYPE:
181 case CM_DRP_EXCLUSIVE:
183 case CM_DRP_ADDRESS:
188 return REG_DWORD;
189
191 case CM_DRP_SECURITY:
193 default:
194 return REG_BINARY;
195 }
196
197 return REG_NONE;
198}
#define CM_DRP_BUSNUMBER
Definition: cfgmgr32.h:703
#define CM_DRP_LOCATION_INFORMATION
Definition: cfgmgr32.h:689
#define CM_DRP_CONFIGFLAGS
Definition: cfgmgr32.h:686
#define CM_DRP_SECURITY_SDS
Definition: cfgmgr32.h:707
#define CM_DRP_REMOVAL_POLICY
Definition: cfgmgr32.h:719
#define CM_DRP_ENUMERATOR_NAME
Definition: cfgmgr32.h:704
#define CM_DRP_REMOVAL_POLICY_HW_DEFAULT
Definition: cfgmgr32.h:720
#define CM_DRP_BUSTYPEGUID
Definition: cfgmgr32.h:701
#define CM_DRP_LOWERFILTERS
Definition: cfgmgr32.h:697
#define CM_DRP_SECURITY
Definition: cfgmgr32.h:705
#define CM_DRP_MFG
Definition: cfgmgr32.h:687
#define CM_DRP_EXCLUSIVE
Definition: cfgmgr32.h:711
#define CM_DRP_REMOVAL_POLICY_OVERRIDE
Definition: cfgmgr32.h:721
#define CM_DRP_CAPABILITIES
Definition: cfgmgr32.h:691
#define CM_DRP_UPPERFILTERS
Definition: cfgmgr32.h:693
#define CM_DRP_CLASSGUID
Definition: cfgmgr32.h:684
#define CM_DRP_COMPATIBLEIDS
Definition: cfgmgr32.h:678
#define CM_DRP_DEVICEDESC
Definition: cfgmgr32.h:676
#define CM_DRP_CLASS
Definition: cfgmgr32.h:683
#define CM_DRP_LEGACYBUSTYPE
Definition: cfgmgr32.h:702
#define CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cfgmgr32.h:690
#define CM_DRP_DEVTYPE
Definition: cfgmgr32.h:709
#define CM_DRP_FRIENDLYNAME
Definition: cfgmgr32.h:688
#define CM_DRP_INSTALL_STATE
Definition: cfgmgr32.h:722
#define CM_DRP_UI_NUMBER
Definition: cfgmgr32.h:692
#define CM_DRP_CHARACTERISTICS
Definition: cfgmgr32.h:713
#define CM_DRP_UI_NUMBER_DESC_FORMAT
Definition: cfgmgr32.h:716
#define CM_DRP_ADDRESS
Definition: cfgmgr32.h:715
#define CM_DRP_DEVICE_POWER_DATA
Definition: cfgmgr32.h:718
#define CM_DRP_HARDWAREID
Definition: cfgmgr32.h:677
#define CM_DRP_SERVICE
Definition: cfgmgr32.h:680

Referenced by CM_Get_Class_Registry_PropertyA(), CM_Set_Class_Registry_PropertyA(), CM_Set_Class_Registry_PropertyW(), CM_Set_DevNode_Registry_Property_ExA(), and CM_Set_DevNode_Registry_Property_ExW().

◆ GuidToString()

static BOOL GuidToString ( _In_ LPGUID  Guid,
_Out_ LPWSTR  String 
)
static

Definition at line 118 of file cfgmgr.c.

121{
122 LPWSTR lpString;
123
124 if (UuidToStringW(Guid, &lpString) != RPC_S_OK)
125 return FALSE;
126
127 lstrcpyW(&String[1], lpString);
128
129 String[0] = '{';
130 String[MAX_GUID_STRING_LEN - 2] = '}';
132
133 RpcStringFreeW(&lpString);
134
135 return TRUE;
136}
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762

Referenced by CM_Delete_Class_Key_Ex(), CM_Get_Class_Key_Name_ExW(), and CM_Get_Class_Name_ExW().

◆ IsValidConflictData()

BOOL IsValidConflictData ( _In_opt_ PCONFLICT_DATA  pConflictData)

Definition at line 467 of file cfgmgr.c.

469{
470 BOOL bValid = TRUE;
471
472 if (pConflictData == NULL)
473 return FALSE;
474
476 {
477 if (pConflictData->ulMagic != CONFLICT_MAGIC)
478 bValid = FALSE;
479 }
481 {
482 bValid = FALSE;
483 }
484 _SEH2_END;
485
486 return bValid;
487}
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71

Referenced by CM_Free_Resource_Conflict_Handle(), and CM_Get_Resource_Conflict_Count().

◆ IsValidLogConf()

BOOL IsValidLogConf ( _In_opt_ PLOG_CONF_INFO  pLogConfInfo)

Definition at line 419 of file cfgmgr.c.

421{
422 BOOL bValid = TRUE;
423
424 if (pLogConfInfo == NULL)
425 return FALSE;
426
428 {
429 if (pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
430 bValid = FALSE;
431 }
433 {
434 bValid = FALSE;
435 }
436 _SEH2_END;
437
438 return bValid;
439}

Referenced by CM_Free_Log_Conf_Ex(), CM_Free_Log_Conf_Handle(), CM_Get_Log_Conf_Priority_Ex(), CM_Get_Next_Log_Conf_Ex(), and CM_Get_Next_Res_Des_Ex().

◆ IsValidRangeList()

BOOL IsValidRangeList ( _In_opt_ PINTERNAL_RANGE_LIST  pRangeList)

Definition at line 395 of file cfgmgr.c.

397{
398 BOOL bValid = TRUE;
399
400 if (pRangeList == NULL)
401 return FALSE;
402
404 {
405 if (pRangeList->ulMagic != RANGE_LIST_MAGIC)
406 bValid = FALSE;
407 }
409 {
410 bValid = FALSE;
411 }
412 _SEH2_END;
413
414 return bValid;
415}

Referenced by CM_Add_Range(), CM_Dup_Range_List(), CM_First_Range(), CM_Free_Range_List(), and CM_Test_Range_Available().

◆ IsValidResDes()

BOOL IsValidResDes ( _In_opt_ PRES_DES_INFO  pResDesInfo)

Definition at line 443 of file cfgmgr.c.

445{
446 BOOL bValid = TRUE;
447
448 if (pResDesInfo == NULL)
449 return FALSE;
450
452 {
453 if (pResDesInfo->ulMagic != RES_DES_MAGIC)
454 bValid = FALSE;
455 }
457 {
458 bValid = FALSE;
459 }
460 _SEH2_END;
461
462 return bValid;
463}
#define RES_DES_MAGIC
Definition: cfgmgr.c:77

Referenced by CM_Free_Res_Des_Handle(), and CM_Get_Next_Res_Des_Ex().

◆ RpcStatusToCmStatus()

static CONFIGRET RpcStatusToCmStatus ( _In_ RPC_STATUS  Status)
static

Definition at line 141 of file cfgmgr.c.

143{
144 return CR_FAILURE;
145}

Referenced by CM_Add_Empty_Log_Conf_Ex(), CM_Add_ID_ExW(), CM_Create_DevNode_ExW(), CM_Delete_Class_Key_Ex(), CM_Delete_DevNode_Key_Ex(), CM_Disable_DevNode_Ex(), CM_Enable_DevNode_Ex(), CM_Enumerate_Classes_Ex(), CM_Enumerate_Enumerators_ExW(), CM_Free_Log_Conf_Ex(), CM_Get_Child_Ex(), CM_Get_Class_Name_ExW(), CM_Get_Class_Registry_PropertyW(), CM_Get_Depth_Ex(), CM_Get_Device_ID_List_ExW(), CM_Get_Device_ID_List_Size_ExW(), CM_Get_Device_Interface_Alias_ExW(), CM_Get_Device_Interface_List_ExW(), CM_Get_Device_Interface_List_Size_ExW(), CM_Get_DevNode_Custom_Property_ExW(), CM_Get_DevNode_Registry_Property_ExW(), CM_Get_DevNode_Status_Ex(), CM_Get_First_Log_Conf_Ex(), CM_Get_Global_State_Ex(), CM_Get_Hardware_Profile_Info_ExW(), CM_Get_HW_Prof_Flags_ExW(), CM_Get_Log_Conf_Priority_Ex(), CM_Get_Next_Log_Conf_Ex(), CM_Get_Next_Res_Des_Ex(), CM_Get_Parent_Ex(), CM_Get_Sibling_Ex(), CM_Get_Version_Ex(), CM_Is_Dock_Station_Present_Ex(), CM_Is_Version_Available_Ex(), CM_Locate_DevNode_ExW(), CM_Move_DevNode_Ex(), CM_Query_And_Remove_SubTree_ExW(), CM_Query_Arbitrator_Free_Data_Ex(), CM_Query_Arbitrator_Free_Size_Ex(), CM_Query_Resource_Conflict_List(), CM_Reenumerate_DevNode_Ex(), CM_Register_Device_Driver_Ex(), CM_Register_Device_Interface_ExW(), CM_Request_Device_Eject_ExW(), CM_Request_Eject_PC_Ex(), CM_Run_Detection_Ex(), CM_Set_Class_Registry_PropertyW(), CM_Set_DevNode_Problem_Ex(), CM_Set_DevNode_Registry_Property_ExW(), CM_Set_HW_Prof_Ex(), CM_Set_HW_Prof_Flags_ExW(), CM_Setup_DevNode_Ex(), CM_Uninstall_DevNode_Ex(), CM_Unregister_Device_Interface_ExW(), CMP_GetBlockedDriverInfo(), CMP_GetServerSideDeviceInstallFlags(), CMP_Init_Detection(), CMP_RegisterNotification(), CMP_Report_LogOn(), CMP_UnregisterNotification(), CMP_WaitServicesAvailable(), and GetDeviceInstanceKeyPath().

◆ SplitDeviceInstanceId()

static VOID SplitDeviceInstanceId ( _In_ PWSTR  pszDeviceInstanceId,
_Out_ PWSTR  pszDeviceId,
_Out_ PWSTR  pszInstanceId 
)
static

Definition at line 203 of file cfgmgr.c.

207{
208 PWCHAR ptr;
209
210 wcscpy(pszDeviceId, pszDeviceInstanceId);
211
212 ptr = wcschr(pszDeviceId, L'\\');
213 if (ptr != NULL)
214 {
215 *ptr = UNICODE_NULL;
216 ptr++;
217
218 wcscpy(pszInstanceId, ptr);
219 }
220 else
221 {
222 *pszInstanceId = UNICODE_NULL;
223 }
224}
#define wcschr
Definition: compat.h:17
static PVOID ptr
Definition: dispmode.c:27

Referenced by GetDeviceInstanceKeyPath().

Variable Documentation

◆ BackslashOpenBrace

const WCHAR BackslashOpenBrace[] = {'\\', '{', 0}
static

Definition at line 34 of file cfgmgr.c.

Referenced by CM_Open_Class_Key_ExW().

◆ Class

const WCHAR Class[] = {'C','l','a','s','s',0}
static

Definition at line 36 of file cfgmgr.c.

◆ CloseBrace

const WCHAR CloseBrace[] = {'}', 0}
static

Definition at line 35 of file cfgmgr.c.

Referenced by CM_Open_Class_Key_ExW().

◆ ControlClass

const WCHAR ControlClass[]
static
Initial value:
= {'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'C','l','a','s','s',0}

Definition at line 38 of file cfgmgr.c.

Referenced by BeginFile(), CM_Open_Class_Key_ExW(), and PiControlSyncDeviceAction().

◆ DeviceClasses

const WCHAR DeviceClasses[]
static
Initial value:
= {'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'D','e','v','i','c','e','C','l','a','s','s','e','s',0}

Definition at line 43 of file cfgmgr.c.

Referenced by CM_Open_Class_Key_ExW().