mirror of https://github.com/dahall/Vanara.git
2964 lines
168 KiB
C#
2964 lines
168 KiB
C#
using Microsoft.Win32.SafeHandles;
|
||
using System;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text;
|
||
using Vanara.InteropServices;
|
||
using static Vanara.PInvoke.AdvApi32;
|
||
using static Vanara.PInvoke.SetupAPI;
|
||
|
||
namespace Vanara.PInvoke
|
||
{
|
||
/// <summary>Items from the CfgMgr32.dll</summary>
|
||
public static partial class CfgMgr32
|
||
{
|
||
/// <summary>The callback routine invoked by the Configuration Manager when listening for events.</summary>
|
||
/// <param name="notify">The handle of the notification context which invoked the callback.</param>
|
||
/// <param name="context">A user-provided callback context.</param>
|
||
/// <param name="action">The device action which triggered the callback.</param>
|
||
/// <param name="eventData">The callback data.</param>
|
||
/// <param name="eventDataSize">The size of the callback data struct.</param>
|
||
/// <returns>
|
||
/// If responding to a <see cref="CM_NOTIFY_ACTION.CM_NOTIFY_ACTION_DEVICEQUERYREMOVE"/> notification, the <see
|
||
/// cref="CM_NOTIFY_CALLBACK"/> callback should return either <see cref="Win32Error.ERROR_SUCCESS"/> or <see
|
||
/// cref="Win32Error.ERROR_CANCELLED"/>, as appropriate. Otherwise, the callback should return <see
|
||
/// cref="Win32Error.ERROR_SUCCESS"/>. The callback should not return any other values.
|
||
/// </returns>
|
||
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
|
||
public delegate Win32Error CM_NOTIFY_CALLBACK(HCMNOTIFICATION notify, [Optional] IntPtr context, CM_NOTIFY_ACTION action, in CM_NOTIFY_EVENT_DATA eventData, uint eventDataSize);
|
||
|
||
/// <summary>
|
||
/// A variable of ULONG type that supplies one of the following flag values that apply if the caller supplies a device instance identifier
|
||
/// </summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Locate_DevNodeA")]
|
||
[Flags]
|
||
public enum CM_LOCATE_DEVINST : uint
|
||
{
|
||
/// <summary></summary>
|
||
CM_LOCATE_DEVINST_NORMAL = CM_LOCATE_DEVNODE.CM_LOCATE_DEVNODE_NORMAL,
|
||
|
||
/// <summary></summary>
|
||
CM_LOCATE_DEVINST_PHANTOM = CM_LOCATE_DEVNODE.CM_LOCATE_DEVNODE_PHANTOM,
|
||
|
||
/// <summary></summary>
|
||
CM_LOCATE_DEVINST_CANCELREMOVE = CM_LOCATE_DEVNODE.CM_LOCATE_DEVNODE_CANCELREMOVE,
|
||
|
||
/// <summary></summary>
|
||
CM_LOCATE_DEVINST_NOVALIDATION = CM_LOCATE_DEVNODE.CM_LOCATE_DEVNODE_NOVALIDATION,
|
||
}
|
||
|
||
/// <summary>
|
||
/// A variable of ULONG type that supplies one of the following flag values that apply if the caller supplies a device instance identifier
|
||
/// </summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Locate_DevNodeA")]
|
||
[Flags]
|
||
public enum CM_LOCATE_DEVNODE : uint
|
||
{
|
||
/// <summary>
|
||
/// The function retrieves the device instance handle for the specified device only if the device is currently configured in the
|
||
/// device tree.
|
||
/// </summary>
|
||
CM_LOCATE_DEVNODE_NORMAL = 0x00000000,
|
||
|
||
/// <summary>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or the device is a nonpresent device that is not currently configured in the device tree.
|
||
/// </summary>
|
||
CM_LOCATE_DEVNODE_PHANTOM = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or in the process of being removed from the device tree. If the device is in the process of being removed, the function
|
||
/// cancels the removal of the device.
|
||
/// </summary>
|
||
CM_LOCATE_DEVNODE_CANCELREMOVE = 0x00000002,
|
||
|
||
/// <summary>Not used.</summary>
|
||
CM_LOCATE_DEVNODE_NOVALIDATION = 0x00000004,
|
||
}
|
||
|
||
/// <summary>This enumeration identifies Plug and Play device event types.</summary>
|
||
/// <remarks>
|
||
/// When a driver calls the CM_Register_Notification function, the pCallback parameter contains a pointer to a routine to be called
|
||
/// when a specified PnP event occurs. The callback routine's Action parameter is a value from the <c>CM_NOTIFY_ACTION</c> enumeration.
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/ne-cfgmgr32-cm_notify_action typedef enum _CM_NOTIFY_ACTION {
|
||
// CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL, CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL, CM_NOTIFY_ACTION_DEVICEQUERYREMOVE,
|
||
// CM_NOTIFY_ACTION_DEVICEQUERYREMOVEFAILED, CM_NOTIFY_ACTION_DEVICEREMOVEPENDING, CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE,
|
||
// CM_NOTIFY_ACTION_DEVICECUSTOMEVENT, CM_NOTIFY_ACTION_DEVICEINSTANCEENUMERATED, CM_NOTIFY_ACTION_DEVICEINSTANCESTARTED,
|
||
// CM_NOTIFY_ACTION_DEVICEINSTANCEREMOVED, CM_NOTIFY_ACTION_MAX } CM_NOTIFY_ACTION, *PCM_NOTIFY_ACTION;
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NE:cfgmgr32._CM_NOTIFY_ACTION")]
|
||
public enum CM_NOTIFY_ACTION
|
||
{
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE. This
|
||
/// action indicates that a device interface that meets your filter criteria has been enabled.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL = 0,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE. This
|
||
/// action indicates that a device interface that meets your filter criteria has been disabled.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE. This
|
||
/// action indicates that the device is being query removed. In order to allow the query remove to succeed, call CloseHandle to
|
||
/// close any handles you have open to the device. If you do not do this, your open handle prevents the query remove of this
|
||
/// device from succeeding. See Registering for Notification of Device Interface Arrival and Device Removal for more
|
||
/// information.To veto the query remove, return ERROR_CANCELLED. However, it is recommended that you do not veto the query
|
||
/// remove and allow it to happen by closing any handles you have open to the device.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEQUERYREMOVE,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE. This
|
||
/// action indicates that the query remove of a device was failed. If you closed the handle to this device during a previous
|
||
/// notification of CM_NOTIFY_ACTION_DEVICEQUERYREMOVE, open a new handle to the device to continue sending I/O requests to it.
|
||
/// See Registering for Notification of Device Interface Arrival and Device Removal for more information.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEQUERYREMOVEFAILED,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE.The device
|
||
/// will be removed. If you still have an open handle to the device, call CloseHandle to close the device handle. See
|
||
/// Registering for Notification of Device Interface Arrival and Device Removal for more information. The system may send a
|
||
/// CM_NOTIFY_ACTION_DEVICEREMOVEPENDING notification without sending a corresponding CM_NOTIFY_ACTION_DEVICEQUERYREMOVE
|
||
/// message. In such cases, the applications and drivers must recover from the loss of the device as best they can.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEREMOVEPENDING,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE.The device
|
||
/// has been removed. If you still have an open handle to the device, call CloseHandle to close the device handle. See
|
||
/// Registering for Notification of Device Interface Arrival and Device Removal for more information. The system may send a
|
||
/// CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE notification without sending corresponding CM_NOTIFY_ACTION_DEVICEQUERYREMOVE or
|
||
/// CM_NOTIFY_ACTION_DEVICEREMOVEPENDING messages. In such cases, the applications and drivers must recover from the loss of the
|
||
/// device as best they can.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEREMOVECOMPLETE,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE. This
|
||
/// action is sent when a driver-defined custom event has occurred.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICECUSTOMEVENT,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE. This
|
||
/// action is sent when a new device instance that meets your filter criteria has been enumerated.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEINSTANCEENUMERATED,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE. This
|
||
/// action is sent when a device instance that meets your filter criteria becomes started.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEINSTANCESTARTED,
|
||
|
||
/// <summary>
|
||
/// For this value, set the FilterType member of the CM_NOTIFY_FILTER structure to CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE. This
|
||
/// action is sent when a device instance that meets your filter criteria is no longer present.
|
||
/// </summary>
|
||
CM_NOTIFY_ACTION_DEVICEINSTANCEREMOVED,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="CM_NOTIFY_FILTER"/></summary>
|
||
[Flags]
|
||
public enum CM_NOTIFY_FILTER_FLAG : uint
|
||
{
|
||
/// <summary>
|
||
/// Register to receive notifications for PnP events for all device interface classes. The memory at
|
||
/// <c>pFilter->u.DeviceInterface.ClassGuid</c> must be zeroes. Do not use this flag with
|
||
/// CM_NOTIFY_FILTER_FLAG_ALL_DEVICE_INSTANCES. This flag is only valid if <c>pFilter->FilterType</c> is CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE.
|
||
/// </summary>
|
||
CM_NOTIFY_FILTER_FLAG_ALL_INTERFACE_CLASSES = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// Register to receive notifications for PnP events for all devices. <c>pFilter->u.DeviceInstance.InstanceId</c> must be an
|
||
/// empty string. Do not use this flag with CM_NOTIFY_FILTER_FLAG_ALL_INTERFACE_CLASSES. This flag is only valid if
|
||
/// <c>pFilter->FilterType</c> is CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE.
|
||
/// </summary>
|
||
CM_NOTIFY_FILTER_FLAG_ALL_DEVICE_INSTANCES = 0x00000002,
|
||
}
|
||
|
||
/// <summary>Options for <see cref="CM_NOTIFY_FILTER"/></summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32._CM_NOTIFY_FILTER")]
|
||
public enum CM_NOTIFY_FILTER_TYPE
|
||
{
|
||
/// <summary>
|
||
/// Register for notifications for device interface events. <c>pFilter->u.DeviceInterface.ClassGuid</c> should be filled in
|
||
/// with the GUID of the device interface class to receive notifications for.
|
||
/// </summary>
|
||
CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE = 0,
|
||
|
||
/// <summary>
|
||
/// Register for notifications for device handle events. <c>pFilter->u.DeviceHandle.hTarget</c> must be filled in with a
|
||
/// handle to the device to receive notifications for.
|
||
/// </summary>
|
||
CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE,
|
||
|
||
/// <summary>
|
||
/// Register for notifications for device instance events. <c>pFilter->u.DeviceInstance.InstanceId</c> should be filled in
|
||
/// with the device instance ID of the device to receive notifications for.
|
||
/// </summary>
|
||
CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE,
|
||
}
|
||
|
||
/// <summary>Open class key flags</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Class_KeyW")]
|
||
public enum CM_OPEN_CLASS_KEY
|
||
{
|
||
/// <summary>The key to be opened is for a device setup class.</summary>
|
||
CM_OPEN_CLASS_KEY_INSTALLER = 0x00000000,
|
||
|
||
/// <summary>The key to be opened is for a device interface class.</summary>
|
||
CM_OPEN_CLASS_KEY_INTERFACE = 0x00000001,
|
||
}
|
||
|
||
/// <summary>Caller-supplied flags that specify how reenumeration should occur.</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Reenumerate_DevNode")]
|
||
[Flags]
|
||
public enum CM_REENUMERATE : uint
|
||
{
|
||
/// <summary>
|
||
/// Specifies default reenumeration behavior, in which reenumeration occurs synchronously. This flag is functionally equivalent
|
||
/// to CM_REENUMERATE_SYNCHRONOUS.
|
||
/// </summary>
|
||
CM_REENUMERATE_NORMAL = 0x00000000,
|
||
|
||
/// <summary>
|
||
/// Reenumeration should occur synchronously. The call to this function returns when all devices in the specified subtree have
|
||
/// been reenumerated. If this flag is set, the CM_REENUMERATE_ASYNCHRONOUS flag should not also be set. This flag is
|
||
/// functionally equivalent to CM_REENUMERATE_NORMAL.
|
||
/// </summary>
|
||
CM_REENUMERATE_SYNCHRONOUS = 0x00000001,
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Specifies that Plug and Play should make another attempt to install any devices in the specified subtree that have been
|
||
/// detected but are not yet configured, or are marked as needing reinstallation, or for which installation must be completed.
|
||
/// This flag can be set along with either the CM_REENUMERATE_SYNCHRONOUS flag or the CM_REENUMERATE_ASYNCHRONOUS flag.
|
||
/// </para>
|
||
/// <para>
|
||
/// This flag must be used with extreme caution, because it can cause the PnP manager to prompt the user to perform installation
|
||
/// of any such devices. Currently, only components such as Device Manager and Hardware Wizard use this flag, to allow the user
|
||
/// to retry installation of devices that might already have been detected but are not currently installed.
|
||
/// </para>
|
||
/// </summary>
|
||
CM_REENUMERATE_RETRY_INSTALLATION = 0x00000002,
|
||
|
||
/// <summary>
|
||
/// Reenumeration should occur asynchronously. The call to this function returns immediately after the PnP manager receives the
|
||
/// reenumeration request. If this flag is set, the CM_REENUMERATE_SYNCHRONOUS flag should not also be set.
|
||
/// </summary>
|
||
CM_REENUMERATE_ASYNCHRONOUS = 0x00000004,
|
||
}
|
||
|
||
/// <summary>A bitwise OR of the caller-supplied flag constants</summary>
|
||
[Flags]
|
||
public enum CM_REMOVE : uint
|
||
{
|
||
/// <summary></summary>
|
||
CM_REMOVE_UI_OK = 0x00000000,
|
||
|
||
/// <summary></summary>
|
||
CM_REMOVE_UI_NOT_OK = 0x00000001,
|
||
|
||
/// <summary></summary>
|
||
CM_REMOVE_NO_RESTART = 0x00000002,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="CM_Setup_DevNode"/>.</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Setup_DevNode")]
|
||
public enum CM_SETUP_DEVNODE
|
||
{
|
||
/// <summary>Configure devinst without (re)starting</summary>
|
||
CM_SETUP_DEVNODE_CONFIG = 0x00000005,
|
||
|
||
/// <summary>Configure devinst class without (re)starting</summary>
|
||
CM_SETUP_DEVNODE_CONFIG_CLASS = 0x00000006,
|
||
|
||
/// <summary>Configure devinst extensions without (re)starting</summary>
|
||
CM_SETUP_DEVNODE_CONFIG_EXTENSIONS = 0x00000007,
|
||
|
||
/// <summary>Reset devinst configuration without (re)starting</summary>
|
||
CM_SETUP_DEVNODE_CONFIG_RESET = 0x00000008,
|
||
|
||
/// <summary>Restarts a device instance that is not running because of a problem with the device configuration.</summary>
|
||
CM_SETUP_DEVNODE_READY = 0x00000000,
|
||
|
||
/// <summary>
|
||
/// Resets a device instance that has the no restart device status flag set. The no restart device status flag is set if a
|
||
/// device is removed by calling <c>CM_Query_And_Remove_SubTree</c> or <c>CM_Query_And_Remove_SubTree_Ex</c> and specifying the
|
||
/// CM_REMOVE_NO_RESTART flag.
|
||
/// </summary>
|
||
CM_SETUP_DEVNODE_RESET = 0x00000004,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="DMA_DES"/>.</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32.DMA_Des_s")]
|
||
[Flags]
|
||
public enum DMA_DES_FLAGS : uint
|
||
{
|
||
/// <summary>Bitmask for the bits within DD_Flags that specify the channel width value.</summary>
|
||
mDD_Width = 0x3,
|
||
|
||
/// <summary>8-bit DMA channel</summary>
|
||
fDD_BYTE = 0x0,
|
||
|
||
/// <summary>16-bit DMA channel</summary>
|
||
fDD_WORD = 0x1,
|
||
|
||
/// <summary>32-bit DMA channel</summary>
|
||
fDD_DWORD = 0x2,
|
||
|
||
/// <summary>8-bit and 16-bit DMA channel</summary>
|
||
fDD_BYTE_AND_WORD = 0x3,
|
||
|
||
/// <summary>Bitmask for the bits within DD_Flags that specify the bus mastering value.</summary>
|
||
mDD_BusMaster = 0x4,
|
||
|
||
/// <summary>No bus mastering</summary>
|
||
fDD_NoBusMaster = 0x0,
|
||
|
||
/// <summary>Bus mastering</summary>
|
||
fDD_BusMaster = 0x4,
|
||
|
||
/// <summary>Bitmask for the bits within DD_Flags that specify the DMA type value.</summary>
|
||
mDD_Type = 0x18,
|
||
|
||
/// <summary>Standard DMA</summary>
|
||
fDD_TypeStandard = 0x00,
|
||
|
||
/// <summary>Type-A DMA</summary>
|
||
fDD_TypeA = 0x08,
|
||
|
||
/// <summary>Type-B DMA</summary>
|
||
fDD_TypeB = 0x10,
|
||
|
||
/// <summary>Type-F DMA</summary>
|
||
fDD_TypeF = 0x18,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="IO_DES"/>.</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32.IO_Des_s")]
|
||
[Flags]
|
||
public enum IO_DES_FLAGS : uint
|
||
{
|
||
/// <summary>Bitmask for the bits within IOD_DesFlags that specify the port type value.</summary>
|
||
fIOD_PortType = 0x1,
|
||
|
||
/// <summary>The device is accessed in memory address space.</summary>
|
||
fIOD_Memory = 0x0,
|
||
|
||
/// <summary>The device is accessed in I/O address space.</summary>
|
||
fIOD_IO = 0x1,
|
||
|
||
/// <summary>Bitmask for the bits within IOD_DesFlags that specify the decode value.</summary>
|
||
fIOD_DECODE = 0x00fc,
|
||
|
||
/// <summary>The device decodes 10 bits of the port address.</summary>
|
||
fIOD_10_BIT_DECODE = 0x0004,
|
||
|
||
/// <summary>The device decodes 12 bits of the port address.</summary>
|
||
fIOD_12_BIT_DECODE = 0x0008,
|
||
|
||
/// <summary>The device decodes 16 bits of the port address.</summary>
|
||
fIOD_16_BIT_DECODE = 0x0010,
|
||
|
||
/// <summary>The device uses "positive decode" instead of "subtractive decode."</summary>
|
||
fIOD_POSITIVE_DECODE = 0x0020,
|
||
|
||
/// <summary></summary>
|
||
fIOD_PASSIVE_DECODE = 0x0040,
|
||
|
||
/// <summary></summary>
|
||
fIOD_WINDOW_DECODE = 0x0080,
|
||
|
||
/// <summary></summary>
|
||
fIOD_PORT_BAR = 0x0100,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="IRQ_DES_32"/></summary>
|
||
[Flags]
|
||
public enum IRQD_FLAGS : ushort
|
||
{
|
||
/// <summary>Bitmask,whether the IRQ may be shared:</summary>
|
||
mIRQD_Share = 0x1,
|
||
|
||
/// <summary>The IRQ may not be shared</summary>
|
||
fIRQD_Exclusive = 0x0,
|
||
|
||
/// <summary>The IRQ may be shared</summary>
|
||
fIRQD_Share = 0x1,
|
||
|
||
/// <summary>Bitmask,whether edge or level triggered:</summary>
|
||
mIRQD_Edge_Level = 0x2,
|
||
|
||
/// <summary>The IRQ is level-sensitive</summary>
|
||
fIRQD_Level = 0x0,
|
||
|
||
/// <summary>The IRQ is edge-sensitive</summary>
|
||
fIRQD_Edge = 0x2,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="MEM_DES"/></summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NS:cfgmgr32.Mem_Des_s")]
|
||
[Flags]
|
||
public enum MEM_DES_FLAGS : uint
|
||
{
|
||
/// <summary>Bitmask, whether memory is writable</summary>
|
||
mMD_MemoryType = 0x1,
|
||
|
||
/// <summary>Memory range is read-only</summary>
|
||
fMD_ROM = 0x0,
|
||
|
||
/// <summary>Memory range may be written to</summary>
|
||
fMD_RAM = 0x1,
|
||
|
||
/// <summary>Bitmask, memory is 24 or 32-bit</summary>
|
||
mMD_32_24 = 0x2,
|
||
|
||
/// <summary>Memory range is 24-bit</summary>
|
||
fMD_24 = 0x0,
|
||
|
||
/// <summary>Memory range is 32-bit</summary>
|
||
fMD_32 = 0x2,
|
||
|
||
/// <summary>Bitmask,whether memory prefetchable</summary>
|
||
mMD_Prefetchable = 0x4,
|
||
|
||
/// <summary>Memory range is not prefetchable</summary>
|
||
fMD_PrefetchDisallowed = 0x0,
|
||
|
||
/// <summary>Memory range is prefetchable</summary>
|
||
fMD_PrefetchAllowed = 0x4,
|
||
|
||
/// <summary>Bitmask,whether memory is readable</summary>
|
||
mMD_Readable = 0x8,
|
||
|
||
/// <summary>Memory range is readable</summary>
|
||
fMD_ReadAllowed = 0x0,
|
||
|
||
/// <summary>Memory range is write-only</summary>
|
||
fMD_ReadDisallowed = 0x8,
|
||
|
||
/// <summary>Bitmask,supports write-behind</summary>
|
||
mMD_CombinedWrite = 0x10,
|
||
|
||
/// <summary>no combined-write caching</summary>
|
||
fMD_CombinedWriteDisallowed = 0x0,
|
||
|
||
/// <summary>supports combined-write caching</summary>
|
||
fMD_CombinedWriteAllowed = 0x10,
|
||
|
||
/// <summary>Bitmask,whether memory is cacheable</summary>
|
||
mMD_Cacheable = 0x20,
|
||
|
||
/// <summary>Memory range is non-cacheable</summary>
|
||
fMD_NonCacheable = 0x0,
|
||
|
||
/// <summary>Memory range is cacheable</summary>
|
||
fMD_Cacheable = 0x20,
|
||
|
||
/// <summary>Memory range is bridge window decode.</summary>
|
||
fMD_WINDOW_DECODE = 0x40,
|
||
|
||
/// <summary>Memory BAR resource.</summary>
|
||
fMD_MEMORY_BAR = 0x80,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="MFCARD_DES"/></summary>
|
||
[Flags]
|
||
public enum MFCARD_DES_FLAGS : uint
|
||
{
|
||
/// <summary>Bitmask, whether audio is enabled or not</summary>
|
||
mPMF_AUDIO_ENABLE = 0x8,
|
||
|
||
/// <summary>Audio is enabled</summary>
|
||
fPMF_AUDIO_ENABLE = 0x8,
|
||
}
|
||
|
||
/// <summary>Flags for <see cref="PCCARD_DES"/>.</summary>
|
||
[Flags]
|
||
public enum PCD_FLAGS : uint
|
||
{
|
||
/// <summary>Bitmask, whether I/O is 8 or 16 bits</summary>
|
||
mPCD_IO_8_16 = 0x1,
|
||
|
||
/// <summary>I/O is 8-bit</summary>
|
||
fPCD_IO_8 = 0x0,
|
||
|
||
/// <summary>I/O is 16-bit</summary>
|
||
fPCD_IO_16 = 0x1,
|
||
|
||
/// <summary>Bitmask, whether MEM is 8 or 16 bits</summary>
|
||
mPCD_MEM_8_16 = 0x2,
|
||
|
||
/// <summary>MEM is 8-bit</summary>
|
||
fPCD_MEM_8 = 0x0,
|
||
|
||
/// <summary>MEM is 16-bit</summary>
|
||
fPCD_MEM_16 = 0x2,
|
||
|
||
/// <summary>Bitmask, whether MEMx is Attribute or Common</summary>
|
||
mPCD_MEM_A_C = 0xC,
|
||
|
||
/// <summary>MEM1 is Attribute</summary>
|
||
fPCD_MEM1_A = 0x4,
|
||
|
||
/// <summary>MEM2 is Attribute</summary>
|
||
fPCD_MEM2_A = 0x8,
|
||
|
||
/// <summary>zero wait on 8 bit I/O</summary>
|
||
fPCD_IO_ZW_8 = 0x10,
|
||
|
||
/// <summary>iosrc 16</summary>
|
||
fPCD_IO_SRC_16 = 0x20,
|
||
|
||
/// <summary>wait states on 16 bit io</summary>
|
||
fPCD_IO_WS_16 = 0x40,
|
||
|
||
/// <summary>Bitmask, for additional wait states on memory windows</summary>
|
||
mPCD_MEM_WS = 0x300,
|
||
|
||
/// <summary>1 wait state</summary>
|
||
fPCD_MEM_WS_ONE = 0x100,
|
||
|
||
/// <summary>2 wait states</summary>
|
||
fPCD_MEM_WS_TWO = 0x200,
|
||
|
||
/// <summary>3 wait states</summary>
|
||
fPCD_MEM_WS_THREE = 0x300,
|
||
|
||
/// <summary>MEM is Attribute</summary>
|
||
fPCD_MEM_A = 0x4,
|
||
|
||
/// <summary></summary>
|
||
fPCD_ATTRIBUTES_PER_WINDOW = 0x8000,
|
||
|
||
/// <summary>I/O window 1 is 16-bit</summary>
|
||
fPCD_IO1_16 = 0x00010000,
|
||
|
||
/// <summary>I/O window 1 zero wait on 8 bit I/O</summary>
|
||
fPCD_IO1_ZW_8 = 0x00020000,
|
||
|
||
/// <summary>I/O window 1 iosrc 16</summary>
|
||
fPCD_IO1_SRC_16 = 0x00040000,
|
||
|
||
/// <summary>I/O window 1 wait states on 16 bit io</summary>
|
||
fPCD_IO1_WS_16 = 0x00080000,
|
||
|
||
/// <summary>I/O window 2 is 16-bit</summary>
|
||
fPCD_IO2_16 = 0x00100000,
|
||
|
||
/// <summary>I/O window 2 zero wait on 8 bit I/O</summary>
|
||
fPCD_IO2_ZW_8 = 0x00200000,
|
||
|
||
/// <summary>I/O window 2 iosrc 16</summary>
|
||
fPCD_IO2_SRC_16 = 0x00400000,
|
||
|
||
/// <summary>I/O window 2 wait states on 16 bit io</summary>
|
||
fPCD_IO2_WS_16 = 0x00800000,
|
||
|
||
/// <summary>MEM window 1 Bitmask, for additional wait states on memory windows</summary>
|
||
mPCD_MEM1_WS = 0x03000000,
|
||
|
||
/// <summary>MEM window 1, 1 wait state</summary>
|
||
fPCD_MEM1_WS_ONE = 0x01000000,
|
||
|
||
/// <summary>MEM window 1, 2 wait states</summary>
|
||
fPCD_MEM1_WS_TWO = 0x02000000,
|
||
|
||
/// <summary>MEM window 1, 3 wait states</summary>
|
||
fPCD_MEM1_WS_THREE = 0x03000000,
|
||
|
||
/// <summary>MEM window 1 is 16-bit</summary>
|
||
fPCD_MEM1_16 = 0x04000000,
|
||
|
||
/// <summary>MEM window 2 Bitmask, for additional wait states on memory windows</summary>
|
||
mPCD_MEM2_WS = 0x30000000,
|
||
|
||
/// <summary>MEM window 2, 1 wait state</summary>
|
||
fPCD_MEM2_WS_ONE = 0x10000000,
|
||
|
||
/// <summary>MEM window 2, 2 wait states</summary>
|
||
fPCD_MEM2_WS_TWO = 0x20000000,
|
||
|
||
/// <summary>MEM window 2, 3 wait states</summary>
|
||
fPCD_MEM2_WS_THREE = 0x30000000,
|
||
|
||
/// <summary>MEM window 2 is 16-bit</summary>
|
||
fPCD_MEM2_16 = 0x40000000,
|
||
}
|
||
|
||
/// <summary>Specifies how the registry key is to be opened.</summary>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Class_KeyW")]
|
||
public enum REGDISPOSITION
|
||
{
|
||
/// <summary>Open the key if it exists. Otherwise, create the key.</summary>
|
||
RegDisposition_OpenAlways = 0x00000000,
|
||
|
||
/// <summary>Open the key only if it exists.</summary>
|
||
RegDisposition_OpenExisting = 0x00000001,
|
||
}
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Get_Sibling</c> function obtains a device instance handle to the next sibling 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 sibling 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>
|
||
/// <para>
|
||
/// To enumerate all children of a devnode in the local machine's device tree, first call CM_Get_Child to obtain a handle to the
|
||
/// first child node, then call <c>CM_Get_Sibling</c> to obtain handles for the rest of the children.
|
||
/// </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_get_sibling CMAPI CONFIGRET CM_Get_Sibling( PDEVINST
|
||
// pdnDevInst, DEVINST dnDevInst, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Sibling")]
|
||
public static extern CONFIGRET CM_Get_Sibling(out uint pdnDevInst, uint dnDevInst, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Get_Sibling instead.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Get_Sibling_Ex</c> function obtains a device instance handle to the next sibling node of a specified device node, 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 sibling node that this function retrieves. The retrieved handle is
|
||
/// bound to the machine handle specified by hMachine.
|
||
/// </param>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle specified 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 device node in the local machine's device tree, first call CM_Get_Child_Ex to obtain a handle to
|
||
/// the first child node, then call <c>CM_Get_Sibling_Ex</c> to obtain handles for the rest of the children.
|
||
/// </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_sibling_ex CMAPI CONFIGRET CM_Get_Sibling_Ex(
|
||
// PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Sibling_Ex")]
|
||
public static extern CONFIGRET CM_Get_Sibling_Ex(out uint pdnDevInst, 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 and should not be used.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Get_Version</c> function returns version 4.0 of the Plug and Play (PnP) Configuration Manager DLL (Cfgmgr32.dll) for a
|
||
/// local machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <returns>
|
||
/// If the function succeeds, it returns the major revision number in the high-order byte, and the minor revision number in the
|
||
/// low-order byte. Version 4.0 is returned as 0x0400. By default, version 4.0 is supported by Microsoft Windows 2000 and later
|
||
/// versions of Windows. If an internal error occurs, the function returns 0x0000. Call GetLastError to obtain the error code for
|
||
/// the failure.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This function returns version 4.0 of the configuration manager to ensure compatibility with version 4.0 and all later versions
|
||
/// of the configuration manager, and to ensure compatibility with all applications that require version 4.0 of the configuration manager.
|
||
/// </para>
|
||
/// <para>
|
||
/// To determine if a specific version of the configuration manager is available on a machine, use CM_Is_Version_Available or CM_Is_Version_Available_Ex.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_get_version CMAPI WORD CM_Get_Version();
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Version")]
|
||
public static extern ushort CM_Get_Version();
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated and should not be used.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Get_Version_Ex</c> function returns version 4.0 of the Plug and Play (PnP) Configuration Manager DLL (Cfgmgr32.dll)
|
||
/// for a local or a remote machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hMachine">
|
||
/// <para>Supplies a machine handle that is returned by 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 function succeeds, it returns the major revision number in the high-order byte and the minor revision number in the
|
||
/// low-order byte. Version 4.0 is returned as 0x0400. By default, version 4.0 is supported by Microsoft Windows 2000 and later
|
||
/// versions of Windows. If an internal error occurs, the function returns 0x0000. Call GetLastError to obtain the error code for
|
||
/// the failure.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This function returns version 4.0 of the configuration manager to ensure compatibility with version 4.0 and all later versions
|
||
/// of the configuration manager, and to ensure compatibility with all applications that require version 4.0 of the configuration manager.
|
||
/// </para>
|
||
/// <para>
|
||
/// To determine if a specific version of the configuration manager is available on a machine, use CM_Is_Version_Available or CM_Is_Version_Available_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_version_ex CMAPI WORD CM_Get_Version_Ex( HMACHINE
|
||
// hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Get_Version_Ex")]
|
||
public static extern ushort CM_Get_Version_Ex([In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Is_Dock_Station_Present</c> function identifies whether a docking station is present in a local machine.</summary>
|
||
/// <param name="pbPresent">
|
||
/// Pointer to a Boolean value that indicates whether a docking station is present in a local machine. The function sets *pbPresent
|
||
/// to <c>TRUE</c> if a docking station is present. Otherwise, the function sets *pbPresent to <c>FALSE</c>.
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to determine whether a docking station is present in a local machine. You can also use the following related
|
||
/// functions with docking stations:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present_Ex identifies whether a docking station is present in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC requests that a portable PC, which is inserted in a local docking station, be ejected.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC_Ex requests that a portable PC, which is inserted in a local or a remote docking station, be ejected.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_is_dock_station_present CMAPI CONFIGRET
|
||
// CM_Is_Dock_Station_Present( PBOOL pbPresent );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Is_Dock_Station_Present")]
|
||
public static extern CONFIGRET CM_Is_Dock_Station_Present([MarshalAs(UnmanagedType.Bool)] out bool pbPresent);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Is_Dock_Station_Present instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Is_Dock_Station_Present_Ex</c> function identifies whether a docking station is present in a local or a remote machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="pbPresent">
|
||
/// Pointer to a Boolean value that indicates whether a docking station is present in a local machine. The function sets *pbPresent
|
||
/// to <c>TRUE</c> if a docking station is present. The function sets *pbPresent to <c>FALSE</c> if the function cannot connect to
|
||
/// the specified machine or a docking station is not present.
|
||
/// </param>
|
||
/// <param name="hMachine">
|
||
/// <para>Supplies a machine handle that is returned by 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, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to determine whether a docking station is present in a local or a remote machine. You can also use the
|
||
/// following related functions with docking stations:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present identifies whether a docking station is present in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC requests that a portable PC, which is inserted in a local docking station, be ejected.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC_Ex requests that a portable PC, which is inserted in a local or a remote docking station, be ejected.</para>
|
||
/// </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_is_dock_station_present_ex CMAPI CONFIGRET
|
||
// CM_Is_Dock_Station_Present_Ex( PBOOL pbPresent, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Is_Dock_Station_Present_Ex")]
|
||
public static extern CONFIGRET CM_Is_Dock_Station_Present_Ex([MarshalAs(UnmanagedType.Bool)] out bool pbPresent, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated and should not be used.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Is_Version_Available</c> function indicates whether a specified version of the Plug and Play (PnP) Configuration
|
||
/// Manager DLL (Cfgmgr32.dll) is supported by a local machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="wVersion">
|
||
/// <para>
|
||
/// Identifies a version of the configuration manager. The supported version of the configuration manager corresponds directly to
|
||
/// the operating system version. The major version is specified by the high-order byte and the minor version is specified by the
|
||
/// low-order byte.
|
||
/// </para>
|
||
/// <para>
|
||
/// For example, 0x0400 specifies version 4.0, which is supported by default by Microsoft Windows 2000 and later versions of
|
||
/// Windows. 0x0501 specifies version 5.1, which is supported by Windows XP and later versions of Windows.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// The function returns <c>TRUE</c> if the local machine supports the specified version of the configuration manager. Otherwise,
|
||
/// the function returns <c>FALSE</c>.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// Use this function to determine whether a specified version of the configuration manager is supported by a local machine. If the
|
||
/// specified version is supported, all versions earlier and including this version are supported by the machine. You can also use
|
||
/// CM_Is_Version_Available_Ex to determine if a local or a remote machine supports a specific version of the configuration manager.
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_is_version_available CMAPI BOOL
|
||
// CM_Is_Version_Available( WORD wVersion );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Is_Version_Available")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool CM_Is_Version_Available(ushort wVersion);
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated and should not be used.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Is_Version_Available_Ex</c> function indicates whether a specified version of the Plug and Play (PNP) Configuration
|
||
/// Manager DLL (Cfgmgr32.dll) is supported by a local or a remote machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="wVersion">
|
||
/// Identifies a version of the configuration manager. The supported version of the configuration manager corresponds directly to
|
||
/// the operating system version. The major version is specified by the high-order byte and the minor version is specified by the
|
||
/// low-order byte. For example, 0x0400 specifies version 4.0, which is supported by default by Microsoft Windows NT 4.0 and later
|
||
/// versions of Windows. Version 0x0501 specifies version 5.1, which is supported by Windows XP and later versions of Windows.
|
||
/// </param>
|
||
/// <param name="hMachine">
|
||
/// <para>Supplies a machine handle that is returned by 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>
|
||
/// The function returns <c>TRUE</c> if the function can connect to the specified machine and if the machine supports the specified
|
||
/// version. Otherwise, the function returns <c>FALSE</c>.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to determine whether a specified version of the configuration manager is supported by a local or a remote
|
||
/// machine. If the specified version is supported, all versions earlier and including this version are supported by the machine.
|
||
/// You can also use CM_Is_Version_Available to determine if the local machine supports a specific version of the configuration manager.
|
||
/// </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_is_version_available_ex CMAPI BOOL
|
||
// CM_Is_Version_Available_Ex( WORD wVersion, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Is_Version_Available_Ex")]
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
public static extern bool CM_Is_Version_Available_Ex(ushort wVersion, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Locate_DevNode</c> function obtains a device instance handle to the device node that is associated with a specified
|
||
/// device instance ID on the local machine.
|
||
/// </summary>
|
||
/// <param name="pdnDevInst">
|
||
/// A pointer to a device instance handle that <c>CM_Locate_DevNode</c> retrieves. The retrieved handle is bound to the local machine.
|
||
/// </param>
|
||
/// <param name="pDeviceID">
|
||
/// A pointer to a NULL-terminated string representing a device instance ID. If this value is <c>NULL</c>, or if it points to a
|
||
/// zero-length string, the function retrieves a device instance handle to the device at the root of the device tree.
|
||
/// </param>
|
||
/// <param name="ulFlags">
|
||
/// <para>
|
||
/// A variable of ULONG type that supplies one of the following flag values that apply if the caller supplies a device instance identifier:
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_NORMAL</para>
|
||
/// <para>
|
||
/// The function retrieves the device instance handle for the specified device only if the device is currently configured in the
|
||
/// device tree.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_PHANTOM</para>
|
||
/// <para>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or the device is a nonpresent device that is not currently configured in the device tree.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_CANCELREMOVE</para>
|
||
/// <para>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or in the process of being removed from the device tree. If the device is in the process of being removed, the function
|
||
/// cancels the removal of the device.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_NOVALIDATION</para>
|
||
/// <para>Not used.</para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the operation succeeds, <c>CM_Locate_DevNode</c> returns CR_SUCCESS. Otherwise, the function returns one of the CR_Xxx error
|
||
/// codes that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>For information about using device instance handles that are bound to the local machine, see CM_Get_Child.</para>
|
||
/// <para>
|
||
/// <para>Note</para>
|
||
/// <para>
|
||
/// The cfgmgr32.h header defines CM_Locate_DevNode 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_locate_devnodea CMAPI CONFIGRET CM_Locate_DevNodeA(
|
||
// PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Locate_DevNodeA")]
|
||
public static extern CONFIGRET CM_Locate_DevNode(out uint pdnDevInst, [In, Optional, MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, CM_LOCATE_DEVNODE ulFlags = CM_LOCATE_DEVNODE.CM_LOCATE_DEVNODE_NORMAL);
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Locate_DevNode instead.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Locate_DevNode_Ex</c> function obtains a device instance handle to the device node that is associated with a specified
|
||
/// device instance ID, on a local machine or a remote machine.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="pdnDevInst">
|
||
/// A pointer to the device instance handle that this function retrieves. The retrieved handle is bound to the machine handle
|
||
/// specified by hMachine.
|
||
/// </param>
|
||
/// <param name="pDeviceID">
|
||
/// A pointer to a NULL-terminated string representing a device instance ID. If this value is <c>NULL</c>, or if it points to a
|
||
/// zero-length string, the function supplies a device instance handle to the device at the root of the device tree.
|
||
/// </param>
|
||
/// <param name="ulFlags">
|
||
/// <para>
|
||
/// A variable of ULONG type that supplies one of the following flag values that apply if the caller supplies a device instance identifier:
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_NORMAL</para>
|
||
/// <para>
|
||
/// The function retrieves the device instance handle for the specified device only if the device is currently configured in the
|
||
/// device tree.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_PHANTOM</para>
|
||
/// <para>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or the device is a nonpresent device that is not currently configured in the device tree.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_CANCELREMOVE</para>
|
||
/// <para>
|
||
/// The function retrieves a device instance handle for the specified device if the device is currently configured in the device
|
||
/// tree or in the process of being removed for the device tree. If the device is in the process of being removed, the function
|
||
/// cancels the removal of the device.
|
||
/// </para>
|
||
/// <para>CM_LOCATE_DEVNODE_NOVALIDATION</para>
|
||
/// <para>Not used.</para>
|
||
/// </param>
|
||
/// <param name="hMachine">
|
||
/// <para>
|
||
/// A machine handle obtained from a call to CM_Connect_Machine, or a machine handle to which a device information set is bound. The
|
||
/// machine handle for a device information set is obtained from the <c>RemoteMachineHandle</c> member of the
|
||
/// SP_DEVINFO_LIST_DETAIL_DATA structure for the device information set. Call SetupDiGetDeviceInfoListDetail to obtain an
|
||
/// SP_DEVINFO_LIST_DETAIL_DATA structure.
|
||
/// </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, <c>CM_Locate_DevNode</c> returns CR_SUCCESS. Otherwise, the function returns one of the CR_-prefixed
|
||
/// error codes that are 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_locate_devnode_exw CMAPI CONFIGRET
|
||
// CM_Locate_DevNode_ExW( PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Locate_DevNode_ExW")]
|
||
public static extern CONFIGRET CM_Locate_DevNode_Ex(out uint pdnDevInst, [In, Optional, MarshalAs(UnmanagedType.LPTStr)] string pDeviceID, CM_LOCATE_DEVNODE ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>Converts a specified <c>CONFIGRET</c> code to its equivalent system error code.</summary>
|
||
/// <param name="CmReturnCode">The <c>CONFIGRET</c> code to be converted. <c>CONFIGRET</c> error codes are defined in CfgMgr32.h.</param>
|
||
/// <param name="DefaultErr">
|
||
/// A default system error code to be returned when no system error code is mapped to the specified <c>CONFIGRET</c> code.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>The system error code that corresponds to the <c>CONFIGRET</c> code. System error codes are defined in Winerror.h.</para>
|
||
/// <para>
|
||
/// When there is no mapping from the specified <c>CONFIGRET</c> code to a system error code, <c>CM_MapCrToWin32Err</c> returns the
|
||
/// value specified in the DefaultErr parameter.
|
||
/// </para>
|
||
/// </returns>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_mapcrtowin32err CMAPI DWORD CM_MapCrToWin32Err(
|
||
// CONFIGRET CmReturnCode, DWORD DefaultErr );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_MapCrToWin32Err")]
|
||
public static extern Win32Error CM_MapCrToWin32Err(CONFIGRET CmReturnCode, uint DefaultErr);
|
||
|
||
/// <summary>The <c>CM_Modify_Res_Des</c> function modifies a specified resource descriptor on the local machine.</summary>
|
||
/// <param name="prdResDes">Pointer to a location to receive a handle to the modified resource descriptor.</param>
|
||
/// <param name="rdResDes">
|
||
/// <para>
|
||
/// Caller-supplied handle to the resource descriptor to be modified. 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><c>CM_Modify_Res_Des</c></para>
|
||
/// <para>CM_Modify_Res_Des_Ex</para>
|
||
/// </param>
|
||
/// <param name="ResourceID">
|
||
/// Caller-supplied resource type identifier. This must be one of the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
|
||
/// </param>
|
||
/// <param name="ResourceData">
|
||
/// Caller-supplied pointer to a resource descriptor, which can be one of the structures listed under the CM_Add_Res_Des function's
|
||
/// description of ResourceData.
|
||
/// </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_Modify_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>
|
||
/// The caller-supplied resource descriptor data replaces the existing data. The values specified for ResourceID and ResourceLen do
|
||
/// not have to match the existing resource descriptor.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the value specified for ResourceID is <c>ResType_ClassSpecific</c>, then the specified resource descriptor must be the last
|
||
/// one associated with the logical configuration.
|
||
/// </para>
|
||
/// <para>
|
||
/// Callers of <c>CM_Modify_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_modify_res_des CMAPI CONFIGRET CM_Modify_Res_Des(
|
||
// PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Modify_Res_Des")]
|
||
public static extern CONFIGRET CM_Modify_Res_Des(out SafeRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, [In] IntPtr ResourceData, uint ResourceLen, uint ulFlags = 0);
|
||
|
||
/// <summary>The <c>CM_Modify_Res_Des</c> function modifies a specified resource descriptor on the local machine.</summary>
|
||
/// <typeparam name="T">The type of the data.</typeparam>
|
||
/// <param name="rdResDes">
|
||
/// <para>
|
||
/// Caller-supplied handle to the resource descriptor to be modified. 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><c>CM_Modify_Res_Des</c></para>
|
||
/// <para>CM_Modify_Res_Des_Ex</para>
|
||
/// </param>
|
||
/// <param name="data">
|
||
/// Caller-supplied pointer to a resource descriptor, which can be one of the structures listed under the CM_Add_Res_Des function's
|
||
/// description of ResourceData.
|
||
/// </param>
|
||
/// <param name="ResourceID">
|
||
/// Caller-supplied resource type identifier. This must be one of the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>A handle to the modified resource descriptor.</para>
|
||
/// <para>
|
||
/// <c>Note</c> Starting with Windows 8, <c>CM_Modify_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>
|
||
/// <exception cref="ArgumentException">Unable to determine RESOURCEID from type. - T</exception>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The caller-supplied resource descriptor data replaces the existing data. The values specified for ResourceID and ResourceLen do
|
||
/// not have to match the existing resource descriptor.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the value specified for ResourceID is <c>ResType_ClassSpecific</c>, then the specified resource descriptor must be the last
|
||
/// one associated with the logical configuration.
|
||
/// </para>
|
||
/// <para>
|
||
/// Callers of this function must have <c>SeLoadDriverPrivilege</c>. (Privileges are described in the Microsoft Windows SDK documentation.)
|
||
/// </para>
|
||
/// </remarks>
|
||
public static SafeRES_DES CM_Modify_Res_Des<T>(RES_DES rdResDes, 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_Modify_Res_Des(out var hRD, rdResDes, 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_Modify_Res_Des instead.]</para>
|
||
/// <para>The <c>CM_Modify_Res_Des_Ex</c> function modifies a specified resource descriptor on a local or a remote machine.</para>
|
||
/// </summary>
|
||
/// <param name="prdResDes">Pointer to a location to receive a handle to the modified resource descriptor.</param>
|
||
/// <param name="rdResDes">
|
||
/// <para>
|
||
/// Caller-supplied handle to the resource descriptor to be modified. 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><c>CM_Modify_Res_Des_Ex</c></para>
|
||
/// </param>
|
||
/// <param name="ResourceID">
|
||
/// Caller-supplied resource type identifier. This must be one of the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
|
||
/// </param>
|
||
/// <param name="ResourceData">
|
||
/// Caller-supplied pointer to a resource descriptor, which can be one of the structures listed under the CM_Add_Res_Des_Ex
|
||
/// function's description of ResourceData.
|
||
/// </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.</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_Modify_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>
|
||
/// The caller-supplied resource descriptor data replaces the existing data. The values specified for ResourceID and ResourceLen do
|
||
/// not have to match the existing resource descriptor.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the value specified for ResourceID is <c>ResType_ClassSpecific</c>, then the specified resource descriptor must be the last
|
||
/// one associated with the logical configuration.
|
||
/// </para>
|
||
/// <para>
|
||
/// Callers of <c>CM_Modify_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_modify_res_des_ex CMAPI CONFIGRET
|
||
// CM_Modify_Res_Des_Ex( PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData, ULONG ResourceLen, ULONG
|
||
// ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Modify_Res_Des_Ex")]
|
||
public static extern CONFIGRET CM_Modify_Res_Des_Ex(out SafeRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, [In] IntPtr ResourceData, uint ResourceLen, [In, Optional] uint ulFlags,
|
||
[In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Open_Class_Key</c> function opens the device setup class registry key, the device interface class registry key, or a
|
||
/// specific subkey of a class.
|
||
/// </summary>
|
||
/// <param name="ClassGuid">
|
||
/// Pointer to the GUID of the class whose registry key is to be opened. This parameter is optional and can be NULL. If this
|
||
/// parameter is NULL, the root of the class tree is opened.
|
||
/// </param>
|
||
/// <param name="pszClassName">Reserved. Must be set to NULL.</param>
|
||
/// <param name="samDesired">The registry security access for the key to be opened.</param>
|
||
/// <param name="Disposition">
|
||
/// <para>Specifies how the registry key is to be opened. May be one of the following values:</para>
|
||
/// <para>RegDisposition_OpenAlways</para>
|
||
/// <para>Open the key if it exists. Otherwise, create the key.</para>
|
||
/// <para>RegDisposition_OpenExisting</para>
|
||
/// <para>Open the key only if it exists.</para>
|
||
/// </param>
|
||
/// <param name="phkClass">Pointer to an HKEY that will receive the opened key upon success.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>Open class key flags:</para>
|
||
/// <para>CM_OPEN_CLASS_KEY_INSTALLER</para>
|
||
/// <para>The key to be opened is for a device setup class.</para>
|
||
/// <para>CM_OPEN_CLASS_KEY_INTERFACE</para>
|
||
/// <para>The key to be opened is for a device interface 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>
|
||
/// <remarks>Close the handle returned from this function by calling <c>RegCloseKey</c>.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_open_class_keyw CMAPI CONFIGRET CM_Open_Class_KeyW(
|
||
// LPGUID ClassGuid, LPCWSTR pszClassName, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Class_KeyW")]
|
||
public static extern CONFIGRET CM_Open_Class_Key(in Guid ClassGuid, [Optional, MarshalAs(UnmanagedType.LPTStr)] string pszClassName, REGSAM samDesired, REGDISPOSITION Disposition,
|
||
out SafeRegistryHandle phkClass, CM_OPEN_CLASS_KEY ulFlags);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Open_Class_Key</c> function opens the device setup class registry key, the device interface class registry key, or a
|
||
/// specific subkey of a class.
|
||
/// </summary>
|
||
/// <param name="ClassGuid">
|
||
/// Pointer to the GUID of the class whose registry key is to be opened. This parameter is optional and can be NULL. If this
|
||
/// parameter is NULL, the root of the class tree is opened.
|
||
/// </param>
|
||
/// <param name="pszClassName">Reserved. Must be set to NULL.</param>
|
||
/// <param name="samDesired">The registry security access for the key to be opened.</param>
|
||
/// <param name="Disposition">
|
||
/// <para>Specifies how the registry key is to be opened. May be one of the following values:</para>
|
||
/// <para>RegDisposition_OpenAlways</para>
|
||
/// <para>Open the key if it exists. Otherwise, create the key.</para>
|
||
/// <para>RegDisposition_OpenExisting</para>
|
||
/// <para>Open the key only if it exists.</para>
|
||
/// </param>
|
||
/// <param name="phkClass">Pointer to an HKEY that will receive the opened key upon success.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>Open class key flags:</para>
|
||
/// <para>CM_OPEN_CLASS_KEY_INSTALLER</para>
|
||
/// <para>The key to be opened is for a device setup class.</para>
|
||
/// <para>CM_OPEN_CLASS_KEY_INTERFACE</para>
|
||
/// <para>The key to be opened is for a device interface 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>
|
||
/// <remarks>Close the handle returned from this function by calling <c>RegCloseKey</c>.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_open_class_keyw CMAPI CONFIGRET CM_Open_Class_KeyW(
|
||
// LPGUID ClassGuid, LPCWSTR pszClassName, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Class_KeyW")]
|
||
public static extern CONFIGRET CM_Open_Class_Key([In, Optional] InteropServices.GuidPtr ClassGuid,
|
||
[Optional, MarshalAs(UnmanagedType.LPTStr)] string pszClassName, REGSAM samDesired, REGDISPOSITION Disposition,
|
||
out SafeRegistryHandle phkClass, CM_OPEN_CLASS_KEY ulFlags);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Open_Device_Interface_Key</c> function opens the registry subkey that is used by applications and drivers to store
|
||
/// information that is specific to a device interface.
|
||
/// </summary>
|
||
/// <param name="pszDeviceInterface">
|
||
/// Pointer to a string that identifies the device interface instance to open the registry subkey for.
|
||
/// </param>
|
||
/// <param name="samDesired">The requested registry security access to the registry subkey.</param>
|
||
/// <param name="Disposition">
|
||
/// <para>Specifies how the registry key is to be opened. May be one of the following values:</para>
|
||
/// <para>RegDisposition_OpenAlways</para>
|
||
/// <para>Open the key if it exists. Otherwise, create the key.</para>
|
||
/// <para>RegDisposition_OpenExisting</para>
|
||
/// <para>Open the key only if it exists.</para>
|
||
/// </param>
|
||
/// <param name="phkDeviceInterface">Pointer to an HKEY that will receive the opened key upon success.</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>
|
||
/// <remarks>
|
||
/// <para>Close the handle returned from this function by calling <c>RegCloseKey</c>.</para>
|
||
/// <para>
|
||
/// <para>Note</para>
|
||
/// <para>
|
||
/// The cfgmgr32.h header defines CM_Open_Device_Interface_Key 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_open_device_interface_keya CMAPI CONFIGRET
|
||
// CM_Open_Device_Interface_KeyA( LPCSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY
|
||
// phkDeviceInterface, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Device_Interface_KeyA")]
|
||
public static extern CONFIGRET CM_Open_Device_Interface_Key([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition,
|
||
out SafeRegistryHandle phkDeviceInterface, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Open_Device_Interface_Key instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Open_Device_Interface_Key_ExA</c> function opens the registry subkey that is used by applications and drivers to store
|
||
/// information that is specific to a device interface.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="pszDeviceInterface">
|
||
/// Pointer to a string that identifies the device interface instance to open the registry subkey for.
|
||
/// </param>
|
||
/// <param name="samDesired">The requested registry security access to the registry subkey.</param>
|
||
/// <param name="Disposition">
|
||
/// <para>Specifies how the registry key is to be opened. May be one of the following values:</para>
|
||
/// <para>RegDisposition_OpenAlways</para>
|
||
/// <para>Open the key if it exists. Otherwise, create the key.</para>
|
||
/// <para>RegDisposition_OpenExisting</para>
|
||
/// <para>Open the key only if it exists.</para>
|
||
/// </param>
|
||
/// <param name="phkDeviceInterface">Pointer to an HKEY that will receive the opened key upon success.</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>Close the handle returned from this function by calling <c>RegCloseKey</c>.</para>
|
||
/// <para>
|
||
/// <para>Note</para>
|
||
/// <para>
|
||
/// The cfgmgr32.h header defines CM_Open_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>
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_open_device_interface_key_exa CMAPI CONFIGRET
|
||
// CM_Open_Device_Interface_Key_ExA( LPCSTR pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition, PHKEY
|
||
// phkDeviceInterface, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_Device_Interface_Key_ExA")]
|
||
public static extern CONFIGRET CM_Open_Device_Interface_Key_Ex([MarshalAs(UnmanagedType.LPTStr)] string pszDeviceInterface, REGSAM samDesired, REGDISPOSITION Disposition,
|
||
out SafeRegistryHandle phkDeviceInterface, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Open_DevNode_Key</c> function opens a registry key for device-specific configuration information.</summary>
|
||
/// <param name="dnDevNode">Caller-supplied device instance handle that is bound to the local machine</param>
|
||
/// <param name="samDesired">The registry security access that is required for the requested key.</param>
|
||
/// <param name="ulHardwareProfile">
|
||
/// The hardware profile to open if ulFlags includes CM_REGISTRY_CONFIG. If this value is zero, the key for the current hardware
|
||
/// profile is opened.
|
||
/// </param>
|
||
/// <param name="Disposition">
|
||
/// <para>Specifies how the registry key is to be opened. May be one of the following values:</para>
|
||
/// <para>RegDisposition_OpenAlways</para>
|
||
/// <para>Open the key if it exists. Otherwise, create the key.</para>
|
||
/// <para>RegDisposition_OpenExisting</para>
|
||
/// <para>Open the key only if it exists.</para>
|
||
/// </param>
|
||
/// <param name="phkDevice">Pointer to an HKEY that will receive the opened key upon success.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>
|
||
/// Open device node key flags. Indicates the scope and type of registry storage key to open. Can be a combination of the following flags:
|
||
/// </para>
|
||
/// <para>CM_REGISTRY_HARDWARE</para>
|
||
/// <para>Open the device<63>s hardware key. Do not combine with CM_REGISTRY_SOFTWARE.</para>
|
||
/// <para>CM_REGISTRY_SOFTWARE</para>
|
||
/// <para>Open the device<63>s software key. Do not combine with CM_REGISTRY_HARDWARE.</para>
|
||
/// <para>CM_REGISTRY_USER</para>
|
||
/// <para>Open the per-user key for the current user. Do not combine with CM_REGISTRY_CONFIG.</para>
|
||
/// <para>CM_REGISTRY_CONFIG</para>
|
||
/// <para>Open 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>
|
||
/// <remarks>Close the handle returned from this function by calling <c>RegCloseKey</c>.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_open_devnode_key CMAPI CONFIGRET CM_Open_DevNode_Key(
|
||
// DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Open_DevNode_Key")]
|
||
public static extern CONFIGRET CM_Open_DevNode_Key(uint dnDevNode, REGSAM samDesired, uint ulHardwareProfile, REGDISPOSITION Disposition, out SafeRegistryHandle phkDevice, CM_REGISTRY ulFlags);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Query_And_Remove_SubTree</c> function checks whether a device instance and its children can be removed and, if so, it
|
||
/// removes them.
|
||
/// </summary>
|
||
/// <param name="dnAncestor">
|
||
/// Caller-supplied device instance handle to the device at the root of the subtree to be removed. This device instance handle is
|
||
/// bound to the local machine.
|
||
/// </param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a PNP_VETO_TYPE-typed value that indicates the reason for the veto.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a text string that is associated with the veto type. The type of information this
|
||
/// string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// Caller-supplied value representing the length (number of characters) of the string buffer supplied by pszVetoName. This should
|
||
/// be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">A bitwise OR of the caller-supplied flag constants that are described in the <c>Remarks</c> section.</param>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the other CR_-prefixed error codes
|
||
/// defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The purpose of the <c>CM_Query_And_Remove_SubTree</c> function is to allow an application to prepare a device for safe removal
|
||
/// from the local machine. Use this function to remove devices only if a driver has not set the <c>SurpriseRemovalOK</c> member of
|
||
/// DEVICE_CAPABILITIES. If a driver has set <c>SurpriseRemovalOK</c>, the application should call CM_Request_Device_Eject instead
|
||
/// of <c>CM_Query_And_Remove_SubTree</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>CM_Query_And_Remove_SubTree</c> supports setting the flags parameter ulFlags with one of the following two flags; these flags
|
||
/// apply only if Windows or an installer vetoes the removal of a device:
|
||
/// </para>
|
||
/// <para>
|
||
/// Beginning with Windows XP, <c>CM_Query_And_Remove_SubTree</c> also supports setting the following additional flag; this flag
|
||
/// applies only if the function successfully removes the device instance:
|
||
/// </para>
|
||
/// <para>
|
||
/// Windows applications that do not require the low-level operation <c>CM_Query_And_Remove_SubTree</c> should use the
|
||
/// DIF_PROPERTYCHANGE request to disable a device instead of using <c>CM_Query_And_Remove_SubTree</c> to remove a device. The
|
||
/// DIF_PROPERTYCHANGE request can be used to enable, disable, restart, stop, or change the properties of a device.
|
||
/// </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_query_and_remove_subtreew CMAPI CONFIGRET
|
||
// CM_Query_And_Remove_SubTreeW( DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_And_Remove_SubTreeW")]
|
||
public static extern CONFIGRET CM_Query_And_Remove_SubTree(uint dnAncestor, out PNP_VETO_TYPE pVetoType, [Optional] StringBuilder pszVetoName, uint ulNameLength, CM_REMOVE ulFlags);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Query_And_Remove_SubTree</c> function checks whether a device instance and its children can be removed and, if so, it
|
||
/// removes them.
|
||
/// </summary>
|
||
/// <param name="dnAncestor">
|
||
/// Caller-supplied device instance handle to the device at the root of the subtree to be removed. This device instance handle is
|
||
/// bound to the local machine.
|
||
/// </param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a PNP_VETO_TYPE-typed value that indicates the reason for the veto.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a text string that is associated with the veto type. The type of information this
|
||
/// string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// Caller-supplied value representing the length (number of characters) of the string buffer supplied by pszVetoName. This should
|
||
/// be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">A bitwise OR of the caller-supplied flag constants that are described in the <c>Remarks</c> section.</param>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, it returns one of the other CR_-prefixed error codes
|
||
/// defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The purpose of the <c>CM_Query_And_Remove_SubTree</c> function is to allow an application to prepare a device for safe removal
|
||
/// from the local machine. Use this function to remove devices only if a driver has not set the <c>SurpriseRemovalOK</c> member of
|
||
/// DEVICE_CAPABILITIES. If a driver has set <c>SurpriseRemovalOK</c>, the application should call CM_Request_Device_Eject instead
|
||
/// of <c>CM_Query_And_Remove_SubTree</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>CM_Query_And_Remove_SubTree</c> supports setting the flags parameter ulFlags with one of the following two flags; these flags
|
||
/// apply only if Windows or an installer vetoes the removal of a device:
|
||
/// </para>
|
||
/// <para>
|
||
/// Beginning with Windows XP, <c>CM_Query_And_Remove_SubTree</c> also supports setting the following additional flag; this flag
|
||
/// applies only if the function successfully removes the device instance:
|
||
/// </para>
|
||
/// <para>
|
||
/// Windows applications that do not require the low-level operation <c>CM_Query_And_Remove_SubTree</c> should use the
|
||
/// DIF_PROPERTYCHANGE request to disable a device instead of using <c>CM_Query_And_Remove_SubTree</c> to remove a device. The
|
||
/// DIF_PROPERTYCHANGE request can be used to enable, disable, restart, stop, or change the properties of a device.
|
||
/// </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_query_and_remove_subtreew CMAPI CONFIGRET
|
||
// CM_Query_And_Remove_SubTreeW( DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_And_Remove_SubTreeW")]
|
||
public static extern CONFIGRET CM_Query_And_Remove_SubTree(uint dnAncestor, [In, Optional] IntPtr pVetoType, [Optional] StringBuilder pszVetoName, uint ulNameLength, CM_REMOVE ulFlags);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Query_And_Remove_SubTree instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Query_And_Remove_SubTree_Ex</c> function checks whether a device instance and its children can be removed and, if so,
|
||
/// it removes them.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dnAncestor">
|
||
/// Caller-supplied device instance handle to the device at the root of the subtree to be removed. This device instance handle is
|
||
/// bound to the machine handle supplied by hMachine.
|
||
/// </param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a PNP_VETO_TYPE-typed value that indicates the reason for the veto.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a text string that is associated with the veto type. The type of information this
|
||
/// string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length (number of characters) of the string buffer supplied by pszVetoName.
|
||
/// This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">A bitwise OR of the caller-supplied flag constants that are described in the <c>Remarks</c> section.</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 purpose of the <c>CM_Query_And_Remove_SubTree_Ex</c> function is to allow an application to prepare a device for safe
|
||
/// removal from a remote machine. Use this function to remove devices only if a driver has not set the <c>SurpriseRemovalOK</c>
|
||
/// member of DEVICE_CAPABILITIES. If a driver has set <c>SurpriseRemovalOK</c>, the application should call
|
||
/// CM_Request_Device_Eject_Ex instead of <c>CM_Query_And_Remove_SubTree_Ex</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>CM_Query_And_Remove_SubTree_Ex</c> supports setting the flags parameter ulFlags with one of the following two flags; these
|
||
/// flags apply only if Windows or an installer vetoes the removal of a device:
|
||
/// </para>
|
||
/// <para>
|
||
/// Beginning with Windows XP, <c>CM_Query_And_Remove_SubTree_Ex</c> also supports setting the following additional flag; this flag
|
||
/// applies only if the function successfully removes the device instance:
|
||
/// </para>
|
||
/// <para>
|
||
/// Device installation applications that do not require the low-level operation of <c>CM_Query_And_Remove_SubTree_Ex</c> should use
|
||
/// the DIF_PROPERTYCHANGE request to disable a device instead of using <c>CM_Query_And_Remove_SubTree_Ex</c> to remove a device.
|
||
/// The DIF_PROPERTYCHANGE request can be used to enable, disable, restart, stop, or change the properties of a device.
|
||
/// </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_query_and_remove_subtree_exw CMAPI CONFIGRET
|
||
// CM_Query_And_Remove_SubTree_ExW( DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG
|
||
// ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_And_Remove_SubTree_ExW")]
|
||
public static extern CONFIGRET CM_Query_And_Remove_SubTree_Ex(uint dnAncestor, out PNP_VETO_TYPE pVetoType, [Optional] StringBuilder pszVetoName, uint ulNameLength, CM_REMOVE ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Query_And_Remove_SubTree instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Query_And_Remove_SubTree_Ex</c> function checks whether a device instance and its children can be removed and, if so,
|
||
/// it removes them.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dnAncestor">
|
||
/// Caller-supplied device instance handle to the device at the root of the subtree to be removed. This device instance handle is
|
||
/// bound to the machine handle supplied by hMachine.
|
||
/// </param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a PNP_VETO_TYPE-typed value that indicates the reason for the veto.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional) If the caller does not pass <c>NULL</c> and the removal request is vetoed (that is, the function returns
|
||
/// CR_REMOVE_VETOED), on return this points to a text string that is associated with the veto type. The type of information this
|
||
/// string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length (number of characters) of the string buffer supplied by pszVetoName.
|
||
/// This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">A bitwise OR of the caller-supplied flag constants that are described in the <c>Remarks</c> section.</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 purpose of the <c>CM_Query_And_Remove_SubTree_Ex</c> function is to allow an application to prepare a device for safe
|
||
/// removal from a remote machine. Use this function to remove devices only if a driver has not set the <c>SurpriseRemovalOK</c>
|
||
/// member of DEVICE_CAPABILITIES. If a driver has set <c>SurpriseRemovalOK</c>, the application should call
|
||
/// CM_Request_Device_Eject_Ex instead of <c>CM_Query_And_Remove_SubTree_Ex</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>CM_Query_And_Remove_SubTree_Ex</c> supports setting the flags parameter ulFlags with one of the following two flags; these
|
||
/// flags apply only if Windows or an installer vetoes the removal of a device:
|
||
/// </para>
|
||
/// <para>
|
||
/// Beginning with Windows XP, <c>CM_Query_And_Remove_SubTree_Ex</c> also supports setting the following additional flag; this flag
|
||
/// applies only if the function successfully removes the device instance:
|
||
/// </para>
|
||
/// <para>
|
||
/// Device installation applications that do not require the low-level operation of <c>CM_Query_And_Remove_SubTree_Ex</c> should use
|
||
/// the DIF_PROPERTYCHANGE request to disable a device instead of using <c>CM_Query_And_Remove_SubTree_Ex</c> to remove a device.
|
||
/// The DIF_PROPERTYCHANGE request can be used to enable, disable, restart, stop, or change the properties of a device.
|
||
/// </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_query_and_remove_subtree_exw CMAPI CONFIGRET
|
||
// CM_Query_And_Remove_SubTree_ExW( DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG
|
||
// ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_And_Remove_SubTree_ExW")]
|
||
public static extern CONFIGRET CM_Query_And_Remove_SubTree_Ex(uint dnAncestor, [In, Optional] IntPtr pVetoType, [Optional] StringBuilder pszVetoName, uint ulNameLength, CM_REMOVE ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Query_Resource_Conflict_List</c> function identifies device instances having resource requirements that conflict with
|
||
/// a specified device instance's resource description.
|
||
/// </summary>
|
||
/// <param name="pclConflictList">Caller-supplied address of a location to receive a handle to a conflict list.</param>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
|
||
/// <param name="ResourceID">
|
||
/// Caller-supplied resource type identifier. This must be one of the <c>ResType_</c>-prefixed constants defined in Cfgmgr32.h.
|
||
/// </param>
|
||
/// <param name="ResourceData">
|
||
/// Caller-supplied pointer to a resource descriptor, which can be one of the structures listed under the CM_Add_Res_Des function's
|
||
/// description of ResourceData.
|
||
/// </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">Caller-supplied machine handle to which the caller-supplied device instance handle is bound.</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_Query_Resource_Conflict_List</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>
|
||
/// When calling <c>CM_Query_Resource_Conflict_List</c>, specify a device instance handle and resource descriptor. (Resource
|
||
/// descriptors for existing device nodes can be obtained by calling CM_Get_Res_Des_Data.) These parameters indicate the specific
|
||
/// resources you'd like a specific device to use. The resulting conflict list identifies devices that use the same resources, along
|
||
/// with resources reserved by the machine.
|
||
/// </para>
|
||
/// <para>
|
||
/// After calling <c>CM_Query_Resource_Conflict_List</c>, an application can call CM_Get_Resource_Conflict_Count to determine the
|
||
/// number of conflicts contained in the resource conflict list. (The number of conflicts can be zero.) Then the application can
|
||
/// call CM_Get_Resource_Conflict_Details for each entry in the conflict list.
|
||
/// </para>
|
||
/// <para>After an application has finished using the handle received for pclConflictList, it must call CM_Free_Resource_Conflict_Handle.</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>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_query_resource_conflict_list CMAPI CONFIGRET
|
||
// CM_Query_Resource_Conflict_List( PCONFLICT_LIST pclConflictList, DEVINST dnDevInst, RESOURCEID ResourceID, PCVOID ResourceData,
|
||
// ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_Resource_Conflict_List")]
|
||
public static extern CONFIGRET CM_Query_Resource_Conflict_List(out SafeCONFLICT_LIST pclConflictList, uint dnDevInst, RESOURCEID ResourceID, [In] IntPtr ResourceData,
|
||
uint ResourceLen, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Query_Resource_Conflict_List</c> function identifies device instances having resource requirements that conflict with
|
||
/// a specified device instance's resource description.
|
||
/// </summary>
|
||
/// <typeparam name="T">The type of the supplied data.</typeparam>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
|
||
/// <param name="data">
|
||
/// Caller-supplied pointer to a resource descriptor, which can be one of the structures listed under the CM_Add_Res_Des function's
|
||
/// description of ResourceData.
|
||
/// </param>
|
||
/// <param name="ResourceID">
|
||
/// Caller-supplied resource type identifier. If <c>0</c>, then the <see cref="RESOURCEID"/> is determined by <typeparamref name="T"/>.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>A handle to a conflict list.</para>
|
||
/// <para>
|
||
/// <c>Note</c> Starting with Windows 8, <c>CM_Query_Resource_Conflict_List</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>
|
||
/// When calling <c>CM_Query_Resource_Conflict_List</c>, specify a device instance handle and resource descriptor. (Resource
|
||
/// descriptors for existing device nodes can be obtained by calling CM_Get_Res_Des_Data.) These parameters indicate the specific
|
||
/// resources you'd like a specific device to use. The resulting conflict list identifies devices that use the same resources, along
|
||
/// with resources reserved by the machine.
|
||
/// </para>
|
||
/// <para>
|
||
/// After calling <c>CM_Query_Resource_Conflict_List</c>, an application can call CM_Get_Resource_Conflict_Count to determine the
|
||
/// number of conflicts contained in the resource conflict list. (The number of conflicts can be zero.) Then the application can
|
||
/// call CM_Get_Resource_Conflict_Details for each entry in the conflict list.
|
||
/// </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>
|
||
/// </remarks>
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Query_Resource_Conflict_List")]
|
||
public static SafeCONFLICT_LIST CM_Query_Resource_Conflict_List<T>(uint dnDevInst, 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_Query_Resource_Conflict_List(out var hcl, dnDevInst, ResourceID, mem, mem.Size).ThrowIfFailed();
|
||
return hcl;
|
||
}
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Reenumerate_DevNode</c> function enumerates the devices identified by a specified device node and all of its children.
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>
|
||
/// Caller-supplied flags that specify how reenumeration should occur. This parameter can be set to a combination of the following
|
||
/// flags, as noted:
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_ASYNCHRONOUS</para>
|
||
/// <para>
|
||
/// Reenumeration should occur asynchronously. The call to this function returns immediately after the PnP manager receives the
|
||
/// reenumeration request. If this flag is set, the CM_REENUMERATE_SYNCHRONOUS flag should not also be set.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_NORMAL</para>
|
||
/// <para>
|
||
/// Specifies default reenumeration behavior, in which reenumeration occurs synchronously. This flag is functionally equivalent to CM_REENUMERATE_SYNCHRONOUS.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_RETRY_INSTALLATION</para>
|
||
/// <para>
|
||
/// Specifies that Plug and Play should make another attempt to install any devices in the specified subtree that have been detected
|
||
/// but are not yet configured, or are marked as needing reinstallation, or for which installation must be completed. This flag can
|
||
/// be set along with either the CM_REENUMERATE_SYNCHRONOUS flag or the CM_REENUMERATE_ASYNCHRONOUS flag.
|
||
/// </para>
|
||
/// <para>
|
||
/// This flag must be used with extreme caution, because it can cause the PnP manager to prompt the user to perform installation of
|
||
/// any such devices. Currently, only components such as Device Manager and Hardware Wizard use this flag, to allow the user to
|
||
/// retry installation of devices that might already have been detected but are not currently installed.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_SYNCHRONOUS</para>
|
||
/// <para>
|
||
/// Reenumeration should occur synchronously. The call to this function returns when all devices in the specified subtree have been
|
||
/// reenumerated. If this flag is set, the CM_REENUMERATE_ASYNCHRONOUS flag should not also be set. This flag is functionally
|
||
/// equivalent to CM_REENUMERATE_NORMAL.
|
||
/// </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>
|
||
/// If the specified device node represents a hardware or software bus device, the PnP manager queries the device's drivers for a
|
||
/// list of children, then attempts to configure and start any child devices that were not previously configured. The PnP manager
|
||
/// also initiates surprise-removal of devices that are no longer present (see IRP_MN_SURPRISE_REMOVAL).
|
||
/// </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_reenumerate_devnode CMAPI CONFIGRET
|
||
// CM_Reenumerate_DevNode( DEVINST dnDevInst, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Reenumerate_DevNode")]
|
||
public static extern CONFIGRET CM_Reenumerate_DevNode(uint dnDevInst, CM_REENUMERATE ulFlags);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Reenumerate_DevNode instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Reenumerate_DevNode_Ex</c> function enumerates the devices identified by a specified device node and all of its children.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>
|
||
/// Caller-supplied flags that specify how reenumeration should occur. This parameter can be set to a combination of the following
|
||
/// flags, as noted:
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_ASYNCHRONOUS</para>
|
||
/// <para>
|
||
/// Reenumeration should occur asynchronously. The call to this function returns immediately after the PnP manager receives the
|
||
/// reenumeration request. If this flag is set, the CM_REENUMERATE_SYNCHRONOUS flag should not also be set.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_NORMAL</para>
|
||
/// <para>
|
||
/// Specifies default reenumeration behavior, in which reenumeration occurs synchronously. This flag is currently equivalent to CM_REENUMERATE_SYNCHRONOUS.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_RETRY_INSTALLATION</para>
|
||
/// <para>
|
||
/// Specifies that Plug and Play should make another attempt to install any devices in the specified subtree that have been detected
|
||
/// but are not yet configured, or are marked as needing reinstallation, or for which installation must be completed. This flag can
|
||
/// be set along with either the CM_REENUMERATE_SYNCHRONOUS flag or the CM_REENUMERATE_ASYNCHRONOUS flag.
|
||
/// </para>
|
||
/// <para>
|
||
/// This flag must be used with extreme caution, because it can cause the PnP manager to prompt the user to perform installation of
|
||
/// any such devices. Currently, only components such as Device Manager and Hardware Wizard use this flag, to allow the user to
|
||
/// retry installation of devices that might already have been detected but are not currently installed.
|
||
/// </para>
|
||
/// <para>CM_REENUMERATE_SYNCHRONOUS</para>
|
||
/// <para>
|
||
/// Reenumeration should occur synchronously. The call to this function returns when all devices in the specified subtree have been
|
||
/// reenumerated. If this flag is set, the CM_REENUMERATE_ASYNCHRONOUS flag should not also be set. This flag is currently
|
||
/// equivalent to CM_REENUMERATE_NORMAL.
|
||
/// </para>
|
||
/// </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>
|
||
/// If the specified device node represents a hardware or software bus device, the PnP manager queries the device's drivers for a
|
||
/// list of children, then attempts to configure and start any child devices that were not previously configured. The PnP manager
|
||
/// also initiates surprise-removal of devices that are no longer present (see IRP_MN_SURPRISE_REMOVAL).
|
||
/// </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_reenumerate_devnode_ex CMAPI CONFIGRET
|
||
// CM_Reenumerate_DevNode_Ex( DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Reenumerate_DevNode_Ex")]
|
||
public static extern CONFIGRET CM_Reenumerate_DevNode_Ex(uint dnDevInst, CM_REENUMERATE ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Use RegisterDeviceNotification instead of <c>CM_Register_Notification</c> if your code targets Windows 7 or earlier versions of
|
||
/// Windows. Kernel mode callers should use IoRegisterPlugPlayNotification instead.
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Register_Notification</c> function registers an application callback routine to be called when a PnP event of the
|
||
/// specified type occurs.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="pFilter">Pointer to a CM_NOTIFY_FILTER structure.</param>
|
||
/// <param name="pContext">
|
||
/// Pointer to a caller-allocated buffer containing the context to be passed to the callback routine in pCallback.
|
||
/// </param>
|
||
/// <param name="pCallback">
|
||
/// <para>
|
||
/// Pointer to the routine to be called when the specified PnP event occurs. See the <c>Remarks</c> section for the callback
|
||
/// function's prototype.
|
||
/// </para>
|
||
/// <para>The callback routine<6E>s Action parameter will be a value from the CM_NOTIFY_ACTION enumeration.</para>
|
||
/// <para>
|
||
/// Upon receiving a notification, how the callback examines the notification will depend on the <c>FilterType</c> member of the
|
||
/// callback routine's EventData parameter:
|
||
/// </para>
|
||
/// <para>CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE</para>
|
||
/// <para>The callback should examine <c>EventData->u.DeviceInterface</c>.</para>
|
||
/// <para>CM_NOTIFY_FILTER_TYPE_DEVICEHANDLE</para>
|
||
/// <para>The callback should examine <c>EventData->u.DeviceHandle</c>.</para>
|
||
/// <para>CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE</para>
|
||
/// <para>The callback should examine <c>EventData->u.DeviceInstance</c>.</para>
|
||
/// </param>
|
||
/// <param name="pNotifyContext">Pointer to receive the HCMNOTIFICATION handle that corresponds to the registration call.</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>
|
||
/// Be sure to handle Plug and Play device events as quickly as possible. If your event handler performs any operation that may
|
||
/// block execution (such as I/O), it is best to start another thread to perform the operation asynchronously.
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Register_Notification</c> function does not provide notification of existing device interfaces. To retrieve existing
|
||
/// interfaces, first call <c>CM_Register_Notification</c>, and then call CM_Get_Device_Interface_List. If the interface is enabled
|
||
/// after your driver calls <c>CM_Register_Notification</c>, but before your driver calls <c>CM_Get_Device_Interface_List</c>, the
|
||
/// driver receives a notification for the interface arrival, and the interface also appears in the list of device interface
|
||
/// instances returned by <c>CM_Get_Device_Interface_List</c>.
|
||
/// </para>
|
||
/// <para>
|
||
/// HCMNOTIFICATION handles returned by <c>CM_Register_Notification</c> must be closed by calling the CM_Unregister_Notification
|
||
/// function when they are no longer needed.
|
||
/// </para>
|
||
/// <para>A callback routine uses the following function prototype:</para>
|
||
/// <para>
|
||
/// <code>typedef __callback DWORD (CALLBACK *PCM_NOTIFY_CALLBACK)( _In_ HCMNOTIFICATION hNotify, _In_opt_ PVOID Context, _In_ CM_NOTIFY_ACTION Action, _In_reads_bytes_(EventDataSize) PCM_NOTIFY_EVENT_DATA EventData, _In_ DWORD EventDataSize );</code>
|
||
/// </para>
|
||
/// <para>
|
||
/// If responding to a <c>CM_NOTIFY_ACTION_DEVICEQUERYREMOVE</c> notification, the PCM_NOTIFY_CALLBACK callback should return either
|
||
/// ERROR_SUCCESS or ERROR_CANCELLED, as appropriate. Otherwise, the callback should return ERROR_SUCCESS. The callback should not
|
||
/// return any other values. For a description of other actions, please refer to the CM_NOTIFY_ACTION documentation. Also see
|
||
/// CM_NOTIFY_EVENT_DATA for information about the structure that this callback receives in the EventData parameter.
|
||
/// </para>
|
||
/// <para>Examples</para>
|
||
/// <para>For an example, see Registering for Notification of Device Interface Arrival and Device Removal.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_register_notification CMAPI CONFIGRET
|
||
// CM_Register_Notification( PCM_NOTIFY_FILTER pFilter, PVOID pContext, PCM_NOTIFY_CALLBACK pCallback, PHCMNOTIFICATION
|
||
// pNotifyContext );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Register_Notification")]
|
||
public static extern CONFIGRET CM_Register_Notification(in CM_NOTIFY_FILTER pFilter, [In, Optional] IntPtr pContext, CM_NOTIFY_CALLBACK pCallback, out SafeHCMNOTIFICATION pNotifyContext);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Request_Device_Eject</c> function prepares a local device instance for safe removal, if the device is removable. If
|
||
/// the device can be physically ejected, it will be.
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional.) If not <c>NULL</c>, this points to a location that, if the removal request fails, receives a PNP_VETO_TYPE-typed
|
||
/// value indicating the reason for the failure.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional.) If not <c>NULL</c>, this is a caller-supplied pointer to a string buffer that receives a text string. The type of
|
||
/// information this string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length of the string buffer supplied by pszVetoName. This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">Not used.</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>
|
||
/// If pszVetoName is <c>NULL</c>, the PnP manager displays a message to the user indicating the device was removed or, if the
|
||
/// request failed, identifying the reason for the failure. If pszVetoName is not <c>NULL</c>, the PnP manager does not display a
|
||
/// message. (Note, however, that for Microsoft Windows 2000 only, the PnP manager displays a message even if pszVetoName is not
|
||
/// <c>NULL</c>, if the device's CM_DEVCAP_DOCKDEVICE capability is set.)
|
||
/// </para>
|
||
/// <para>
|
||
/// Callers of <c>CM_Request_Device_Eject</c> sometimes require <c>SeUndockPrivilege</c> or <c>SeLoadDriverPrivilege</c>, as follows:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is set (the device is a "dock" device), callers must have
|
||
/// <c>SeUndockPrivilege</c>. ( <c>SeLoadDriverPrivilege</c> is not required.)
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is not set (the device is not a "dock" device), and if the calling process is
|
||
/// either not interactive or is running in a multi-user environment in a session not attached to the physical console (such as a
|
||
/// remote Terminal Services session), callers of this function must have <c>SeLoadDriverPrivilege</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>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_request_device_ejectw CMAPI CONFIGRET
|
||
// CM_Request_Device_EjectW( DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Device_EjectW")]
|
||
public static extern CONFIGRET CM_Request_Device_Eject(uint dnDevInst, out PNP_VETO_TYPE pVetoType, [Out] StringBuilder pszVetoName, uint ulNameLength, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Request_Device_Eject</c> function prepares a local device instance for safe removal, if the device is removable. If
|
||
/// the device can be physically ejected, it will be.
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional.) If not <c>NULL</c>, this points to a location that, if the removal request fails, receives a PNP_VETO_TYPE-typed
|
||
/// value indicating the reason for the failure.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional.) If not <c>NULL</c>, this is a caller-supplied pointer to a string buffer that receives a text string. The type of
|
||
/// information this string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length of the string buffer supplied by pszVetoName. This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">Not used.</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>
|
||
/// If pszVetoName is <c>NULL</c>, the PnP manager displays a message to the user indicating the device was removed or, if the
|
||
/// request failed, identifying the reason for the failure. If pszVetoName is not <c>NULL</c>, the PnP manager does not display a
|
||
/// message. (Note, however, that for Microsoft Windows 2000 only, the PnP manager displays a message even if pszVetoName is not
|
||
/// <c>NULL</c>, if the device's CM_DEVCAP_DOCKDEVICE capability is set.)
|
||
/// </para>
|
||
/// <para>
|
||
/// Callers of <c>CM_Request_Device_Eject</c> sometimes require <c>SeUndockPrivilege</c> or <c>SeLoadDriverPrivilege</c>, as follows:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is set (the device is a "dock" device), callers must have
|
||
/// <c>SeUndockPrivilege</c>. ( <c>SeLoadDriverPrivilege</c> is not required.)
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is not set (the device is not a "dock" device), and if the calling process is
|
||
/// either not interactive or is running in a multi-user environment in a session not attached to the physical console (such as a
|
||
/// remote Terminal Services session), callers of this function must have <c>SeLoadDriverPrivilege</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>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_request_device_ejectw CMAPI CONFIGRET
|
||
// CM_Request_Device_EjectW( DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Device_EjectW")]
|
||
public static extern CONFIGRET CM_Request_Device_Eject(uint dnDevInst, [In, Optional] IntPtr pVetoType, [Out] StringBuilder pszVetoName, uint ulNameLength, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Request_Device_Eject instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Request_Device_Eject_Ex</c> function prepares a local or a remote device instance for safe removal, if the device is
|
||
/// removable. If the device can be physically ejected, it will be.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional.) If not <c>NULL</c>, this points to a location that, if the removal request fails, receives a PNP_VETO_TYPE-typed
|
||
/// value indicating the reason for the failure.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional.) If not <c>NULL</c>, this is a caller-supplied pointer to a string buffer that receives a text string. The type of
|
||
/// information this string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length of the string buffer supplied by pszVetoName. This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">Not used.</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>
|
||
/// If pszVetoName is <c>NULL</c>, the PnP manager displays a message to the user indicating the device was removed or, if the
|
||
/// request failed, identifying the reason for the failure. If pszVetoName is not <c>NULL</c>, the PnP manager does not display a
|
||
/// message. (Note, however, that for Microsoft Windows 2000 only, the PnP manager displays a message even if pszVetoName is not
|
||
/// <c>NULL</c>, if the device's CM_DEVCAP_DOCKDEVICE capability is set.)
|
||
/// </para>
|
||
/// <para>
|
||
/// For remote machines, this function only works for "dock" device instances. That is, the function can only be used remotely to
|
||
/// undock a machine. In that case, the caller must have <c>SeUndockPrivilege</c>.
|
||
/// </para>
|
||
/// <para>Callers of <c>CM_Request_Eject_Ex</c> sometimes require <c>SeUndockPrivilege</c> or <c>SeLoadDriverPrivilege</c>, as follows:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is set (the device is a "dock" device), callers must have
|
||
/// <c>SeUndockPrivilege</c>. ( <c>SeLoadDriverPrivilege</c> is not required.)
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is not set (the device is not a "dock" device), and if the calling process is
|
||
/// either not interactive or is running in a multi-user environment in a session not attached to the physical console (such as a
|
||
/// remote Terminal Services session) callers of this function must have <c>SeLoadDriverPrivilege</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>(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_request_device_eject_exw CMAPI CONFIGRET
|
||
// CM_Request_Device_Eject_ExW( DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags,
|
||
// HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Device_Eject_ExW")]
|
||
public static extern CONFIGRET CM_Request_Device_Eject_Ex(uint dnDevInst, out PNP_VETO_TYPE pVetoType, [Out] StringBuilder pszVetoName, uint ulNameLength, [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_Request_Device_Eject instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Request_Device_Eject_Ex</c> function prepares a local or a remote device instance for safe removal, if the device is
|
||
/// removable. If the device can be physically ejected, it will be.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the machine handle supplied by hMachine.</param>
|
||
/// <param name="pVetoType">
|
||
/// (Optional.) If not <c>NULL</c>, this points to a location that, if the removal request fails, receives a PNP_VETO_TYPE-typed
|
||
/// value indicating the reason for the failure.
|
||
/// </param>
|
||
/// <param name="pszVetoName">
|
||
/// (Optional.) If not <c>NULL</c>, this is a caller-supplied pointer to a string buffer that receives a text string. The type of
|
||
/// information this string provides is dependent on the value received by pVetoType. For information about these strings, see PNP_VETO_TYPE.
|
||
/// </param>
|
||
/// <param name="ulNameLength">
|
||
/// (Optional.) Caller-supplied value representing the length of the string buffer supplied by pszVetoName. This should be set to MAX_PATH.
|
||
/// </param>
|
||
/// <param name="ulFlags">Not used.</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>
|
||
/// If pszVetoName is <c>NULL</c>, the PnP manager displays a message to the user indicating the device was removed or, if the
|
||
/// request failed, identifying the reason for the failure. If pszVetoName is not <c>NULL</c>, the PnP manager does not display a
|
||
/// message. (Note, however, that for Microsoft Windows 2000 only, the PnP manager displays a message even if pszVetoName is not
|
||
/// <c>NULL</c>, if the device's CM_DEVCAP_DOCKDEVICE capability is set.)
|
||
/// </para>
|
||
/// <para>
|
||
/// For remote machines, this function only works for "dock" device instances. That is, the function can only be used remotely to
|
||
/// undock a machine. In that case, the caller must have <c>SeUndockPrivilege</c>.
|
||
/// </para>
|
||
/// <para>Callers of <c>CM_Request_Eject_Ex</c> sometimes require <c>SeUndockPrivilege</c> or <c>SeLoadDriverPrivilege</c>, as follows:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is set (the device is a "dock" device), callers must have
|
||
/// <c>SeUndockPrivilege</c>. ( <c>SeLoadDriverPrivilege</c> is not required.)
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// If the device's CM_DEVCAP_DOCKDEVICE capability is not set (the device is not a "dock" device), and if the calling process is
|
||
/// either not interactive or is running in a multi-user environment in a session not attached to the physical console (such as a
|
||
/// remote Terminal Services session) callers of this function must have <c>SeLoadDriverPrivilege</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>(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_request_device_eject_exw CMAPI CONFIGRET
|
||
// CM_Request_Device_Eject_ExW( DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, ULONG ulNameLength, ULONG ulFlags,
|
||
// HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Device_Eject_ExW")]
|
||
public static extern CONFIGRET CM_Request_Device_Eject_Ex(uint dnDevInst, [In, Optional] IntPtr pVetoType, [Out] StringBuilder pszVetoName, uint ulNameLength, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Request_Eject_PC</c> function requests that a portable PC, which is inserted in a local docking station, be ejected.
|
||
/// </summary>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to request that a portable PC, which is inserted in a local docking station, be ejected. You can also use the
|
||
/// following related functions with docking stations:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present identifies whether a docking station is present in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present_Ex identifies whether a docking station is present in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC_Ex requests that a portable PC, which is inserted in a local or a remote docking station, be ejected.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_request_eject_pc CMAPI CONFIGRET CM_Request_Eject_PC();
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Eject_PC")]
|
||
public static extern CONFIGRET CM_Request_Eject_PC();
|
||
|
||
/// <summary>
|
||
/// <para>[Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Request_Eject_PC instead.]</para>
|
||
/// <para>
|
||
/// The <c>CM_Request_Eject_PC_Ex</c> function requests that a portable PC, which is inserted in a local or a remote docking
|
||
/// station, be ejected.
|
||
/// </para>
|
||
/// </summary>
|
||
/// <param name="hMachine">
|
||
/// <para>Supplies a machine handle that is returned by 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, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to request that a portable PC, which is inserted in a local or a remote docking station, be ejected. You can
|
||
/// also use the following related functions with docking stations:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present identifies whether a docking station is present in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Is_Dock_Station_Present_Ex identifies whether a docking station is present in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Request_Eject_PC requests that a portable PC, which is inserted in a local docking station, be ejected.</para>
|
||
/// </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_request_eject_pc_ex CMAPI CONFIGRET
|
||
// CM_Request_Eject_PC_Ex( HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Request_Eject_PC_Ex")]
|
||
public static extern CONFIGRET CM_Request_Eject_PC_Ex([In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_Class_Property</c> function sets a class property for a device setup class or a device interface class.</summary>
|
||
/// <param name="ClassGUID">
|
||
/// Pointer to the GUID that identifies the device interface class or device setup class for which to set a device property. For
|
||
/// information about specifying the class type, see the ulFlags parameter.
|
||
/// </param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device class property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device class property. To delete a property,
|
||
/// set this to DEVPROP_TYPE_EMPTY.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device class property. If either the property or the data is to be
|
||
/// deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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_Set_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_set_class_propertyw CMAPI CONFIGRET
|
||
// CM_Set_Class_PropertyW( LPCGUID ClassGUID, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const PBYTE PropertyBuffer,
|
||
// ULONG PropertyBufferSize, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_Class_PropertyW")]
|
||
public static extern CONFIGRET CM_Set_Class_Property(in Guid ClassGUID, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer, uint PropertyBufferSize, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Set_Class_Property instead.]
|
||
/// </para>
|
||
/// <para>The <c>CM_Set_Class_Property_ExW</c> function sets a class property for a device setup class or a device interface class.</para>
|
||
/// </summary>
|
||
/// <param name="ClassGUID">
|
||
/// Pointer to the GUID that identifies the device interface class or device setup class for which to set a device property. For
|
||
/// information about specifying the class type, see the ulFlags parameter.
|
||
/// </param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device class property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device class property. To delete a property,
|
||
/// set this to <c>DEVPROP_TYPE_EMPTY</c>.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device class property. If either the property or the data is to be
|
||
/// deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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_Set_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_set_class_property_exw CMAPI CONFIGRET
|
||
// CM_Set_Class_Property_ExW( LPCGUID ClassGUID, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const PBYTE
|
||
// PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_Class_Property_ExW")]
|
||
public static extern CONFIGRET CM_Set_Class_Property_Ex(in Guid ClassGUID, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer, uint PropertyBufferSize,
|
||
CM_CLASS_PROPERTY ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_Class_Registry_Property</c> function sets or deletes a property of a device setup class.</summary>
|
||
/// <param name="ClassGuid">A pointer to the GUID that represents the device setup class for which to set a property.</param>
|
||
/// <param name="ulProperty">
|
||
/// A value of type ULONG that identifies the property to set. This value must be one of the CM_CRP_Xxx values that are described
|
||
/// for the ulProperty parameter of the CM_Get_Class_Registry_Property function.
|
||
/// </param>
|
||
/// <param name="Buffer">
|
||
/// A pointer to a buffer that contains the property data. This parameter is optional and can be set to <c>NULL</c>. For more
|
||
/// information about setting this parameter and the corresponding ulLength parameter, see the following <c>Remarks</c> section.
|
||
/// </param>
|
||
/// <param name="ulLength">A value of type ULONG that specifies the size, in bytes, of the property data.</param>
|
||
/// <param name="ulFlags">Reserved for internal use only. Must be set to zero.</param>
|
||
/// <param name="hMachine">
|
||
/// A handle to a remote machine on which to set the specified device setup class property. This parameter is optional. If set to
|
||
/// <c>NULL</c>, the property is set on the local machine.
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the operation succeeds, <c>CM_Set_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>
|
||
/// <para>If Buffer is <c>NULL</c>, ulLength must be set to zero.</para>
|
||
/// <para>If ulLength is set to zero, the function deletes the property.</para>
|
||
/// <para>
|
||
/// If Buffer is not set to <c>NULL</c> and ulLength is not set to zero, the supplied value must be the correct size for the REG_Xxx
|
||
/// data type for the property that is specified in ulProperty.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_set_class_registry_propertyw CMAPI CONFIGRET
|
||
// CM_Set_Class_Registry_PropertyW( LPGUID ClassGuid, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags, HMACHINE
|
||
// hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_Class_Registry_PropertyW")]
|
||
public static extern CONFIGRET CM_Set_Class_Registry_Property(in Guid ClassGuid, CM_CRP ulProperty, [In, Optional] IntPtr Buffer, uint ulLength, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_Device_Interface_Property</c> function sets a device property of a device interface.</summary>
|
||
/// <param name="pszDeviceInterface">
|
||
/// Pointer to a string that identifies the device interface instance for which to set a property for.
|
||
/// </param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device interface property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device interface property. To delete a
|
||
/// property, this must be set to DEVPROP_TYPE_EMPTY.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device interface property. If either the property or the data is
|
||
/// being deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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>
|
||
/// <remarks><c>CM_Set_Device_Interface_Property</c> is part of the Unified Device Property Model.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_set_device_interface_propertyw CMAPI CONFIGRET
|
||
// CM_Set_Device_Interface_PropertyW( LPCWSTR pszDeviceInterface, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const
|
||
// PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_Device_Interface_PropertyW")]
|
||
public static extern CONFIGRET CM_Set_Device_Interface_Property(string pszDeviceInterface, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer,
|
||
uint PropertyBufferSize, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use
|
||
/// CM_Set_Device_Interface_Property instead.]
|
||
/// </para>
|
||
/// <para>The <c>CM_Set_Device_Interface_Property_ExW</c> function sets a device property of a device interface.</para>
|
||
/// </summary>
|
||
/// <param name="pszDeviceInterface">
|
||
/// Pointer to a string that identifies the device interface instance for which to set a property for.
|
||
/// </param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device interface property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device interface property. To delete a
|
||
/// property, this must be set to DEVPROP_TYPE_EMPTY.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device interface property. If either the property or the data is
|
||
/// being deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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><c>CM_Set_Device_Interface_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_set_device_interface_property_exw CMAPI CONFIGRET
|
||
// CM_Set_Device_Interface_Property_ExW( LPCWSTR pszDeviceInterface, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const
|
||
// PBYTE PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_Device_Interface_Property_ExW")]
|
||
public static extern CONFIGRET CM_Set_Device_Interface_Property_Ex(string pszDeviceInterface, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer,
|
||
uint PropertyBufferSize, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_DevNode_Problem</c> function sets a problem code for a device that is installed in a local machine.</summary>
|
||
/// <param name="dnDevInst">Caller-supplied device instance handle that is bound to the local machine.</param>
|
||
/// <param name="ulProblem">
|
||
/// Supplies a problem code, which is zero or one of the CM_PROB_Xxx flags that are described in Device Manager Error Messages. A
|
||
/// value of zero indicates that a problem is not set for the device.
|
||
/// </param>
|
||
/// <param name="ulFlags">Must be set to zero.</param>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to set a problem code for a device that is installed in a local machine. You can also use the following
|
||
/// functions to set a device's problem code and to obtain the problem code set for the device:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Get_DevNode_Status returns the problem code set for a device installed in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Get_DevNode_Status_Ex returns the problem code set for a device installed in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Set_DevNode_Problem_Ex sets a problem code for a device installed in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <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_set_devnode_problem CMAPI CONFIGRET
|
||
// CM_Set_DevNode_Problem( DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_DevNode_Problem")]
|
||
public static extern CONFIGRET CM_Set_DevNode_Problem(uint dnDevInst, CM_PROB ulProblem, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Set_DevNode_Problem instead.]
|
||
/// </para>
|
||
/// <para>
|
||
/// The <c>CM_Set_DevNode_Problem_Ex</c> function sets a problem code for a device that is installed in 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="ulProblem">
|
||
/// Supplies a problem code, which is zero or one of the CM_PROB_Xxx flags that are described in Device Manager Error Messages. A
|
||
/// value of zero indicates that a problem code is not set for the device.
|
||
/// </param>
|
||
/// <param name="ulFlags">Must be set to 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, the function returns one of the CR_-prefixed error codes
|
||
/// that are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Use this function to set a problem code for a device that is installed in a local or a remote machine. You can also use the
|
||
/// following functions to set a device's problem code and to obtain the problem code set for the device:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Get_DevNode_Status returns the problem code set for a device installed in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Get_DevNode_Status_Ex returns the problem code set for a device installed in a local or a remote machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// <para>CM_Set_DevNode_Problem sets a problem code for a device installed in a local machine.</para>
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <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_set_devnode_problem_ex CMAPI CONFIGRET
|
||
// CM_Set_DevNode_Problem_Ex( DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_DevNode_Problem_Ex")]
|
||
public static extern CONFIGRET CM_Set_DevNode_Problem_Ex(uint dnDevInst, CM_PROB ulProblem, [In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_DevNode_Property</c> function sets a device instance property.</summary>
|
||
/// <param name="dnDevInst">Device instance handle that is bound to the local machine.</param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device instance property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device instance property. To delete a
|
||
/// property, this must be set to DEVPROP_TYPE_EMPTY.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device instance property. If either the property or the data is
|
||
/// being deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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>
|
||
/// <remarks><c>CM_Set_DevNode_Property</c> is part of the Unified Device Property Model.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_set_devnode_propertyw CMAPI CONFIGRET
|
||
// CM_Set_DevNode_PropertyW( DEVINST dnDevInst, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const PBYTE PropertyBuffer,
|
||
// ULONG PropertyBufferSize, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_DevNode_PropertyW")]
|
||
public static extern CONFIGRET CM_Set_DevNode_Property(uint dnDevInst, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer, uint PropertyBufferSize, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// [Beginning with Windows 8 and Windows Server 2012, this function has been deprecated. Please use CM_Set_DevNode_Property instead.]
|
||
/// </para>
|
||
/// <para>The <c>CM_Set_DevNode_Property_ExW</c> function sets a device instance property.</para>
|
||
/// </summary>
|
||
/// <param name="dnDevInst">Device instance handle that is bound to the local machine.</param>
|
||
/// <param name="PropertyKey">
|
||
/// Pointer to a DEVPROPKEY structure that represents the property key of the device instance property to set.
|
||
/// </param>
|
||
/// <param name="PropertyType">
|
||
/// A DEVPROPTYPE-typed value that represents the property-data-type identifier for the device instance property. To delete a
|
||
/// property, this must be set to DEVPROP_TYPE_EMPTY.
|
||
/// </param>
|
||
/// <param name="PropertyBuffer">
|
||
/// Pointer to a buffer that contains the property value of the device instance property. If either the property or the data is
|
||
/// being deleted, this pointer must be set to NULL, and PropertyBufferSize must be set to zero.
|
||
/// </param>
|
||
/// <param name="PropertyBufferSize">
|
||
/// The size, in bytes, of the PropertyBuffer buffer. If PropertyBuffer is set to NULL, PropertyBufferSize must be set to zero.
|
||
/// </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><c>CM_Set_DevNode_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_set_devnode_property_exw CMAPI CONFIGRET
|
||
// CM_Set_DevNode_Property_ExW( DEVINST dnDevInst, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, const PBYTE
|
||
// PropertyBuffer, ULONG PropertyBufferSize, ULONG ulFlags, HMACHINE hMachine );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Unicode)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_DevNode_Property_ExW")]
|
||
public static extern CONFIGRET CM_Set_DevNode_Property_Ex(uint dnDevInst, in DEVPROPKEY PropertyKey, DEVPROPTYPE PropertyType, [In, Optional] IntPtr PropertyBuffer, uint PropertyBufferSize,
|
||
[In, Optional] uint ulFlags, [In, Optional] HMACHINE hMachine);
|
||
|
||
/// <summary>The <c>CM_Set_DevNode_Registry_Property</c> function sets a specified device property in the registry.</summary>
|
||
/// <param name="dnDevInst">A caller-supplied device instance handle that is bound to the local machine.</param>
|
||
/// <param name="ulProperty">
|
||
/// A CM_DRP_-prefixed constant value that identifies the device property to be set in the registry. These constants are defined in Cfgmgr32.h.
|
||
/// </param>
|
||
/// <param name="Buffer">
|
||
/// A pointer to a caller-supplied buffer that supplies the requested device property, formatted appropriately for the property's
|
||
/// data type.
|
||
/// </param>
|
||
/// <param name="ulLength">The length, in bytes, of the supplied device property.</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 that are
|
||
/// defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>For information about how to use 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_set_devnode_registry_propertyw CMAPI CONFIGRET
|
||
// CM_Set_DevNode_Registry_PropertyW( DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, CharSet = CharSet.Auto)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Set_DevNode_Registry_PropertyW")]
|
||
public static extern CONFIGRET CM_Set_DevNode_Registry_Property(uint dnDevInst, CM_DRP ulProperty, [In, Optional] IntPtr Buffer, uint ulLength, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// The <c>CM_Setup_DevNode</c> function restarts a device instance that is not running because there is a problem with the device configuration.
|
||
/// </summary>
|
||
/// <param name="dnDevInst">A device instance handle that is bound to the local system.</param>
|
||
/// <param name="ulFlags">
|
||
/// <para>One of the following flag values:</para>
|
||
/// <para>CM_SETUP_DEVNODE_READY</para>
|
||
/// <para>Restarts a device instance that is not running because of a problem with the device configuration.</para>
|
||
/// <para>CM_SETUP_DEVNODE_RESET (Windows XP and later versions of Windows)</para>
|
||
/// <para>
|
||
/// Resets a device instance that has the no restart device status flag set. The no restart device status flag is set if a device is
|
||
/// removed by calling <c>CM_Query_And_Remove_SubTree</c> or <c>CM_Query_And_Remove_SubTree_Ex</c> and specifying the
|
||
/// CM_REMOVE_NO_RESTART flag.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// If the operation succeeds, the function returns CR_SUCCESS. Otherwise it returns one of the error codes with "CR_" prefix that
|
||
/// are defined in Cfgmgr32.h.
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// Device installation applications should use the DIF_PROPERTYCHANGE request to restart a device instead of using this function.
|
||
/// The DIF_PROPERTYCHANGE request can be used to enable, disable, restart, stop, or change the properties of a device.
|
||
/// </para>
|
||
/// <para>
|
||
/// If a device instance does not have a problem and is already started, <c>CM_Setup_DevNode</c> returns without changing the status
|
||
/// of the device instance.
|
||
/// </para>
|
||
/// <para>Call CM_Get_DevNode_Status or CM_Get_DevNode_Status_Ex to determine the status and problem code for a device instance.</para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_setup_devnode CMAPI CONFIGRET CM_Setup_DevNode(
|
||
// DEVINST dnDevInst, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Setup_DevNode")]
|
||
public static extern CONFIGRET CM_Setup_DevNode(uint dnDevInst, CM_SETUP_DEVNODE ulFlags);
|
||
|
||
/// <summary>The <c>CM_Uninstall_DevNode</c> function removes all persistent state associated with a device instance.</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>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// This function uninstalls the device without sending an <c>IRP_MN_QUERY_REMOVE_DEVICE</c> request or calling class installers or
|
||
/// co-installers. If your application will run only on a Target Platform of Desktop, instead of calling
|
||
/// <c>CM_Uninstall_DevNode</c>, the application should uninstall the device by calling SetupDiCallClassInstaller with the
|
||
/// DIF_REMOVE code, or by calling DiUninstallDevice.
|
||
/// </para>
|
||
/// <para>Use the following sequence to call this function:</para>
|
||
/// <list type="number">
|
||
/// <item>
|
||
/// <term>Check if CM_Get_DevNode_Status returns success. This means that the device is present.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>If the device is present, call CM_Query_And_Remove_SubTree.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Call <c>CM_Uninstall_DevNode</c>.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_uninstall_devnode CMAPI CONFIGRET
|
||
// CM_Uninstall_DevNode( DEVNODE dnDevInst, ULONG ulFlags );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Uninstall_DevNode")]
|
||
public static extern CONFIGRET CM_Uninstall_DevNode(uint dnDevInst, uint ulFlags = 0);
|
||
|
||
/// <summary>
|
||
/// <para>
|
||
/// Use UnregisterDeviceNotification instead of <c>CM_Unregister_Notification</c> if your code targets Windows 7 or earlier versions
|
||
/// of Windows.
|
||
/// </para>
|
||
/// <para>The <c>CM_Unregister_Notification</c> function closes the specified HCMNOTIFICATION handle.</para>
|
||
/// </summary>
|
||
/// <param name="NotifyContext">The HCMNOTIFICATION handle returned by the CM_Register_Notification function.</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>
|
||
/// Do not call <c>CM_Unregister_Notification</c> from a notification callback. Doing so may cause a deadlock because
|
||
/// <c>CM_Unregister_Notification</c> waits for pending callbacks to finish.
|
||
/// </para>
|
||
/// <para>
|
||
/// Instead, if you want to unregister from the notification callback, you must do so asynchronously. The following sequence shows
|
||
/// one way to do this:
|
||
/// </para>
|
||
/// <list type="number">
|
||
/// <item>
|
||
/// <term>
|
||
/// Allocate a context structure to use with your notifications. Include a pointer to a threadpool work structure ( <c>PTP_WORK</c>)
|
||
/// and any other information you would like to pass to the notification callback.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// Call CreateThreadpoolWork. Provide a callback function that calls <c>CM_Unregister_Notification</c>. Add the returned work
|
||
/// structure to the previously allocated context structure.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Call CM_Register_Notification and provide the context structure as the pContext parameter.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Do work, get notifications, etc.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// Call SubmitThreadpoolWork from within the notification callback, providing the pointer to a threadpool work structure (
|
||
/// <c>PTP_WORK</c>) stored in your context structure.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>When the threadpool thread runs, the work item calls <c>CM_Unregister_Notification</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Call CloseThreadpoolWork to release the work object.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>If you are finished with the context structure, don't forget to release resources and and free the structure.</para>
|
||
/// <para>
|
||
/// <c>Caution</c> Do not free the context structure until after the work item has called <c>CM_Unregister_Notification</c>. You can
|
||
/// still receive notifications after submitting the threadpool work item and before the work item calls <c>CM_Unregister_Notification</c>.
|
||
/// </para>
|
||
/// <para>Examples</para>
|
||
/// <para>The following example shows how to unregister from the notification callback, as described in the Remarks section.</para>
|
||
/// <para>
|
||
/// <code>typedef struct _CALLBACK_CONTEXT { BOOL bUnregister; PTP_WORK pWork; HCMNOTIFICATION hNotify; CRITICAL_SECTION lock; } CALLBACK_CONTEXT, *PCALLBACK_CONTEXT; DWORD WINAPI EventCallback( __in HCMNOTIFICATION hNotification, __in PVOID Context, __in CM_NOTIFY_ACTION Action, __in PCM_NOTIFY_EVENT_DATA EventData, __in DWORD EventDataSize ) { PCALLBACK_CONTEXT pCallbackContext = (PCALLBACK_CONTEXT)Context; // unregister from the callback EnterCriticalSection(&(pCallbackContext->lock)); // in case this callback fires before the registration call returns, make sure the notification handle is properly set Context->hNotify = hNotification; if (!pCallbackContext->bUnregister) { pCallbackContext->bUnregister = TRUE; SubmitThreadpoolWork(pCallbackContext->pWork); } LeaveCriticalSection(&(pCallbackContext->lock)); return ERROR_SUCCESS; }; VOID CALLBACK WorkCallback( _Inout_ PTP_CALLBACK_INSTANCE Instance, _Inout_opt_ PVOID Context, _Inout_ PTP_WORK pWork ) { PCALLBACK_CONTEXT pCallbackContext = (PCALLBACK_CONTEXT)Context; CM_Unregister_Notification(pCallbackContext->hNotify); } VOID NotificationFunction() { CONFIGRET cr = CR_SUCCESS; HRESULT hr = S_OK; CM_NOTIFY_FILTER NotifyFilter = { 0 }; BOOL bShouldUnregister = FALSE; PCALLBACK_CONTEXT context; context = (PCALLBACK_CONTEXT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CALLBACK_CONTEXT)); if (context == NULL) { goto end; } InitializeCriticalSection(&(context->lock)); NotifyFilter.cbSize = sizeof(NotifyFilter); NotifyFilter.Flags = 0; NotifyFilter.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINSTANCE; NotifyFilter.Reserved = 0; hr = StringCchCopy(NotifyFilter.u.DeviceInstance.InstanceId, MAX_DEVICE_ID_LEN, TEST_DEVICE_INSTANCE_ID); if (FAILED(hr)) { goto end; } context->pWork = CreateThreadpoolWork(WorkCallback, context, NULL); if (context->pWork == NULL) { goto end; } cr = CM_Register_Notification(&NotifyFilter, context, EventCallback, &context->hNotify); if (cr != CR_SUCCESS) { goto end; } // ... do work here ... EnterCriticalSection(&(context->lock)); if (!context->bUnregister) { // unregister not from the callback bShouldUnregister = TRUE; context->bUnregister = TRUE; } LeaveCriticalSection(&(context->lock)); if (bShouldUnregister) { cr = CM_Unregister_Notification(context->hNotify); if (cr != CR_SUCCESS) { goto end; } } else { // if the callback is the one performing the unregister, wait for the threadpool work item to complete the unregister WaitForThreadpoolWorkCallbacks(context->pWork, FALSE); } end: if (context != NULL) { if (context->pWork != NULL) { CloseThreadpoolWork(context->pWork); } DeleteCriticalSection(&(context->lock)); HeapFree(GetProcessHeap(), 0, context); } return; }</code>
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_unregister_notification CMAPI CONFIGRET
|
||
// CM_Unregister_Notification( HCMNOTIFICATION NotifyContext );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = false, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_Unregister_Notification")]
|
||
public static extern CONFIGRET CM_Unregister_Notification([In] HCMNOTIFICATION NotifyContext);
|
||
|
||
/// <summary>
|
||
/// The <c>CMP_WaitNoPendingInstallEvents</c> (CM_WaitNoPendingInstallEvents) function waits until there are no pending device
|
||
/// installation activities for the PnP manager to perform.
|
||
/// </summary>
|
||
/// <param name="dwTimeout">
|
||
/// <para>Specifies a time-out interval, in milliseconds.</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>If dwTimeout is set to zero, the function tests whether there are pending installation events and returns immediately.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>If dwTimeout is set to INFINITE (defined in Winbase.h), the function's time-out interval never elapses.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>
|
||
/// For all other dwTimeout values, the function returns when the specified interval elapses, even if there are still pending
|
||
/// installation events.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>The function returns one of the following values (defined in Winbase.h):</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>WAIT_OBJECT_0</term>
|
||
/// <term>There are no pending installation activities.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>WAIT_TIMEOUT</term>
|
||
/// <term>The time-out interval elapsed, and installation activities are still pending.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>WAIT_FAILED</term>
|
||
/// <term>The function failed. Call GetLastError for additional error information.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// The function waits for an internal event object, which the PnP manager sets when it determines that no installation activities
|
||
/// are pending.
|
||
/// </para>
|
||
/// <para>
|
||
/// If a non-zero time-out value is specified, then <c>CMP_WaitNoPendingInstallEvents</c> will return either when no installation
|
||
/// events are pending or when the time-out period has expired, whichever comes first.
|
||
/// </para>
|
||
/// <para>
|
||
/// New installation events can occur at any time. This function just indicates that there are no pending installation activities at
|
||
/// the moment it is called.
|
||
/// </para>
|
||
/// <para>
|
||
/// This function is typically used by device installation applications. For more information, see Writing a Device Installation Application.
|
||
/// </para>
|
||
/// <para>
|
||
/// Do not call this function while processing any events inside of a system-initiated callback function that is expected to return
|
||
/// within a short amount of time. This includes service startup (for example in the <c>ServiceMain</c> callback function) or while
|
||
/// processing any control in the service handler (for example, the <c>Handler</c> callback function), or from installation
|
||
/// components such as class-installers or co-installers.
|
||
/// </para>
|
||
/// <para>
|
||
/// For Windows XP (with no service pack installed), this function must be called from session zero, with administrator privileges.
|
||
/// For Windows XP with Service Pack 1 (SP1) and later versions of Windows, the function can be called from any session, and
|
||
/// administrator privileges are not required.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/cfgmgr32/nf-cfgmgr32-cm_waitnopendinginstallevents DWORD
|
||
// CM_WaitNoPendingInstallEvents( DWORD dwTimeout );
|
||
[DllImport(Lib_Cfgmgr32, SetLastError = true, ExactSpelling = true)]
|
||
[PInvokeData("cfgmgr32.h", MSDNShortId = "NF:cfgmgr32.CM_WaitNoPendingInstallEvents")]
|
||
public static extern Kernel32.WAIT_STATUS CM_WaitNoPendingInstallEvents(uint dwTimeout);
|
||
|
||
/// <summary>Gets the .NET exception for a <see cref="CONFIGRET"/> value.</summary>
|
||
/// <param name="cr">The <see cref="CONFIGRET"/> value to check.</param>
|
||
/// <param name="message">The message.</param>
|
||
/// <returns>An exception instance or <see langword="null"/> if value indicated success.</returns>
|
||
public static Exception GetException(this CONFIGRET cr, string message = null)
|
||
{
|
||
if (cr == CONFIGRET.CR_SUCCESS) return null;
|
||
var err = cr.ToError(Win32Error.RPC_S_UNKNOWN_IF);
|
||
if (err == Win32Error.RPC_S_UNKNOWN_IF)
|
||
{
|
||
var ex = new Exception(message);
|
||
ex.Data.Add("CONFIGRET", cr);
|
||
return ex;
|
||
}
|
||
return err.GetException(message);
|
||
}
|
||
|
||
/// <summary>Throws an exception if <see cref="CONFIGRET"/> value is not <see cref="CONFIGRET.CR_SUCCESS"/>.</summary>
|
||
/// <param name="cr">The <see cref="CONFIGRET"/> value to check.</param>
|
||
/// <param name="message">The message.</param>
|
||
public static void ThrowIfFailed(this CONFIGRET cr, string message = null) { if (cr != CONFIGRET.CR_SUCCESS) throw cr.GetException(message); }
|
||
|
||
/// <summary>Converts a specified <c>CONFIGRET</c> code to its equivalent system error code.</summary>
|
||
/// <param name="cr">The <c>CONFIGRET</c> code to be converted.</param>
|
||
/// <param name="defaultErr">
|
||
/// A default system error code to be returned when no system error code is mapped to the specified <c>CONFIGRET</c> code.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>The system error code that corresponds to the <c>CONFIGRET</c> code.</para>
|
||
/// <para>
|
||
/// When there is no mapping from the specified <c>CONFIGRET</c> code to a system error code, <c>CM_MapCrToWin32Err</c> returns the
|
||
/// value specified in <paramref name="defaultErr"/>.
|
||
/// </para>
|
||
/// </returns>
|
||
public static Win32Error ToError(this CONFIGRET cr, Win32Error defaultErr) => CM_MapCrToWin32Err(cr, (uint)defaultErr);
|
||
}
|
||
} |