diff --git a/PInvoke/CfgMgr32/CfgMgr32.cs b/PInvoke/CfgMgr32/CfgMgr32.cs index 993b4b7d..4d6a1380 100644 --- a/PInvoke/CfgMgr32/CfgMgr32.cs +++ b/PInvoke/CfgMgr32/CfgMgr32.cs @@ -2765,7 +2765,7 @@ namespace Vanara.PInvoke protected override bool InternalReleaseHandle() => CM_Disconnect_Machine(handle) == 0; } - /// Provides a for that is disposed using . + /// Provides a for that is disposed using . public class SafeLOG_CONF : SafeHANDLE { /// Initializes a new instance of the class and assigns an existing handle. @@ -2808,127 +2808,5 @@ namespace Vanara.PInvoke /// protected override bool InternalReleaseHandle() => CM_Free_Res_Des_Handle(handle) == 0; } - - /* - CM_Get_Device_ID_ListA - CM_Get_Device_ID_ListW - CM_Get_Device_ID_List_Size_ExW - CM_Get_Device_ID_List_SizeA - CM_Get_Device_ID_List_SizeW - CM_Get_Device_ID_Size - CM_Get_Device_ID_Size_Ex - CM_Get_Device_IDW - CM_Get_Device_Interface_AliasW - CM_Get_Device_Interface_List_SizeA - CM_Get_Device_Interface_List_SizeW - CM_Get_Device_Interface_ListA - CM_Get_Device_Interface_ListW - CM_Get_Device_Interface_Property_ExW - CM_Get_Device_Interface_Property_Keys_ExW - CM_Get_Device_Interface_Property_KeysW - CM_Get_Device_Interface_PropertyW - CM_Get_DevNode_Property_ExW - CM_Get_DevNode_Property_Keys - CM_Get_DevNode_Property_Keys_Ex - CM_Get_DevNode_PropertyW - CM_Get_DevNode_Registry_PropertyW - CM_Get_DevNode_Status - CM_Get_DevNode_Status_Ex - CM_Get_First_Log_Conf - CM_Get_First_Log_Conf_Ex - CM_Get_HW_Prof_Flags_ExA - CM_Get_HW_Prof_Flags_ExW - CM_Get_HW_Prof_FlagsA - CM_Get_HW_Prof_FlagsW - CM_Get_Log_Conf_Priority - CM_Get_Log_Conf_Priority_Ex - CM_Get_Next_Log_Conf - CM_Get_Next_Log_Conf_Ex - CM_Get_Next_Res_Des - CM_Get_Next_Res_Des_Ex - CM_Get_Parent - CM_Get_Parent_Ex - CM_Get_Res_Des_Data - CM_Get_Res_Des_Data_Ex - CM_Get_Res_Des_Data_Size - CM_Get_Res_Des_Data_Size_Ex - CM_Get_Resource_Conflict_Count - CM_Get_Resource_Conflict_DetailsW - CM_Get_Sibling - CM_Get_Sibling_Ex - CM_Get_Version - CM_Get_Version_Ex - CM_Is_Dock_Station_Present - CM_Is_Dock_Station_Present_Ex - CM_Is_Version_Available - CM_Is_Version_Available_Ex - CM_Locate_DevNode_ExW - CM_Locate_DevNodeA - CM_Locate_DevNodeW - CM_MapCrToWin32Err - CM_Modify_Res_Des - CM_Modify_Res_Des_Ex - CM_Open_Class_KeyW - CM_Open_Device_Interface_Key_ExA - CM_Open_Device_Interface_Key_ExW - CM_Open_Device_Interface_KeyA - CM_Open_Device_Interface_KeyW - CM_Open_DevNode_Key - CM_Query_And_Remove_SubTree_ExW - CM_Query_And_Remove_SubTreeW - CM_Query_Resource_Conflict_List - CM_Reenumerate_DevNode - CM_Reenumerate_DevNode_Ex - CM_Register_Notification - CM_Request_Device_Eject_ExW - CM_Request_Device_EjectW - CM_Request_Eject_PC - CM_Request_Eject_PC_Ex - CM_Set_Class_Property_ExW - CM_Set_Class_PropertyW - CM_Set_Class_Registry_PropertyW - CM_Set_Device_Interface_Property_ExW - CM_Set_Device_Interface_PropertyW - CM_Set_DevNode_Problem - CM_Set_DevNode_Problem_Ex - CM_Set_DevNode_Property_ExW - CM_Set_DevNode_PropertyW - CM_Set_DevNode_Registry_PropertyW - CM_Setup_DevNode - CM_Uninstall_DevNode - CM_Unregister_Notification - CM_WaitNoPendingInstallEvents - - BUSNUMBER_DES - BUSNUMBER_RANGE - BUSNUMBER_RESOURCE - CM_NOTIFY_EVENT_DATA - CM_NOTIFY_FILTER - CONFLICT_DETAILS_A - CONFLICT_DETAILS_W - CS_DES - CS_RESOURCE - DMA_DES - DMA_RANGE - DMA_RESOURCE - IO_DES - IO_RANGE - IO_RESOURCE - IRQ_DES_32 - IRQ_DES_64 - IRQ_RANGE - IRQ_RESOURCE_32 - IRQ_RESOURCE_64 - MEM_DES - MEM_RANGE - MEM_RESOURCE - MFCARD_DES - MFCARD_RESOURCE - PCCARD_DES - PCCARD_RESOURCE - - CM_NOTIFY_ACTION - - */ } } \ No newline at end of file diff --git a/PInvoke/CfgMgr32/CfgMgr32_2.cs b/PInvoke/CfgMgr32/CfgMgr32_2.cs new file mode 100644 index 00000000..ffc64465 --- /dev/null +++ b/PInvoke/CfgMgr32/CfgMgr32_2.cs @@ -0,0 +1,2338 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using static Vanara.PInvoke.SetupAPI; + +namespace Vanara.PInvoke +{ + /// Items from the CfgMgr32.dll + public static partial class CfgMgr32 + { + /// CONFLICT_DETAILS.CD_ulFlags values. + [PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32._CONFLICT_DETAILS_A")] + [Flags] + public enum CM_CDFLAGS : uint + { + /// + /// If set, the string contained in the CD_szDescription member represents a driver name instead of a device name, and + /// CD_dnDevInst is -1. + /// + CM_CDFLAGS_DRIVER = 0x00000001, + + /// If set, the conflicting resources are owned by the root device (that is, the HAL), and CD_dnDevInst is -1. + CM_CDFLAGS_ROOT_OWNED = 0x00000002, + + /// If set, the owner of the conflicting resources cannot be determined, and CD_dnDevInst is -1. + CM_CDFLAGS_RESERVED = 0x00000004, + } + + /// CONFLICT_DETAILS.CD_ulMask values. + [PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32._CONFLICT_DETAILS_A")] + [Flags] + public enum CM_CDMASK : uint + { + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_dnDevInst member. + CM_CDMASK_DEVINST = 0x00000001, + + /// Not used. + CM_CDMASK_RESDES = 0x00000002, + + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_ulFlags member. + CM_CDMASK_FLAGS = 0x00000004, + + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_szDescription member. + CM_CDMASK_DESCRIPTION = 0x00000008, + } + + /// Identifies the device property to be obtained from the registry. + [PInvokeData("cfgmgr32.h")] + public enum CM_DRP + { + /// DeviceDesc REG_SZ property (RW) + CM_DRP_DEVICEDESC = 0x00000001, + + /// HardwareID REG_MULTI_SZ property (RW) + CM_DRP_HARDWAREID = 0x00000002, + + /// CompatibleIDs REG_MULTI_SZ property (RW) + CM_DRP_COMPATIBLEIDS = 0x00000003, + + /// unused + CM_DRP_UNUSED0 = 0x00000004, + + /// Service REG_SZ property (RW) + CM_DRP_SERVICE = 0x00000005, + + /// unused + CM_DRP_UNUSED1 = 0x00000006, + + /// unused + CM_DRP_UNUSED2 = 0x00000007, + + /// Class REG_SZ property (RW) + CM_DRP_CLASS = 0x00000008, + + /// ClassGUID REG_SZ property (RW) + CM_DRP_CLASSGUID = 0x00000009, + + /// Driver REG_SZ property (RW) + CM_DRP_DRIVER = 0x0000000A, + + /// ConfigFlags REG_DWORD property (RW) + CM_DRP_CONFIGFLAGS = 0x0000000B, + + /// Mfg REG_SZ property (RW) + CM_DRP_MFG = 0x0000000C, + + /// FriendlyName REG_SZ property (RW) + CM_DRP_FRIENDLYNAME = 0x0000000D, + + /// LocationInformation REG_SZ property (RW) + CM_DRP_LOCATION_INFORMATION = 0x0000000E, + + /// PhysicalDeviceObjectName REG_SZ property (R) + CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME = 0x0000000F, + + /// Capabilities REG_DWORD property (R) + CM_DRP_CAPABILITIES = 0x00000010, + + /// UiNumber REG_DWORD property (R) + CM_DRP_UI_NUMBER = 0x00000011, + + /// UpperFilters REG_MULTI_SZ property (RW) + CM_DRP_UPPERFILTERS = 0x00000012, + + /// UpperFilters REG_MULTI_SZ property (RW) + CM_CRP_UPPERFILTERS = CM_DRP_UPPERFILTERS, + + /// LowerFilters REG_MULTI_SZ property (RW) + CM_DRP_LOWERFILTERS = 0x00000013, + + /// LowerFilters REG_MULTI_SZ property (RW) + CM_CRP_LOWERFILTERS = CM_DRP_LOWERFILTERS, + + /// Bus Type Guid, GUID, (R) + CM_DRP_BUSTYPEGUID = 0x00000014, + + /// Legacy bus type, INTERFACE_TYPE, (R) + CM_DRP_LEGACYBUSTYPE = 0x00000015, + + /// Bus Number, DWORD, (R) + CM_DRP_BUSNUMBER = 0x00000016, + + /// Enumerator Name REG_SZ property (R) + CM_DRP_ENUMERATOR_NAME = 0x00000017, + + /// Security - Device override (RW) + CM_DRP_SECURITY = 0x00000018, + + /// Class default security (RW) + CM_CRP_SECURITY = CM_DRP_SECURITY, + + /// Security - Device override (RW) + CM_DRP_SECURITY_SDS = 0x00000019, + + /// Class default security (RW) + CM_CRP_SECURITY_SDS = CM_DRP_SECURITY_SDS, + + /// Device Type - Device override (RW) + CM_DRP_DEVTYPE = 0x0000001A, + + /// Class default Device-type (RW) + CM_CRP_DEVTYPE = CM_DRP_DEVTYPE, + + /// Exclusivity - Device override (RW) + CM_DRP_EXCLUSIVE = 0x0000001B, + + /// Class default (RW) + CM_CRP_EXCLUSIVE = CM_DRP_EXCLUSIVE, + + /// Characteristics - Device Override (RW) + CM_DRP_CHARACTERISTICS = 0x0000001C, + + /// Class default (RW) + CM_CRP_CHARACTERISTICS = CM_DRP_CHARACTERISTICS, + + /// Device Address (R) + CM_DRP_ADDRESS = 0x0000001D, + + /// UINumberDescFormat REG_SZ property (RW) + CM_DRP_UI_NUMBER_DESC_FORMAT = 0x0000001E, + + /// CM_POWER_DATA REG_BINARY property (R) + CM_DRP_DEVICE_POWER_DATA = 0x0000001F, + + /// CM_DEVICE_REMOVAL_POLICY REG_DWORD (R) + CM_DRP_REMOVAL_POLICY = 0x00000020, + + /// CM_DRP_REMOVAL_POLICY_HW_DEFAULT REG_DWORD (R) + CM_DRP_REMOVAL_POLICY_HW_DEFAULT = 0x00000021, + + /// CM_DRP_REMOVAL_POLICY_OVERRIDE REG_DWORD (RW) + CM_DRP_REMOVAL_POLICY_OVERRIDE = 0x00000022, + + /// CM_DRP_INSTALL_STATE REG_DWORD (R) + CM_DRP_INSTALL_STATE = 0x00000023, + + /// CM_DRP_LOCATION_PATHS REG_MULTI_SZ (R) + CM_DRP_LOCATION_PATHS = 0x00000024, + + /// Base ContainerID REG_SZ property (R) + CM_DRP_BASE_CONTAINERID = 0x00000025, + } + + /// Flags for CM_Get_Device_Interface_List_Size. + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_List_SizeW")] + public enum CM_GET_DEVICE_INTERFACE_LIST + { + /// + /// The function provides the size of a list containing device interfaces associated with devices that are currently active, and + /// which match the specified GUID and device instance ID, if any. + /// + CM_GET_DEVICE_INTERFACE_LIST_PRESENT = 0x00000000, + + /// + /// The function provides the size of a list that contains device interfaces associated with all devices that match the + /// specified GUID and device instance ID, if any. + /// + CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES = 0x00000001, + } + + /// Device problem. + [PInvokeData("cfg.h")] + public enum CM_PROB + { + /// no config for device + CM_PROB_NOT_CONFIGURED = 0x00000001, + + /// service load failed + CM_PROB_DEVLOADER_FAILED = 0x00000002, + + /// out of memory + CM_PROB_OUT_OF_MEMORY = 0x00000003, + + /// + CM_PROB_ENTRY_IS_WRONG_TYPE = 0x00000004, + + /// + CM_PROB_LACKED_ARBITRATOR = 0x00000005, + + /// boot config conflict + CM_PROB_BOOT_CONFIG_CONFLICT = 0x00000006, + + /// + CM_PROB_FAILED_FILTER = 0x00000007, + + /// Devloader not found + CM_PROB_DEVLOADER_NOT_FOUND = 0x00000008, + + /// Invalid ID + CM_PROB_INVALID_DATA = 0x00000009, + + /// + CM_PROB_FAILED_START = 0x0000000A, + + /// + CM_PROB_LIAR = 0x0000000B, + + /// config conflict + CM_PROB_NORMAL_CONFLICT = 0x0000000C, + + /// + CM_PROB_NOT_VERIFIED = 0x0000000D, + + /// requires restart + CM_PROB_NEED_RESTART = 0x0000000E, + + /// + CM_PROB_REENUMERATION = 0x0000000F, + + /// + CM_PROB_PARTIAL_LOG_CONF = 0x00000010, + + /// unknown res type + CM_PROB_UNKNOWN_RESOURCE = 0x00000011, + + /// + CM_PROB_REINSTALL = 0x00000012, + + /// + CM_PROB_REGISTRY = 0x00000013, + + /// WINDOWS 95 ONLY + CM_PROB_VXDLDR = 0x00000014, + + /// devinst will remove + CM_PROB_WILL_BE_REMOVED = 0x00000015, + + /// devinst is disabled + CM_PROB_DISABLED = 0x00000016, + + /// Devloader not ready + CM_PROB_DEVLOADER_NOT_READY = 0x00000017, + + /// device doesn't exist + CM_PROB_DEVICE_NOT_THERE = 0x00000018, + + /// + CM_PROB_MOVED = 0x00000019, + + /// + CM_PROB_TOO_EARLY = 0x0000001A, + + /// no valid log config + CM_PROB_NO_VALID_LOG_CONF = 0x0000001B, + + /// install failed + CM_PROB_FAILED_INSTALL = 0x0000001C, + + /// device disabled + CM_PROB_HARDWARE_DISABLED = 0x0000001D, + + /// can't share IRQ + CM_PROB_CANT_SHARE_IRQ = 0x0000001E, + + /// driver failed add + CM_PROB_FAILED_ADD = 0x0000001F, + + /// service's Start = 4 + CM_PROB_DISABLED_SERVICE = 0x00000020, + + /// resource translation failed + CM_PROB_TRANSLATION_FAILED = 0x00000021, + + /// no soft config + CM_PROB_NO_SOFTCONFIG = 0x00000022, + + /// device missing in BIOS table + CM_PROB_BIOS_TABLE = 0x00000023, + + /// IRQ translator failed + CM_PROB_IRQ_TRANSLATION_FAILED = 0x00000024, + + /// DriverEntry() failed. + CM_PROB_FAILED_DRIVER_ENTRY = 0x00000025, + + /// Driver should have unloaded. + CM_PROB_DRIVER_FAILED_PRIOR_UNLOAD = 0x00000026, + + /// Driver load unsuccessful. + CM_PROB_DRIVER_FAILED_LOAD = 0x00000027, + + /// Error accessing driver's service key + CM_PROB_DRIVER_SERVICE_KEY_INVALID = 0x00000028, + + /// Loaded legacy service created no devices + CM_PROB_LEGACY_SERVICE_NO_DEVICES = 0x00000029, + + /// Two devices were discovered with the same name + CM_PROB_DUPLICATE_DEVICE = 0x0000002A, + + /// The drivers set the device state to failed + CM_PROB_FAILED_POST_START = 0x0000002B, + + /// This device was failed post start via usermode + CM_PROB_HALTED = 0x0000002C, + + /// The devinst currently exists only in the registry + CM_PROB_PHANTOM = 0x0000002D, + + /// The system is shutting down + CM_PROB_SYSTEM_SHUTDOWN = 0x0000002E, + + /// The device is offline awaiting removal + CM_PROB_HELD_FOR_EJECT = 0x0000002F, + + /// One or more drivers is blocked from loading + CM_PROB_DRIVER_BLOCKED = 0x00000030, + + /// System hive has grown too large + CM_PROB_REGISTRY_TOO_LARGE = 0x00000031, + + /// Failed to apply one or more registry properties + CM_PROB_SETPROPERTIES_FAILED = 0x00000032, + + /// Device is stalled waiting on a dependency to start + CM_PROB_WAITING_ON_DEPENDENCY = 0x00000033, + + /// Failed load driver due to unsigned image. + CM_PROB_UNSIGNED_DRIVER = 0x00000034, + + /// Device is being used by kernel debugger + CM_PROB_USED_BY_DEBUGGER = 0x00000035, + + /// Device is being reset + CM_PROB_DEVICE_RESET = 0x00000036, + + /// Device is blocked while console is locked + CM_PROB_CONSOLE_LOCKED = 0x00000037, + + /// Device needs extended class configuration to start + CM_PROB_NEED_CLASS_CONFIG = 0x00000038, + + /// Assignment to guest partition failed + CM_PROB_GUEST_ASSIGNMENT_FAILED = 0x00000039, + } + + /// configuration flags + public enum CSCONFIGFLAG + { + /// The device instance is disabled in the specified hardware profile. + CSCONFIGFLAG_DISABLED = 1, + + /// The hardware profile does not support the specified device instance. + CSCONFIGFLAG_DO_NOT_CREATE = 2, + + /// The device cannot be started in the specified hardware profile. + CSCONFIGFLAG_DO_NOT_START = 4, + + /// Bitwise OR of the other CSCONFIGFLAG_Xxx flags. + CSCONFIGFLAG_BITS = 7, + } + + /// + /// The CM_Get_Device_ID_List_Size function retrieves the buffer size required to hold a list of device instance IDs for the + /// local machine's device instances. + /// + /// Receives a value representing the required buffer size, in characters. + /// + /// Caller-supplied pointer to a character string specifying a subset of the machine's device instance identifiers, or NULL. + /// See the following description of ulFlags. + /// + /// + /// One of the optional, caller-supplied bit flags that specify search filters. If no flags are specified, the function supplies the + /// buffer size required to hold all instance identifiers for all device instances. For a list of bit flags, see the ulFlags + /// description for CM_Get_Device_ID_List. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// The CM_Get_Device_ID_List_Size function should be called to determine the buffer size required by CM_Get_Device_ID_List. + /// + /// The size value supplied in the location pointed to by pulLen is guaranteed to represent a buffer size large enough to hold all + /// device instance identifier strings and terminating NULLs. The supplied value might actually represent a buffer size that is + /// larger than necessary, so don't assume the value represents the true length of the character strings that CM_Get_Device_ID_List + /// will provide. + /// + /// For information about device instance IDs, see Device Identification Strings. + /// + /// Note + /// + /// The cfgmgr32.h header defines CM_Get_Device_ID_List_Size as an alias which automatically selects the ANSI or Unicode version of + /// this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code + /// that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see + /// Conventions for Function Prototypes. + /// + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_list_sizea CMAPI CONFIGRET + // CM_Get_Device_ID_List_SizeA( PULONG pulLen, PCSTR pszFilter, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_List_SizeA")] + public static extern CONFIGRET CM_Get_Device_ID_List_Size(out uint pulLen, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pszFilter, CM_GETIDLIST ulFlags); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Device_ID_List_Size instead.] + /// + /// + /// The CM_Get_Device_ID_List_Size_Ex function retrieves the buffer size required to hold a list of device instance IDs for a + /// local or a remote machine's device instances. + /// + /// + /// Receives a value representing the required buffer size, in characters. + /// + /// Caller-supplied pointer to a character string specifying a subset of the machine's device instance identifiers, or NULL. + /// See the following description of ulFlags. + /// + /// + /// One of the optional, caller-supplied bit flags that specify search filters. If no flags are specified, the function supplies the + /// buffer size required to hold all instance identifiers for all device instances. For a list of bit flags, see the ulFlags + /// description for CM_Get_Device_ID_List_Ex. + /// + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// The CM_Get_Device_ID_List_Size_Ex function should be called to determine the buffer size required by CM_Get_Device_ID_List_Ex. + /// + /// The size value supplied in the location pointed to by pulLen is guaranteed to represent a buffer size large enough to hold all + /// device instance identifier strings and terminating NULLs. The supplied value might actually represent a buffer size that is + /// larger than necessary, so don't assume the value represents the true length of the character strings that + /// CM_Get_Device_ID_List_Ex will provide. + /// + /// For information about device instance IDs, see Device Identification Strings. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_list_size_exw CMAPI CONFIGRET + // CM_Get_Device_ID_List_Size_ExW( PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_List_Size_ExW")] + public static extern CONFIGRET CM_Get_Device_ID_List_Size_Ex(out uint pulLen, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pszFilter, CM_GETIDLIST ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Device_ID_Size function retrieves the buffer size required to hold a device instance ID for a device instance + /// on the local machine. + /// + /// Receives a value representing the required buffer size, in characters. + /// Caller-supplied device instance handle that is bound to the local machine. + /// Not used, must be zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// The CM_Get_Device_ID_Size function should be called to determine the buffer size required by CM_Get_Device_ID. + /// + /// The size value supplied in the location pointed to by pulLen is less than MAX_DEVICE_ID_LEN, and does not include the identifier + /// string's terminating NULL. If the specified device instance does not exist, the function supplies a size value of zero. + /// + /// For information about device instance IDs, see Device Identification Strings. + /// For information about using device instance handles that are bound to the local machine, see CM_Get_Child. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_size CMAPI CONFIGRET + // CM_Get_Device_ID_Size( PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_Size")] + public static extern CONFIGRET CM_Get_Device_ID_Size(out uint pulLen, uint dnDevInst, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Device_ID_Size instead.] + /// + /// + /// The CM_Get_Device_ID_Size_Ex function retrieves the buffer size required to hold a device instance ID for a device + /// instance on a local or a remote machine. + /// + /// + /// Receives a value representing the required buffer size, in characters. + /// Caller-supplied device instance handle that is bound to the local machine. + /// Not used, must be zero. + /// + /// Caller-supplied machine handle to which the caller-supplied device instance handle is bound. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// The CM_Get_Device_ID_Size_Ex function should be called to determine the buffer size required by CM_Get_Device_ID_Ex. + /// + /// The size value supplied in the location pointed to by pulLen is less than MAX_DEVICE_ID_LEN, and does not include the identifier + /// string's terminating NULL. If the specified device instance does not exist, the function supplies a size value of zero. + /// + /// For information about device instance IDs, see Device Identification Strings. + /// For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_size_ex CMAPI CONFIGRET + // CM_Get_Device_ID_Size_Ex( PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_Size_Ex")] + public static extern CONFIGRET CM_Get_Device_ID_Size_Ex(out uint pulLen, uint dnDevInst, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Device_ID function retrieves the device instance ID for a specified device instance on the local machine. + /// + /// Caller-supplied device instance handle that is bound to the local machine. + /// + /// Address of a buffer to receive a device instance ID string. The required buffer size can be obtained by calling + /// CM_Get_Device_ID_Size, then incrementing the received value to allow room for the string's terminating NULL. + /// + /// Caller-supplied length, in characters, of the buffer specified by Buffer. + /// Not used, must be zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// + /// The function appends a NULL terminator to the supplied device instance ID string, unless the buffer is too small to hold the + /// string. In this case, the function supplies as much of the identifier string as will fit into the buffer, and then returns CR_BUFFER_SMALL. + /// + /// For information about device instance IDs, see Device Identification Strings. + /// For information about using device instance handles that are bound to the local machine, see CM_Get_Child. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_idw CMAPI CONFIGRET CM_Get_Device_IDW( + // DEVINST dnDevInst, PWSTR Buffer, ULONG BufferLen, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_IDW")] + public static extern CONFIGRET CM_Get_Device_IDW(uint dnDevInst, StringBuilder Buffer, uint BufferLen, uint ulFlags = 0); + + /// + /// The CM_Get_Device_Interface_Alias function returns the alias of the specified device interface instance, if the alias exists. + /// + /// + /// Pointer to the name of the device interface instance for which to retrieve an alias. The caller typically received this string + /// from a call to CM_Get_Device_Interface_List, or in a PnP notification structure. + /// + /// Pointer to a GUID specifying the interface class of the alias to retrieve. + /// + /// + /// Specifies a pointer to a buffer, that upon successful return, points to a string containing the name of the alias. The caller + /// must free this string when it is no longer needed. + /// + /// A buffer is required. Otherwise, the call will fail. + /// + /// + /// + /// Supplies the count of characters in pszAliasDeviceInterface and receives the number of characters required to hold the alias + /// device interface. + /// + /// On input, this parameter must be greater than 0. + /// + /// Reserved. Do not use. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// + /// Return code + /// Description + /// + /// + /// CR_NO_SUCH_DEVICE_INTERFACE + /// Possibly indicates that there is no alias of the specified interface class. + /// + /// + /// CR_OUT_OF_MEMORY + /// There is not enough memory to complete the operation. + /// + /// + /// CR_BUFFER_SMALL + /// The buffer passed is too small. + /// + /// + /// + /// + /// + /// Device interfaces are considered aliases if they are exposed by the same underlying device and have identical interface + /// reference strings, but are of different interface classes. + /// + /// + /// The pszDeviceInterface parameter specifies a device interface instance for a particular device, belonging to a particular + /// interface class, with a particular reference string. CM_Get_Device_Interface_Alias returns another device interface + /// instance for the same device and reference string, but of a different interface class, if it exists. + /// + /// + /// For example, the function driver for a fault-tolerant volume could register and set two device interfaces, one of the + /// fault-tolerant-volume interface class and one of the volume interface class. Another driver could call + /// CM_Get_Device_Interface_Alias with the symbolic link for one of the interfaces and ask whether the other interface exists + /// by specifying its interface class. + /// + /// + /// Two device interfaces with NULL reference strings are aliases if they are exposed by the same underlying device and have + /// different interface class GUIDs. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_aliasw CMAPI CONFIGRET + // CM_Get_Device_Interface_AliasW( LPCWSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPWSTR pszAliasDeviceInterface, PULONG + // pulLength, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_AliasW")] + public static extern CONFIGRET CM_Get_Device_Interface_Alias([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, in Guid AliasInterfaceGuid, + [MarshalAs(UnmanagedType.LPTStr)] StringBuilder pszAliasDeviceInterface, ref uint pulLength, uint ulFlags = 0); + + /// + /// The CM_Get_Device_Interface_List function retrieves a list of device interface instances that belong to a specified + /// device interface class. + /// + /// Supplies a GUID that identifies a device interface class. + /// + /// Caller-supplied pointer to a NULL-terminated string that represents a device instance ID. If specified, the function retrieves + /// device interfaces that are supported by the device for the specified class. If this value is NULL, or if it points to a + /// zero-length string, the function retrieves all interfaces that belong to the specified class. + /// + /// + /// Caller-supplied pointer to a buffer that receives multiple, NULL-terminated Unicode strings, each representing the symbolic link + /// name of an interface instance. + /// + /// + /// Caller-supplied value that specifies the length, in characters, of the buffer pointed to by Buffer. Call + /// CM_Get_Device_Interface_List_Size to determine the required buffer size. + /// + /// + /// Contains one of the following caller-supplied flags: + /// CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES + /// + /// The function provides a list containing device interfaces associated with all devices that match the specified GUID and device + /// instance ID, if any. + /// + /// CM_GET_DEVICE_INTERFACE_LIST_PRESENT + /// + /// The function provides a list containing device interfaces associated with devices that are currently active, and which match the + /// specified GUID and device instance ID, if any. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the error codes with the CR_ prefix as + /// defined in Cfgmgr32.h. + /// + /// The following table includes some of the more common error codes that this function might return. + /// + /// + /// Return code + /// Description + /// + /// + /// CR_BUFFER_SMALL + /// The Buffer buffer is too small to hold the requested list of device interfaces. + /// + /// + /// + /// + /// + /// Between calling CM_Get_Device_Interface_List_Size to get the size of the list and calling CM_Get_Device_Interface_List to + /// get the list, a new device interface can be added to the system causing the size returned to no longer be valid. Callers should + /// be robust to that condition and retry getting the size and the list if CM_Get_Device_Interface_List returns CR_BUFFER_SMALL. + /// + /// Examples + /// This snippet illustrates retrying getting the size and the list as described in the Remarks section. + /// + /// CONFIGRET cr = CR_SUCCESS; PWSTR DeviceInterfaceList = NULL; ULONG DeviceInterfaceListLength = 0; do { cr = CM_Get_Device_Interface_List_Size(&DeviceInterfaceListLength, (LPGUID)&GUID_DEVINTERFACE_VOLUME, NULL, CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES); if (cr != CR_SUCCESS) { break; } if (DeviceInterfaceList != NULL) { HeapFree(GetProcessHeap(), 0, DeviceInterfaceList); } DeviceInterfaceList = (PWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, DeviceInterfaceListLength * sizeof(WCHAR)); if (DeviceInterfaceList == NULL) { cr = CR_OUT_OF_MEMORY; break; } cr = CM_Get_Device_Interface_List((LPGUID)&GUID_DEVINTERFACE_VOLUME, NULL, DeviceInterfaceList, DeviceInterfaceListLength, CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES); } while (cr == CR_BUFFER_SMALL); if (cr != CR_SUCCESS) { goto Exit; } + /// + /// + /// Note + /// + /// The cfgmgr32.h header defines CM_Get_Device_Interface_List as an alias which automatically selects the ANSI or Unicode version + /// of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with + /// code that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see + /// Conventions for Function Prototypes. + /// + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_lista CMAPI CONFIGRET + // CM_Get_Device_Interface_ListA( LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_ListA")] + public static extern CONFIGRET CM_Get_Device_Interface_List(in Guid InterfaceClassGuid, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, + [MarshalAs(UnmanagedType.LPTStr)] StringBuilder Buffer, uint BufferLen, CM_GET_DEVICE_INTERFACE_LIST ulFlags); + + /// + /// The CM_Get_Device_Interface_List_Size function retrieves the buffer size that must be passed to the + /// CM_Get_Device_Interface_List function. + /// + /// + /// Caller-supplied pointer to a location that receives the required length, in characters, of a buffer to hold the multiple Unicode + /// strings that will be returned by CM_Get_Device_Interface_List. + /// + /// Supplies a GUID that identifies a device interface class. + /// + /// Caller-supplied pointer to a NULL-terminated string that represents a device instance ID. If specified, the function retrieves + /// the length of symbolic link names for the device interfaces that are supported by the device, for the specified class. If this + /// value is NULL, or if it points to a zero-length string, the function retrieves the length of symbolic link names for all + /// interfaces that belong to the specified class. + /// + /// + /// Contains one of the following caller-supplied flags: + /// + /// + /// Value + /// Meaning + /// + /// + /// CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES + /// + /// The function provides the size of a list that contains device interfaces associated with all devices that match the specified + /// GUID and device instance ID, if any. + /// + /// + /// + /// CM_GET_DEVICE_INTERFACE_LIST_PRESENT + /// + /// The function provides the size of a list containing device interfaces associated with devices that are currently active, and + /// which match the specified GUID and device instance ID, if any. + /// + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the error codes with the + /// CR_ prefix as defined in Cfgmgr32.h. + /// + /// + /// Note + /// + /// The cfgmgr32.h header defines CM_Get_Device_Interface_List_Size as an alias which automatically selects the ANSI or Unicode + /// version of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral + /// alias with code that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more + /// information, see Conventions for Function Prototypes. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_list_sizew CMAPI CONFIGRET + // CM_Get_Device_Interface_List_SizeW( PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_List_SizeW")] + public static extern CONFIGRET CM_Get_Device_Interface_List_Size(out uint pulLen, in Guid InterfaceClassGuid, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, CM_GET_DEVICE_INTERFACE_LIST ulFlags); + + /// The CM_Get_Device_Interface_Property function retrieves a device property that is set for a device interface. + /// + /// Pointer to a string that identifies the device interface instance to retrieve the property from. + /// + /// + /// Pointer to a DEVPROPKEY structure that represents the device interface property key of the device interface property to retrieve. + /// + /// + /// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device interface + /// property. The property-data-type identifier is a bitwise OR between a base-data-type identifier and, if the base-data type is + /// modified, a property-data-type modifier. + /// + /// + /// A pointer to a buffer that receives the requested device interface property. CM_Get_Device_Interface_Property retrieves + /// the requested property only if the buffer is large enough to hold all the property value data. The pointer can be NULL. + /// + /// + /// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, *PropertyBufferSize must be set to zero. As + /// output, if the buffer is not large enough to hold all the property value data, CM_Get_Device_Interface_Property returns + /// the size of the data, in bytes, in *PropertyBufferSize. + /// + /// Reserved. Must be set to zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_Device_Interface_Property is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_propertyw CMAPI CONFIGRET + // CM_Get_Device_Interface_PropertyW( LPCWSTR pszDeviceInterface, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PBYTE + // PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_PropertyW")] + public static extern CONFIGRET CM_Get_Device_Interface_Property([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, in DEVPROPKEY PropertyKey, out DEVPROPTYPE PropertyType, + [Out, Optional] IntPtr PropertyBuffer, ref uint PropertyBufferSize, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use + /// CM_Get_Device_Interface_Property instead.] + /// + /// The CM_Get_Device_Interface_Property_ExW function retrieves a device property that is set for a device interface. + /// + /// + /// Pointer to a string that identifies the device interface instance to retrieve the property from. + /// + /// + /// Pointer to a DEVPROPKEY structure that represents the device interface property key of the device interface property to retrieve. + /// + /// + /// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device interface + /// property. The property-data-type identifier is a bitwise OR between a base-data-type identifier and, if the base-data type is + /// modified, a property-data-type modifier. + /// + /// + /// A pointer to a buffer that receives the requested device interface property. CM_Get_Device_Interface_Property_ExW + /// retrieves the requested property only if the buffer is large enough to hold all the property value data. The pointer can be NULL. + /// + /// + /// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, *PropertyBufferSize must be set to zero. As + /// output, if the buffer is not large enough to hold all the property value data, CM_Get_Device_Interface_Property_ExW + /// returns the size of the data, in bytes, in *PropertyBufferSize. + /// + /// Reserved. Must be set to zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_Device_Interface_Property_ExW is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_property_exw CMAPI CONFIGRET + // CM_Get_Device_Interface_Property_ExW( LPCWSTR pszDeviceInterface, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PBYTE + // PropertyBuffer, PULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_Property_ExW")] + public static extern CONFIGRET CM_Get_Device_Interface_Property_Ex([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, in DEVPROPKEY PropertyKey, out DEVPROPTYPE PropertyType, + [Out, Optional] IntPtr PropertyBuffer, ref uint PropertyBufferSize, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Device_Interface_Property_Keys function retrieves an array of device property keys that represent the device + /// properties that are set for a device interface. + /// + /// + /// Pointer to a string that identifies the device interface instance to retrieve the property keys from. + /// + /// + /// Pointer to a buffer that receives an array of DEVPROPKEY-typed values, where each value is a device property key that represents + /// a device property that is set for the device interface. The pointer is optional and can be NULL + /// + /// + /// The size, in DEVPROPKEY-typed units, of the PropertyKeyArray buffer. If PropertyKeyArray is set to NULL, *PropertyKeyCount must + /// be set to zero. As output, if PropertyKeyArray is not large enough to hold all the property key data, + /// CM_Get_Device_Interface_Property_Keys returns the count of the keys, in *PropertyKeyCount. + /// + /// Reserved. Must be set to zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_Device_Interface_Property_Keys is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_property_keysw CMAPI CONFIGRET + // CM_Get_Device_Interface_Property_KeysW( LPCWSTR pszDeviceInterface, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, ULONG + // ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_Property_KeysW")] + public static extern CONFIGRET CM_Get_Device_Interface_Property_Keys([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] DEVPROPKEY[] PropertyKeyArray, ref uint PropertyKeyCount, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use + /// CM_Get_Device_Interface_Property_Keys instead.] + /// + /// + /// The CM_Get_Device_Interface_Property_Keys_ExW function retrieves an array of device property keys that represent the + /// device properties that are set for a device interface. + /// + /// + /// + /// Pointer to a string that identifies the device interface instance to retrieve the property keys from. + /// + /// + /// Pointer to a buffer that receives an array of DEVPROPKEY-typed values, where each value is a device property key that represents + /// a device property that is set for the device interface. The pointer is optional and can be NULL + /// + /// + /// The size, in DEVPROPKEY-typed units, of the PropertyKeyArray buffer. If PropertyKeyArray is set to NULL, *PropertyKeyCount must + /// be set to zero. As output, if PropertyKeyArray is not large enough to hold all the property key data, + /// CM_Get_Device_Interface_Property_Keys_ExW returns the count of the keys, in *PropertyKeyCount. + /// + /// Reserved. Must be set to zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_Device_Interface_Property_Keys_ExW is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_interface_property_keys_exw CMAPI CONFIGRET + // CM_Get_Device_Interface_Property_Keys_ExW( LPCWSTR pszDeviceInterface, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, + // ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_Interface_Property_Keys_ExW")] + public static extern CONFIGRET CM_Get_Device_Interface_Property_Keys_Ex([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] DEVPROPKEY[] PropertyKeyArray, ref uint PropertyKeyCount, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// The CM_Get_DevNode_Property function retrieves a device instance property. + /// Device instance handle that is bound to the local machine. + /// + /// Pointer to a DEVPROPKEY structure that represents the device property key of the requested device instance property. + /// + /// + /// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device instance + /// property, where the property-data-type identifier is the bitwise OR between a base-data-type identifier and, if the base-data + /// type is modified, a property-data-type modifier. + /// + /// + /// Pointer to a buffer that receives the requested device instance property. CM_Get_DevNode_Property retrieves the requested + /// property only if the buffer is large enough to hold all the property value data. The pointer can be NULL. + /// + /// + /// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, *PropertyBufferSize must be set to zero. As + /// output, if the buffer is not large enough to hold all the property value data, CM_Get_DevNode_Property returns the size + /// of the data, in bytes, in *PropertyBufferSize. + /// + /// Reserved. Must be set to zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_DevNode_Property is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_propertyw CMAPI CONFIGRET + // CM_Get_DevNode_PropertyW( DEVINST dnDevInst, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PBYTE PropertyBuffer, + // PULONG PropertyBufferSize, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_PropertyW")] + public static extern CONFIGRET CM_Get_DevNode_Property(uint dnDevInst, in DEVPROPKEY PropertyKey, out DEVPROPTYPE PropertyType, [Out, Optional] IntPtr PropertyBuffer, + ref uint PropertyBufferSize, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_DevNode_Property instead.] + /// + /// The CM_Get_DevNode_Property_ExW function retrieves a device instance property. + /// + /// Device instance handle that is bound to the local machine. + /// + /// Pointer to a DEVPROPKEY structure that represents the device property key of the requested device instance property. + /// + /// + /// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device instance + /// property, where the property-data-type identifier is the bitwise OR between a base-data-type identifier and, if the base-data + /// type is modified, a property-data-type modifier. + /// + /// + /// Pointer to a buffer that receives the requested device instance property. CM_Get_DevNode_Property_ExW retrieves the + /// requested property only if the buffer is large enough to hold all the property value data. The pointer can be NULL. + /// + /// + /// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, *PropertyBufferSize must be set to zero. As + /// output, if the buffer is not large enough to hold all the property value data, CM_Get_DevNode_Property_ExW returns the + /// size of the data, in bytes, in *PropertyBufferSize. + /// + /// Reserved. Must be set to zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_DevNode_Property_ExW is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_property_exw CMAPI CONFIGRET + // CM_Get_DevNode_Property_ExW( DEVINST dnDevInst, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PBYTE PropertyBuffer, + // PULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Property_ExW")] + public static extern CONFIGRET CM_Get_DevNode_Property_Ex(uint dnDevInst, in DEVPROPKEY PropertyKey, out DEVPROPTYPE PropertyType, [Out, Optional] IntPtr PropertyBuffer, + ref uint PropertyBufferSize, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_DevNode_Property_Keys function retrieves an array of the device property keys that represent the device + /// properties that are set for a device instance. + /// + /// Device instance handle that is bound to the local machine. + /// + /// Pointer to a buffer that receives an array of DEVPROPKEY-typed values, where each value is a device property key that represents + /// a device property that is set for the device instance. The pointer is optional and can be NULL. + /// + /// + /// The size, in DEVPROPKEY-typed units, of the PropertyKeyArray buffer. If PropertyKeyArray is set to NULL, *PropertyKeyCount must + /// be set to zero. As output, If PropertyKeyArray is not large enough to hold all the property key data, + /// CM_Get_DevNode_Property_Keys returns the count of the keys in *PropertyKeyCount. + /// + /// Reserved. Must be set to zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_DevNode_Property_Keys is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_property_keys CMAPI CONFIGRET + // CM_Get_DevNode_Property_Keys( DEVINST dnDevInst, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Property_Keys")] + public static extern CONFIGRET CM_Get_DevNode_Property_Keys(uint dnDevInst, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] DEVPROPKEY[] PropertyKeyArray, + ref uint PropertyKeyCount, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_DevNode_Property_Keys instead.] + /// + /// + /// The CM_Get_DevNode_Property_Keys_Ex function retrieves an array of the device property keys that represent the device + /// properties that are set for a device instance. + /// + /// + /// Device instance handle that is bound to the local machine. + /// + /// Pointer to a buffer that receives an array of DEVPROPKEY-typed values, where each value is a device property key that represents + /// a device property that is set for the device instance. The pointer is optional and can be NULL. + /// + /// + /// The size, in DEVPROPKEY-typed units, of the PropertyKeyArray buffer. If PropertyKeyArray is set to NULL, *PropertyKeyCount must + /// be set to zero. As output, If PropertyKeyArray is not large enough to hold all the property key data, + /// CM_Get_DevNode_Property_Keys_Ex returns the count of the keys in *PropertyKeyCount. + /// + /// Reserved. Must be set to zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// CM_Get_DevNode_Property_Keys_Ex is part of the Unified Device Property Model. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_property_keys_ex CMAPI CONFIGRET + // CM_Get_DevNode_Property_Keys_Ex( DEVINST dnDevInst, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags, + // HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Property_Keys_Ex")] + public static extern CONFIGRET CM_Get_DevNode_Property_Keys_Ex(uint dnDevInst, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] DEVPROPKEY[] PropertyKeyArray, + ref uint PropertyKeyCount, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// The CM_Get_DevNode_Registry_Property function retrieves a specified device property from the registry. + /// A caller-supplied device instance handle that is bound to the local machine. + /// + /// A CM_DRP_-prefixed constant value that identifies the device property to be obtained from the registry. These constants are + /// defined in Cfgmgr32.h. + /// + /// + /// Optional, can be NULL. A pointer to a location that receives the registry data type, specified as a REG_-prefixed + /// constant defined in Winnt.h. + /// + /// + /// Optional, can be NULL. A pointer to a caller-supplied buffer that receives the requested device property. If this value + /// is NULL, the function supplies only the length of the requested data in the address pointed to by pulLength. + /// + /// + /// A pointer to a ULONG variable into which the function stores the length, in bytes, of the requested device property. + /// If the Buffer parameter is set to NULL, the ULONG variable must be set to zero. + /// + /// If the Buffer parameter is not set to NULL, the ULONG variable must be set to the length, in bytes, of the + /// caller-supplied buffer. + /// + /// + /// Not used, must be zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes that are + /// defined in Cfgmgr32.h. + /// + /// For information about how to use device instance handles that are bound to the local machine, see CM_Get_Child. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_registry_propertyw CMAPI CONFIGRET + // CM_Get_DevNode_Registry_PropertyW( DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, + // ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Registry_PropertyW")] + public static extern CONFIGRET CM_Get_DevNode_Registry_Property(uint dnDevInst, CM_DRP ulProperty, out REG_VALUE_TYPE pulRegDataType, [Out, Optional] IntPtr Buffer, ref uint pulLength, uint ulFlags = 0); + + /// + /// The CM_Get_DevNode_Status function obtains the status of a device instance from its device node (devnode) in the local + /// machine's device tree. + /// + /// + /// Address of a location to receive status bit flags. The function can set any combination of the DN_- prefixed bit flags + /// defined in Cfg.h. + /// + /// + /// Address of a location to receive one of the CM_PROB_-prefixed problem values defined in Cfg.h. Used only if + /// DN_HAS_PROBLEM is set in pulStatus. + /// + /// Caller-supplied device instance handle that is bound to the local machine. + /// Not used, must be zero. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// For information about using device instance handles that are bound to the local machine, see CM_Get_Child. + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_status CMAPI CONFIGRET + // CM_Get_DevNode_Status( PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Status")] + public static extern CONFIGRET CM_Get_DevNode_Status(out DN pulStatus, out CM_PROB pulProblemNumber, uint dnDevInst, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_DevNode_Status instead.] + /// + /// + /// The CM_Get_DevNode_Status_Ex function obtains the status of a device instance from its device node (devnode) on a local + /// or a remote machine's device tree. + /// + /// + /// + /// Address of a location to receive status bit flags. The function can set any combination of the DN_-prefixed bit flags defined in Cfg.h. + /// + /// + /// Address of a location to receive one of the CM_PROB_-prefixed problem values defined in Cfg.h. Used only if DN_HAS_PROBLEM is + /// set in pulStatus. + /// + /// Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine. + /// Not used, must be zero. + /// + /// Caller-supplied machine handle to which the caller-supplied device instance handle is bound. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_devnode_status_ex CMAPI CONFIGRET + // CM_Get_DevNode_Status_Ex( PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_DevNode_Status_Ex")] + public static extern CONFIGRET CM_Get_DevNode_Status_Ex(out DN pulStatus, out CM_PROB pulProblemNumber, uint dnDevInst, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_First_Log_Conf function obtains the first logical configuration, of a specified configuration type, associated + /// with a specified device instance on the local machine. + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. See the following Remarks section. + /// + /// Caller-supplied device instance handle that is bound to the local machine. + /// + /// + /// Caller-supplied flag value indicating the type of logical configuration being requested. One of the flags in the following table + /// must be specified. + /// + /// + /// + /// Configuration Type Flags + /// Definitions + /// + /// + /// BASIC_LOG_CONF + /// The caller is requesting basic configuration information. + /// + /// + /// FILTERED_LOG_CONF + /// The caller is requesting filtered configuration information. + /// + /// + /// ALLOC_LOG_CONF + /// The caller is requesting allocated configuration information. + /// + /// + /// BOOT_LOG_CONF + /// The caller is requesting boot configuration information. + /// + /// + /// FORCED_LOG_CONF + /// The caller is requesting forced configuration information. + /// + /// + /// OVERRIDE_LOG_CONF + /// The caller is requesting override configuration information. + /// + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_First_Log_Conf returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// Calling CM_Add_Empty_Log_Conf or CM_Free_Log_Conf can invalidate the handle obtained from a previous call to + /// CM_Get_First_Log_Conf. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf or + /// CM_Free_Log_Conf, your code must call CM_Get_First_Log_Conf again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_First_Log_Conf is called with plcLogConf set to NULL, no handle is returned. This allows you to use the + /// return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// For information about using device instance handles that are bound to the local machine, see CM_Get_Child. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_first_log_conf CMAPI CONFIGRET + // CM_Get_First_Log_Conf( PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_First_Log_Conf")] + public static extern CONFIGRET CM_Get_First_Log_Conf(out SafeLOG_CONF plcLogConf, uint dnDevInst, LOG_CONF_FLAG ulFlags); + + /// + /// The CM_Get_First_Log_Conf function obtains the first logical configuration, of a specified configuration type, associated + /// with a specified device instance on the local machine. + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. See the following Remarks section. + /// + /// Caller-supplied device instance handle that is bound to the local machine. + /// + /// + /// Caller-supplied flag value indicating the type of logical configuration being requested. One of the flags in the following table + /// must be specified. + /// + /// + /// + /// Configuration Type Flags + /// Definitions + /// + /// + /// BASIC_LOG_CONF + /// The caller is requesting basic configuration information. + /// + /// + /// FILTERED_LOG_CONF + /// The caller is requesting filtered configuration information. + /// + /// + /// ALLOC_LOG_CONF + /// The caller is requesting allocated configuration information. + /// + /// + /// BOOT_LOG_CONF + /// The caller is requesting boot configuration information. + /// + /// + /// FORCED_LOG_CONF + /// The caller is requesting forced configuration information. + /// + /// + /// OVERRIDE_LOG_CONF + /// The caller is requesting override configuration information. + /// + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_First_Log_Conf returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// Calling CM_Add_Empty_Log_Conf or CM_Free_Log_Conf can invalidate the handle obtained from a previous call to + /// CM_Get_First_Log_Conf. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf or + /// CM_Free_Log_Conf, your code must call CM_Get_First_Log_Conf again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_First_Log_Conf is called with plcLogConf set to NULL, no handle is returned. This allows you to use the + /// return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// For information about using device instance handles that are bound to the local machine, see CM_Get_Child. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_first_log_conf CMAPI CONFIGRET + // CM_Get_First_Log_Conf( PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_First_Log_Conf")] + public static extern CONFIGRET CM_Get_First_Log_Conf([In, Optional] IntPtr plcLogConf, uint dnDevInst, LOG_CONF_FLAG ulFlags); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_First_Log_Conf instead.] + /// + /// + /// The CM_Get_First_Log_Conf_Ex function obtains the first logical configuration associated with a specified device instance + /// on a local or a remote machine. + /// + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. See the Remarks section. + /// + /// Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine. + /// + /// Caller-supplied flag value indicating the type of logical configuration being requested. For a list of flags, see the ulFlags + /// description for CM_Get_First_Log_Conf. + /// + /// + /// Caller-supplied machine handle to which the caller-supplied device instance handle is bound. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_First_Log_Conf_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// Calling CM_Add_Empty_Log_Conf_Ex or CM_Free_Log_Conf_Ex can invalidate the handle obtained from a previous call to + /// CM_Get_First_Log_Conf_Ex. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf_Ex + /// or CM_Free_Log_Conf_Ex, your code must call CM_Get_First_Log_Conf_Ex again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_First_Log_Conf_Ex is called with plcLogConf set to NULL, no handle is returned. This allows you to use + /// the return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_first_log_conf_ex CMAPI CONFIGRET + // CM_Get_First_Log_Conf_Ex( PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_First_Log_Conf_Ex")] + public static extern CONFIGRET CM_Get_First_Log_Conf_Ex(out SafeLOG_CONF plcLogConf, uint dnDevInst, LOG_CONF_FLAG ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_First_Log_Conf instead.] + /// + /// + /// The CM_Get_First_Log_Conf_Ex function obtains the first logical configuration associated with a specified device instance + /// on a local or a remote machine. + /// + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. See the Remarks section. + /// + /// Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine. + /// + /// Caller-supplied flag value indicating the type of logical configuration being requested. For a list of flags, see the ulFlags + /// description for CM_Get_First_Log_Conf. + /// + /// + /// Caller-supplied machine handle to which the caller-supplied device instance handle is bound. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_First_Log_Conf_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// Calling CM_Add_Empty_Log_Conf_Ex or CM_Free_Log_Conf_Ex can invalidate the handle obtained from a previous call to + /// CM_Get_First_Log_Conf_Ex. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf_Ex + /// or CM_Free_Log_Conf_Ex, your code must call CM_Get_First_Log_Conf_Ex again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_First_Log_Conf_Ex is called with plcLogConf set to NULL, no handle is returned. This allows you to use + /// the return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_first_log_conf_ex CMAPI CONFIGRET + // CM_Get_First_Log_Conf_Ex( PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_First_Log_Conf_Ex")] + public static extern CONFIGRET CM_Get_First_Log_Conf_Ex([In, Optional] IntPtr plcLogConf, uint dnDevInst, LOG_CONF_FLAG ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated and should not be used.] + /// + /// The CM_Get_HW_Prof_Flags function retrieves the hardware profile-specific configuration flags for a device instance on a + /// local machine. + /// + /// + /// + /// Pointer to a NULL-terminated string that contains the device instance ID of the device for which to retrieve hardware + /// profile-specific configuration flags. + /// + /// + /// A variable of ULONG type that specifies the identifier of the hardware profile for which to retrieve configuration flags. If + /// this parameter is zero, this function retrieves the configuration flags for the current hardware profile. + /// + /// + /// + /// Pointer to a caller-supplied variable of ULONG type that receives zero or a bitwise OR of the following configuration flags that + /// are defined in Regstr.h: + /// + /// CSCONFIGFLAG_BITS + /// Bitwise OR of the other CSCONFIGFLAG_Xxx flags. + /// CSCONFIGFLAG_DISABLE + /// The device instance is disabled in the specified hardware profile. + /// CSCONFIGFLAG_DO_NOT_CREATE + /// The hardware profile does not support the specified device instance. + /// CSCONFIGFLAG_DO_NOT_START + /// The device cannot be started in the specified hardware profile. + /// + /// Reserved for internal use. Must be set to zero. + /// + /// If the operation succeeds, CM_Get_HW_Prof_Flags returns CR_SUCCESS. Otherwise, the function returns one of the CR_Xxx + /// error codes that are defined in Cfgmgr32.h. + /// + /// + /// To retrieve a list of hardware profile IDs that are currently defined on a local machine, call SetupDiGetHwProfileList. + /// To retrieve configuration flags for a device instance on a remote machine, call CM_Get_HW_Prof_Flags_Ex. + /// + /// Note + /// + /// The cfgmgr32.h header defines CM_Get_HW_Prof_Flags as an alias which automatically selects the ANSI or Unicode version of this + /// function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that + /// not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions + /// for Function Prototypes. + /// + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_hw_prof_flagsa CMAPI CONFIGRET + // CM_Get_HW_Prof_FlagsA( DEVINSTID_A pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_HW_Prof_FlagsA")] + public static extern CONFIGRET CM_Get_HW_Prof_Flags([MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, uint ulHardwareProfile, out CSCONFIGFLAG pulValue, uint ulFlags = 0); + + /// + /// [This function has been deprecated and should not be used.] + /// + /// The CM_Get_HW_Prof_Flags_Ex function retrieves the hardware profile-specific configuration flags for a device instance on + /// a remote machine or a local machine. + /// + /// + /// + /// Pointer to a NULL-terminated string that contains the device instance ID of the device for which to retrieve hardware + /// profile-specific configuration flags. + /// + /// + /// A variable of ULONG type that specifies the identifier of the hardware profile for which to retrieve configuration flags. If + /// this parameter is zero, this function retrieves the configuration flags for the current hardware profile. + /// + /// + /// + /// Pointer to a caller-supplied variable of ULONG type that receives zero or a bitwise OR of the following configuration flags that + /// are defined in Regstr.h: + /// + /// CSCONFIGFLAG_BITS + /// Bitwise OR of the other CSCONFIGFLAG_Xxx flags. + /// CSCONFIGFLAG_DISABLE + /// The device instance is disabled in the specified hardware profile. + /// CSCONFIGFLAG_DO_NOT_CREATE + /// The hardware profile does not support the specified device instance. + /// CSCONFIGFLAG_DO_NOT_START + /// The device cannot be started in the specified hardware profile. + /// + /// Reserved for internal use. Must be set to zero. + /// + /// + /// A machine handle that is returned by call to CM_Connect_Machine or NULL. If this parameter is set to NULL, + /// CM_Get_HW_Prof_Flags_Ex retrieves the configuration flags on the local machine. + /// + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, CM_Get_HW_Prof_Flags returns CR_SUCCESS. Otherwise, the function returns one of the + /// CR_-prefixed error codes that are defined in Cfgmgr32.h. + /// + /// + /// To retrieve a list of the hardware profile IDs that are currently defined on a remote machine, call SetupDiGetHwProfileListEx. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + /// Note + /// + /// The cfgmgr32.h header defines CM_Get_HW_Prof_Flags_Ex as an alias which automatically selects the ANSI or Unicode version of + /// this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code + /// that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see + /// Conventions for Function Prototypes. + /// + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_hw_prof_flags_exa CMAPI CONFIGRET + // CM_Get_HW_Prof_Flags_ExA( DEVINSTID_A pDeviceID, ULONG ulHardwareProfile, PULONG pulValue, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_HW_Prof_Flags_ExA")] + public static extern CONFIGRET CM_Get_HW_Prof_Flags_Ex([MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, uint ulHardwareProfile, out CSCONFIGFLAG pulValue, + [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Log_Conf_Priority function obtains the configuration priority of a specified logical configuration on the + /// local machine. + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Add_Empty_Log_Conf + /// CM_Add_Empty_Log_Conf_Ex + /// CM_Get_First_Log_Conf + /// CM_Get_First_Log_Conf_Ex + /// CM_Get_Next_Log_Conf + /// CM_Get_Next_Log_Conf_Ex + /// + /// + /// Caller-supplied address of a location to receive a configuration priority value. For a list of priority values, see the + /// description of Priority for CM_Add_Empty_Log_Conf. + /// + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Log_Conf_Priority returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_log_conf_priority CMAPI CONFIGRET + // CM_Get_Log_Conf_Priority( LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Log_Conf_Priority")] + public static extern CONFIGRET CM_Get_Log_Conf_Priority(LOG_CONF lcLogConf, out PRIORITY pPriority, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Log_Conf_Priority instead.] + /// + /// + /// The CM_Get_Log_Conf_Priority_Ex function obtains the configuration priority of a specified logical configuration on a + /// local or a remote machine. + /// + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Add_Empty_Log_Conf + /// CM_Add_Empty_Log_Conf_Ex + /// CM_Get_First_Log_Conf + /// CM_Get_First_Log_Conf_Ex + /// CM_Get_Next_Log_Conf + /// CM_Get_Next_Log_Conf_Ex + /// + /// + /// Caller-supplied address of a location to receive a configuration priority value. For a list of priority values, see the + /// description of Priority for CM_Add_Empty_Log_Conf_Ex. + /// + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Log_Conf_Priority_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_log_conf_priority_ex CMAPI CONFIGRET + // CM_Get_Log_Conf_Priority_Ex( LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Log_Conf_Priority_Ex")] + public static extern CONFIGRET CM_Get_Log_Conf_Priority_Ex(LOG_CONF lcLogConf, out PRIORITY pPriority, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Next_Log_Conf function obtains the next logical configuration associated with a specific device instance on + /// the local machine. + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. (See the following Remarks section. + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Get_First_Log_Conf + /// CM_Get_Next_Log_Conf + /// + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Log_Conf returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate the logical configurations associated with a device instance, call CM_Get_First_Log_Conf to obtain the first + /// logical configuration of a specified configuration type, then call CM_Get_Next_Log_Conf repeatedly until it returns CR_NO_MORE_LOG_CONF. + /// + /// + /// Calling CM_Add_Empty_Log_Conf or CM_Free_Log_Conf can invalidate the handle obtained from a previous call to + /// CM_Get_Next_Log_Conf. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf or + /// CM_Free_Log_Conf, your code must call CM_Get_First_Log_Conf again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_Next_Log_Conf is called with plcLogConf set to NULL, no handle is returned. This allows you to use the + /// return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_log_conf CMAPI CONFIGRET + // CM_Get_Next_Log_Conf( PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Log_Conf")] + public static extern CONFIGRET CM_Get_Next_Log_Conf(out SafeLOG_CONF plcLogConf, LOG_CONF lcLogConf, uint ulFlags = 0); + + /// + /// The CM_Get_Next_Log_Conf function obtains the next logical configuration associated with a specific device instance on + /// the local machine. + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. (See the following Remarks section. + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Get_First_Log_Conf + /// CM_Get_Next_Log_Conf + /// + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Log_Conf returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate the logical configurations associated with a device instance, call CM_Get_First_Log_Conf to obtain the first + /// logical configuration of a specified configuration type, then call CM_Get_Next_Log_Conf repeatedly until it returns CR_NO_MORE_LOG_CONF. + /// + /// + /// Calling CM_Add_Empty_Log_Conf or CM_Free_Log_Conf can invalidate the handle obtained from a previous call to + /// CM_Get_Next_Log_Conf. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf or + /// CM_Free_Log_Conf, your code must call CM_Get_First_Log_Conf again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_Next_Log_Conf is called with plcLogConf set to NULL, no handle is returned. This allows you to use the + /// return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_log_conf CMAPI CONFIGRET + // CM_Get_Next_Log_Conf( PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Log_Conf")] + public static extern CONFIGRET CM_Get_Next_Log_Conf([In, Optional] IntPtr plcLogConf, LOG_CONF lcLogConf, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Next_Log_Conf instead.] + /// + /// + /// The CM_Get_Next_Log_Conf_Ex function obtains the next logical configuration associated with a specific device instance on + /// a local or a remote machine. + /// + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. (See the following Remarks section. + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Get_First_Log_Conf_Ex + /// CM_Get_Next_Log_Conf_Ex + /// + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Log_Conf_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate the logical configurations associated with a device instance, call CM_Get_First_Log_Conf_Ex to obtain the first + /// logical configuration, then call CM_Get_Next_Log_Conf_Ex repeatedly until it returns CR_NO_MORE_LOG_CONF. + /// + /// + /// Calling CM_Add_Empty_Log_Conf_Ex or CM_Free_Log_Conf_Ex can invalidate the handle obtained from a previous call to + /// CM_Get_Next_Log_Conf_Ex. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf_Ex + /// or CM_Free_Log_Conf_Ex, your code must call CM_Get_First_Log_Conf_Ex again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_Next_Log_Conf_Ex is called with plcLogConf set to NULL, no handle is returned. This allows you to use + /// the return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_log_conf_ex CMAPI CONFIGRET + // CM_Get_Next_Log_Conf_Ex( PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Log_Conf_Ex")] + public static extern CONFIGRET CM_Get_Next_Log_Conf_Ex(out SafeLOG_CONF plcLogConf, LOG_CONF lcLogConf, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Next_Log_Conf instead.] + /// + /// + /// The CM_Get_Next_Log_Conf_Ex function obtains the next logical configuration associated with a specific device instance on + /// a local or a remote machine. + /// + /// + /// + /// Address of a location to receive the handle to a logical configuration, or NULL. (See the following Remarks section. + /// + /// + /// + /// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the + /// following functions: + /// + /// CM_Get_First_Log_Conf_Ex + /// CM_Get_Next_Log_Conf_Ex + /// + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Log_Conf_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate the logical configurations associated with a device instance, call CM_Get_First_Log_Conf_Ex to obtain the first + /// logical configuration, then call CM_Get_Next_Log_Conf_Ex repeatedly until it returns CR_NO_MORE_LOG_CONF. + /// + /// + /// Calling CM_Add_Empty_Log_Conf_Ex or CM_Free_Log_Conf_Ex can invalidate the handle obtained from a previous call to + /// CM_Get_Next_Log_Conf_Ex. Thus if you want to obtain logical configurations after calling CM_Add_Empty_Log_Conf_Ex + /// or CM_Free_Log_Conf_Ex, your code must call CM_Get_First_Log_Conf_Ex again and start at the first configuration. + /// + /// The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle. + /// + /// If CM_Get_Next_Log_Conf_Ex is called with plcLogConf set to NULL, no handle is returned. This allows you to use + /// the return status to determine if a configuration exists without the need to subsequently free the handle. + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_log_conf_ex CMAPI CONFIGRET + // CM_Get_Next_Log_Conf_Ex( PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Log_Conf_Ex")] + public static extern CONFIGRET CM_Get_Next_Log_Conf_Ex([In, Optional] IntPtr plcLogConf, LOG_CONF lcLogConf, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Next_Res_Des function obtains a handle to the next resource descriptor, of a specified resource type, for a + /// logical configuration on the local machine. + /// + /// Pointer to a location to receive a resource descriptor handle. + /// + /// Caller-supplied handle to either a resource descriptor or a logical configuration. For more information, see the following + /// Remarks section. + /// + /// + /// Caller-supplied resource type identifier, indicating the type of resource descriptor being requested. This must be one of the + /// ResType_-prefixed constants defined in Cfgmgr32.h. + /// + /// + /// Pointer to a location to receive a resource type identifier, if ForResource specifies ResType_All. For any other + /// ForResource value, callers should set this to NULL. + /// + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Res_Des returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate a logical configuration's resource descriptors, begin by calling CM_Get_Next_Res_Des with the logical + /// configuration's handle as the argument for rdResDes. This obtains a handle to the first resource descriptor of the type + /// specified by ForResource. Then for each subsequent call to CM_Get_Next_Res_Des, specify the most recently obtained + /// descriptor handle as the argument for rdResDes. Repeat until the function returns CR_NO_MORE_RES_DES. + /// + /// To retrieve the information stored in a resource descriptor, call CM_Get_Res_Des_Data. + /// To modify the information stored in a resource descriptor, call CM_Modify_Res_Des. + /// + /// Callers of CM_Get_Next_Res_Des must call CM_Free_Res_Des_Handle to deallocate the resource descriptor handle, after it is + /// no longer needed. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_res_des CMAPI CONFIGRET CM_Get_Next_Res_Des( + // PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Res_Des")] + public static extern CONFIGRET CM_Get_Next_Res_Des(out SafeRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, out RESOURCEID pResourceID, uint ulFlags = 0); + + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Next_Res_Des instead.] + /// + /// The CM_Get_Next_Res_Des_Ex function obtains a handle to the next resource descriptor, of a specified resource type, for a + /// logical configuration on a local or a remote machine. + /// + /// + /// Pointer to a location to receive a resource descriptor handle. + /// + /// Caller-supplied handle to either a resource descriptor or a logical configuration. For more information, see the following + /// Remarks section. + /// + /// + /// Caller-supplied resource type identifier, indicating the type of resource descriptor being requested. This must be one of the + /// ResType_-prefixed constants defined in Cfgmgr32.h. + /// + /// + /// Pointer to a location to receive a resource type identifier, if ForResource specifies ResType_All. For any other + /// ForResource value, callers should set this to NULL. + /// + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Next_Res_Des_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// To enumerate a logical configuration's resource descriptors, begin by calling CM_Get_Next_Res_Des_Ex with the logical + /// configuration's handle as the argument for rdResDes. This obtains a handle to the first resource descriptor of the type + /// specified by ForResource. Then for each subsequent call to CM_Get_Next_Res_Des_Ex, specify the most recently obtained + /// descriptor handle as the argument for rdResDes. Repeat until the function returns CR_NO_MORE_RES_DES. + /// + /// To retrieve the information stored in a resource descriptor, call CM_Get_Res_Des_Data_Ex. + /// To modify the information stored in a resource descriptor, call CM_Modify_Res_Des_Ex. + /// + /// Callers of CM_Get_Next_Res_Des_Ex must call CM_Free_Res_Des_Handle to deallocate the resource descriptor handle, after it + /// is no longer needed. + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_next_res_des_ex CMAPI CONFIGRET + // CM_Get_Next_Res_Des_Ex( PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, PRESOURCEID pResourceID, ULONG ulFlags, + // HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Next_Res_Des_Ex")] + public static extern CONFIGRET CM_Get_Next_Res_Des_Ex(out SafeRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource, out RESOURCEID pResourceID, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Parent instead.] + /// + /// The CM_Get_Parent_Ex function obtains a device instance handle to the parent node of a specified device node (devnode) in + /// a local or a remote machine's device tree. + /// + /// + /// + /// Caller-supplied pointer to the device instance handle to the parent node that this function retrieves. The retrieved handle is + /// bound to the machine handle specified by hMachine. + /// + /// Caller-supplied device instance handle that is bound to the machine handle specified by hMachine. + /// Not used, must be zero. + /// + /// Caller-supplied machine handle to which the caller-supplied device instance handle is bound. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex. + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_parent_ex CMAPI CONFIGRET CM_Get_Parent_Ex( + // PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Parent_Ex")] + public static extern CONFIGRET CM_Get_Parent_Ex(out uint pdnDevInst, uint dnDevInst, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// The CM_Get_Res_Des_Data function retrieves the information stored in a resource descriptor on the local machine. + /// Caller-supplied handle to a resource descriptor, obtained by a previous call to CM_Get_Next_Res_Des. + /// + /// Address of a buffer to receive the contents of a resource descriptor. The required buffer size should be obtained by calling CM_Get_Res_Des_Data_Size. + /// + /// Caller-supplied length of the buffer specified by Buffer. + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Res_Des_Data returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario. + /// To request information about the hardware resources on a local machine it is necessary implement an architecture-native version + /// of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// Information returned in the buffer supplied by Buffer will be formatted as one of the resource type structures listed in the + /// description of CM_Add_Res_Des, based on the resource type that was specified when CM_Get_Next_Res_Des was called to obtain the + /// resource descriptor handle. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_res_des_data CMAPI CONFIGRET CM_Get_Res_Des_Data( + // RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Res_Des_Data")] + public static extern CONFIGRET CM_Get_Res_Des_Data(RES_DES rdResDes, [Out] IntPtr Buffer, uint BufferLen, uint ulFlags = 0); + + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Res_Des_Data instead.] + /// + /// The CM_Get_Res_Des_Data_Ex function retrieves the information stored in a resource descriptor on a local or a remote machine. + /// + /// + /// Caller-supplied handle to a resource descriptor, obtained by a previous call to CM_Get_Next_Res_Des_Ex. + /// + /// Address of a buffer to receive the contents of a resource descriptor. The required buffer size should be obtained by calling CM_Get_Res_Des_Data_Size_Ex. + /// + /// Caller-supplied length of the buffer specified by Buffer. + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Res_Des_Data_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// Information returned in the buffer supplied by Buffer will be formatted as one of the resource type structures listed in the + /// description of CM_Add_Res_Des_Ex, based on the resource type that was specified when CM_Get_Next_Res_Des_Ex was called to obtain + /// the resource descriptor handle. + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_res_des_data_ex CMAPI CONFIGRET + // CM_Get_Res_Des_Data_Ex( RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Res_Des_Data_Ex")] + public static extern CONFIGRET CM_Get_Res_Des_Data_Ex(RES_DES rdResDes, [Out] IntPtr Buffer, uint BufferLen, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Res_Des_Data_Size function obtains the buffer size required to hold the information contained in a specified + /// resource descriptor on the local machine. + /// + /// Caller-supplied address of a location to receive the required buffer size. + /// Caller-supplied handle to a resource descriptor, obtained by a previous call to CM_Get_Next_Res_Des. + /// Not used, must be zero. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Res_Des_Data_Size returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// The returned size value represents the size of the appropriate resource structure (see CM_Add_Res_Des). If the resource + /// descriptor resides in a resource requirements list, the returned size includes both the size of the resource structure and the + /// space allocated for associated range arrays. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_res_des_data_size CMAPI CONFIGRET + // CM_Get_Res_Des_Data_Size( PULONG pulSize, RES_DES rdResDes, ULONG ulFlags ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Res_Des_Data_Size")] + public static extern CONFIGRET CM_Get_Res_Des_Data_Size(out uint pulSize, RES_DES rdResDes, uint ulFlags = 0); + + /// + /// + /// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Res_Des_Data_Size instead.] + /// + /// + /// The CM_Get_Res_Des_Data_Size_Ex function obtains the buffer size required to hold the information contained in a + /// specified resource descriptor on a local or a remote machine. + /// + /// + /// Caller-supplied address of a location to receive the required buffer size. + /// Caller-supplied handle to a resource descriptor, obtained by a previous call to CM_Get_Next_Res_Des_Ex. + /// Not used, must be zero. + /// + /// Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine. + /// + /// Note Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as + /// this functionality has been removed. + /// + /// + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// Note Starting with Windows 8, CM_Get_Res_Des_Data_Size_Ex returns CR_CALL_NOT_IMPLEMENTED when used in a Wow64 + /// scenario. To request information about the hardware resources on a local machine it is necessary implement an + /// architecture-native version of the application using the hardware resource APIs. For example: An AMD64 application for AMD64 systems. + /// + /// + /// + /// + /// The returned size value represents the size of the appropriate resource structure (see CM_Add_Res_Des_Ex). If the resource + /// descriptor resides in a resource requirements list, the returned size includes both the size of the resource structure and the + /// space allocated for associated range arrays. + /// + /// + /// Functionality to access remote machines has been removed in Windows 8 and Windows Server 2012 and later operating systems thus + /// you cannot access remote machines when running on these versions of Windows. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_res_des_data_size_ex CMAPI CONFIGRET + // CM_Get_Res_Des_Data_Size_Ex( PULONG pulSize, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Res_Des_Data_Size_Ex")] + public static extern CONFIGRET CM_Get_Res_Des_Data_Size_Ex(out uint pulSize, RES_DES rdResDes, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine); + + /// + /// The CM_Get_Resource_Conflict_Count function obtains the number of conflicts contained in a specified resource conflict list. + /// + /// Caller-supplied handle to a conflict list, obtained by a previous call to CM_Query_Resource_Conflict_List. + /// Caller-supplied address of a location to receive the conflict count. + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// + /// The count value obtained by calling CM_Get_Resource_Conflict_Count can be used to determine the number of times to call + /// CM_Get_Resource_Conflict_Details, which supplies information about each conflict. + /// + /// If there are no entries in the conflict list, the location supplied by pulCount will receive zero. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_resource_conflict_count CMAPI CONFIGRET + // CM_Get_Resource_Conflict_Count( CONFLICT_LIST clConflictList, PULONG pulCount ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Resource_Conflict_Count")] + public static extern CONFIGRET CM_Get_Resource_Conflict_Count(CONFLICT_LIST clConflictList, out uint pulCount); + + /// + /// The CM_Get_Resource_Conflict_Details function obtains the details about one of the resource conflicts in a conflict list. + /// + /// Caller-supplied handle to a conflict list, obtained by a previous call to CM_Query_Resource_Conflict_List. + /// + /// Caller-supplied value used as an index into the conflict list. This value can be from zero to one less than the number returned + /// by CM_Get_Resource_Conflict_Count. + /// + /// + /// Caller-supplied address of a CONFLICT_DETAILS structure to receive conflict details. The caller must supply values for the + /// structure's CD_ulSize and CD_ulMask structures. + /// + /// + /// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h. + /// + /// + /// + /// To determine conflicting resource requirements between a specified device and other devices on a machine, use the following steps. + /// + /// + /// + /// Call CM_Query_Resource_Conflict_List to obtain a handle to a list of resource conflicts. + /// + /// + /// Call CM_Get_Resource_Conflict_Count to determine the number of conflicts contained in the resource conflict list. + /// + /// + /// Call CM_Get_Resource_Conflict_Details for each entry in the conflict list. + /// + /// + /// The following conflicts are typically not reported: + /// + /// + /// + /// If there are multiple conflicts for a resource, and the owners of only some of the conflicts can be determined, the conflicts + /// without identifiable owners are not reported. + /// + /// + /// + /// Conflicts that appear to be with the specified device (that is, the device conflicts with itself) are not reported. + /// + /// + /// If multiple non-Plug and Play devices use the same driver, resource conflicts among these devices might not be reported. + /// + /// + /// Sometimes, resources assigned to the HAL might be reported as either conflicting with the HAL or not available. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_resource_conflict_detailsw CMAPI CONFIGRET + // CM_Get_Resource_Conflict_DetailsW( CONFLICT_LIST clConflictList, ULONG ulIndex, PCONFLICT_DETAILS_W pConflictDetails ); + [DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)] + [PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Resource_Conflict_DetailsW")] + public static extern CONFIGRET CM_Get_Resource_Conflict_Details(CONFLICT_LIST clConflictList, uint ulIndex, ref CONFLICT_DETAILS pConflictDetails); + + /// The CONFLICT_DETAILS structure is used as a parameter to the CM_Get_Resource_Conflict_Details function. + /// + /// Note + /// + /// The cfgmgr32.h header defines CONFLICT_DETAILS as an alias which automatically selects the ANSI or Unicode version of this + /// function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that + /// not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see Conventions + /// for Function Prototypes. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/ns-cfgmgr32-conflict_details_a typedef struct _CONFLICT_DETAILS_A { + // ULONG CD_ulSize; ULONG CD_ulMask; DEVINST CD_dnDevInst; RES_DES CD_rdResDes; ULONG CD_ulFlags; CHAR CD_szDescription[MAX_PATH]; } + // CONFLICT_DETAILS_A, *PCONFLICT_DETAILS_A; + [PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32._CONFLICT_DETAILS_A")] + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] + public struct CONFLICT_DETAILS + { + /// Size, in bytes, of the CONFLICT_DETAILS structure. + public uint CD_ulSize; + + /// + /// + /// One or more bit flags supplied by the caller of CM_Get_Resource_Conflict_Details. The bit flags are described in the + /// following table. + /// + /// + /// + /// Flag + /// Description + /// + /// + /// CM_CDMASK_DEVINST + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_dnDevInst member. + /// + /// + /// CM_CDMASK_RESDES + /// Not used. + /// + /// + /// CM_CDMASK_FLAGS + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_ulFlags member. + /// + /// + /// CM_CDMASK_DESCRIPTION + /// If set, CM_Get_Resource_Conflict_Details supplies a value for the CD_szDescription member. + /// + /// + /// + public CM_CDMASK CD_ulMask; + + /// + /// If CM_CDMASK_DEVINST is set in CD_ulMask, this member will receive a handle to a device instance that has conflicting + /// resources. If a handle is not obtainable, the member receives -1. + /// + public uint CD_dnDevInst; + + /// Not used. + public RES_DES CD_rdResDes; + + /// + /// If CM_CDMASK_FLAGS is set in CD_ulMask, this member can receive bit flags listed in the following table. + /// + /// + /// Flag + /// Description + /// + /// + /// CM_CDFLAGS_DRIVER + /// + /// If set, the string contained in the CD_szDescription member represents a driver name instead of a device name, and + /// CD_dnDevInst is -1. + /// + /// + /// + /// CM_CDFLAGS_ROOT_OWNED + /// If set, the conflicting resources are owned by the root device (that is, the HAL), and CD_dnDevInst is -1. + /// + /// + /// CM_CDFLAGS_RESERVED + /// If set, the owner of the conflicting resources cannot be determined, and CD_dnDevInst is -1. + /// + /// + /// + public CM_CDFLAGS CD_ulFlags; + + /// + /// If CM_CDMASK_DESCRIPTION is set in CD_ulMask, this member will receive a NULL-terminated text string representing a + /// description of the device that owns the resources. If CM_CDFLAGS_DRIVER is set in CD_ulFlags, this string represents + /// a driver name. If CM_CDFLAGS_ROOT_OWNED or CM_CDFLAGS_RESERVED is set, the string value is NULL. + /// + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260 /*MAX_PATH*/)] + public string CD_szDescription; + + /// Gets a default value for the structure with the size field set. + public static readonly CONFLICT_DETAILS Default = new() { CD_ulSize = (uint)Marshal.SizeOf(typeof(CONFLICT_DETAILS)) }; + } + } +} \ No newline at end of file diff --git a/PInvoke/CfgMgr32/CfgMgr32_3.cs b/PInvoke/CfgMgr32/CfgMgr32_3.cs new file mode 100644 index 00000000..9208c23e --- /dev/null +++ b/PInvoke/CfgMgr32/CfgMgr32_3.cs @@ -0,0 +1,87 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using static Vanara.PInvoke.SetupAPI; + +namespace Vanara.PInvoke +{ + /// Items from the CfgMgr32.dll + public static partial class CfgMgr32 + { + /* + CM_Get_Sibling + CM_Get_Sibling_Ex + CM_Get_Version + CM_Get_Version_Ex + CM_Is_Dock_Station_Present + CM_Is_Dock_Station_Present_Ex + CM_Is_Version_Available + CM_Is_Version_Available_Ex + CM_Locate_DevNode_ExW + CM_Locate_DevNodeA + CM_Locate_DevNodeW + CM_MapCrToWin32Err + CM_Modify_Res_Des + CM_Modify_Res_Des_Ex + CM_Open_Class_KeyW + CM_Open_Device_Interface_Key_ExA + CM_Open_Device_Interface_Key_ExW + CM_Open_Device_Interface_KeyA + CM_Open_Device_Interface_KeyW + CM_Open_DevNode_Key + CM_Query_And_Remove_SubTree_ExW + CM_Query_And_Remove_SubTreeW + CM_Query_Resource_Conflict_List + CM_Reenumerate_DevNode + CM_Reenumerate_DevNode_Ex + CM_Register_Notification + CM_Request_Device_Eject_ExW + CM_Request_Device_EjectW + CM_Request_Eject_PC + CM_Request_Eject_PC_Ex + CM_Set_Class_Property_ExW + CM_Set_Class_PropertyW + CM_Set_Class_Registry_PropertyW + CM_Set_Device_Interface_Property_ExW + CM_Set_Device_Interface_PropertyW + CM_Set_DevNode_Problem + CM_Set_DevNode_Problem_Ex + CM_Set_DevNode_Property_ExW + CM_Set_DevNode_PropertyW + CM_Set_DevNode_Registry_PropertyW + CM_Setup_DevNode + CM_Uninstall_DevNode + CM_Unregister_Notification + CM_WaitNoPendingInstallEvents + + BUSNUMBER_DES + BUSNUMBER_RANGE + BUSNUMBER_RESOURCE + CM_NOTIFY_EVENT_DATA + CM_NOTIFY_FILTER + CS_DES + CS_RESOURCE + DMA_DES + DMA_RANGE + DMA_RESOURCE + IO_DES + IO_RANGE + IO_RESOURCE + IRQ_DES_32 + IRQ_DES_64 + IRQ_RANGE + IRQ_RESOURCE_32 + IRQ_RESOURCE_64 + MEM_DES + MEM_RANGE + MEM_RESOURCE + MFCARD_DES + MFCARD_RESOURCE + PCCARD_DES + PCCARD_RESOURCE + + CM_NOTIFY_ACTION + + */ + } +} \ No newline at end of file