2021-04-28 16:00:11 -04:00
using System ;
2021-04-28 18:56:02 -04:00
using System.Collections.Generic ;
2021-05-02 23:52:39 -04:00
using System.Linq ;
2021-04-11 23:18:25 -04:00
using System.Runtime.InteropServices ;
using System.Text ;
2021-05-02 23:52:39 -04:00
using Vanara.Extensions ;
using Vanara.InteropServices ;
2021-04-28 18:56:02 -04:00
using static Vanara . PInvoke . SetupAPI ;
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
namespace Vanara.PInvoke ;
/// <summary>
/// Items from the CfgMgr32.dll
/// </summary>
public static partial class CfgMgr32
2021-04-11 23:18:25 -04:00
{
2023-03-31 11:47:53 -04:00
// Win95 compatibility--not applicable to 32-bit ConfigMgr Win95 compatibility--not applicable to 32-bit ConfigMgr Win95
// compatibility--not applicable to 32-bit ConfigMgr
private const string Lib_Cfgmgr32 = "cfgmgr32.dll" ;
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
public const int CONFIGMG_VERSION = 0x0400 ;
public const int MAX_CLASS_NAME_LEN = 32 ;
public const int MAX_CONFIG_VALUE = 9999 ;
public const int MAX_DEVICE_ID_LEN = 200 ;
public const int MAX_DEVNODE_ID_LEN = MAX_DEVICE_ID_LEN ;
public const int MAX_DMA_CHANNELS = 7 ;
public const int MAX_GUID_STRING_LEN = 39 ; // 38 chars + terminator null
public const int MAX_INSTANCE_VALUE = 9999 ;
public const int MAX_IO_PORTS = 20 ;
public const int MAX_IRQS = 7 ;
public const int MAX_MEM_REGISTERS = 9 ;
public const int MAX_PROFILE_LEN = 80 ;
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
/// <summary>Caller-supplied flag constant that specifies the list onto which the supplied device ID should be appended.</summary>
[PInvokeData("cfgmgr32.h")]
public enum CM_ADD_ID
{
/// <summary></summary>
CM_ADD_ID_HARDWARE = 0x00000000 ,
/// <summary></summary>
CM_ADD_ID_COMPATIBLE = 0x00000001 ,
}
/// <summary>Class property flags</summary>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Class_Property_ExW")]
public enum CM_CLASS_PROPERTY
{
/// <summary>ClassGUID specifies a device setup class. Do not combine with CM_CLASS_PROPERTY_INTERFACE.</summary>
CM_CLASS_PROPERTY_INSTALLER = 0x00000000 ,
/// <summary>ClassGUID specifies a device interface class. Do not combine with CM_CLASS_PROPERTY_INSTALLER.</summary>
CM_CLASS_PROPERTY_INTERFACE = 0x00000001 ,
}
2021-05-02 23:52:39 -04:00
/// <summary>
2023-03-31 11:47:53 -04:00
/// A value of type ULONG that identifies the property to be retrieved.
2021-05-02 23:52:39 -04:00
/// </summary>
2023-03-31 11:47:53 -04:00
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Class_Registry_PropertyW")]
public enum CM_CRP
2021-04-11 23:18:25 -04:00
{
2023-03-31 11:47:53 -04:00
/// <summary>UpperFilters REG_MULTI_SZ property (RW)</summary>
CM_CRP_UPPERFILTERS = CM_DRP . CM_DRP_UPPERFILTERS ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>LowerFilters REG_MULTI_SZ property (RW)</summary>
CM_CRP_LOWERFILTERS = CM_DRP . CM_DRP_LOWERFILTERS ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Class default security (RW)</summary>
CM_CRP_SECURITY = CM_DRP . CM_DRP_SECURITY ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Class default security (RW)</summary>
CM_CRP_SECURITY_SDS = CM_DRP . CM_DRP_SECURITY_SDS ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Class default Device-type (RW)</summary>
CM_CRP_DEVTYPE = CM_DRP . CM_DRP_DEVTYPE ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Class default (RW)</summary>
CM_CRP_EXCLUSIVE = CM_DRP . CM_DRP_EXCLUSIVE ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Class default (RW)</summary>
CM_CRP_CHARACTERISTICS = CM_DRP . CM_DRP_CHARACTERISTICS ,
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Delete class key flags</summary>
[PInvokeData("cfgmgr32.h")]
public enum CM_DELETE_CLASS
{
/// <summary>Delete the class only if it does not contain any subkeys.</summary>
CM_DELETE_CLASS_ONLY = 0x00000000 ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Delete the class and all of its subkeys.</summary>
CM_DELETE_CLASS_SUBKEYS = 0x00000001 ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Indicates that ClassGuid specifies a device interface class and not a device setup class.</summary>
CM_DELETE_CLASS_INTERFACE = 0x00000002 ,
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Disable flags</summary>
[PInvokeData("cfgmgr32.h")]
[Flags]
public enum CM_DISABLE : uint
{
/// <summary>Ask the driver</summary>
CM_DISABLE_POLITE = 0x00000000 ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Don't ask the driver</summary>
CM_DISABLE_ABSOLUTE = 0x00000001 ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Don't ask the driver, and won't be restarteable</summary>
CM_DISABLE_HARDWARE = 0x00000002 ,
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Do not display any interface to the user if the attempt to disable the device fails.</summary>
CM_DISABLE_UI_NOT_OK = 0x00000004 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Disables the device across reboots.</summary>
CM_DISABLE_PERSIST = 0x00000008 ,
}
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Enumerate flags.</summary>
[Flags]
public enum CM_ENUMERATE_CLASSES : uint
{
/// <summary>Enumerate device setup classes.</summary>
CM_ENUMERATE_CLASSES_INSTALLER = 0x00000000 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Enumerate device interface classes.</summary>
CM_ENUMERATE_CLASSES_INTERFACE = 0x00000001 ,
}
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>One of the following caller-supplied bit flags that specifies search filters.</summary>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_ListA")]
[Flags]
public enum CM_GETIDLIST
{
/// <summary>If this flag is set, pszFilter is ignored, and a list of all devices on the system is returned.</summary>
CM_GETIDLIST_FILTER_NONE = 0x00000000 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// If this flag is set, pszFilter must specify the name of a device enumerator, optionally followed by a device ID. The string
/// format is EnumeratorName\<DeviceID>, such as <c>ROOT</c> or <c>ROOT\*PNP0500</c>.
/// </para>
/// <para>
/// If pszFilter supplies only an enumerator name, the function returns device instance IDs for the instances of each device
/// associated with the enumerator. Enumerator names can be obtained by calling CM_Enumerate_Enumerators.
/// </para>
/// <para>
/// If pszFilter supplies both an enumerator and a device ID, the function returns device instance IDs only for the instances of
/// the specified device that is associated with the enumerator.
/// </para>
/// </summary>
CM_GETIDLIST_FILTER_ENUMERATOR = 0x00000001 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// If this flag is set, pszFilter must specify the name of a Microsoft Windows service (typically a driver). The function
/// returns device instance IDs for the device instances controlled by the specified service.
/// </para>
/// <para>
/// Note that if the device tree does not contain a devnode for the specified service, this function creates one by default. To
/// inhibit this behavior, also set CM_GETIDLIST_DONOTGENERATE.
/// </para>
/// </summary>
CM_GETIDLIST_FILTER_SERVICE = 0x00000002 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// ejection relations of the specified device instance.
/// </summary>
CM_GETIDLIST_FILTER_EJECTRELATIONS = 0x00000004 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// removal relations of the specified device instance.
/// </summary>
CM_GETIDLIST_FILTER_REMOVALRELATIONS = 0x00000008 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// power relations of the specified device instance.
/// </summary>
CM_GETIDLIST_FILTER_POWERRELATIONS = 0x00000010 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// bus relations of the specified device instance.
/// </summary>
CM_GETIDLIST_FILTER_BUSRELATIONS = 0x00000020 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// Used only with CM_GETIDLIST_FILTER_SERVICE. If set, and if the device tree does not contain a devnode for the specified
/// service, this flag prevents the function from creating a devnode for the service.
/// </summary>
CM_GETIDLIST_DONOTGENERATE = 0x10000040 ,
/// <summary>
/// <para>If this flag is set, pszFilter must specify the device instance identifier of a composite device node (devnode).</para>
/// <para>
/// The function returns the device instance identifiers of the devnodes that represent the transport relations of the specified
/// composite devnode.
/// </para>
/// <para>For more information about composite devnodes and transport relations, see the following <c>Remarks</c> section.</para>
/// </summary>
CM_GETIDLIST_FILTER_TRANSPORTRELATIONS = 0x00000080 ,
/// <summary>
/// If this flag is set, the returned list contains only device instances that are currently present on the system. This value
/// can be combined with other ulFlags values, such as CM_GETIDLIST_FILTER_CLASS.
/// </summary>
CM_GETIDLIST_FILTER_PRESENT = 0x00000100 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If this flag is set, pszFilter contains a string that specifies a device setup class GUID. The returned list contains device
/// instances for which the property (referenced by the CM_DRP_CLASSGUID constant) matches the specified device setup class GUID.
/// </summary>
CM_GETIDLIST_FILTER_CLASS = 0x00000200 ,
}
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Delete device node key flags. Indicates the scope and type of registry storage key to delete.</summary>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Delete_DevNode_Key")]
[Flags]
public enum CM_REGISTRY
{
/// <summary>Delete the device<63> s hardware key. Do not combine with CM_REGISTRY_SOFTWARE.</summary>
CM_REGISTRY_HARDWARE = 0x00000000 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Delete the device<63> s software key. Do not combine with CM_REGISTRY_HARDWARE.</summary>
CM_REGISTRY_SOFTWARE = 0x00000001 ,
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Delete the per-user key for the current user. Do not combine with CM_REGISTRY_CONFIG.</summary>
CM_REGISTRY_USER = 0x00000100 ,
/// <summary>Delete the key that stores hardware profile-specific configuration information. Do not combine with CM_REGISTRY_USER.</summary>
CM_REGISTRY_CONFIG = 0x00000200 ,
}
/// <summary>One of the CR_-prefixed error codes defined in Cfgmgr32.h.</summary>
[PInvokeData("cfgmgr32.h")]
public enum CONFIGRET : uint
{
2021-04-11 23:18:25 -04:00
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
2023-03-31 11:47:53 -04:00
CR_SUCCESS = 0x00000000 ,
CR_DEFAULT = 0x00000001 ,
CR_OUT_OF_MEMORY = 0x00000002 ,
CR_INVALID_POINTER = 0x00000003 ,
CR_INVALID_FLAG = 0x00000004 ,
CR_INVALID_DEVNODE = 0x00000005 ,
CR_INVALID_DEVINST = CR_INVALID_DEVNODE ,
CR_INVALID_RES_DES = 0x00000006 ,
CR_INVALID_LOG_CONF = 0x00000007 ,
CR_INVALID_ARBITRATOR = 0x00000008 ,
CR_INVALID_NODELIST = 0x00000009 ,
CR_DEVNODE_HAS_REQS = 0x0000000A ,
CR_DEVINST_HAS_REQS = CR_DEVNODE_HAS_REQS ,
CR_INVALID_RESOURCEID = 0x0000000B ,
CR_DLVXD_NOT_FOUND = 0x0000000C , // WIN 95 ONLY
CR_NO_SUCH_DEVNODE = 0x0000000D ,
CR_NO_SUCH_DEVINST = CR_NO_SUCH_DEVNODE ,
CR_NO_MORE_LOG_CONF = 0x0000000E ,
CR_NO_MORE_RES_DES = 0x0000000F ,
CR_ALREADY_SUCH_DEVNODE = 0x00000010 ,
CR_ALREADY_SUCH_DEVINST = CR_ALREADY_SUCH_DEVNODE ,
CR_INVALID_RANGE_LIST = 0x00000011 ,
CR_INVALID_RANGE = 0x00000012 ,
CR_FAILURE = 0x00000013 ,
CR_NO_SUCH_LOGICAL_DEV = 0x00000014 ,
CR_CREATE_BLOCKED = 0x00000015 ,
CR_NOT_SYSTEM_VM = 0x00000016 , // WIN 95 ONLY
CR_REMOVE_VETOED = 0x00000017 ,
CR_APM_VETOED = 0x00000018 ,
CR_INVALID_LOAD_TYPE = 0x00000019 ,
CR_BUFFER_SMALL = 0x0000001A ,
CR_NO_ARBITRATOR = 0x0000001B ,
CR_NO_REGISTRY_HANDLE = 0x0000001C ,
CR_REGISTRY_ERROR = 0x0000001D ,
CR_INVALID_DEVICE_ID = 0x0000001E ,
CR_INVALID_DATA = 0x0000001F ,
CR_INVALID_API = 0x00000020 ,
CR_DEVLOADER_NOT_READY = 0x00000021 ,
CR_NEED_RESTART = 0x00000022 ,
CR_NO_MORE_HW_PROFILES = 0x00000023 ,
CR_DEVICE_NOT_THERE = 0x00000024 ,
CR_NO_SUCH_VALUE = 0x00000025 ,
CR_WRONG_TYPE = 0x00000026 ,
CR_INVALID_PRIORITY = 0x00000027 ,
CR_NOT_DISABLEABLE = 0x00000028 ,
CR_FREE_RESOURCES = 0x00000029 ,
CR_QUERY_VETOED = 0x0000002A ,
CR_CANT_SHARE_IRQ = 0x0000002B ,
CR_NO_DEPENDENT = 0x0000002C ,
CR_SAME_RESOURCES = 0x0000002D ,
CR_NO_SUCH_REGISTRY_KEY = 0x0000002E ,
CR_INVALID_MACHINENAME = 0x0000002F , // NT ONLY
CR_REMOTE_COMM_FAILURE = 0x00000030 , // NT ONLY
CR_MACHINE_UNAVAILABLE = 0x00000031 , // NT ONLY
CR_NO_CM_SERVICES = 0x00000032 , // NT ONLY
CR_ACCESS_DENIED = 0x00000033 , // NT ONLY
CR_CALL_NOT_IMPLEMENTED = 0x00000034 ,
CR_INVALID_PROPERTY = 0x00000035 ,
CR_DEVICE_INTERFACE_ACTIVE = 0x00000036 ,
CR_NO_SUCH_DEVICE_INTERFACE = 0x00000037 ,
CR_INVALID_REFERENCE_STRING = 0x00000038 ,
CR_INVALID_CONFLICT_LIST = 0x00000039 ,
CR_INVALID_INDEX = 0x0000003A ,
CR_INVALID_STRUCTURE_SIZE = 0x0000003B ,
2021-04-11 23:18:25 -04:00
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
2023-03-31 11:47:53 -04:00
}
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Caller-supplied flags that specify the type of the logical configuration.</summary>
[PInvokeData("cfgmgr32.h")]
public enum LOG_CONF_FLAG
{
/// <summary>Specifies the req list.</summary>
BASIC_LOG_CONF = 0x00000000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Specifies the filtered req list.</summary>
FILTERED_LOG_CONF = 0x00000001 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Specifies the Alloc Element.</summary>
ALLOC_LOG_CONF = 0x00000002 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Specifies the RM Alloc Element.</summary>
BOOT_LOG_CONF = 0x00000003 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Specifies the Forced Log Conf</summary>
FORCED_LOG_CONF = 0x00000004 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Specifies the Override req list.</summary>
OVERRIDE_LOG_CONF = 0x00000005 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Number of Log Conf type</summary>
NUM_LOG_CONF = 0x00000006 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The bits of the log conf type.</summary>
LOG_CONF_BITS = 0x00000007 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Same priority, new one first</summary>
PRIORITY_EQUAL_FIRST = 0x00000008 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Same priority, new one last</summary>
PRIORITY_EQUAL_LAST = 0x00000000 ,
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// If the PnP manager rejects a request to perform an operation, the PNP_VETO_TYPE enumeration is used to identify the reason for
/// the rejection.
/// </summary>
/// <remarks>
/// <para>
/// Text strings are associated with most of the veto types, and a function that receives a veto type value can typically request to
/// also receive the value's associated text string. The following table identifies the text string associated with each value.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>pVeto type value</term>
/// <term>Text String</term>
/// </listheader>
/// <item>
/// <term>PNP_VetoTypeUnknown</term>
/// <term>None.</term>
/// </item>
/// <item>
/// <term>PNP_VetoLegacyDevice</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoPendingClose</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoWindowsApp</term>
/// <term>An application module name.</term>
/// </item>
/// <item>
/// <term>PNP_VetoWindowsService</term>
/// <term>A Windows service name.</term>
/// </item>
/// <item>
/// <term>PNP_VetoOutstandingOpen</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoDevice</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoDriver</term>
/// <term>A driver name.</term>
/// </item>
/// <item>
/// <term>PNP_VetoIllegalDeviceRequest</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoInsufficientPower</term>
/// <term>None.</term>
/// </item>
/// <item>
/// <term>PNP_VetoNonDisableable</term>
/// <term>A device instance path.</term>
/// </item>
/// <item>
/// <term>PNP_VetoLegacyDriver</term>
/// <term>A Windows service name.</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfg/ne-cfg-pnp_veto_type typedef enum _PNP_VETO_TYPE { PNP_VetoTypeUnknown,
// PNP_VetoLegacyDevice, PNP_VetoPendingClose, PNP_VetoWindowsApp, PNP_VetoWindowsService, PNP_VetoOutstandingOpen, PNP_VetoDevice,
// PNP_VetoDriver, PNP_VetoIllegalDeviceRequest, PNP_VetoInsufficientPower, PNP_VetoNonDisableable, PNP_VetoLegacyDriver,
// PNP_VetoInsufficientRights, PNP_VetoAlreadyRemoved } PNP_VETO_TYPE, *PPNP_VETO_TYPE;
[PInvokeData("cfg.h", MSDNShortId = "NE:cfg._PNP_VETO_TYPE")]
public enum PNP_VETO_TYPE
{
/// <summary>The specified operation was rejected for an unknown reason.</summary>
PNP_VetoTypeUnknown ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The device does not support the specified PnP operation.</summary>
PNP_VetoLegacyDevice ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The specified operation cannot be completed because of a pending close operation.</summary>
PNP_VetoPendingClose ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>A Microsoft Win32 application vetoed the specified operation.</summary>
PNP_VetoWindowsApp ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>A Win32 service vetoed the specified operation.</summary>
PNP_VetoWindowsService ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The requested operation was rejected because of outstanding open handles.</summary>
PNP_VetoOutstandingOpen ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The device supports the specified operation, but the device rejected the operation.</summary>
PNP_VetoDevice ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The driver supports the specified operation, but the driver rejected the operation.</summary>
PNP_VetoDriver ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The device does not support the specified operation.</summary>
PNP_VetoIllegalDeviceRequest ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>There is insufficient power to perform the requested operation.</summary>
PNP_VetoInsufficientPower ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The device cannot be disabled.</summary>
PNP_VetoNonDisableable ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The driver does not support the specified PnP operation.</summary>
PNP_VetoLegacyDriver ,
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>The caller has insufficient privileges to complete the operation.</summary>
PNP_VetoInsufficientRights ,
}
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Caller-supplied configuration priority value.</summary>
[PInvokeData("cfg.h")]
public enum PRIORITY
{
/// <summary>Coming from a forced config</summary>
LCPRI_FORCECONFIG = 0x00000000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Coming from a boot config</summary>
LCPRI_BOOTCONFIG = 0x00000001 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Preferable (better performance)</summary>
LCPRI_DESIRED = 0x00002000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Workable (acceptable performance)</summary>
LCPRI_NORMAL = 0x00003000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>CM only--do not use</summary>
LCPRI_LASTBESTCONFIG = 0x00003FFF ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Not desired, but will work</summary>
LCPRI_SUBOPTIMAL = 0x00005000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>CM only--do not use</summary>
LCPRI_LASTSOFTCONFIG = 0x00007FFF ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Need to restart</summary>
LCPRI_RESTART = 0x00008000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Need to reboot</summary>
LCPRI_REBOOT = 0x00009000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Need to shutdown/power-off</summary>
LCPRI_POWEROFF = 0x0000A000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Need to change a jumper</summary>
LCPRI_HARDRECONFIG = 0x0000C000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Cannot be changed</summary>
LCPRI_HARDWIRED = 0x0000E000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Impossible configuration</summary>
LCPRI_IMPOSSIBLE = 0x0000F000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Disabled configuration</summary>
LCPRI_DISABLED = 0x0000FFFF ,
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Caller-supplied resource type identifier, which identifies the type of structure supplied by ResourceData.</summary>
[PInvokeData("cfgmgr32.h")]
public enum RESOURCEID
{
/// <summary>Return all resource types</summary>
ResType_All = 0x00000000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Arbitration always succeeded</summary>
ResType_None = 0x00000000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Physical address resource</summary>
[CorrespondingType(typeof(MEM_RESOURCE))]
ResType_Mem = 0x00000001 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Physical I/O address resource</summary>
[CorrespondingType(typeof(IO_RESOURCE))]
ResType_IO = 0x00000002 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>DMA channels resource</summary>
[CorrespondingType(typeof(DMA_RESOURCE))]
ResType_DMA = 0x00000003 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>IRQ resource</summary>
[CorrespondingType(typeof(IRQ_RESOURCE_32))]
[CorrespondingType(typeof(IRQ_RESOURCE_64))]
ResType_IRQ = 0x00000004 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Used as spacer to sync subsequent ResTypes w/NT</summary>
ResType_DoNotUse = 0x00000005 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>bus number resource</summary>
[CorrespondingType(typeof(BUSNUMBER_RESOURCE))]
ResType_BusNumber = 0x00000006 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Memory resources >= 4GB</summary>
ResType_MemLarge = 0x00000007 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Maximum known (arbitrated) ResType</summary>
ResType_MAX = 0x00000007 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Ignore this resource</summary>
ResType_Ignored_Bit = 0x00008000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>class-specific resource</summary>
[CorrespondingType(typeof(CS_RESOURCE))]
ResType_ClassSpecific = 0x0000FFFF ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>reserved for internal use</summary>
ResType_Reserved = 0x00008000 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>device private data</summary>
//[CorrespondingType(typeof(DEVPRIVATE_RESOURCE))]
ResType_DevicePrivate = 0x00008001 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>PC Card configuration data</summary>
[CorrespondingType(typeof(PCCARD_RESOURCE))]
ResType_PcCardConfig = 0x00008002 ,
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>MF Card configuration data</summary>
[CorrespondingType(typeof(MFCARD_RESOURCE))]
ResType_MfCardConfig = 0x00008003 ,
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Add_Empty_Log_Conf</c> function creates an empty logical configuration, for a specified configuration type and a
/// specified device instance, on the local machine.
/// </summary>
/// <param name="plcLogConf">Address of a location to receive the handle to an empty logical configuration.</param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
/// <param name="Priority">
/// <para>
/// Caller-supplied configuration priority value. This must be one of the constant values listed in the following table. The
/// constants are listed in order of priority, from highest to lowest. (For multiple configurations with the same ulFlags value, the
/// system will attempt to use the one with the highest priority first.)
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Priority Constant</term>
/// <term>Definition</term>
/// </listheader>
/// <item>
/// <term>LCPRI_FORCECONFIG</term>
/// <term>Result of a forced configuration.</term>
/// </item>
/// <item>
/// <term>LCPRI_BOOTCONFIG</term>
/// <term>Result of a boot configuration.</term>
/// </item>
/// <item>
/// <term>LCPRI_DESIRED</term>
/// <term>Preferred configuration (better performance).</term>
/// </item>
/// <item>
/// <term>LCPRI_NORMAL</term>
/// <term>Workable configuration (acceptable performance).</term>
/// </item>
/// <item>
/// <term>LCPRI_LASTBESTCONFIG</term>
/// <term>For internal use only.</term>
/// </item>
/// <item>
/// <term>LCPRI_SUBOPTIMAL</term>
/// <term>Not a desirable configuration, but it will work.</term>
/// </item>
/// <item>
/// <term>LCPRI_LASTSOFTCONFIG</term>
/// <term>For internal use only.</term>
/// </item>
/// <item>
/// <term>LCPRI_RESTART</term>
/// <term>The system must be restarted</term>
/// </item>
/// <item>
/// <term>LCPRI_REBOOT</term>
/// <term>The system must be restarted (same as LCPRI_RESTART).</term>
/// </item>
/// <item>
/// <term>LCPRI_POWEROFF</term>
/// <term>The system must be shut down and powered off.</term>
/// </item>
/// <item>
/// <term>LCPRI_HARDRECONFIG</term>
/// <term>A jumper must be changed.</term>
/// </item>
/// <item>
/// <term>LCPRI_HARDWIRED</term>
/// <term>The configuration cannot be changed.</term>
/// </item>
/// <item>
/// <term>LCPRI_IMPOSSIBLE</term>
/// <term>The configuration cannot exist.</term>
/// </item>
/// <item>
/// <term>LCPRI_DISABLED</term>
/// <term>Disabled configuration.</term>
/// </item>
/// </list>
/// </param>
/// <param name="ulFlags">
/// <para>Caller-supplied flags that specify the type of the logical configuration. One of the following flags must be specified.</para>
/// <list type="table">
/// <listheader>
/// <term>Configuration Type Flags</term>
/// <term>Definitions</term>
/// </listheader>
/// <item>
/// <term>BASIC_LOG_CONF</term>
/// <term>Resource descriptors added to this configuration will describe a basic configuration.</term>
/// </item>
/// <item>
/// <term>FILTERED_LOG_CONF</term>
/// <term>Do not use. (Only the PnP manager can create a filtered configuration.)</term>
/// </item>
/// <item>
/// <term>ALLOC_LOG_CONF</term>
/// <term>Do not use. (Only the PnP manager can create an allocated configuration.)</term>
/// </item>
/// <item>
/// <term>BOOT_LOG_CONF</term>
/// <term>Resource descriptors added to this configuration will describe a boot configuration.</term>
/// </item>
/// <item>
/// <term>FORCED_LOG_CONF</term>
/// <term>Resource descriptors added to this configuration will describe a forced configuration.</term>
/// </item>
/// <item>
/// <term>OVERRIDE_LOG_CONF</term>
/// <term>Resource descriptors added to this configuration will describe an override configuration.</term>
/// </item>
/// </list>
/// <para>One of the following bit flags can be ORed with the configuration type flag.</para>
/// <list type="table">
/// <listheader>
/// <term>Priority Comparison Flags</term>
/// <term>Definitions</term>
/// </listheader>
/// <item>
/// <term>PRIORITY_EQUAL_FIRST</term>
/// <term>
/// If multiple configurations of the same type (ulFlags) have the same priority (Priority), this configuration is placed at the
/// head of the list.
/// </term>
/// </item>
/// <item>
/// <term>PRIORITY_EQUAL_LAST</term>
/// <term>
/// (Default) If multiple configurations of the same type (ulFlags) have the same priority (Priority), this configuration is placed
/// at the tail of the list.
/// </term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Add_Empty_Log_Conf</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Calling <c>CM_Add_Empty_Log_Conf</c> can cause the handles returned by CM_Get_First_Log_Conf and CM_Get_Next_Log_Conf to become
/// invalid. Thus if you want to obtain logical configurations after calling <c>CM_Add_Empty_Log_Conf</c>, your code must call
/// <c>CM_Get_First_Log_Conf</c> again and start at the first configuration.
/// </para>
/// <para>To remove a logical configuration created by <c>CM_Add_Empty_Log_Conf</c>, call CM_Free_Log_Conf.</para>
/// <para>The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle.</para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>For information about using device instance handles that are bound to the local machine, see CM_Get_Child.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_empty_log_conf CMAPI CONFIGRET
// CM_Add_Empty_Log_Conf( PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_Empty_Log_Conf")]
public static extern CONFIGRET CM_Add_Empty_Log_Conf ( out SafeLOG_CONF plcLogConf , uint dnDevInst , PRIORITY Priority , LOG_CONF_FLAG ulFlags ) ;
2021-04-11 23:18:25 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Add_Empty_Log_Conf instead.]
/// </para>
/// <para>
/// The <c>CM_Add_Empty_Log_Conf_Ex</c> function creates an empty logical configuration, for a specified configuration type and a
/// specified device instance, on either the local or a remote machine.
/// </para>
/// </summary>
/// <param name="plcLogConf">Pointer to a location to receive the handle to an empty logical configuration.</param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
/// <param name="Priority">
/// Caller-supplied configuration priority value. For a list of values, see the Priority description for CM_Add_Empty_Log_Conf.
/// </param>
/// <param name="ulFlags">
/// Caller-supplied flags that specify the type of the logical configuration. For a list of flags, see the description ulFlags
/// description for CM_Add_Empty_Log_Conf.
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Add_Empty_Log_Conf_Ex</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Calling <c>CM_Add_Empty_Log_Conf_Ex</c> can cause the handles returned by CM_Get_First_Log_Conf_Ex and CM_Get_Next_Log_Conf_Ex
/// to become invalid. Thus if you want to obtain logical configurations after calling <c>CM_Add_Empty_Log_Conf_Ex</c>, your code
/// must call <c>CM_Get_First_Log_Conf_Ex</c> again and start at the first configuration.
/// </para>
/// <para>To remove a logical configuration created by <c>CM_Add_Empty_Log_Conf_Ex</c>, call CM_Free_Log_Conf_Ex.</para>
/// <para>The handle received in plcLogConf must be explicitly freed by calling CM_Free_Log_Conf_Handle.</para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_empty_log_conf_ex CMAPI CONFIGRET
// CM_Add_Empty_Log_Conf_Ex( PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_Empty_Log_Conf_Ex")]
public static extern CONFIGRET CM_Add_Empty_Log_Conf_Ex ( out SafeLOG_CONF plcLogConf , uint dnDevInst , PRIORITY Priority , LOG_CONF_FLAG ulFlags , HMACHINE hMachine ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Add_ID</c> function appends a specified device ID (if not already present) to a device instance's hardware ID list or
/// compatible ID list.
/// </summary>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
/// <param name="pszID">Caller-supplied pointer to a NULL-terminated device ID string.</param>
/// <param name="ulFlags">
/// <para>
/// Caller-supplied flag constant that specifies the list onto which the supplied device ID should be appended. The following flag
/// constants are valid.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Flag Constant</term>
/// <term>Definition</term>
/// </listheader>
/// <item>
/// <term>CM_ADD_ID_COMPATIBLE</term>
/// <term>The specified device ID should be appended to the specific device instance's compatible ID list.</term>
/// </item>
/// <item>
/// <term>CM_ADD_ID_HARDWARE</term>
/// <term>The specified device ID should be appended to the specific device instance's hardware ID list.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// The <c>CM_Add_ID</c> function can only be used when dnDevInst represents a root-enumerated device. For other devices, the bus
/// driver reports hardware and compatible IDs when enumerating a child device after receiving IRP_MN_QUERY_ID.
/// </para>
/// <para>
/// Each appended device ID is considered less compatible than IDs already existing in the specified list. For information about
/// device IDs, hardware IDs, and compatible IDs, see Device Identification Strings.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>For information about using device instance handles that are bound to the local machine, see CM_Get_Child.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_idw CMAPI CONFIGRET CM_Add_IDW( DEVINST dnDevInst,
// PWSTR pszID, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_IDW")]
public static extern CONFIGRET CM_Add_ID ( uint dnDevInst , string pszID , CM_ADD_ID ulFlags ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Add_ID instead.]</para>
/// <para>
/// The <c>CM_Add_ID_Ex</c> function appends a device ID (if not already present) to a device instance's hardware ID list or
/// compatible ID list, on either the local or a remote machine.
/// </para>
/// </summary>
/// <param name="dnDevInst">
/// <para>Caller-supplied device instance handle that is bound to the machine handle supplied by</para>
/// <para>hMachine</para>
/// <para>.</para>
/// </param>
/// <param name="pszID">Caller-supplied pointer to a NULL-terminated device ID string.</param>
/// <param name="ulFlags">
/// <para>
/// Caller-supplied flag constant that specifies the list onto which the supplied device ID should be appended. The following flag
/// constants are valid.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Flag Constant</term>
/// <term>Definition</term>
/// </listheader>
/// <item>
/// <term>CM_ADD_ID_COMPATIBLE</term>
/// <term>The specified device ID should be appended to the specific device instance's compatible ID list.</term>
/// </item>
/// <item>
/// <term>CM_ADD_ID_HARDWARE</term>
/// <term>The specified device ID should be appended to the specific device instance's hardware ID list.</term>
/// </item>
/// </list>
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// Each appended device ID is considered less compatible than IDs already existing in the specified list. For information about
/// device IDs, hardware IDs, and compatible IDs, see Device Identification Strings.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_id_exw CMAPI CONFIGRET CM_Add_ID_ExW( DEVINST
// dnDevInst, PWSTR pszID, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_ID_ExW")]
public static extern CONFIGRET CM_Add_ID_Ex ( uint dnDevInst , string pszID , CM_ADD_ID ulFlags , HMACHINE hMachine ) ;
/// <summary>The <c>CM_Add_Res_Des</c> function adds a resource descriptor to a logical configuration.</summary>
/// <param name="prdResDes">Pointer to a location to receive a handle to the new resource descriptor.</param>
/// <param name="lcLogConf">
/// <para>
/// Caller-supplied handle to the logical configuration to which the resource descriptor should be added. This handle must have been
/// previously obtained by calling one of the following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <param name="ResourceID">
/// Caller-supplied resource type identifier, which identifies the type of structure supplied by ResourceData. This must be one of
/// the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
/// </param>
/// <param name="ResourceData">
/// <para>Caller-supplied pointer to one of the resource structures listed in the following table.</para>
/// <list type="table">
/// <listheader>
/// <term>ResourceID Parameter</term>
/// <term>Resource Structure</term>
/// </listheader>
/// <item>
/// <term>ResType_BusNumber</term>
/// <term>BUSNUMBER_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_ClassSpecific</term>
/// <term>CS_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_DevicePrivate</term>
/// <term>DEVPRIVATE_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_DMA</term>
/// <term>DMA_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_IO</term>
/// <term>IO_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_IRQ</term>
/// <term>IRQ_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_Mem</term>
/// <term>MEM_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_MfCardConfig</term>
/// <term>MFCARD_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_PcCardConfig</term>
/// <term>PCCARD_RESOURCE</term>
/// </item>
/// </list>
/// </param>
/// <param name="ResourceLen">Caller-supplied length of the structure pointed to by ResourceData.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Add_Res_Des</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Callers of <c>CM_Add_Res_Des</c> must call CM_Free_Res_Des_Handle to deallocate the resource descriptor handle, after it is no
/// longer needed.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_res_des CMAPI CONFIGRET CM_Add_Res_Des( PRES_DES
// prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_Res_Des")]
public static extern CONFIGRET CM_Add_Res_Des ( out SafeRES_DES prdResDes , LOG_CONF lcLogConf , RESOURCEID ResourceID , IntPtr ResourceData , uint ResourceLen , uint ulFlags = 0 ) ;
/// <summary>The <c>CM_Add_Res_Des</c> function adds a resource descriptor to a logical configuration.</summary>
/// <typeparam name="T">The type of the data.</typeparam>
/// <param name="lcLogConf">
/// <para>
/// Caller-supplied handle to the logical configuration to which the resource descriptor should be added. This handle must have been
/// previously obtained by calling one of the following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <param name="data">Caller-supplied resource structure.</param>
/// <param name="ResourceID">
/// Caller-supplied resource type identifier, which identifies the type of structure supplied by ResourceData. If this value is 0,
/// the method will attempt to determine the value using <typeparamref name="T"/>.
/// </param>
/// <returns>
/// <para>Pointer to a location to receive a handle to the new resource descriptor.</para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Add_Res_Des</c> throws 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// </remarks>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_Res_Des")]
public static SafeRES_DES CM_Add_Res_Des < T > ( LOG_CONF lcLogConf , T data , RESOURCEID ResourceID = 0 ) where T : struct
{
if ( ResourceID = = 0 & & ! CorrespondingTypeAttribute . CanSet < T , RESOURCEID > ( out ResourceID ) )
throw new ArgumentException ( "Unable to determine RESOURCEID from type." , nameof ( T ) ) ;
using var mem = new SafeAnysizeStruct < T > ( data ) ;
CM_Add_Res_Des ( out var hRD , lcLogConf , ResourceID , mem , mem . Size ) . ThrowIfFailed ( ) ;
return hRD ;
}
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Add_Res_Des instead.]</para>
/// <para>
/// The <c>CM_Add_Res_Des_Ex</c> function adds a resource descriptor to a logical configuration. The logical configuration can be on
/// either the local or a remote machine.
/// </para>
/// </summary>
/// <param name="prdResDes">Pointer to a location to receive a handle to the new resource descriptor.</param>
/// <param name="lcLogConf">
/// <para>
/// Caller-supplied handle to the logical configuration to which the resource descriptor should be added. This handle must have been
/// previously obtained by calling one of the following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <param name="ResourceID">
/// Caller-supplied resource type identifier, which identifies the type of structure supplied by ResourceData. This must be one of
/// the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
/// </param>
/// <param name="ResourceData">
/// <para>Caller-supplied pointer to one of the resource structures listed in the following table.</para>
/// <list type="table">
/// <listheader>
/// <term>ResourceID Parameter</term>
/// <term>Resource Structure</term>
/// </listheader>
/// <item>
/// <term>ResType_BusNumber</term>
/// <term>BUSNUMBER_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_ClassSpecific</term>
/// <term>CS_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_DevicePrivate</term>
/// <term>DEVPRIVATE_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_DMA</term>
/// <term>DMA_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_IO</term>
/// <term>IO_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_IRQ</term>
/// <term>IRQ_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_Mem</term>
/// <term>MEM_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_MfCardConfig</term>
/// <term>MFCARD_RESOURCE</term>
/// </item>
/// <item>
/// <term>ResType_PcCardConfig</term>
/// <term>PCCARD_RESOURCE</term>
/// </item>
/// </list>
/// </param>
/// <param name="ResourceLen">Caller-supplied length of the structure pointed to by ResourceData.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine, or <c>NULL</c>.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Add_Res_Des_Ex</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Callers of <c>CM_Add_Res_Des_Ex</c> must call CM_Free_Res_Des_Handle to deallocate the resource descriptor handle, after it is
/// no longer needed.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_add_res_des_ex CMAPI CONFIGRET CM_Add_Res_Des_Ex(
// PRES_DES prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE
// hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Add_Res_Des_Ex")]
public static extern CONFIGRET CM_Add_Res_Des_Ex ( out SafeRES_DES prdResDes , LOG_CONF lcLogConf , RESOURCEID ResourceID , IntPtr ResourceData ,
uint ResourceLen , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>
/// <para>
/// [Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. You cannot access
/// remote machines when running on these versions of Windows.]
/// </para>
/// <para>The <c>CM_Connect_Machine</c> function creates a connection to a remote machine.</para>
/// </summary>
/// <param name="UNCServerName">
/// Caller-supplied pointer to a text string representing the UNC name, including the <c>\</c> prefix, of the system for which a
/// connection will be made. If the pointer is <c>NULL</c>, the local system is used.
/// </param>
/// <param name="phMachine">
/// <para>Address of a location to receive a machine handle.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// Callers of <c>CM_Connect_Machine</c> must call CM_Disconnect_Machine to deallocate the machine handle, after it is no longer needed.
/// </para>
/// <para>Use machine handles obtained with this function only with the PnP configuration manager functions.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_connect_machinew CMAPI CONFIGRET CM_Connect_MachineW(
// PCWSTR UNCServerName, PHMACHINE phMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Connect_MachineW")]
public static extern CONFIGRET CM_Connect_Machine ( string UNCServerName , out SafeHMACHINE phMachine ) ;
/// <summary>The <c>CM_Delete_Class_Key</c> function removes the specified installed device class from the system.</summary>
/// <param name="ClassGuid">Pointer to the GUID of the device class to remove.</param>
/// <param name="ulFlags">
/// <para>Delete class key flags:</para>
/// <para>CM_DELETE_CLASS_ONLY</para>
/// <para>Delete the class only if it does not contain any subkeys.</para>
/// <para>CM_DELETE_CLASS_SUBKEYS</para>
/// <para>Delete the class and all of its subkeys.</para>
/// <para>CM_DELETE_CLASS_INTERFACE (available only in Windows Vista and later)</para>
/// <para>Indicates that ClassGuid specifies a device interface class and not a device setup class.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_delete_class_key CMAPI CONFIGRET CM_Delete_Class_Key(
// LPGUID ClassGuid, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Delete_Class_Key")]
public static extern CONFIGRET CM_Delete_Class_Key ( in Guid ClassGuid , CM_DELETE_CLASS ulFlags ) ;
/// <summary>
/// The <c>CM_Delete_Device_Interface_Key</c> function deletes the registry subkey that is used by applications and drivers to store
/// interface-specific information.
/// </summary>
/// <param name="pszDeviceInterface">
/// Pointer to a string that identifies the device interface instance of the registry subkey to delete.
/// </param>
/// <param name="ulFlags">Reserved. Must be set to zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_delete_device_interface_keyw CMAPI CONFIGRET
// CM_Delete_Device_Interface_KeyW( LPCWSTR pszDeviceInterface, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Delete_Device_Interface_KeyW")]
public static extern CONFIGRET CM_Delete_Device_Interface_Key ( string pszDeviceInterface , uint ulFlags = 0 ) ;
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Delete_Device_Interface_Key instead.]
/// </para>
/// <para>
/// The <c>CM_Delete_Device_Interface_Key_ExW</c> function deletes the registry subkey that is used by applications and drivers to
/// store interface-specific information.
/// </para>
/// </summary>
/// <param name="pszDeviceInterface">
/// Pointer to a string that identifies the device interface instance of the registry subkey to delete.
/// </param>
/// <param name="ulFlags">Reserved. Must be set to zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>Note</para>
/// <para>
/// The cfgmgr32.h header defines CM_Delete_Device_Interface_Key_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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_delete_device_interface_key_exw CMAPI CONFIGRET
// CM_Delete_Device_Interface_Key_ExW( LPCWSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Delete_Device_Interface_Key_ExW")]
public static extern CONFIGRET CM_Delete_Device_Interface_Key_Ex ( string pszDeviceInterface , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>
/// The <c>CM_Delete_DevNode_Key</c> function deletes the specified user-accessible registry keys that are associated with a device.
/// </summary>
/// <param name="dnDevNode">Device instance handle that is bound to the local machine.</param>
/// <param name="ulHardwareProfile">
/// The hardware profile to delete if ulFlags includes CM_REGISTRY_CONFIG. If this value is zero, the key for the current hardware
/// profile is deleted. If this value is 0xFFFFFFFF, the registry keys for all hardware profiles are deleted.
/// </param>
/// <param name="ulFlags">
/// <para>
/// Delete device node key flags. Indicates the scope and type of registry storage key to delete. Can be a combination of the
/// following flags:
/// </para>
/// <para>CM_REGISTRY_HARDWARE</para>
/// <para>Delete the device<63> s hardware key. Do not combine with CM_REGISTRY_SOFTWARE.</para>
/// <para>CM_REGISTRY_SOFTWARE</para>
/// <para>Delete the device<63> s software key. Do not combine with CM_REGISTRY_HARDWARE.</para>
/// <para>CM_REGISTRY_USER</para>
/// <para>Delete the per-user key for the current user. Do not combine with CM_REGISTRY_CONFIG.</para>
/// <para>CM_REGISTRY_CONFIG</para>
/// <para>Delete the key that stores hardware profile-specific configuration information. Do not combine with CM_REGISTRY_USER.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_delete_devnode_key CMAPI CONFIGRET
// CM_Delete_DevNode_Key( DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Delete_DevNode_Key")]
public static extern CONFIGRET CM_Delete_DevNode_Key ( uint dnDevNode , uint ulHardwareProfile , CM_REGISTRY ulFlags ) ;
/// <summary>The <c>CM_Disable_DevNode</c> function disables a device.</summary>
/// <param name="dnDevInst">Device instance handle that is bound to the local machine.</param>
/// <param name="ulFlags">
/// <para>Disable flags:</para>
/// <para>CM_DISABLE_UI_NOT_OK</para>
/// <para>Do not display any interface to the user if the attempt to disable the device fails.</para>
/// <para>CM_DISABLE_PERSIST</para>
/// <para>Disables the device across reboots.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// By default, <c>CM_Disable_DevNode</c> disables a device at one time, but after reboot the device is enabled again. Starting in
/// Windows 10, you can specify the <c>CM_DISABLE_PERSIST</c> flag to disable the device across reboots.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_disable_devnode CMAPI CONFIGRET CM_Disable_DevNode(
// DEVINST dnDevInst, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Disable_DevNode")]
public static extern CONFIGRET CM_Disable_DevNode ( uint dnDevInst , CM_DISABLE ulFlags = 0 ) ;
/// <summary>
/// <para>
/// [Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed. You cannot access
/// remote machines when running on these versions of Windows.]
/// </para>
/// <para>The <c>CM_Disconnect_Machine</c> function removes a connection to a remote machine.</para>
/// </summary>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// 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.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_disconnect_machine CMAPI CONFIGRET
// CM_Disconnect_Machine( HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Disconnect_Machine")]
public static extern CONFIGRET CM_Disconnect_Machine ( HMACHINE hMachine ) ;
/// <summary>The <c>CM_Enable_DevNode</c> function enables a device.</summary>
/// <param name="dnDevInst">Device instance handle that is bound to the local machine.</param>
/// <param name="ulFlags">Reserved. Must be set to zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_enable_devnode CMAPI CONFIGRET CM_Enable_DevNode(
// DEVINST dnDevInst, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enable_DevNode")]
public static extern CONFIGRET CM_Enable_DevNode ( uint dnDevInst , uint ulFlags = 0 ) ;
/// <summary>
/// The <c>CM_Enumerate_Classes</c> function, when called repeatedly, enumerates the local machine's installed device classes by
/// supplying each class's GUID.
/// </summary>
/// <param name="ulClassIndex">
/// Caller-supplied index into the machine's list of device classes. For more information, see the <c>Remarks</c> section.
/// </param>
/// <param name="ClassGuid">
/// Caller-supplied address of a GUID structure (described in the Microsoft Windows SDK) to receive a device class's GUID.
/// </param>
/// <param name="ulFlags">
/// <para>Beginning with Windows 8, callers can specify the following flags:</para>
/// <para>CM_ENUMERATE_CLASSES_INSTALLER</para>
/// <para>Enumerate device setup classes.</para>
/// <para>CM_ENUMERATE_CLASSES_INTERFACE</para>
/// <para>Enumerate device interface classes.</para>
/// <para>Otherwise, should be set to zero.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate the local machine's device classes, call <c>CM_Enumerate_Classes</c> repeatedly, starting with a ulClassIndex value
/// of zero and incrementing the index value with each subsequent call until the function returns CR_NO_SUCH_VALUE. Some index
/// values might represent list entries containing invalid class data, in which case the function returns CR_INVALID_DATA. This
/// return value can be ignored.
/// </para>
/// <para>The class GUIDs obtained from this function can be used as input to the device installation functions.</para>
/// <para>
/// Beginning with Windows 8 and later operating systems, callers can use the <c>ulFlags</c> member to specify which device classes
/// CM_Enumerate_Classes should return. Prior to Windows 8, CM_Enumerate_Classes returned only device setup classes.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_enumerate_classes CMAPI CONFIGRET
// CM_Enumerate_Classes( ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enumerate_Classes")]
public static extern CONFIGRET CM_Enumerate_Classes ( uint ulClassIndex , out Guid ClassGuid , CM_ENUMERATE_CLASSES ulFlags ) ;
/// <summary>
/// The <c>CM_Enumerate_Classes</c> function, when called repeatedly, enumerates the local machine's installed device classes by
/// supplying each class's GUID.
/// </summary>
/// <param name="ulFlags">
/// <para>Beginning with Windows 8, callers can specify the following flags:</para>
/// <para>CM_ENUMERATE_CLASSES_INSTALLER</para>
/// <para>Enumerate device setup classes.</para>
/// <para>CM_ENUMERATE_CLASSES_INTERFACE</para>
/// <para>Enumerate device interface classes.</para>
/// <para>Otherwise, should be set to zero.</para>
/// </param>
/// <returns>A sequence of device class GUIDs.</returns>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enumerate_Classes")]
public static IEnumerable < Guid > CM_Enumerate_Classes ( CM_ENUMERATE_CLASSES ulFlags )
{
var i = 0 U ;
var cr = CM_Enumerate_Classes ( i , out var guid , ulFlags ) ;
while ( cr = = CONFIGRET . CR_SUCCESS | | cr = = CONFIGRET . CR_INVALID_DATA )
2021-05-02 23:52:39 -04:00
{
2023-03-31 11:47:53 -04:00
if ( cr = = CONFIGRET . CR_SUCCESS )
yield return guid ;
cr = CM_Enumerate_Classes ( + + i , out guid , ulFlags ) ;
2021-05-02 23:52:39 -04:00
}
2023-03-31 11:47:53 -04:00
if ( cr ! = CONFIGRET . CR_NO_SUCH_VALUE & & cr ! = CONFIGRET . CR_SUCCESS & & cr ! = CONFIGRET . CR_INVALID_DATA )
throw cr . GetException ( ) ;
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Enumerate_Classes instead.]
/// </para>
/// <para>
/// The <c>CM_Enumerate_Classes_Ex</c> function, when called repeatedly, enumerates a local or a remote machine's installed device
/// classes, by supplying each class's GUID.
/// </para>
/// </summary>
/// <param name="ulClassIndex">
/// Caller-supplied index into the machine's list of device classes. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="ClassGuid">
/// Caller-supplied address of a GUID structure (described in the Microsoft Windows SDK) to receive a device class's GUID.
/// </param>
/// <param name="ulFlags">
/// <para>Beginning with Windows 8, callers can specify the following flags:</para>
/// <para>CM_ENUMERATE_CLASSES_INSTALLER</para>
/// <para>Enumerate device setup classes.</para>
/// <para>CM_ENUMERATE_CLASSES_INTERFACE</para>
/// <para>Enumerate device interface classes.</para>
/// <para>Otherwise, should be set to zero.</para>
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate the local or a remote machine's device classes, call <c>CM_Enumerate_Classes_Ex</c> repeatedly, starting with a
/// ulClassIndex index value of zero and incrementing the index value with each subsequent call until the function returns
/// CR_NO_SUCH_VALUE. Some index values might represent list entries containing invalid class data, in which case the function
/// returns CR_INVALID_DATA. This return value can be ignored.
/// </para>
/// <para>The class GUIDs obtained from this function can be used as input to the device installation functions.</para>
/// <para>
/// Beginning with Windows 8 and later operating systems, callers can use the <c>ulFlags</c> member to specify which device classes
/// CM_Enumerate_Classes_Ex should return. Prior to Windows 8, CM_Enumerate_Classes_Ex returned only device setup classes.
/// </para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_enumerate_classes_ex CMAPI CONFIGRET
// CM_Enumerate_Classes_Ex( ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enumerate_Classes_Ex")]
public static extern CONFIGRET CM_Enumerate_Classes_Ex ( uint ulClassIndex , out Guid ClassGuid , CM_ENUMERATE_CLASSES ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Enumerate_Enumerators</c> function enumerates the local machine's device enumerators by supplying each enumerator's name.
/// </summary>
/// <param name="ulEnumIndex">
/// Caller-supplied index into the machine's list of device enumerators. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="Buffer">
/// Address of a buffer to receive an enumerator name. This buffer should be MAX_DEVICE_ID_LEN-sized (or, set Buffer to zero and
/// obtain the actual name length in the location referenced by puLength).
/// </param>
/// <param name="pulLength">
/// Caller-supplied address of a location to hold the buffer size. The caller supplies the length of the buffer pointed to by
/// Buffer. The function replaces this value with the actual size of the enumerator's name string. If the caller-supplied buffer
/// length is too small, the function supplies the required buffer size and returns CR_BUFFER_SMALL.
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate the local machine's device enumerators, call <c>CM_Enumerate_Enumerators</c> repeatedly, starting with a
/// ulEnumIndex index value of zero. and incrementing the index value with each subsequent call until the function returns CR_NO_SUCH_VALUE.
/// </para>
/// <para>After enumerator names have been obtained, the names can be used as input to CM_Get_Device_ID_List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_enumerate_enumeratorsw CMAPI CONFIGRET
// CM_Enumerate_EnumeratorsW( ULONG ulEnumIndex, PWSTR Buffer, PULONG pulLength, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enumerate_EnumeratorsW")]
public static extern CONFIGRET CM_Enumerate_Enumerators ( uint ulEnumIndex , StringBuilder Buffer , ref int pulLength , uint ulFlags = 0 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Enumerate_Enumerators</c> function enumerates the local machine's device enumerators by supplying each enumerator's name.
/// </summary>
/// <returns>A sequence of enumerator names.</returns>
public static IEnumerable < string > CM_Enumerate_Enumerators ( )
{
var i = 0 U ;
CONFIGRET cr ;
var sbCap = MAX_DEVICE_ID_LEN ;
StringBuilder sb = new ( sbCap ) ;
while ( ( cr = CM_Enumerate_Enumerators ( i , sb , ref sbCap ) ) = = CONFIGRET . CR_SUCCESS )
{
yield return sb . ToString ( ) ;
i + + ;
sbCap = sb . Capacity ;
}
if ( cr ! = CONFIGRET . CR_NO_SUCH_VALUE & & cr ! = CONFIGRET . CR_SUCCESS )
throw cr . GetException ( ) ;
}
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Enumerate_Enumerators instead.]
/// </para>
/// <para>
/// The <c>CM_Enumerate_Enumerators_Ex</c> function enumerates a local or a remote machine's device enumerators, by supplying each
/// enumerator's name.
/// </para>
/// </summary>
/// <param name="ulEnumIndex">
/// Caller-supplied index into the machine's list of device enumerators. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="Buffer">
/// Address of a buffer to receive an enumerator name. This buffer should be MAX_DEVICE_ID_LEN-sized (or, set Buffer to zero and
/// obtain the actual name length in the location referenced by <c>puLength</c>).
/// </param>
/// <param name="pulLength">
/// Caller-supplied address of a location to hold the buffer size. The caller supplies the length of the buffer pointed to by
/// Buffer. The function replaces this value with the actual size of the enumerator's name string. If the caller-supplied buffer
/// length is too small, the function supplies the required buffer size and returns CR_BUFFER_SMALL.
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate the local or a remote machine's device enumerators, call <c>CM_Enumerate_Enumerators_Ex</c> repeatedly, starting
/// with a ulEnumIndex index value of zero, and incrementing the index value with each subsequent call until the function returns CR_NO_SUCH_VALUE.
/// </para>
/// <para>After enumerator names have been obtained, the names can be used as input to CM_Get_Device_ID_List.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_enumerate_enumerators_exw CMAPI CONFIGRET
// CM_Enumerate_Enumerators_ExW( ULONG ulEnumIndex, PWSTR Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Enumerate_Enumerators_ExW")]
public static extern CONFIGRET CM_Enumerate_Enumerators_Ex ( uint ulEnumIndex , StringBuilder Buffer , ref int pulLength , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Free_Log_Conf</c> function removes a logical configuration and all associated resource descriptors from the local machine.
/// </summary>
/// <param name="lcLogConfToBeFreed">
/// <para>
/// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the
/// following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Log_Conf</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Calling <c>CM_Free_Log_Conf</c> can cause the handles returned by CM_Get_First_Log_Conf and CM_Get_Next_Log_Conf to become
/// invalid. Thus if you want to obtain logical configurations after calling <c>CM_Free_Log_Conf</c>, your code must call
/// <c>CM_Get_First_Log_Conf</c> again and start at the first configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Log_Conf</c> frees the configuration, but not the configuration's handle. To free the handle, call <c>CM_Free_Log_Conf_Handle</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_log_conf CMAPI CONFIGRET CM_Free_Log_Conf(
// LOG_CONF lcLogConfToBeFreed, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Log_Conf")]
public static extern CONFIGRET CM_Free_Log_Conf ( [ In ] LOG_CONF lcLogConfToBeFreed , uint ulFlags = 0 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Free_Log_Conf instead.]</para>
/// <para>
/// The <c>CM_Free_Log_Conf_Ex</c> function removes a logical configuration and all associated resource descriptors from either a
/// local or a remote machine.
/// </para>
/// </summary>
/// <param name="lcLogConfToBeFreed">
/// <para>
/// Caller-supplied handle to a logical configuration. This handle must have been previously obtained by calling one of the
/// following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Log_Conf_Ex</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Calling <c>CM_Free_Log_Conf_Ex</c> can cause the handles returned by CM_Get_First_Log_Conf_Ex and CM_Get_Next_Log_Conf_Ex to
/// become invalid. Thus if you want to obtain logical configurations after calling <c>CM_Free_Log_Conf_Ex</c>, your code must call
/// <c>CM_Get_First_Log_Conf_Ex</c> again and start at the first configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Log_Conf_Ex</c> frees the configuration, but not the configuration's handle. To free the handle,
/// call <c>CM_Free_Log_Conf_Handle_Ex</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_log_conf_ex CMAPI CONFIGRET CM_Free_Log_Conf_Ex(
// LOG_CONF lcLogConfToBeFreed, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Log_Conf_Ex")]
public static extern CONFIGRET CM_Free_Log_Conf_Ex ( [ In ] LOG_CONF lcLogConfToBeFreed , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Free_Log_Conf_Handle</c> function invalidates a logical configuration handle and frees its associated memory allocation.
/// </summary>
/// <param name="lcLogConf">
/// <para>
/// Caller-supplied logical configuration handle. This handle must have been previously obtained by calling one of the following functions:
/// </para>
/// <para>CM_Add_Empty_Log_Conf</para>
/// <para>CM_Add_Empty_Log_Conf_Ex</para>
/// <para>CM_Get_First_Log_Conf</para>
/// <para>CM_Get_First_Log_Conf_Ex</para>
/// <para>CM_Get_Next_Log_Conf</para>
/// <para>CM_Get_Next_Log_Conf_Ex</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// Each time your code calls one of the functions listed under the description of lcLogConf, it must subsequently call <c>CM_Free_Log_Conf_Handle</c>.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_log_conf_handle CMAPI CONFIGRET
// CM_Free_Log_Conf_Handle( LOG_CONF lcLogConf );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Log_Conf_Handle")]
public static extern CONFIGRET CM_Free_Log_Conf_Handle ( LOG_CONF lcLogConf ) ;
/// <summary>The <c>CM_Free_Res_Des</c> function removes a resource descriptor from a logical configuration on the local machine.</summary>
/// <param name="prdResDes">
/// Caller-supplied location to receive a handle to the configuration's previous resource descriptor. This parameter can be
/// <c>NULL</c>. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="rdResDes">
/// <para>
/// Caller-supplied handle to the resource descriptor to be removed. This handle must have been previously obtained by calling one
/// of the following functions:
/// </para>
/// <para>CM_Add_Res_Des</para>
/// <para>CM_Add_Res_Des_Ex</para>
/// <para>CM_Get_Next_Res_Des</para>
/// <para>CM_Get_Next_Res_Des_Ex</para>
/// <para>CM_Modify_Res_Des</para>
/// <para>CM_Modify_Res_Des_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Res_Des</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Resource descriptors for each configuration are stored in an array. If you specify an address for prdResDes, then
/// <c>CM_Free_Res_Des</c> returns a handle to the resource descriptor that was previous, in the array, to the one removed. If the
/// handle specified by rdResDes represents the resource descriptor located first in the array, then prdResDes receives a handle to
/// the logical configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Res_Des</c> frees the resource descriptor, but not the descriptor's handle. To free the handle,
/// call <c>CM_Free_Res_Des_Handle</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_res_des CMAPI CONFIGRET CM_Free_Res_Des( PRES_DES
// prdResDes, RES_DES rdResDes, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Res_Des")]
public static extern CONFIGRET CM_Free_Res_Des ( out SafeRES_DES prdResDes , RES_DES rdResDes , uint ulFlags = 0 ) ;
/// <summary>The <c>CM_Free_Res_Des</c> function removes a resource descriptor from a logical configuration on the local machine.</summary>
/// <param name="prdResDes">
/// Caller-supplied location to receive a handle to the configuration's previous resource descriptor. This parameter can be
/// <c>NULL</c>. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="rdResDes">
/// <para>
/// Caller-supplied handle to the resource descriptor to be removed. This handle must have been previously obtained by calling one
/// of the following functions:
/// </para>
/// <para>CM_Add_Res_Des</para>
/// <para>CM_Add_Res_Des_Ex</para>
/// <para>CM_Get_Next_Res_Des</para>
/// <para>CM_Get_Next_Res_Des_Ex</para>
/// <para>CM_Modify_Res_Des</para>
/// <para>CM_Modify_Res_Des_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Res_Des</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Resource descriptors for each configuration are stored in an array. If you specify an address for prdResDes, then
/// <c>CM_Free_Res_Des</c> returns a handle to the resource descriptor that was previous, in the array, to the one removed. If the
/// handle specified by rdResDes represents the resource descriptor located first in the array, then prdResDes receives a handle to
/// the logical configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Res_Des</c> frees the resource descriptor, but not the descriptor's handle. To free the handle,
/// call <c>CM_Free_Res_Des_Handle</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_res_des CMAPI CONFIGRET CM_Free_Res_Des( PRES_DES
// prdResDes, RES_DES rdResDes, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Res_Des")]
public static extern CONFIGRET CM_Free_Res_Des ( [ In , Optional ] IntPtr prdResDes , RES_DES rdResDes , uint ulFlags = 0 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Free_Res_Des instead.]</para>
/// <para>
/// The <c>CM_Free_Res_Des_Ex</c> function removes a resource descriptor from a logical configuration on either a local or a remote machine.
/// </para>
/// </summary>
/// <param name="prdResDes">
/// Caller-supplied location to receive a handle to the configuration's previous resource descriptor. This parameter can be
/// <c>NULL</c>. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="rdResDes">
/// <para>
/// Caller-supplied handle to the resource descriptor to be removed. This handle must have been previously obtained by calling one
/// of the following functions:
/// </para>
/// <para>CM_Add_Res_Des</para>
/// <para>CM_Add_Res_Des_Ex</para>
/// <para>CM_Get_Next_Res_Des</para>
/// <para>CM_Get_Next_Res_Des_Ex</para>
/// <para>CM_Modify_Res_Des</para>
/// <para>CM_Modify_Res_Des_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Res_Des_Ex</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Resource descriptors for each configuration are stored in an array. If you specify an address for prdResDes, then
/// <c>CM_Free_Res_Des</c> returns a handle to the resource descriptor that was previous, in the array, to the one removed. If the
/// handle specified by rdResDes represents the resource descriptor located first in the array, then prdResDes receives a handle to
/// the logical configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Res_Des_Ex</c> frees the resource descriptor, but not the descriptor's handle. To free the handle,
/// call <c>CM_Free_Res_Des_Handle_Ex</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_res_des_ex CMAPI CONFIGRET CM_Free_Res_Des_Ex(
// PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Res_Des_Ex")]
public static extern CONFIGRET CM_Free_Res_Des_Ex ( out SafeRES_DES prdResDes , RES_DES rdResDes , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Free_Res_Des instead.]</para>
/// <para>
/// The <c>CM_Free_Res_Des_Ex</c> function removes a resource descriptor from a logical configuration on either a local or a remote machine.
/// </para>
/// </summary>
/// <param name="prdResDes">
/// Caller-supplied location to receive a handle to the configuration's previous resource descriptor. This parameter can be
/// <c>NULL</c>. For more information, see the following <c>Remarks</c> section.
/// </param>
/// <param name="rdResDes">
/// <para>
/// Caller-supplied handle to the resource descriptor to be removed. This handle must have been previously obtained by calling one
/// of the following functions:
/// </para>
/// <para>CM_Add_Res_Des</para>
/// <para>CM_Add_Res_Des_Ex</para>
/// <para>CM_Get_Next_Res_Des</para>
/// <para>CM_Get_Next_Res_Des_Ex</para>
/// <para>CM_Modify_Res_Des</para>
/// <para>CM_Modify_Res_Des_Ex</para>
/// </param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </para>
/// <para>
/// <c>Note</c> Starting with Windows 8, <c>CM_Free_Res_Des_Ex</c> 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.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// Resource descriptors for each configuration are stored in an array. If you specify an address for prdResDes, then
/// <c>CM_Free_Res_Des</c> returns a handle to the resource descriptor that was previous, in the array, to the one removed. If the
/// handle specified by rdResDes represents the resource descriptor located first in the array, then prdResDes receives a handle to
/// the logical configuration.
/// </para>
/// <para>
/// Note that calling <c>CM_Free_Res_Des_Ex</c> frees the resource descriptor, but not the descriptor's handle. To free the handle,
/// call <c>CM_Free_Res_Des_Handle_Ex</c>.
/// </para>
/// <para>
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
/// </para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_res_des_ex CMAPI CONFIGRET CM_Free_Res_Des_Ex(
// PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Res_Des_Ex")]
public static extern CONFIGRET CM_Free_Res_Des_Ex ( [ In , Optional ] IntPtr prdResDes , RES_DES rdResDes , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Free_Res_Des_Handle</c> function invalidates a resource description handle and frees its associated memory allocation.
/// </summary>
/// <param name="rdResDes">
/// <para>
/// Caller-supplied resource descriptor handle to be freed. This handle must have been previously obtained by calling one of the
/// following functions:
/// </para>
/// <para>CM_Add_Res_Des</para>
/// <para>CM_Add_Res_Des_Ex</para>
/// <para>CM_Get_Next_Res_Des</para>
/// <para>CM_Get_Next_Res_Des_Ex</para>
/// <para>CM_Modify_Res_Des</para>
/// <para>CM_Modify_Res_Des_Ex</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// Each time your code calls one of the functions listed under the description of rdResDes, it must subsequently call <c>CM_Free_Res_Des_Handle</c>.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_res_des_handle CMAPI CONFIGRET
// CM_Free_Res_Des_Handle( RES_DES rdResDes );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Res_Des_Handle")]
public static extern CONFIGRET CM_Free_Res_Des_Handle ( RES_DES rdResDes ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Free_Resource_Conflict_Handle</c> function invalidates a handle to a resource conflict list, and frees the handle's
/// associated memory allocation.
/// </summary>
/// <param name="clConflictList">
/// Caller-supplied handle to be freed. This conflict list handle must have been previously obtained by calling CM_Query_Resource_Conflict_List.
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// An application must call <c>CM_Free_Resource_Conflict_Handle</c> after it has finished using the handle that was obtained
/// calling CM_Query_Resource_Conflict_List.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_free_resource_conflict_handle CMAPI CONFIGRET
// CM_Free_Resource_Conflict_Handle( CONFLICT_LIST clConflictList );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Free_Resource_Conflict_Handle")]
public static extern CONFIGRET CM_Free_Resource_Conflict_Handle ( CONFLICT_LIST clConflictList ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Get_Child</c> function is used to retrieve a device instance handle to the first child node of a specified device node
/// (devnode) in the local machine's device tree.
/// </summary>
/// <param name="pdnDevInst">
/// Caller-supplied pointer to the device instance handle to the child node that this function retrieves. The retrieved handle is
/// bound to the local machine. See the <c>Remarks</c> section.
/// </param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate all children of a devnode in the local machine's device tree, first call <c>CM_Get_Child</c> to obtain a device
/// instance handle to the first child node, then call CM_Get_Sibling to obtain handles for the rest of the children.
/// </para>
/// <para><c>Using Device Instance Handles</c></para>
/// <para>Device instance handle that you use with PnP configuration manager functions are bound to machine handles, as follows:</para>
/// <list type="bullet">
/// <item>
/// <term>All local device instance handles are bound to a NULL-valued local machine handle.</term>
/// </item>
/// <item>
/// <term>
/// If you use a remote machine handle to obtain a device instance handle, the resulting remote device instance handle is bound to
/// the remote machine handle.
/// </term>
/// </item>
/// <item>
/// <term>A device instance handle can be used only with the machine handle to which it is bound.</term>
/// </item>
/// <item>
/// <term>
/// A device instance handle can be used with another device instance handle only if both device instance handles are bound to the
/// same machine handle.
/// </term>
/// </item>
/// </list>
/// <para>To obtain a device instance handle that is bound to the local machine, do one of the following.</para>
/// <list type="bullet">
/// <item>
/// <term>
/// Use one of the following functions that retrieve only local device instance handles: CM_Locate_DevNode, <c>CM_Get_Child</c>,
/// CM_Get_Parent, or CM_Get_Sibling.
/// </term>
/// </item>
/// <item>
/// <term>
/// Use one of the following functions, which retrieves local and remote device instance handles, to retrieve a local device
/// instance handle: CM_Locate_DevNode_Ex, CM_Get_Child_Ex, CM_Get_Parent_Ex, or CM_Get_Sibling_Ex.
/// </term>
/// </item>
/// </list>
/// <para>
/// You can also use the device installation functions to obtain local device instance handles from a device information set that is
/// bound to the local machine. Do the following steps:
/// </para>
/// <list type="number">
/// <item>
/// <term>
/// Obtain a device information set that is bound to the local machine. (A device instance handle obtained from a device information
/// set is bound to the machine handle to which the device information set is bound. You obtain the machine handle for a device
/// information set from the <c>RemoteMachineHandle</c> member of its SP_DEVINFO_LIST_DETAIL_DATA structure. For a local device
/// information set that is bound to the local machine, the value of <c>RemoteMachineHandle</c> is <c>NULL</c>. Call
/// SetupDiGetDeviceInfoListDetail to obtain an SP_DEVINFO_LIST_DETAIL_DATA structure.)
/// </term>
/// </item>
/// <item>
/// <term>Obtain an SP_DEVINFO_DATA structure for a device instance in the device information set.</term>
/// </item>
/// <item>
/// <term>Obtain the device instance handle for the device instance from the <c>DevInst</c> member of the SP_DEVINFO_DATA structure.</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_child CMAPI CONFIGRET CM_Get_Child( PDEVINST
// pdnDevInst, DEVINST dnDevInst, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Child")]
public static extern CONFIGRET CM_Get_Child ( out uint pdnDevInst , uint dnDevInst , uint ulFlags = 0 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Child instead.]</para>
/// <para>
/// The <c>CM_Get_Child_Ex</c> function is used to retrieve a device instance handle to the first child node of a specified device
/// node (devnode) in a local or a remote machine's device tree.
/// </para>
/// </summary>
/// <param name="pdnDevInst">
/// Caller-supplied pointer to the device instance handle to the child node that this function retrieves. The retrieved handle is
/// bound to the machine handle supplied by hMachine. See the <c>Remarks</c> section.
/// </param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// To enumerate all children of a devnode in a local or a remote machine's device tree, first call <c>CM_Get_Child_Ex</c> to obtain
/// a handle to the first child node, then call CM_Get_Sibling_Ex to obtain handles for the rest of the children.
/// </para>
/// <para><c>Using Device Instance Handles</c></para>
/// <para>Device instance handle that you use with PnP configuration manager functions are bound to machine handles, as follows:</para>
/// <list type="bullet">
/// <item>
/// <term>All local device instance handles are bound to a NULL-valued local machine handle.</term>
/// </item>
/// <item>
/// <term>
/// If you use a remote machine handle to obtain a device instance handle, the resulting remote device instance handle is bound to
/// the remote machine handle.
/// </term>
/// </item>
/// <item>
/// <term>A device instance handle can be used only with the machine handle to which it is bound.</term>
/// </item>
/// <item>
/// <term>
/// A device instance handle can be used with another device instance handle only if both device instance handles are bound to the
/// same machine handle.
/// </term>
/// </item>
/// </list>
/// <para>Use CM_Connect_Machine to obtain a remote machine handle for use with remote device instance handles.</para>
/// <para>To obtain a local or a remote device instance handle, do one of the following.</para>
/// <list type="bullet">
/// <item>
/// <term>
/// Use one of the following functions to retrieve a device instance handle bound to the local machine: CM_Locate_DevNode,
/// CM_Get_Child, CM_Get_Parent, or CM_Get_Sibling.
/// </term>
/// </item>
/// <item>
/// <term>
/// Use one of the following functions to retrieve a device instance handle bound to a local or a remote machine:
/// CM_Locate_DevNode_Ex, <c>CM_Get_Child_Ex</c>, CM_Get_Parent_Ex, or CM_Get_Sibling_Ex.
/// </term>
/// </item>
/// </list>
/// <para>You can also use the device installation functions to obtain device instance handles. Do the following steps:</para>
/// <list type="number">
/// <item>
/// <term>Obtain a device information set.</term>
/// </item>
/// <item>
/// <term>Obtain an SP_DEVINFO_DATA structure for a device instance in the device information set.</term>
/// </item>
/// <item>
/// <term>Obtain the device instance handle for the device instance from the <c>DevInst</c> member of the SP_DEVINFO_DATA structure.</term>
/// </item>
/// <item>
/// <term>
/// Obtain the machine handle to which the device instance handle is bound. A device instance handle obtained from a device
/// information set is bound to the machine handle to which the device information set is bound. You obtain the machine handle for a
/// device information set from the <c>RemoteMachineHandle</c> member of its SP_DEVINFO_LIST_DETAIL_DATA structure. (Call
/// SetupDiGetDeviceInfoListDetail to obtain an SP_DEVINFO_LIST_DETAIL_DATA structure.)
/// </term>
/// </item>
/// </list>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_child_ex CMAPI CONFIGRET CM_Get_Child_Ex( PDEVINST
// pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Child_Ex")]
public static extern CONFIGRET CM_Get_Child_Ex ( out uint pdnDevInst , uint dnDevInst , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Get_Class_Property</c> function retrieves a device property that is set for a device interface class or device setup class.
/// </summary>
/// <param name="ClassGUID">
/// Pointer to the GUID that identifies the device interface class or device setup class for which to retrieve a device property
/// that is set for the device class. For information about specifying the class type, see the ulFlags parameter.
/// </param>
/// <param name="PropertyKey">
/// Pointer to a DEVPROPKEY structure that represents the device property key of the requested device class property.
/// </param>
/// <param name="PropertyType">
/// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device class 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.
/// </param>
/// <param name="PropertyBuffer">
/// Pointer to a buffer that receives the requested device class property. <c>CM_Get_Class_Property</c> retrieves the requested
/// property value only if the buffer is large enough to hold all the property value data. The pointer can be NULL.
/// </param>
/// <param name="PropertyBufferSize">
/// The size, in bytes, of the PropertyBuffer buffer. If the PropertyBuffer parameter 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, <c>CM_Get_Class_Property</c>
/// returns the size of the data, in bytes, in *PropertyBufferSize.
/// </param>
/// <param name="ulFlags">
/// <para>Class property flags:</para>
/// <para>CM_CLASS_PROPERTY_INSTALLER</para>
/// <para>ClassGUID specifies a device setup class. Do not combine with CM_CLASS_PROPERTY_INTERFACE.</para>
/// <para>CM_CLASS_PROPERTY_INTERFACE</para>
/// <para>ClassGUID specifies a device interface class. Do not combine with CM_CLASS_PROPERTY_INSTALLER.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks><c>CM_Get_Class_Property</c> is part of the Unified Device Property Model.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_class_propertyw CMAPI CONFIGRET
// CM_Get_Class_PropertyW( LPCGUID ClassGUID, 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_Class_PropertyW")]
public static extern CONFIGRET CM_Get_Class_Property ( in Guid ClassGUID , in DEVPROPKEY PropertyKey , out DEVPROPTYPE PropertyType , [ Out , Optional ] IntPtr PropertyBuffer ,
ref uint PropertyBufferSize , CM_CLASS_PROPERTY ulFlags ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Class_Property instead.]
/// </para>
/// <para>
/// The <c>CM_Get_Class_Property_ExW</c> function retrieves a device property that is set for a device interface class or device
/// setup class.
/// </para>
/// </summary>
/// <param name="ClassGUID">
/// Pointer to the GUID that identifies the device interface class or device setup class for which to retrieve a device property
/// that is set for the device class. For information about specifying the class type, see the ulFlags parameter.
/// </param>
/// <param name="PropertyKey">
/// Pointer to a DEVPROPKEY structure that represents the device property key of the requested device class property.
/// </param>
/// <param name="PropertyType">
/// Pointer to a DEVPROPTYPE-typed variable that receives the property-data-type identifier of the requested device class 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.
/// </param>
/// <param name="PropertyBuffer">
/// Pointer to a buffer that receives the requested device class property. <c>CM_Get_Class_Property_ExW</c> retrieves the requested
/// property value only if the buffer is large enough to hold all the property value data. The pointer can be NULL.
/// </param>
/// <param name="PropertyBufferSize">
/// The size, in bytes, of the PropertyBuffer buffer. If the PropertyBuffer parameter 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, <c>CM_Get_Class_Property_ExW</c>
/// returns the size of the data, in bytes, in *PropertyBufferSize.
/// </param>
/// <param name="ulFlags">
/// <para>Class property flags:</para>
/// <para>CM_CLASS_PROPERTY_INSTALLER</para>
/// <para>ClassGUID specifies a device setup class. Do not combine with CM_CLASS_PROPERTY_INTERFACE.</para>
/// <para>CM_CLASS_PROPERTY_INTERFACE</para>
/// <para>ClassGUID specifies a device interface class. Do not combine with CM_CLASS_PROPERTY_INSTALLER.</para>
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks><c>CM_Get_Class_Property_ExW</c> is part of the Unified Device Property Model.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_class_property_exw CMAPI CONFIGRET
// CM_Get_Class_Property_ExW( LPCGUID ClassGUID, 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_Class_Property_ExW")]
public static extern CONFIGRET CM_Get_Class_Property_Ex ( in Guid ClassGUID , in DEVPROPKEY PropertyKey , out DEVPROPTYPE PropertyType , [ Out , Optional ] IntPtr PropertyBuffer ,
ref uint PropertyBufferSize , CM_CLASS_PROPERTY ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-05-05 22:34:12 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Get_Class_Property_Keys</c> function retrieves an array of the device property keys that represent the device
/// properties that are set for a device interface class or device setup class.
/// </summary>
/// <param name="ClassGUID">
/// Pointer to the GUID that identifies the device interface class or device setup class for which to retrieve the property keys
/// for. For information about specifying the class type, see the ulFlags parameter.
/// </param>
/// <param name="PropertyKeyArray">
/// 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 class. The pointer is optional and can be NULL.
/// </param>
/// <param name="PropertyKeyCount">
/// 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,
/// <c>CM_Get_Class_Property_Keys</c> returns the count of the keys, in *PropertyKeyCount.
/// </param>
/// <param name="ulFlags">
/// <para>Class property key flags:</para>
/// <para>CM_CLASS_PROPERTY_INSTALLER</para>
/// <para>ClassGUID specifies a device setup class. Do not combine with CM_CLASS_PROPERTY_INTERFACE.</para>
/// <para>CM_CLASS_PROPERTY_INTERFACE</para>
/// <para>ClassGUID specifies a device interface class. Do not combine with CM_CLASS_PROPERTY_INSTALLER.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks><c>CM_Get_Class_Property_Keys</c> is part of the Unified Device Property Model.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_class_property_keys CMAPI CONFIGRET
// CM_Get_Class_Property_Keys( LPCGUID ClassGUID, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Class_Property_Keys")]
public static extern CONFIGRET CM_Get_Class_Property_Keys ( in Guid ClassGUID , [ In , Out , Optional , MarshalAs ( UnmanagedType . LPArray , SizeParamIndex = 2 ) ] DEVPROPKEY [ ] ? PropertyKeyArray ,
ref int PropertyKeyCount , CM_CLASS_PROPERTY ulFlags ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Class_Property_Keys instead.]
/// </para>
/// <para>
/// The <c>CM_Get_Class_Property_Keys_Ex</c> function retrieves an array of the device property keys that represent the device
/// properties that are set for a device interface class or device setup class.
/// </para>
/// </summary>
/// <param name="ClassGUID">
/// Pointer to the GUID that identifies the device interface class or device setup class for which to retrieve the property keys
/// for. For information about specifying the class type, see the ulFlags parameter.
/// </param>
/// <param name="PropertyKeyArray">
/// 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 class. The pointer is optional and can be NULL.
/// </param>
/// <param name="PropertyKeyCount">
/// 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,
/// <c>CM_Get_Class_Property_Keys_Ex</c> returns the count of the keys, in *PropertyKeyCount.
/// </param>
/// <param name="ulFlags">
/// <para>Class property key flags:</para>
/// <para>CM_CLASS_PROPERTY_INSTALLER</para>
/// <para>ClassGUID specifies a device setup class. Do not combine with CM_CLASS_PROPERTY_INTERFACE.</para>
/// <para>CM_CLASS_PROPERTY_INTERFACE</para>
/// <para>ClassGUID specifies a device interface class. Do not combine with CM_CLASS_PROPERTY_INSTALLER.</para>
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks><c>CM_Get_Class_Property_Keys_Ex</c> is part of the Unified Device Property Model.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_class_property_keys_ex CMAPI CONFIGRET
// CM_Get_Class_Property_Keys_Ex( LPCGUID ClassGUID, DEVPROPKEY *PropertyKeyArray, PULONG PropertyKeyCount, ULONG ulFlags, HMACHINE
// hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Class_Property_Keys_Ex")]
public static extern CONFIGRET CM_Get_Class_Property_Keys_Ex ( in Guid ClassGUID , [ In , Out , Optional , MarshalAs ( UnmanagedType . LPArray , SizeParamIndex = 2 ) ] DEVPROPKEY [ ] ? PropertyKeyArray ,
ref uint PropertyKeyCount , CM_CLASS_PROPERTY ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>The <c>CM_Get_Class_Registry_Property</c> function retrieves a device setup class property.</summary>
/// <param name="ClassGuid">A pointer to the GUID that represents the device setup class for which to retrieve a property.</param>
/// <param name="ulProperty">
/// <para>
/// A value of type ULONG that identifies the property to be retrieved. This value must be one of the following CM_CRP_Xxx values
/// that are defined in Cfgmgr32.h:
/// </para>
/// <para>CM_CRP_UPPERFILTERS</para>
/// <para>
/// Represents a REG_MULTI_SZ-type list of strings, where each string contains the name of an upper-level filter driver that is
/// registered for the class.
/// </para>
/// <para>CM_CRP_LOWERFILTERS</para>
/// <para>
/// Represents a REG_MULTI_SZ-typed list of strings, where each string contains the name of a lower-level filter drivers that is
/// registered for the class.
/// </para>
/// <para>CM_CRP_SECURITY</para>
/// <para>Represents a value of type REG_BINARY that contains a variable-length, self-relative, SECURITY_DESCRIPTOR structure.</para>
/// <para>CM_CRP_SECURITY_SDS</para>
/// <para>
/// Represents a string of type REG_SZ that contains a security descriptor in the Security Descriptor Definition Language (SDDL) format.
/// </para>
/// <para>CM_CRP_DEVTYPE</para>
/// <para>
/// Represents a value of type REG_DWORD that indicates the device type for the class. For more information, see Specifying Device Types.
/// </para>
/// <para>CM_CRP_EXCLUSIVE</para>
/// <para>
/// Represents a value of type REG_DWORD that indicates whether users can obtain exclusive access to devices for this class. The
/// returned value is 1 if exclusive access is allowed, or zero otherwise.
/// </para>
/// <para>CM_CRP_CHARACTERISTICS</para>
/// <para>
/// Represents a value of type DWORD that indicates the device characteristics for the class. For a list of characteristics flags,
/// see the DeviceCharacteristics parameter of the IoCreateDevice routine.
/// </para>
/// </param>
/// <param name="pulRegDataType">
/// A pointer to a variable of type ULONG that receives the REG_Xxx constant that represents the data type of the requested
/// property. The REG_Xxx constants are defined in Winnt.h and are described in the <c>Type</c> member of the
/// KEY_VALUE_BASIC_INFORMATION structure. This parameter is optional and can be set to <c>NULL</c>.
/// </param>
/// <param name="Buffer">
/// A pointer to a buffer that receives the requested property data. For more information about this parameter and the buffer-size
/// parameter pulLength, see the following <c>Remarks</c> section.
/// </param>
/// <param name="pulLength">
/// A pointer to variable of type ULONG whose value, on input, is the size, in bytes, of the buffer that is supplied by Buffer. On
/// return, <c>CM_Get_Class_Registry_Property</c> sets this variable to the size, in bytes, of the requested property.
/// </param>
/// <param name="ulFlags">Reserved for internal use only. Must be set to zero.</param>
/// <param name="hMachine">
/// A handle to a remote machine from which to retrieve the specified device class property. This parameter is optional, and, if it
/// is set to <c>NULL</c>, the property is retrieved from the local machine.
/// </param>
/// <returns>
/// If the operation succeeds, <c>CM_Get_Class_Registry_Property</c> returns CR_SUCCESS. Otherwise, the function returns one of the
/// other CR_Xxx status codes that are defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// To determine the size, in bytes, of a property before attempting to retrieve the property, first call
/// <c>CM_Get_Class_Registry_Property</c>, supplying a <c>NULL</c> Buffer pointer and a <c></c> pulLength value of zero. In response
/// to such a call, the function does not retrieve the property, but sets <c></c> pulLength to the size of the requested property
/// and returns CR_BUFFER_SMALL. After obtaining the property size, call <c>CM_Get_Class_Registry_Property</c> again, supplying a
/// Buffer pointer to the buffer to receive the property data and supplying the property size in <c>*</c> pulLength.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_class_registry_propertyw CMAPI CONFIGRET
// CM_Get_Class_Registry_PropertyW( LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG
// ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Class_Registry_PropertyW")]
public static extern CONFIGRET CM_Get_Class_Registry_Property ( in Guid ClassGuid , CM_CRP ulProperty , out REG_VALUE_TYPE pulRegDataType , [ Out , Optional ] IntPtr Buffer ,
ref uint pulLength , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>
/// The <c>CM_Get_Depth</c> function is used to obtain the depth of a specified device node (devnode) within the local machine's
/// device tree.
/// </summary>
/// <param name="pulDepth">
/// Caller-supplied address of a location to receive a depth value, where zero represents the device tree's root node, one
/// represents the root node's children, and so on.
/// </param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>For information about using device instance handles that are bound to the local machine, see CM_Get_Child.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_depth CMAPI CONFIGRET CM_Get_Depth( PULONG
// pulDepth, DEVINST dnDevInst, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Depth")]
public static extern CONFIGRET CM_Get_Depth ( out uint pulDepth , uint dnDevInst , uint ulFlags = 0 ) ;
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Depth instead.]</para>
/// <para>
/// The <c>CM_Get_Depth_Ex</c> function is used to obtain the depth of a specified device node (devnode) within a local or a remote
/// machine's device tree.
/// </para>
/// </summary>
/// <param name="pulDepth">
/// Caller-supplied address of a location to receive a depth value, where zero represents the device tree's root node, one
/// represents the root node's children, and so on.
/// </param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_depth_ex CMAPI CONFIGRET CM_Get_Depth_Ex( PULONG
// pulDepth, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Depth_Ex")]
public static extern CONFIGRET CM_Get_Depth_Ex ( out uint pulDepth , uint dnDevInst , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Device_ID instead.]</para>
/// <para>
/// The <c>CM_Get_Device_ID_Ex</c> function retrieves the device instance ID for a specified device instance on a local or a remote machine.
/// </para>
/// </summary>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
/// <param name="Buffer">
/// 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_Ex, then incrementing the received value to allow room for the string's terminating <c>NULL</c>.
/// </param>
/// <param name="BufferLen">Caller-supplied length, in characters, of the buffer specified by Buffer.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// 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.
/// </para>
/// <para>For information about device instance IDs, see Device Identification Strings.</para>
/// <para>For information about using device instance handles that are bound to a local or a remote machine, see CM_Get_Child_Ex.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_exw CMAPI CONFIGRET
// CM_Get_Device_ID_ExW( DEVINST dnDevInst, PWSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_ExW")]
public static extern CONFIGRET CM_Get_Device_ID_Ex ( uint dnDevInst , StringBuilder Buffer , uint BufferLen , [ In , Optional ] uint ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
/// <summary>
/// The <c>CM_Get_Device_ID_List</c> function retrieves a list of device instance IDs for the local computer's device instances.
/// </summary>
/// <param name="pszFilter">
/// Caller-supplied pointer to a character string that is either set to a subset of the computer's device instance identifiers
/// (IDs), or to <c>NULL</c>. See the following description of ulFlags.
/// </param>
/// <param name="Buffer">
/// Address of a buffer to receive a set of NULL-terminated device instance identifier strings. The end of the set is terminated by
/// an extra <c>NULL</c>. The required buffer size should be obtained by calling CM_Get_Device_ID_List_Size.
/// </param>
/// <param name="BufferLen">Caller-supplied length, in characters, of the buffer specified by Buffer.</param>
/// <param name="ulFlags">
/// <para>One of the following caller-supplied bit flags that specifies search filters:</para>
/// <para>CM_GETIDLIST_FILTER_BUSRELATIONS</para>
/// <para>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the bus
/// relations of the specified device instance.
/// </para>
/// <para>CM_GETIDLIST_FILTER_CLASS (Windows 7 and later versions of Windows)</para>
/// <para>
/// If this flag is set, pszFilter contains a string that specifies a device setup class GUID. The returned list contains device
/// instances for which the property (referenced by the CM_DRP_CLASSGUID constant) matches the specified device setup class GUID.
/// </para>
/// <para>The CM_DRP_CLASSGUID constant is defined in Cfgmgr32.h.</para>
/// <para>CM_GETIDLIST_FILTER_PRESENT (Windows 7 and later versions of Windows)</para>
/// <para>
/// If this flag is set, the returned list contains only device instances that are currently present on the system. This value can
/// be combined with other ulFlags values, such as CM_GETIDLIST_FILTER_CLASS.
/// </para>
/// <para>CM_GETIDLIST_FILTER_TRANSPORTRELATIONS (Windows 7 and later versions of Windows)</para>
/// <para>If this flag is set, pszFilter must specify the device instance identifier of a composite device node (devnode).</para>
/// <para>
/// The function returns the device instance identifiers of the devnodes that represent the transport relations of the specified
/// composite devnode.
/// </para>
/// <para>For more information about composite devnodes and transport relations, see the following <c>Remarks</c> section.</para>
/// <para>CM_GETIDLIST_DONOTGENERATE</para>
/// <para>
/// Used only with CM_GETIDLIST_FILTER_SERVICE. If set, and if the device tree does not contain a devnode for the specified service,
/// this flag prevents the function from creating a devnode for the service.
/// </para>
/// <para>CM_GETIDLIST_FILTER_EJECTRELATIONS</para>
/// <para>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// ejection relations of the specified device instance.
/// </para>
/// <para>CM_GETIDLIST_FILTER_ENUMERATOR</para>
/// <para>
/// If this flag is set, pszFilter must specify the name of a device enumerator, optionally followed by a device ID. The string
/// format is EnumeratorName\<DeviceID>, such as <c>ROOT</c> or <c>ROOT\*PNP0500</c>.
/// </para>
/// <para>
/// If pszFilter supplies only an enumerator name, the function returns device instance IDs for the instances of each device
/// associated with the enumerator. Enumerator names can be obtained by calling CM_Enumerate_Enumerators.
/// </para>
/// <para>
/// If pszFilter supplies both an enumerator and a device ID, the function returns device instance IDs only for the instances of the
/// specified device that is associated with the enumerator.
/// </para>
/// <para>CM_GETIDLIST_FILTER_NONE</para>
/// <para>If this flag is set, pszFilter is ignored, and a list of all devices on the system is returned.</para>
/// <para>CM_GETIDLIST_FILTER_POWERRELATIONS</para>
/// <para>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the power
/// relations of the specified device instance.
/// </para>
/// <para>CM_GETIDLIST_FILTER_REMOVALRELATIONS</para>
/// <para>
/// If this flag is set, pszFilter must specify a device instance identifier. The function returns device instance IDs for the
/// removal relations of the specified device instance.
/// </para>
/// <para>CM_GETIDLIST_FILTER_SERVICE</para>
/// <para>
/// If this flag is set, pszFilter must specify the name of a Microsoft Windows service (typically a driver). The function returns
/// device instance IDs for the device instances controlled by the specified service.
/// </para>
/// <para>
/// Note that if the device tree does not contain a devnode for the specified service, this function creates one by default. To
/// inhibit this behavior, also set CM_GETIDLIST_DONOTGENERATE.
/// </para>
/// <para>If no search filter flag is specified, the function returns all device instance IDs for all device instances.</para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>
/// Starting with Windows 7, a device that supports multiple transport paths for packet-based data is referred to as a composite
/// device and is represented by a composite devnode. A composite devnode logically represents the composite device to the user and
/// applications as a single device, even though the composite devnode can have multiple paths to the physical device.
/// </para>
/// <para>
/// Each active transport path to the physical device is represented by a transport devnode and is referred to as a transport
/// relation for the composite device.
/// </para>
/// <para>
/// The composite devnode (but not the related transport devnodes) exposes device interfaces to applications and the system. When an
/// application uses these public device interfaces, the composite device routes the packet-based data to one or more of these
/// transport devnodes, which then transport the data to the physical device.
/// </para>
/// <para>
/// For example, if a physical cell phone is simultaneously connected to the computer on the USB and the Bluetooth buses, each bus
/// enumerates a child transport devnode on that bus to represent the device's physical connection.
/// </para>
/// <para>
/// In this case, if you set the CM_GETIDLIST_FILTER_TRANSPORTRELATIONS flags in ulFlags and specify the device instance ID of the
/// cell phone's composite devnode in pszFilter, the function returns the device instance IDs for the two transport devnodes in the
/// Buffer parameter.
/// </para>
/// <para>For more information about device instance IDs, see Device Identification Strings.</para>
/// <para>
/// <para>Note</para>
/// <para>
/// The cfgmgr32.h header defines CM_Get_Device_ID_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.
/// </para>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_lista CMAPI CONFIGRET
// CM_Get_Device_ID_ListA( PCSTR pszFilter, PZZSTR Buffer, ULONG BufferLen, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_ListA")]
public static extern CONFIGRET CM_Get_Device_ID_List ( [ In , Optional , MarshalAs ( UnmanagedType . LPTStr ) ] string? pszFilter , [ Out ] IntPtr Buffer ,
uint BufferLen , CM_GETIDLIST ulFlags = 0 ) ;
/// <summary>
/// The <c>CM_Get_Device_ID_List</c> function retrieves a list of device instance IDs for the local computer's device instances.
/// </summary>
/// <param name="ulFlags">Bit flags that specifies search filters</param>
/// <param name="pszFilter">
/// Caller-supplied string that is either set to a subset of the computer's device instance identifiers
/// (IDs), or to <see langword="null"/>. See the description of ulFlags.
/// </param>
/// <returns>A sequence of device instance identifier strings.</returns>
/// <remarks>
/// <para>
/// Starting with Windows 7, a device that supports multiple transport paths for packet-based data is referred to as a composite
/// device and is represented by a composite devnode. A composite devnode logically represents the composite device to the user and
/// applications as a single device, even though the composite devnode can have multiple paths to the physical device.
/// </para>
/// <para>
/// Each active transport path to the physical device is represented by a transport devnode and is referred to as a transport
/// relation for the composite device.
/// </para>
/// <para>
/// The composite devnode (but not the related transport devnodes) exposes device interfaces to applications and the system. When an
/// application uses these public device interfaces, the composite device routes the packet-based data to one or more of these
/// transport devnodes, which then transport the data to the physical device.
/// </para>
/// <para>
/// For example, if a physical cell phone is simultaneously connected to the computer on the USB and the Bluetooth buses, each bus
/// enumerates a child transport devnode on that bus to represent the device's physical connection.
/// </para>
/// <para>
/// In this case, if you set the CM_GETIDLIST_FILTER_TRANSPORTRELATIONS flags in ulFlags and specify the device instance ID of the
/// cell phone's composite devnode in pszFilter, the function returns the device instance IDs for the two transport devnodes in the
/// Buffer parameter.
/// </para>
/// <para>For more information about device instance IDs, see Device Identification Strings.</para>
/// </remarks>
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_ListA")]
public static IEnumerable < string > CM_Get_Device_ID_List ( CM_GETIDLIST ulFlags = 0 , string pszFilter = null )
{
while ( true )
{
CM_Get_Device_ID_List_Size ( out var len , pszFilter , ulFlags ) . ThrowIfFailed ( ) ;
using var mem = new SafeCoTaskMemHandle ( len * StringHelper . GetCharSize ( ) ) ;
var ret = CM_Get_Device_ID_List ( pszFilter , mem , len , ulFlags ) ;
if ( ret = = CONFIGRET . CR_SUCCESS )
return mem . ToStringEnum ( ) . ToArray ( ) ;
else if ( ret ! = CONFIGRET . CR_BUFFER_SMALL )
ret . ThrowIfFailed ( ) ;
}
}
2021-05-05 22:34:12 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// <para>
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Device_ID_List instead.]
/// </para>
/// <para>
/// The <c>CM_Get_Device_ID_List_Ex</c> function retrieves a list of device instance IDs for the device instances on a local or a
/// remote machine.
/// </para>
/// </summary>
/// <param name="pszFilter">
/// Caller-supplied pointer to a character string specifying a subset of the machine's device instance identifiers, or <c>NULL</c>.
/// See the following description of ulFlags.
/// </param>
/// <param name="Buffer">
/// Address of a buffer to receive a set of NULL-terminated device instance identifier strings. The end of the set is terminated by
/// an extra <c>NULL</c>. The required buffer size should be obtained by calling CM_Get_Device_ID_List_Size_Ex.
/// </param>
/// <param name="BufferLen">Caller-supplied length, in characters, of the buffer specified by Buffer.</param>
/// <param name="ulFlags">
/// One of the optional, caller-supplied bit flags that specify search filters. If no flags are specified, the function supplies all
/// instance identifiers for all device instances. For a list of bit flags, see the ulFlags description for CM_Get_Device_ID_List.
/// </param>
/// <param name="hMachine">
/// <para>Caller-supplied machine handle, obtained from a previous call to CM_Connect_Machine.</para>
/// <para>
/// <c>Note</c> Using this function to access remote machines is not supported beginning with Windows 8 and Windows Server 2012, as
/// this functionality has been removed.
/// </para>
/// </param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>
/// <para>For information about device instance IDs, see Device Identification Strings.</para>
/// <para>
/// 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.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_device_id_list_exw CMAPI CONFIGRET
// CM_Get_Device_ID_List_ExW( PCWSTR pszFilter, PZZWSTR Buffer, ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine );
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Device_ID_List_ExW")]
public static extern CONFIGRET CM_Get_Device_ID_List_Ex ( [ In , Optional , MarshalAs ( UnmanagedType . LPTStr ) ] string? pszFilter , [ Out ] IntPtr Buffer ,
uint BufferLen , [ In , Optional ] CM_GETIDLIST ulFlags , [ In , Optional ] HMACHINE hMachine ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>
/// The <c>CM_Get_Parent</c> function obtains a device instance handle to the parent node of a specified device node (devnode) in
/// the local machine's device tree.
/// </summary>
/// <param name="pdnDevInst">
/// Caller-supplied pointer to the device instance handle to the parent node that this function retrieves. The retrieved handle is
/// bound to the local machine.
/// </param>
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
/// <param name="ulFlags">Not used, must be zero.</param>
/// <returns>
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the CR_-prefixed error codes defined in Cfgmgr32.h.
/// </returns>
/// <remarks>For information about using a device instance handle that is bound to the local machine, see CM_Get_Child.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_parent CMAPI CONFIGRET CM_Get_Parent( PDEVINST
// pdnDevInst, DEVINST dnDevInst, ULONG ulFlags );
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Parent")]
public static extern CONFIGRET CM_Get_Parent ( out uint pdnDevInst , uint dnDevInst , uint ulFlags = 0 ) ;
/// <summary>Provides a handle to a resource conflict list.</summary>
[PInvokeData("cfgmgr32.h")]
[StructLayout(LayoutKind.Sequential)]
public struct CONFLICT_LIST : IHandle
{
private readonly IntPtr handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="CONFLICT_LIST"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public CONFLICT_LIST ( IntPtr preexistingHandle ) = > handle = preexistingHandle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Returns an invalid handle by instantiating a <see cref="CONFLICT_LIST"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static CONFLICT_LIST NULL = > new ( IntPtr . Zero ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull = > handle = = IntPtr . Zero ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an explicit conversion from <see cref="CONFLICT_LIST"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr ( CONFLICT_LIST h ) = > h . handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="CONFLICT_LIST"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator CONFLICT_LIST ( IntPtr h ) = > new ( h ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ! = ( CONFLICT_LIST h1 , CONFLICT_LIST h2 ) = > ! ( h1 = = h2 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator = = ( CONFLICT_LIST h1 , CONFLICT_LIST h2 ) = > h1 . Equals ( h2 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override bool Equals ( object obj ) = > obj is CONFLICT_LIST h & & handle = = h . handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override int GetHashCode ( ) = > handle . GetHashCode ( ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public IntPtr DangerousGetHandle ( ) = > handle ;
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a handle to a notification context.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct HCMNOTIFICATION : IHandle
{
private readonly IntPtr handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="HCMNOTIFICATION"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public HCMNOTIFICATION ( IntPtr preexistingHandle ) = > handle = preexistingHandle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Returns an invalid handle by instantiating a <see cref="HCMNOTIFICATION"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static HCMNOTIFICATION NULL = > new ( IntPtr . Zero ) ;
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull = > handle = = IntPtr . Zero ;
/// <summary>Performs an explicit conversion from <see cref="HCMNOTIFICATION"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr ( HCMNOTIFICATION h ) = > h . handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HCMNOTIFICATION"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HCMNOTIFICATION ( IntPtr h ) = > new ( h ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ! = ( HCMNOTIFICATION h1 , HCMNOTIFICATION h2 ) = > ! ( h1 = = h2 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator = = ( HCMNOTIFICATION h1 , HCMNOTIFICATION h2 ) = > h1 . Equals ( h2 ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override bool Equals ( object obj ) = > obj is HCMNOTIFICATION h & & handle = = h . handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override int GetHashCode ( ) = > handle . GetHashCode ( ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public IntPtr DangerousGetHandle ( ) = > handle ;
}
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a handle to a device instance.</summary>
[PInvokeData("cfgmgr32.h")]
[StructLayout(LayoutKind.Sequential), System.Diagnostics.DebuggerDisplay("{handle}")]
public struct HMACHINE
{
private readonly IntPtr handle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="HMACHINE"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public HMACHINE ( IntPtr preexistingHandle ) = > handle = preexistingHandle ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Returns an invalid handle by instantiating a <see cref="HMACHINE"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static HMACHINE NULL = > new ( IntPtr . Zero ) ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull = > handle = = IntPtr . Zero ;
2021-04-28 18:56:02 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an explicit conversion from <see cref="HMACHINE"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr ( HMACHINE h ) = > h . handle ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HMACHINE"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HMACHINE ( IntPtr h ) = > new ( h ) ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ! = ( HMACHINE h1 , HMACHINE h2 ) = > ! ( h1 = = h2 ) ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator = = ( HMACHINE h1 , HMACHINE h2 ) = > h1 . Equals ( h2 ) ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override bool Equals ( object obj ) = > obj is HMACHINE h & & handle = = h . handle ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override int GetHashCode ( ) = > handle . GetHashCode ( ) ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public IntPtr DangerousGetHandle ( ) = > handle ;
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a handle to a logical configuration.</summary>
[PInvokeData("cfgmgr32.h")]
[StructLayout(LayoutKind.Sequential)]
public struct LOG_CONF : IHandle
{
private readonly IntPtr handle ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="LOG_CONF"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public LOG_CONF ( IntPtr preexistingHandle ) = > handle = preexistingHandle ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Returns an invalid handle by instantiating a <see cref="LOG_CONF"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static LOG_CONF NULL = > new ( IntPtr . Zero ) ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull = > handle = = IntPtr . Zero ;
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an explicit conversion from <see cref="LOG_CONF"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr ( LOG_CONF h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="LOG_CONF"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator LOG_CONF ( IntPtr h ) = > new ( h ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ! = ( LOG_CONF h1 , LOG_CONF h2 ) = > ! ( h1 = = h2 ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator = = ( LOG_CONF h1 , LOG_CONF h2 ) = > h1 . Equals ( h2 ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override bool Equals ( object obj ) = > obj is LOG_CONF h & & handle = = h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override int GetHashCode ( ) = > handle . GetHashCode ( ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public IntPtr DangerousGetHandle ( ) = > handle ;
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a handle to a resource descriptor.</summary>
[PInvokeData("cfgmgr32.h")]
[StructLayout(LayoutKind.Sequential)]
public struct RES_DES : IHandle
{
private readonly IntPtr handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="RES_DES"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public RES_DES ( IntPtr preexistingHandle ) = > handle = preexistingHandle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Returns an invalid handle by instantiating a <see cref="RES_DES"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static RES_DES NULL = > new ( IntPtr . Zero ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull = > handle = = IntPtr . Zero ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an explicit conversion from <see cref="RES_DES"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr ( RES_DES h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="RES_DES"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator RES_DES ( IntPtr h ) = > new ( h ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ! = ( RES_DES h1 , RES_DES h2 ) = > ! ( h1 = = h2 ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator = = ( RES_DES h1 , RES_DES h2 ) = > h1 . Equals ( h2 ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override bool Equals ( object obj ) = > obj is RES_DES h & & handle = = h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public override int GetHashCode ( ) = > handle . GetHashCode ( ) ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
public IntPtr DangerousGetHandle ( ) = > handle ;
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="CONFLICT_LIST"/> that is disposed using <see cref="CM_Free_Resource_Conflict_Handle(CONFLICT_LIST)"/>.</summary>
public class SafeCONFLICT_LIST : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafeCONFLICT_LIST"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafeCONFLICT_LIST ( IntPtr preexistingHandle , bool ownsHandle = true ) : base ( preexistingHandle , ownsHandle ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="SafeCONFLICT_LIST"/> class.</summary>
private SafeCONFLICT_LIST ( ) : base ( ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="SafeCONFLICT_LIST"/> to <see cref="CONFLICT_LIST"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator CONFLICT_LIST ( SafeCONFLICT_LIST h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
protected override bool InternalReleaseHandle ( ) = > CM_Free_Resource_Conflict_Handle ( handle ) = = 0 ;
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HCMNOTIFICATION"/> that is disposed using <see cref="CM_Unregister_Notification"/>.</summary>
public class SafeHCMNOTIFICATION : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafeHCMNOTIFICATION"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafeHCMNOTIFICATION ( IntPtr preexistingHandle , bool ownsHandle = true ) : base ( preexistingHandle , ownsHandle ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="SafeHCMNOTIFICATION"/> class.</summary>
private SafeHCMNOTIFICATION ( ) : base ( ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="SafeHCMNOTIFICATION"/> to <see cref="HCMNOTIFICATION"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HCMNOTIFICATION ( SafeHCMNOTIFICATION h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
protected override bool InternalReleaseHandle ( ) = > CM_Unregister_Notification ( handle ) = = 0 ;
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HMACHINE"/> that is disposed using <see cref="CM_Disconnect_Machine"/>.</summary>
public class SafeHMACHINE : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafeHMACHINE"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafeHMACHINE ( IntPtr preexistingHandle , bool ownsHandle = true ) : base ( preexistingHandle , ownsHandle ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="SafeHMACHINE"/> class.</summary>
private SafeHMACHINE ( ) : base ( ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="SafeHMACHINE"/> to <see cref="HMACHINE"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HMACHINE ( SafeHMACHINE h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
protected override bool InternalReleaseHandle ( ) = > CM_Disconnect_Machine ( handle ) = = 0 ;
}
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="LOG_CONF"/> that is disposed using <see cref="CM_Free_Log_Conf_Handle"/>.</summary>
public class SafeLOG_CONF : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafeLOG_CONF"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafeLOG_CONF ( IntPtr preexistingHandle , bool ownsHandle = true ) : base ( preexistingHandle , ownsHandle ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="SafeLOG_CONF"/> class.</summary>
private SafeLOG_CONF ( ) : base ( ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="SafeLOG_CONF"/> to <see cref="LOG_CONF"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator LOG_CONF ( SafeLOG_CONF h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
protected override bool InternalReleaseHandle ( ) = > CM_Free_Log_Conf_Handle ( handle ) = = 0 ;
}
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="RES_DES"/> that is disposed using <see cref="CM_Free_Res_Des_Handle"/>.</summary>
public class SafeRES_DES : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafeRES_DES"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafeRES_DES ( IntPtr preexistingHandle , bool ownsHandle = true ) : base ( preexistingHandle , ownsHandle ) { }
2021-05-02 23:52:39 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Initializes a new instance of the <see cref="SafeRES_DES"/> class.</summary>
private SafeRES_DES ( ) : base ( ) { }
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <summary>Performs an implicit conversion from <see cref="SafeRES_DES"/> to <see cref="RES_DES"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator RES_DES ( SafeRES_DES h ) = > h . handle ;
2021-04-28 16:00:11 -04:00
2023-03-31 11:47:53 -04:00
/// <inheritdoc/>
protected override bool InternalReleaseHandle ( ) = > CM_Free_Res_Des_Handle ( handle ) = = 0 ;
2021-04-11 23:18:25 -04:00
}
}