sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Completed additional of all methods and supporting elements to Kernel32

pull/10/head
David Hall 2018-08-07 17:23:17 -06:00
parent acb6097003
commit 13e3259f8b
21 changed files with 17653 additions and 2690 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1756
PInvoke/Kernel32/AppModel.cs Normal file
View File

File diff suppressed because it is too large Load Diff

1097
PInvoke/Kernel32/CorrelationReport.md
View File

File diff suppressed because it is too large Load Diff

210
PInvoke/Kernel32/InterlockedApi.cs Normal file
View File

@ -0,0 +1,210 @@
using System;
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>
/// <para>Initializes the head of a singly linked list.</para>
/// </summary>
/// <param name="ListHead">
/// <para>
/// A pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list. This structure is for system use only.
/// </para>
/// </param>
/// <returns>
/// <para>This function does not return a value.</para>
/// </returns>
/// <remarks>
/// <para>
/// All list items must be aligned on a <c>MEMORY_ALLOCATION_ALIGNMENT</c> boundary. Unaligned items can cause unpredictable results.
/// See <c>_aligned_malloc</c>.
/// </para>
/// <para>
/// To add items to the list, use the InterlockedPushEntrySList function. To remove items from the list, use the
/// InterlockedPopEntrySList function.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Using Singly Linked Lists.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-initializeslisthead void
// InitializeSListHead( PSLIST_HEADER ListHead );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "4e34f947-1687-4ea9-aaa1-8d8dc11dad70")]
public static extern void InitializeSListHead(IntPtr ListHead);
/// <summary>
/// <para>Removes all items from a singly linked list. Access to the list is synchronized on a multiprocessor system.</para>
/// </summary>
/// <param name="ListHead">
/// <para>
/// Pointer to an <c>SLIST_HEADER</c> structure that represents the head of the singly linked list. This structure is for system use only.
/// </para>
/// </param>
/// <returns>
/// <para>The return value is a pointer to the items removed from the list. If the list is empty, the return value is <c>NULL</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// All list items must be aligned on a <c>MEMORY_ALLOCATION_ALIGNMENT</c> boundary; otherwise, this function will behave
/// unpredictably. See <c>_aligned_malloc</c>.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Using Singly Linked Lists.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-interlockedflushslist PSLIST_ENTRY
// InterlockedFlushSList( PSLIST_HEADER ListHead );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "3fde3377-8a98-4976-a350-2c173b209e8c")]
public static extern IntPtr InterlockedFlushSList(IntPtr ListHead);
/// <summary>
/// <para>Removes an item from the front of a singly linked list. Access to the list is synchronized on a multiprocessor system.</para>
/// </summary>
/// <param name="ListHead">
/// <para>Pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list.</para>
/// </param>
/// <returns>
/// <para>The return value is a pointer to the item removed from the list. If the list is empty, the return value is <c>NULL</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// All list items must be aligned on a <c>MEMORY_ALLOCATION_ALIGNMENT</c> boundary; otherwise, this function will behave
/// unpredictably. See <c>_aligned_malloc</c>.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Using Singly Linked Lists.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-interlockedpopentryslist PSLIST_ENTRY
// InterlockedPopEntrySList( PSLIST_HEADER ListHead );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "10760fd4-5973-4ab0-991c-7a5951c798a4")]
public static extern IntPtr InterlockedPopEntrySList(IntPtr ListHead);
/// <summary>
/// <para>Inserts an item at the front of a singly linked list. Access to the list is synchronized on a multiprocessor system.</para>
/// </summary>
/// <param name="ListHead">
/// <para>Pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list.</para>
/// </param>
/// <param name="ListEntry">
/// <para>Pointer to an SLIST_ENTRY structure that represents an item in a singly linked list.</para>
/// </param>
/// <returns>
/// <para>The return value is the previous first item in the list. If the list was previously empty, the return value is <c>NULL</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// All list items must be aligned on a <c>MEMORY_ALLOCATION_ALIGNMENT</c> boundary; otherwise, this function will behave
/// unpredictably. See <c>_aligned_malloc</c>.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Using Singly Linked Lists.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-interlockedpushentryslist PSLIST_ENTRY
// InterlockedPushEntrySList( PSLIST_HEADER ListHead, __drv_aliasesMem PSLIST_ENTRY ListEntry );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "60e3b6f7-f556-4699-be90-db7330cfb8ca")]
public static extern IntPtr InterlockedPushEntrySList(IntPtr ListHead, ref SLIST_ENTRY ListEntry);
/// <summary>
/// Inserts a singly-linked list at the front of another singly linked list. Access to the lists is synchronized on a multiprocessor system.
/// </summary>
/// <param name="ListHead">
/// Pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list. The list specified by the List and
/// ListEnd parameters is inserted at the front of this list.
/// </param>
/// <param name="List">Pointer to an <c>SLIST_ENTRY</c> structure that represents the first item in the list to be inserted.</param>
/// <param name="ListEnd">Pointer to an <c>SLIST_ENTRY</c> structure that represents the last item in the list to be inserted.</param>
/// <param name="Count">The number of items in the list to be inserted.</param>
/// <returns>
/// The return value is the previous first item in the list specified by the ListHead parameter. If the list was previously empty,
/// the return value is <c>NULL</c>.
/// </returns>
// PSLIST_ENTRY FASTCALL InterlockedPushListSList( _Inout_ PSLIST_HEADER ListHead, _Inout_ PSLIST_ENTRY List, _Inout_ PSLIST_ENTRY
// ListEnd, _In_ ULONG Count); https://msdn.microsoft.com/en-us/library/windows/desktop/hh448545(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "hh448545")]
public static extern IntPtr InterlockedPushListSList(IntPtr ListHead, ref SLIST_ENTRY List, ref SLIST_ENTRY ListEnd, uint Count);
/// <summary>
/// <para>
/// Inserts a singly-linked list at the front of another singly linked list. Access to the lists is synchronized on a multiprocessor
/// system. This version of the method does not use the __fastcall calling convention.
/// </para>
/// </summary>
/// <param name="ListHead">
/// <para>
/// Pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list. The list specified by the List and
/// ListEnd parameters is inserted at the front of this list.
/// </para>
/// </param>
/// <param name="List">
/// <para>Pointer to an SLIST_ENTRY structure that represents the first item in the list to be inserted.</para>
/// </param>
/// <param name="ListEnd">
/// <para>Pointer to an SLIST_ENTRY structure that represents the last item in the list to be inserted.</para>
/// </param>
/// <param name="Count">
/// <para>The number of items in the list to be inserted.</para>
/// </param>
/// <returns>
/// <para>
/// The return value is the previous first item in the list specified by the ListHead parameter. If the list was previously empty,
/// the return value is <c>NULL</c>.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// All list items must be aligned on a <c>MEMORY_ALLOCATION_ALIGNMENT</c> boundary; otherwise, this function will behave
/// unpredictably. See <c>_aligned_malloc</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-interlockedpushlistslistex PSLIST_ENTRY
// InterlockedPushListSListEx( PSLIST_HEADER ListHead, PSLIST_ENTRY List, PSLIST_ENTRY ListEnd, ULONG Count );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "f4f334c6-fda8-4c5f-9177-b672c8aed6b3")]
public static extern IntPtr InterlockedPushListSListEx(IntPtr ListHead, ref SLIST_ENTRY List, ref SLIST_ENTRY ListEnd, uint Count);
/// <summary>
/// <para>Retrieves the number of entries in the specified singly linked list.</para>
/// </summary>
/// <param name="ListHead">
/// <para>
/// A pointer to an <c>SLIST_HEADER</c> structure that represents the head of a singly linked list. This structure is for system use only.
/// </para>
/// <para>The list must be previously initialized with the InitializeSListHead function.</para>
/// </param>
/// <returns>
/// <para>The function returns the number of entries in the list, up to a maximum value of 65535.</para>
/// </returns>
/// <remarks>
/// <para>
/// The system does not limit the number of entries in a singly linked list. However, the return value of <c>QueryDepthSList</c> is
/// truncated to 16 bits, so the maximum value it can return is 65535. If the specified singly linked list contains more than 65535
/// entries, <c>QueryDepthSList</c> returns the number of entries in the list modulo 65535. For example, if the specified list
/// contains 65536 entries, <c>QueryDepthSList</c> returns zero.
/// </para>
/// <para>
/// The return value of <c>QueryDepthSList</c> should not be relied upon in multithreaded applications because the item count can be
/// changed at any time by another thread.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/interlockedapi/nf-interlockedapi-querydepthslist USHORT QueryDepthSList(
// PSLIST_HEADER ListHead );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("interlockedapi.h", MSDNShortId = "3f9b4481-647f-457f-bdfb-62e6ae4198e5")]
public static extern ushort QueryDepthSList(IntPtr ListHead);
/// <summary>An <c>SLIST_ENTRY</c> structure describes an entry in a sequenced singly linked list.</summary>
// typedef struct _SLIST_ENTRY { struct _SLIST_ENTRY *Next;} SLIST_ENTRY, *PSLIST_ENTRY; https://msdn.microsoft.com/en-us/library/windows/hardware/ff563805(v=vs.85).aspx
[PInvokeData("Wdm.h", MSDNShortId = "ff563805")]
[StructLayout(LayoutKind.Sequential)]
public struct SLIST_ENTRY
{
/// <summary>Pointer to the next entry in the list, or <c>NULL</c> if there is no next entry in the list.</summary>
public IntPtr Next;
}
}
}

1157
PInvoke/Kernel32/LibLoaderApi.cs
View File

File diff suppressed because it is too large Load Diff

11
PInvoke/Kernel32/MemoryApi.cs
View File

@ -2840,22 +2840,23 @@ namespace Vanara.PInvoke
public static extern SizeT VirtualQueryEx([In] IntPtr hProcess, [In] IntPtr lpAddress, IntPtr lpBuffer, SizeT dwLength);
/// <summary>
/// Unlocks a specified range of pages in the virtual address space of a process, enabling the system to swap the pages out to the paging file if necessary.
/// Unlocks a specified range of pages in the virtual address space of a process, enabling the system to swap the pages out to the
/// paging file if necessary.
/// </summary>
/// <param name="lpAddress">A pointer to the base address of the region of pages to be unlocked.</param>
/// <param name="dwSize">
/// The size of the region being unlocked, in bytes. The region of affected pages includes all pages containing one or more bytes in the range from the
/// lpAddress parameter to . This means that a 2-byte range straddling a page boundary causes both pages to be unlocked.
/// The size of the region being unlocked, in bytes. The region of affected pages includes all pages containing one or more bytes in
/// the range from the lpAddress parameter to . This means that a 2-byte range straddling a page boundary causes both pages to be unlocked.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// BOOL WINAPI VirtualUnlock( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize);
// BOOL WINAPI VirtualUnlock( _In_ LPVOID lpAddress, _In_ SIZE_T dwSize); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366910(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366910")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool VirtualUnlock([In] IntPtr lpAddress, SizeT dwSize);
public static extern bool VirtualUnlock(IntPtr lpAddress, SizeT dwSize);
/// <summary>Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails.</summary>
/// <param name="hProcess">

1816
PInvoke/Kernel32/ProcessSnapshot.cs Normal file
View File

File diff suppressed because it is too large Load Diff

20
PInvoke/Kernel32/ProcessThreadsApi.cs
View File

@ -1546,6 +1546,26 @@ namespace Vanara.PInvoke
[PInvokeData("WinBase.h", MSDNShortId = "ms683180")]
public static extern uint GetCurrentProcessId();
/// <summary>
/// <para>Retrieves the number of the processor the current thread was running on during the call to this function.</para>
/// </summary>
/// <returns>
/// <para>The function returns the current processor number.</para>
/// </returns>
/// <remarks>
/// <para>This function is used to provide information for estimating process performance.</para>
/// <para>
/// On systems with more than 64 logical processors, the <c>GetCurrentProcessorNumber</c> function returns the processor number
/// within the processor group to which the logical processor is assigned. Use the GetCurrentProcessorNumberEx function to retrieve
/// the processor group and number of the current processor.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getcurrentprocessornumber
// DWORD GetCurrentProcessorNumber( );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("processthreadsapi.h", MSDNShortId = "1f2bebc7-a548-409a-ab74-78a4b55c8fa7")]
public static extern uint GetCurrentProcessorNumber();
/// <summary>Retrieves the processor group and number of the logical processor in which the calling thread is running.</summary>
/// <param name="ProcNumber">
/// A pointer to a <c>PROCESSOR_NUMBER</c> structure that receives the processor group to which the logical processor is assigned and the number of the

1398
PInvoke/Kernel32/PsApi.cs Normal file
View File

File diff suppressed because it is too large Load Diff

342
PInvoke/Kernel32/SecurityBaseApi.cs
View File

@ -1,117 +1,243 @@
using System;
using System.Runtime.InteropServices;
using System.Text;
using Vanara.InteropServices;
using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/* AccessCheck
AccessCheckAndAuditAlarmW
AccessCheckByType
AccessCheckByTypeAndAuditAlarmW
AccessCheckByTypeResultList
AccessCheckByTypeResultListAndAuditAlarmByHandleW
AccessCheckByTypeResultListAndAuditAlarmW
AddAccessAllowedAce
AddAccessAllowedAceEx
AddAccessAllowedObjectAce
AddAccessDeniedAce
AddAccessDeniedAceEx
AddAccessDeniedObjectAce
AddAce
AddAuditAccessAce
AddAuditAccessAceEx
AddAuditAccessObjectAce
AddMandatoryAce
AddResourceAttributeAce
AddScopedPolicyIDAce
AdjustTokenGroups
AdjustTokenPrivileges
AllocateAndInitializeSid
AllocateLocallyUniqueId
AreAllAccessesGranted
AreAnyAccessesGranted
CheckTokenCapability
CheckTokenMembership
CheckTokenMembershipEx
ConvertToAutoInheritPrivateObjectSecurity
CopySid
CreatePrivateObjectSecurity
CreatePrivateObjectSecurityEx
CreatePrivateObjectSecurityWithMultipleInheritance
CreateRestrictedToken
CreateWellKnownSid
CveEventWrite
DeleteAce
DeriveCapabilitySidsFromName
DestroyPrivateObjectSecurity
DuplicateToken
DuplicateTokenEx
EqualDomainSid
EqualPrefixSid
EqualSid
FindFirstFreeAce
FreeSid
GetAce
GetAclInformation
GetAppContainerAce
GetCachedSigningLevel
GetFileSecurityW
GetKernelObjectSecurity
GetLengthSid
GetPrivateObjectSecurity
GetSecurityDescriptorControl
GetSecurityDescriptorDacl
GetSecurityDescriptorGroup
GetSecurityDescriptorLength
GetSecurityDescriptorOwner
GetSecurityDescriptorOwner
GetSecurityDescriptorSacl
GetSidIdentifierAuthority
GetSidLengthRequired
GetSidSubAuthority
GetSidSubAuthorityCount
GetTokenInformation
GetWindowsAccountDomainSid
ImpersonateAnonymousToken
ImpersonateLoggedOnUser
ImpersonateSelf
InitializeAcl
InitializeSecurityDescriptor
InitializeSid
IsTokenRestricted
IsValidAcl
IsValidSecurityDescriptor
IsValidSid
IsWellKnownSid
MakeAbsoluteSD
MakeSelfRelativeSD
MapGenericMask
ObjectCloseAuditAlarmW
ObjectDeleteAuditAlarmW
ObjectOpenAuditAlarmW
ObjectPrivilegeAuditAlarmW
PrivilegeCheck
PrivilegedServiceAuditAlarmW
QuerySecurityAccessMask
RevertToSelf
SetAclInformation
SetCachedSigningLevel
SetFileSecurityW
SetKernelObjectSecurity
SetPrivateObjectSecurity
SetPrivateObjectSecurityEx
SetSecurityAccessMask
SetSecurityDescriptorControl
SetSecurityDescriptorDacl
SetSecurityDescriptorGroup
SetSecurityDescriptorOwner
SetSecurityDescriptorRMControl
SetSecurityDescriptorSacl
SetTokenInformation
*/
/// <summary>
/// <para>
/// The <c>AddResourceAttributeAce</c> function adds a SYSTEM_RESOURCE_ATTRIBUTE_ACE access control entry (ACE) to the end of a
/// system access control list (SACL). A <c>SYSTEM_RESOURCE_ATTRIBUTE_ACE</c> structure specifies an attribute name and a
/// value-ordered list of elements that is associated with a resource and potentially used during access checks. The set of standard
/// access rights are defined in the Standard Access Rights topic.
/// </para>
/// </summary>
/// <param name="pAcl">
/// <para>
/// A pointer to an access control list (ACL). This function adds an ACE to this ACL. The value of this parameter cannot be
/// <c>NULL</c>. The ACE is in the form of a SYSTEM_RESOURCE_ATTRIBUTE_ACE structure.
/// </para>
/// </param>
/// <param name="dwAceRevision">
/// <para>
/// Specifies the revision level of the ACL being modified. This value can be ACL_REVISION or ACL_REVISION_DS. Use ACL_REVISION_DS if
/// the ACL contains object-specific ACEs.
/// </para>
/// </param>
/// <param name="AceFlags">
/// <para>
/// A set of bit flags that control ACE inheritance. The function sets these flags in the <c>AceFlags</c> member of the ACE_HEADER
/// structure of the new ACE.
/// </para>
/// <para>
/// For consistency with the Windows 8 Advanced File Permissions UI, applications should specify the CONTAINER_INHERIT_ACE and
/// OBJECT_INHERIT_ACE flags in the parameter.
/// </para>
/// <para>This parameter can be a combination of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>CONTAINER_INHERIT_ACE 2 (0x2)</term>
/// <term>The ACE is inherited by the container objects.</term>
/// </item>
/// <item>
/// <term>INHERIT_ONLY_ACE 8 (0x8)</term>
/// <term>The ACE does not apply to the object the ACE is assigned to, but it can be inherited by child objects.</term>
/// </item>
/// <item>
/// <term>INHERITED_ACE 16 (0x10)</term>
/// <term>
/// Indicates an inherited ACE. This flag allows operations that change the security on a tree of objects to modify inherited ACEs
/// while not changing ACEs that were directly applied to the object.
/// </term>
/// </item>
/// <item>
/// <term>NO_PROPAGATE_INHERIT_ACE 4 (0x4)</term>
/// <term>The OBJECT_INHERIT_ACE and CONTAINER_INHERIT_ACE bits are not propagated to an inherited ACE.</term>
/// </item>
/// <item>
/// <term>OBJECT_INHERIT_ACE 1 (0x1)</term>
/// <term>The ACE is inherited by non-container objects.</term>
/// </item>
/// </list>
/// </param>
/// <param name="AccessMask">
/// <para>Must be zero for Windows 8 and Windows Server 2012.</para>
/// </param>
/// <param name="pSid">
/// <para>Must be the Everyone SID (S-1-1-0) for Windows 8 and Windows Server 2012.</para>
/// </param>
/// <param name="pAttributeInfo">
/// <para>Specifies the attribute information that will be appended after the SID in the ACE.</para>
/// </param>
/// <param name="pReturnLength">
/// <para>
/// The size, in bytes, of the actual ACL buffer used. If the buffer specified by the parameter is not big enough, the value of this
/// parameter is the total size required for the ACL buffer.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns <c>TRUE</c>.</para>
/// <para>If the function fails, it returns <c>FALSE</c>. To get extended error information, call GetLastError.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/securitybaseapi/nf-securitybaseapi-addresourceattributeace BOOL
// AddResourceAttributeAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid,
// PCLAIM_SECURITY_ATTRIBUTES_INFORMATION pAttributeInfo, PDWORD pReturnLength );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("securitybaseapi.h", MSDNShortId = "AA2064E4-6F76-4D7B-8540-D55A91168825")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool AddResourceAttributeAce(PACL pAcl, uint dwAceRevision, uint AceFlags, uint AccessMask, PSID pSid, ref CLAIM_SECURITY_ATTRIBUTES_INFORMATION pAttributeInfo, ref uint pReturnLength);
/// <summary>
/// <para>
/// The <c>AddScopedPolicyIDAce</c> function adds a SYSTEM_SCOPED_POLICY_ID_ACE access control entry (ACE) to the end of a system
/// access control list (SACL). A <c>SYSTEM_SCOPED_POLICY_ID_ACE</c> structure specifies a central access policy (CAP) to be
/// associated with the resource and can be used during access checks. The set of standard access rights are defined in the Standard
/// Access Rights topic.
/// </para>
/// </summary>
/// <param name="pAcl">
/// <para>
/// A pointer to an access control list (ACL). This function adds an ACE to this ACL. The value of this parameter cannot be <c>NULL</c>.
/// </para>
/// </param>
/// <param name="dwAceRevision">
/// <para>
/// Specifies the revision level of the ACL being modified. This value can be ACL_REVISION or ACL_REVISION_DS. Use ACL_REVISION_DS if
/// the ACL contains object-specific ACEs.
/// </para>
/// </param>
/// <param name="AceFlags">
/// <para>
/// A set of bit flags that control ACE inheritance. The function sets these flags in the <c>AceFlags</c> member of the ACE_HEADER
/// structure of the new ACE.
/// </para>
/// <para>
/// For consistency with the Windows 8 Advanced File Permissions UI, applications should specify the CONTAINER_INHERIT_ACE and
/// OBJECT_INHERIT_ACE flags in the parameter.
/// </para>
/// <para>This parameter can be a combination of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>CONTAINER_INHERIT_ACE 2 (0x2)</term>
/// <term>The ACE is inherited by the container objects.</term>
/// </item>
/// <item>
/// <term>INHERIT_ONLY_ACE 8 (0x8)</term>
/// <term>The ACE does not apply to the object the ACE is assigned to, but it can be inherited by child objects.</term>
/// </item>
/// <item>
/// <term>INHERITED_ACE 16 (0x10)</term>
/// <term>
/// Indicates an inherited ACE. This flag allows operations that change the security on a tree of objects to modify inherited ACEs
/// while not changing ACEs that were directly applied to the object.
/// </term>
/// </item>
/// <item>
/// <term>NO_PROPAGATE_INHERIT_ACE 4 (0x4)</term>
/// <term>The OBJECT_INHERIT_ACE and CONTAINER_INHERIT_ACE bits are not propagated to an inherited ACE.</term>
/// </item>
/// <item>
/// <term>OBJECT_INHERIT_ACE 1 (0x1)</term>
/// <term>The ACE is inherited by non-container objects.</term>
/// </item>
/// </list>
/// </param>
/// <param name="AccessMask">
/// <para>Must be zero for Windows 8 and Windows Server 2012.</para>
/// </param>
/// <param name="pSid">
/// <para>A pointer to the SID (S-1-17-*) that identifies the Central Access Policy to be associated with the resource.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns <c>TRUE</c>.</para>
/// <para>If the function fails, it returns <c>FALSE</c>. To get extended error information, call GetLastError.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/securitybaseapi/nf-securitybaseapi-addscopedpolicyidace BOOL
// AddScopedPolicyIDAce( PACL pAcl, DWORD dwAceRevision, DWORD AceFlags, DWORD AccessMask, PSID pSid );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("securitybaseapi.h", MSDNShortId = "30AA5730-566C-4B02-A904-5A38237EE8E3")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool AddScopedPolicyIDAce(PACL pAcl, uint dwAceRevision, uint AceFlags, uint AccessMask, PSID pSid);
/// <summary>
/// <para>The <c>CheckTokenCapability</c> function checks the capabilities of a given token.</para>
/// </summary>
/// <param name="TokenHandle">
/// <para>
/// A handle to an access token. The handle must have TOKEN_QUERY access to the token. The token must be an impersonation token.
/// </para>
/// <para>
/// If is <c>NULL</c>, <c>CheckTokenCapability</c> uses the impersonation token of the calling thread. If the thread is not
/// impersonating, the function duplicates the thread's primary token to create an impersonation token.
/// </para>
/// </param>
/// <param name="CapabilitySidToCheck">
/// <para>
/// A pointer to a capability SID structure. The <c>CheckTokenCapability</c> function checks the capabilities of this access token.
/// </para>
/// </param>
/// <param name="HasCapability">
/// <para>
/// Receives the results of the check. If the access token has the capability, it returns <c>TRUE</c>, otherwise, it returns <c>FALSE</c>.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/securitybaseapi/nf-securitybaseapi-checktokencapability BOOL
// CheckTokenCapability( HANDLE TokenHandle, PSID CapabilitySidToCheck, PBOOL HasCapability );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("securitybaseapi.h", MSDNShortId = "436A5110-B79E-4E64-92E8-1C9E713D0948")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool CheckTokenCapability(IntPtr TokenHandle, PSID CapabilitySidToCheck, [MarshalAs(UnmanagedType.Bool)] out bool HasCapability);
/// <summary>
/// <para>
/// This function constructs two arrays of SIDs out of a capability name. One is an array group SID with NT Authority, and the other
/// is an array of capability SIDs with AppAuthority.
/// </para>
/// </summary>
/// <param name="CapName">
/// <para>Name of the capability in string form.</para>
/// </param>
/// <param name="CapabilityGroupSids">
/// <para>The GroupSids with NTAuthority.</para>
/// </param>
/// <param name="CapabilityGroupSidCount">
/// <para>The count of GroupSids in the array.</para>
/// </param>
/// <param name="CapabilitySids">
/// <para>CapabilitySids with AppAuthority.</para>
/// </param>
/// <param name="CapabilitySidCount">
/// <para>The count of CapabilitySid with AppAuthority.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns <c>TRUE</c>.</para>
/// <para>If the function fails, it returns <c>FALSE</c>. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// The caller is expected to free the individual SIDs returned in each array by calling LocalFree. as well as memory allocated for
/// the array itself.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/securitybaseapi/nf-securitybaseapi-derivecapabilitysidsfromname BOOL
// DeriveCapabilitySidsFromName( LPCWSTR CapName, PSID **CapabilityGroupSids, DWORD *CapabilityGroupSidCount, PSID **CapabilitySids,
// DWORD *CapabilitySidCount );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("securitybaseapi.h", MSDNShortId = "1A911FCC-6D11-4185-B532-20FE6C7C4B0B")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool DeriveCapabilitySidsFromName([MarshalAs(UnmanagedType.LPWStr)] string CapName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] IntPtr[] CapabilityGroupSids, ref uint CapabilityGroupSidCount, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] IntPtr[] CapabilitySids, ref uint CapabilitySidCount);
}
}

8
PInvoke/Kernel32/SynchApi.cs
View File

@ -969,7 +969,7 @@ namespace Vanara.PInvoke
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683560(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "ms683560")]
public static extern int InterlockedCompareExchange(ref int Destination, int Exchange, int Comperand);
public static extern int InterlockedCompareExchange(ref int Destination, int Exchange, int Comparand);
/// <summary>
/// <para>Decrements (decreases by one) the value of the specified 32-bit variable as an atomic operation.</para>
@ -980,7 +980,7 @@ namespace Vanara.PInvoke
// LONG __cdecl InterlockedDecrement( _Inout_ LONG volatile *Addend); https://msdn.microsoft.com/en-us/library/windows/desktop/ms683580(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "ms683580")]
public static extern int InterlockedDecrement(ref int lpAddend);
public static extern int InterlockedDecrement(ref int Addend);
/// <summary>
/// <para>Sets a 32-bit variable to the specified value as an atomic operation.</para>
@ -1017,7 +1017,7 @@ namespace Vanara.PInvoke
// LONG __cdecl InterlockedIncrement( _Inout_ LONG volatile *Addend); https://msdn.microsoft.com/en-us/library/windows/desktop/ms683614(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "ms683614")]
public static extern int InterlockedIncrement(ref int lpAddend);
public static extern int InterlockedIncrement(ref int Addend);
/// <summary>Releases ownership of the specified critical section object.</summary>
/// <param name="lpCriticalSection">A pointer to the critical section object.</param>
@ -1300,7 +1300,7 @@ namespace Vanara.PInvoke
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "ms686289")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetWaitableTimer([In] IntPtr hTimer, [In] ref FILETIME lpDueTime, int lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine,
public static extern bool SetWaitableTimer([In] IntPtr hTimer, [In] ref FILETIME pDueTime, int lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine,
[In] IntPtr lpArgToCompletionRoutine, [MarshalAs(UnmanagedType.Bool)] bool fResume);
/// <summary>

10
PInvoke/Kernel32/TimeZoneApi.cs
View File

@ -160,8 +160,12 @@ namespace Vanara.PInvoke
public static extern bool SetDynamicTimeZoneInformation(ref DYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation);
/// <summary>
/// <para>Sets the current time zone settings. These settings control translations from Coordinated Universal Time (UTC) to local time.</para>
/// <para>To support boundaries for daylight saving time that change from year to year, use the <c>SetDynamicTimeZoneInformation</c> function.</para>
/// <para>
/// Sets the current time zone settings. These settings control translations from Coordinated Universal Time (UTC) to local time.
/// </para>
/// <para>
/// To support boundaries for daylight saving time that change from year to year, use the <c>SetDynamicTimeZoneInformation</c> function.
/// </para>
/// </summary>
/// <param name="lpTimeZoneInformation">A pointer to a <c>TIME_ZONE_INFORMATION</c> structure that contains the new settings.</param>
/// <returns>
@ -172,7 +176,7 @@ namespace Vanara.PInvoke
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("Winbase.h", MSDNShortId = "ms724944")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetTimeZoneInformation([In] ref TIME_ZONE_INFORMATION lpTimeZoneInformation);
public static extern bool SetTimeZoneInformation(ref TIME_ZONE_INFORMATION lpTimeZoneInformation);
/// <summary>Converts a system time to file time format. System time is based on Coordinated Universal Time (UTC).</summary>
/// <param name="lpSystemTime">

851
PInvoke/Kernel32/TlHelp32.cs Normal file
View File

@ -0,0 +1,851 @@
using System;
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>Used by HEAPENTRY32</summary>
[PInvokeData("tlhelp32.h", MSDNShortId = "c5f1dc66-d44f-4491-b0b7-961b163d0f1f")]
[Flags]
public enum HEAPENTRY32_FLAGS
{
/// <summary>The memory block has a fixed (unmovable) location.</summary>
LF32_FIXED = 0x00000001,
/// <summary>The memory block is not used.</summary>
LF32_FREE = 0x00000002,
/// <summary>The memory block location can be moved.</summary>
LF32_MOVEABLE = 0x00000004,
}
/// <summary>Used by HEAPLIST32</summary>
[PInvokeData("tlhelp32.h", MSDNShortId = "61e01d23-9f15-44c5-9f6d-45df4809ccad")]
[Flags]
public enum HEAPLIST32_FLAGS
{
/// <summary>Process's default heap</summary>
HF32_DEFAULT = 1,
/// <summary>Process's shared heap</summary>
HF32_SHARED = 2
}
/// <summary>Flags used by <see cref="CreateToolhelp32Snapshot"/>.</summary>
[PInvokeData("tlhelp32.h", MSDNShortId = "df643c25-7558-424c-b187-b3f86ba51358")]
public enum TH32CS : uint
{
/// <summary>Indicates that the snapshot handle is to be inheritable.</summary>
TH32CS_INHERIT = 0x80000000,
/// <summary>Includes all heaps of the process specified in th32ProcessID in the snapshot. To enumerate the heaps, see Heap32ListFirst.</summary>
TH32CS_SNAPHEAPLIST = 0x00000001,
/// <summary>
/// Includes all modules of the process specified in th32ProcessID in the snapshot. To enumerate the modules, see Module32First.
/// If the function fails with ERROR_BAD_LENGTH, retry the function until it succeeds.
/// <para>
/// 64-bit Windows: Using this flag in a 32-bit process includes the 32-bit modules of the process specified in th32ProcessID,
/// while using it in a 64-bit process includes the 64-bit modules. To include the 32-bit modules of the process specified in
/// th32ProcessID from a 64-bit process, use the TH32CS_SNAPMODULE32 flag.
/// </para>
/// </summary>
TH32CS_SNAPMODULE = 0x00000008,
/// <summary>
/// Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit process. This
/// flag can be combined with TH32CS_SNAPMODULE or TH32CS_SNAPALL. If the function fails with ERROR_BAD_LENGTH, retry the
/// function until it succeeds.
/// </summary>
TH32CS_SNAPMODULE32 = 0x00000010,
/// <summary>Includes all processes in the system in the snapshot. To enumerate the processes, see Process32First.</summary>
TH32CS_SNAPPROCESS = 0x00000002,
/// <summary>
/// Includes all threads in the system in the snapshot. To enumerate the threads, see Thread32First.
/// <para>
/// To identify the threads that belong to a specific process, compare its process identifier to the th32OwnerProcessID member of
/// the THREADENTRY32 structure when enumerating the threads.
/// </para>
/// </summary>
TH32CS_SNAPTHREAD = 0x00000004,
/// <summary>
/// Includes all processes and threads in the system, plus the heaps and modules of the process specified in th32ProcessID.
/// Equivalent to specifying the TH32CS_SNAPHEAPLIST, TH32CS_SNAPMODULE, TH32CS_SNAPPROCESS, and TH32CS_SNAPTHREAD values
/// combined using an OR operation ('|').
/// </summary>
TH32CS_SNAPALL = (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE),
}
/// <summary>
/// <para>Takes a snapshot of the specified processes, as well as the heaps, modules, and threads used by these processes.</para>
/// </summary>
/// <param name="dwFlags">
/// <para>The portions of the system to be included in the snapshot. This parameter can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>TH32CS_INHERIT 0x80000000</term>
/// <term>Indicates that the snapshot handle is to be inheritable.</term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPALL</term>
/// <term>
/// Includes all processes and threads in the system, plus the heaps and modules of the process specified in . Equivalent to
/// specifying the TH32CS_SNAPHEAPLIST, TH32CS_SNAPMODULE, TH32CS_SNAPPROCESS, and TH32CS_SNAPTHREAD values combined using an OR
/// operation ('|').
/// </term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPHEAPLIST 0x00000001</term>
/// <term>Includes all heaps of the process specified in in the snapshot. To enumerate the heaps, see Heap32ListFirst.</term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPMODULE 0x00000008</term>
/// <term>
/// Includes all modules of the process specified in in the snapshot. To enumerate the modules, see Module32First. If the function
/// fails with ERROR_BAD_LENGTH, retry the function until it succeeds. 64-bit Windows: Using this flag in a 32-bit process includes
/// the 32-bit modules of the process specified in , while using it in a 64-bit process includes the 64-bit modules. To include the
/// 32-bit modules of the process specified in from a 64-bit process, use the TH32CS_SNAPMODULE32 flag.
/// </term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPMODULE32 0x00000010</term>
/// <term>
/// Includes all 32-bit modules of the process specified in in the snapshot when called from a 64-bit process. This flag can be
/// combined with TH32CS_SNAPMODULE or TH32CS_SNAPALL. If the function fails with ERROR_BAD_LENGTH, retry the function until it succeeds.
/// </term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPPROCESS 0x00000002</term>
/// <term>Includes all processes in the system in the snapshot. To enumerate the processes, see Process32First.</term>
/// </item>
/// <item>
/// <term>TH32CS_SNAPTHREAD 0x00000004</term>
/// <term>
/// Includes all threads in the system in the snapshot. To enumerate the threads, see Thread32First. To identify the threads that
/// belong to a specific process, compare its process identifier to the th32OwnerProcessID member of the THREADENTRY32 structure when
/// enumerating the threads.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="th32ProcessID">
/// <para>
/// The process identifier of the process to be included in the snapshot. This parameter can be zero to indicate the current process.
/// This parameter is used when the <c>TH32CS_SNAPHEAPLIST</c>, <c>TH32CS_SNAPMODULE</c>, <c>TH32CS_SNAPMODULE32</c>, or
/// <c>TH32CS_SNAPALL</c> value is specified. Otherwise, it is ignored and all processes are included in the snapshot.
/// </para>
/// <para>
/// If the specified process is the Idle process or one of the CSRSS processes, this function fails and the last error code is
/// <c>ERROR_ACCESS_DENIED</c> because their access restrictions prevent user-level code from opening them.
/// </para>
/// <para>
/// If the specified process is a 64-bit process and the caller is a 32-bit process, this function fails and the last error code is
/// <c>ERROR_PARTIAL_COPY</c> (299).
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns an open handle to the specified snapshot.</para>
/// <para>
/// If the function fails, it returns <c>INVALID_HANDLE_VALUE</c>. To get extended error information, call GetLastError. Possible
/// error codes include <c>ERROR_BAD_LENGTH</c>.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The snapshot taken by this function is examined by the other tool help functions to provide their results. Access to the snapshot
/// is read only. The snapshot handle acts as an object handle and is subject to the same rules regarding which processes and threads
/// it is valid in.
/// </para>
/// <para>
/// To enumerate the heap or module states for all processes, specify <c>TH32CS_SNAPALL</c> and set to zero. Then, for each
/// additional process in the snapshot, call <c>CreateToolhelp32Snapshot</c> again, specifying its process identifier and the
/// <c>TH32CS_SNAPHEAPLIST</c> or <c>TH32_SNAPMODULE</c> value.
/// </para>
/// <para>
/// When taking snapshots that include heaps and modules for a process other than the current process, the
/// <c>CreateToolhelp32Snapshot</c> function can fail or return incorrect information for a variety of reasons. For example, if the
/// loader data table in the target process is corrupted or not initialized, or if the module list changes during the function call
/// as a result of DLLs being loaded or unloaded, the function might fail with <c>ERROR_BAD_LENGTH</c> or other error code. Ensure
/// that the target process was not started in a suspended state, and try calling the function again. If the function fails with
/// <c>ERROR_BAD_LENGTH</c> when called with <c>TH32CS_SNAPMODULE</c> or <c>TH32CS_SNAPMODULE32</c>, call the function again until it succeeds.
/// </para>
/// <para>
/// The <c>TH32CS_SNAPMODULE</c> and <c>TH32CS_SNAPMODULE32</c> flags do not retrieve handles for modules that were loaded with the
/// <c>LOAD_LIBRARY_AS_DATAFILE</c> or similar flags. For more information, see LoadLibraryEx.
/// </para>
/// <para>To destroy the snapshot, use the CloseHandle function.</para>
/// <para>
/// Note that you can use the QueryFullProcessImageName function to retrieve the full name of an executable image for both 32- and
/// 64-bit processes from a 32-bit process.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Taking a Snapshot and Viewing Processes.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot HANDLE
// CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "df643c25-7558-424c-b187-b3f86ba51358")]
public static extern IntPtr CreateToolhelp32Snapshot(TH32CS dwFlags, uint th32ProcessID);
/// <summary>
/// <para>Retrieves information about the first block of a heap that has been allocated by a process.</para>
/// </summary>
/// <param name="lphe">
/// <para>A pointer to a HEAPENTRY32 structure.</para>
/// </param>
/// <param name="th32ProcessID">
/// <para>The identifier of the process context that owns the heap.</para>
/// </param>
/// <param name="th32HeapID">
/// <para>The identifier of the heap to be enumerated.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if information for the first heap block has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if the heap is invalid or empty.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The calling application must set the <c>dwSize</c> member of HEAPENTRY32 to the size, in bytes, of the structure.
/// <c>Heap32First</c> changes <c>dwSize</c> to the number of bytes written to the structure. This will never be greater than the
/// initial value of <c>dwSize</c>, but it may be smaller. If the value is smaller, do not rely on the values of any members whose
/// offsets are greater than this value.
/// </para>
/// <para>To access subsequent blocks of the same heap, use the Heap32Next function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Heap List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-heap32first BOOL Heap32First( LPHEAPENTRY32 lphe, DWORD
// th32ProcessID, ULONG_PTR th32HeapID );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "79d01e3a-b11b-46b5-99d0-b445000288a7")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Heap32First(ref HEAPENTRY32 lphe, uint th32ProcessID, UIntPtr th32HeapID);
/// <summary>
/// <para>Retrieves information about the first heap that has been allocated by a specified process.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lphl">
/// <para>A pointer to a HEAPLIST32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the first entry of the heap list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function when no heap list exists or the snapshot does not
/// contain heap list information.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The calling application must set the <c>dwSize</c> member of HEAPLIST32 to the size, in bytes, of the structure.
/// <c>Heap32ListFirst</c> changes <c>dwSize</c> to the number of bytes written to the structure. This will never be greater than the
/// initial value of <c>dwSize</c>, but it may be smaller. If the value is smaller, do not rely on the values of any members whose
/// offsets are greater than this value.
/// </para>
/// <para>To retrieve information about other heaps in the heap list, use the Heap32ListNext function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Heap List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-heap32listfirst BOOL Heap32ListFirst( HANDLE hSnapshot,
// LPHEAPLIST32 lphl );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "b9a2992b-0dc1-41c3-aa23-796def674831")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Heap32ListFirst(IntPtr hSnapshot, ref HEAPLIST32 lphl);
/// <summary>
/// <para>Retrieves information about the next heap that has been allocated by a process.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lphl">
/// <para>A pointer to a HEAPLIST32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the next entry of the heap list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function when no more entries in the heap list exist.
/// </para>
/// </returns>
/// <remarks>
/// <para>To retrieve information about the first heap in a heap list, use the Heap32ListFirst function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Heap List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-heap32listnext BOOL Heap32ListNext( HANDLE hSnapshot,
// LPHEAPLIST32 lphl );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "bb4d573c-a82f-48ac-be22-440d6a1d0c9c")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Heap32ListNext(IntPtr hSnapshot, ref HEAPLIST32 lphl);
/// <summary>
/// <para>Retrieves information about the next block of a heap that has been allocated by a process.</para>
/// </summary>
/// <param name="lphe">
/// <para>A pointer to a HEAPENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if information about the next block in the heap has been copied to the buffer or <c>FALSE</c> otherwise. The
/// GetLastError function returns <c>ERROR_NO_MORE_FILES</c> when no more objects in the heap exist and <c>ERROR_INVALID_DATA</c> if
/// the heap appears to be corrupt or is modified during the walk in such a way that <c>Heap32Next</c> cannot continue.
/// </para>
/// </returns>
/// <remarks>
/// <para>To retrieve information for the first block of a heap, use the Heap32First function.</para>
/// <para>
/// The <c>Heap32Next</c> function does not maintain a reference to the target process. If the target process dies, the system may
/// create a new process using the same process identifier. Therefore, the caller should maintain a reference to the target process
/// as long as it is using <c>Heap32Next</c>.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Heap List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-heap32next BOOL Heap32Next( LPHEAPENTRY32 lphe );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "cc3becd0-edba-47cf-ac2d-26a5d98390e7")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Heap32Next(ref HEAPENTRY32 lphe);
/// <summary>
/// <para>Retrieves information about the first module associated with a process.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lpme">
/// <para>A pointer to a MODULEENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the first entry of the module list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no modules exist or the snapshot does not
/// contain module information.
/// </para>
/// </returns>
/// <remarks>
/// <para>The calling application must set the <c>dwSize</c> member of MODULEENTRY32 to the size, in bytes, of the structure.</para>
/// <para>To retrieve information about other modules associated with the specified process, use the Module32Next function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Module List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-module32first BOOL Module32First( HANDLE hSnapshot,
// LPMODULEENTRY32 lpme );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "bb41cab9-13a1-469d-bf76-68c172e982f6")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Module32First(IntPtr hSnapshot, out MODULEENTRY32 lpme);
/// <summary>
/// <para>Retrieves information about the next module associated with a process or thread.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lpme">
/// <para>A pointer to a MODULEENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the next entry of the module list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no more modules exist.
/// </para>
/// </returns>
/// <remarks>
/// <para>To retrieve information about first module associated with a process, use the Module32First function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Module List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-module32next BOOL Module32Next( HANDLE hSnapshot,
// LPMODULEENTRY32 lpme );
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("tlhelp32.h", MSDNShortId = "88ec1af4-bae7-4cd7-b830-97a98fb337f4")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Module32Next(IntPtr hSnapshot, out MODULEENTRY32 lpme);
/// <summary>
/// <para>Retrieves information about the first process encountered in a system snapshot.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lppe">
/// <para>
/// A pointer to a PROCESSENTRY32 structure. It contains process information such as the name of the executable file, the process
/// identifier, and the process identifier of the parent process.
/// </para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the first entry of the process list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no processes exist or the snapshot does not
/// contain process information.
/// </para>
/// </returns>
/// <remarks>
/// <para>The calling application must set the <c>dwSize</c> member of PROCESSENTRY32 to the size, in bytes, of the structure.</para>
/// <para>To retrieve information about other processes recorded in the same snapshot, use the Process32Next function.</para>
/// <para>Examples</para>
/// <para>For an example, see Taking a Snapshot and Viewing Processes.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-process32first BOOL Process32First( HANDLE hSnapshot,
// LPPROCESSENTRY32 lppe );
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("tlhelp32.h", MSDNShortId = "097790e8-30c2-4b00-9256-fa26e2ceb893")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Process32First(IntPtr hSnapshot, ref PROCESSENTRY32 lppe);
/// <summary>
/// <para>Retrieves information about the next process recorded in a system snapshot.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lppe">
/// <para>A pointer to a PROCESSENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the next entry of the process list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no processes exist or the snapshot does not
/// contain process information.
/// </para>
/// </returns>
/// <remarks>
/// <para>To retrieve information about the first process recorded in a snapshot, use the Process32First function.</para>
/// <para>Examples</para>
/// <para>For an example, see Taking a Snapshot and Viewing Processes.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-process32next BOOL Process32Next( HANDLE hSnapshot,
// LPPROCESSENTRY32 lppe );
[DllImport(Lib.Kernel32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("tlhelp32.h", MSDNShortId = "843a95fd-27ae-4215-83d0-82fc402b82b6")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Process32Next(IntPtr hSnapshot, ref PROCESSENTRY32 lppe);
/// <summary>
/// <para>Retrieves information about the first thread of any process encountered in a system snapshot.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lpte">
/// <para>A pointer to a THREADENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the first entry of the thread list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no threads exist or the snapshot does not
/// contain thread information.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The calling application must set the <c>dwSize</c> member of THREADENTRY32 to the size, in bytes, of the structure.
/// <c>Thread32First</c> changes <c>dwSize</c> to the number of bytes written to the structure. This will never be greater than the
/// initial value of <c>dwSize</c>, but it may be smaller. If the value is smaller, do not rely on the values of any members whose
/// offsets are greater than this value.
/// </para>
/// <para>To retrieve information about other threads recorded in the same snapshot, use the Thread32Next function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Thread List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-thread32first BOOL Thread32First( HANDLE hSnapshot,
// LPTHREADENTRY32 lpte );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "d4cb7a19-850e-43b5-bda5-91be48382d2a")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Thread32First(IntPtr hSnapshot, ref THREADENTRY32 lpte);
/// <summary>
/// <para>Retrieves information about the next thread of any process encountered in the system memory snapshot.</para>
/// </summary>
/// <param name="hSnapshot">
/// <para>A handle to the snapshot returned from a previous call to the CreateToolhelp32Snapshot function.</para>
/// </param>
/// <param name="lpte">
/// <para>A pointer to a THREADENTRY32 structure.</para>
/// </param>
/// <returns>
/// <para>
/// Returns <c>TRUE</c> if the next entry of the thread list has been copied to the buffer or <c>FALSE</c> otherwise. The
/// <c>ERROR_NO_MORE_FILES</c> error value is returned by the GetLastError function if no threads exist or the snapshot does not
/// contain thread information.
/// </para>
/// </returns>
/// <remarks>
/// <para>To retrieve information about the first thread recorded in a snapshot, use the Thread32First function.</para>
/// <para>Examples</para>
/// <para>For an example, see Traversing the Thread List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-thread32next BOOL Thread32Next( HANDLE hSnapshot,
// LPTHREADENTRY32 lpte );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "5efe514e-626c-4138-97a0-bdad217c424f")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Thread32Next(IntPtr hSnapshot, ref THREADENTRY32 lpte);
/// <summary>
/// <para>Copies memory allocated to another process into an application-supplied buffer.</para>
/// </summary>
/// <param name="th32ProcessID">
/// <para>
/// The identifier of the process whose memory is being copied. This parameter can be zero to copy the memory of the current process.
/// </para>
/// </param>
/// <param name="lpBaseAddress">
/// <para>
/// The base address in the specified process to read. Before transferring any data, the system verifies that all data in the base
/// address and memory of the specified size is accessible for read access. If this is the case, the function proceeds. Otherwise,
/// the function fails.
/// </para>
/// </param>
/// <param name="lpBuffer">
/// <para>A pointer to a buffer that receives the contents of the address space of the specified process.</para>
/// </param>
/// <param name="cbRead">
/// <para>The number of bytes to read from the specified process.</para>
/// </param>
/// <param name="lpNumberOfBytesRead">
/// <para>The number of bytes copied to the specified buffer. If this parameter is <c>NULL</c>, it is ignored.</para>
/// </param>
/// <returns>
/// <para>Returns <c>TRUE</c> if successful.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-toolhelp32readprocessmemory BOOL
// Toolhelp32ReadProcessMemory( DWORD th32ProcessID, LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T cbRead, SIZE_T
// *lpNumberOfBytesRead );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("tlhelp32.h", MSDNShortId = "e579b813-32ef-481d-8dc6-f959ec9b6bad")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool Toolhelp32ReadProcessMemory(uint th32ProcessID, IntPtr lpBaseAddress, IntPtr lpBuffer, SizeT cbRead, out SizeT lpNumberOfBytesRead);
/// <summary>
/// <para>Describes one entry (block) of a heap that is being examined.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/ns-tlhelp32-tagheapentry32 typedef struct tagHEAPENTRY32 { SIZE_T
// dwSize; HANDLE hHandle; ULONG_PTR dwAddress; SIZE_T dwBlockSize; DWORD dwFlags; DWORD dwLockCount; DWORD dwResvd; DWORD
// th32ProcessID; ULONG_PTR th32HeapID; } HEAPENTRY32;
[PInvokeData("tlhelp32.h", MSDNShortId = "c5f1dc66-d44f-4491-b0b7-961b163d0f1f")]
[StructLayout(LayoutKind.Sequential)]
public struct HEAPENTRY32
{
/// <summary>
/// <para>
/// The size of the structure, in bytes. Before calling the Heap32First function, set this member to . If you do not initialize
/// <c>dwSize</c>, <c>Heap32First</c> fails.
/// </para>
/// </summary>
public SizeT dwSize;
/// <summary>
/// <para>A handle to the heap block.</para>
/// </summary>
public IntPtr hHandle;
/// <summary>
/// <para>The linear address of the start of the block.</para>
/// </summary>
public UIntPtr dwAddress;
/// <summary>
/// <para>The size of the heap block, in bytes.</para>
/// </summary>
public SizeT dwBlockSize;
/// <summary>
/// <para>This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>LF32_FIXED</term>
/// <term>The memory block has a fixed (unmovable) location.</term>
/// </item>
/// <item>
/// <term>LF32_FREE</term>
/// <term>The memory block is not used.</term>
/// </item>
/// <item>
/// <term>LF32_MOVEABLE</term>
/// <term>The memory block location can be moved.</term>
/// </item>
/// </list>
/// </summary>
public uint dwFlags;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public uint dwLockCount;
/// <summary>
/// <para>Reserved; do not use or alter.</para>
/// </summary>
public uint dwResvd;
/// <summary>
/// <para>The identifier of the process that uses the heap.</para>
/// </summary>
public uint th32ProcessID;
/// <summary>
/// <para>The heap identifier. This is not a handle, and has meaning only to the tool help functions.</para>
/// </summary>
public UIntPtr th32HeapID;
}
/// <summary>
/// <para>Describes an entry from a list that enumerates the heaps used by a specified process.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/ns-tlhelp32-tagheaplist32 typedef struct tagHEAPLIST32 { SIZE_T
// dwSize; DWORD th32ProcessID; ULONG_PTR th32HeapID; DWORD dwFlags; } HEAPLIST32;
[PInvokeData("tlhelp32.h", MSDNShortId = "61e01d23-9f15-44c5-9f6d-45df4809ccad")]
[StructLayout(LayoutKind.Sequential)]
public struct HEAPLIST32
{
/// <summary>
/// <para>
/// The size of the structure, in bytes. Before calling the Heap32ListFirst function, set this member to . If you do not
/// initialize <c>dwSize</c>, <c>Heap32ListFirst</c> will fail.
/// </para>
/// </summary>
public SizeT dwSize;
/// <summary>
/// <para>The identifier of the process to be examined.</para>
/// </summary>
public uint th32ProcessID;
/// <summary>
/// <para>The heap identifier. This is not a handle, and has meaning only to the tool help functions.</para>
/// </summary>
public UIntPtr th32HeapID;
/// <summary>
/// <para>This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>HF32_DEFAULT</term>
/// <term>Process's default heap</term>
/// </item>
/// </list>
/// </summary>
public HEAPLIST32_FLAGS dwFlags;
}
/// <summary>
/// <para>Describes an entry from a list of the modules belonging to the specified process.</para>
/// </summary>
/// <remarks>
/// <para>The <c>modBaseAddr</c> and <c>hModule</c> members are valid only in the context of the process specified by th32ProcessID.</para>
/// <para>Examples</para>
/// <para>For an example that uses <c>MODULEENTRY32</c>, see Traversing the Module List.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/ns-tlhelp32-tagmoduleentry32 typedef struct tagMODULEENTRY32 { DWORD
// dwSize; DWORD th32ModuleID; DWORD th32ProcessID; DWORD GlblcntUsage; DWORD ProccntUsage; BYTE *modBaseAddr; DWORD modBaseSize;
// HMODULE hModule; char szModule[MAX_MODULE_NAME32 + 1]; char szExePath[MAX_PATH]; } MODULEENTRY32;
[PInvokeData("tlhelp32.h", MSDNShortId = "305fab35-625c-42e3-a434-e2513e4c8870")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct MODULEENTRY32
{
private const int MAX_MODULE_NAME32 = 255;
/// <summary>
/// <para>
/// The size of the structure, in bytes. Before calling the Module32First function, set this member to . If you do not initialize
/// <c>dwSize</c>, <c>Module32First</c> fails.
/// </para>
/// </summary>
public uint dwSize;
/// <summary>
/// <para>This member is no longer used, and is always set to one.</para>
/// </summary>
public uint th32ModuleID;
/// <summary>
/// <para>The identifier of the process whose modules are to be examined.</para>
/// </summary>
public uint th32ProcessID;
/// <summary>
/// <para>The load count of the module, which is not generally meaningful, and usually equal to 0xFFFF.</para>
/// </summary>
public uint GlblcntUsage;
/// <summary>
/// <para>The load count of the module (same as GlblcntUsage), which is not generally meaningful, and usually equal to 0xFFFF.</para>
/// </summary>
public uint ProccntUsage;
/// <summary>
/// <para>The base address of the module in the context of the owning process.</para>
/// </summary>
public IntPtr modBaseAddr;
/// <summary>
/// <para>The size of the module, in bytes.</para>
/// </summary>
public uint modBaseSize;
/// <summary>
/// <para>A handle to the module in the context of the owning process.</para>
/// </summary>
public IntPtr hModule;
/// <summary>
/// <para>The module name.</para>
/// </summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_MODULE_NAME32 + 1)]
public string szModule;
/// <summary>
/// <para>The module path.</para>
/// </summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
public string szExePath;
}
/// <summary>
/// <para>Describes an entry from a list of the processes residing in the system address space when a snapshot was taken.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/ns-tlhelp32-tagprocessentry32 typedef struct tagPROCESSENTRY32 {
// DWORD dwSize; DWORD cntUsage; DWORD th32ProcessID; ULONG_PTR th32DefaultHeapID; DWORD th32ModuleID; DWORD cntThreads; DWORD
// th32ParentProcessID; LONG pcPriClassBase; DWORD dwFlags; CHAR szExeFile[MAX_PATH]; } PROCESSENTRY32;
[PInvokeData("tlhelp32.h", MSDNShortId = "9e2f7345-52bf-4bfc-9761-90b0b374c727")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct PROCESSENTRY32
{
/// <summary>
/// <para>
/// The size of the structure, in bytes. Before calling the Process32First function, set this member to . If you do not
/// initialize <c>dwSize</c>, <c>Process32First</c> fails.
/// </para>
/// </summary>
public uint dwSize;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public uint cntUsage;
/// <summary>
/// <para>The process identifier.</para>
/// </summary>
public uint th32ProcessID;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public UIntPtr th32DefaultHeapID;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public uint th32ModuleID;
/// <summary>
/// <para>The number of execution threads started by the process.</para>
/// </summary>
public uint cntThreads;
/// <summary>
/// <para>The identifier of the process that created this process (its parent process).</para>
/// </summary>
public uint th32ParentProcessID;
/// <summary>
/// <para>The base priority of any threads created by this process.</para>
/// </summary>
public int pcPriClassBase;
/// <summary>
/// <para>This member is no longer used, and is always set to zero.</para>
/// </summary>
public uint dwFlags;
/// <summary>
/// <para>
/// The name of the executable file for the process. To retrieve the full path to the executable file, call the Module32First
/// function and check the <c>szExePath</c> member of the MODULEENTRY32 structure that is returned. However, if the calling
/// process is a 32-bit process, you must call the QueryFullProcessImageName function to retrieve the full path of the executable
/// file for a 64-bit process.
/// </para>
/// </summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
public string szExeFile;
}
/// <summary>
/// <para>Describes an entry from a list of the threads executing in the system when a snapshot was taken.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/ns-tlhelp32-tagthreadentry32 typedef struct tagTHREADENTRY32 { DWORD
// dwSize; DWORD cntUsage; DWORD th32ThreadID; DWORD th32OwnerProcessID; LONG tpBasePri; LONG tpDeltaPri; DWORD dwFlags; } THREADENTRY32;
[PInvokeData("tlhelp32.h", MSDNShortId = "923feca1-8807-4752-8a5a-79075688aabd")]
[StructLayout(LayoutKind.Sequential)]
public struct THREADENTRY32
{
/// <summary>
/// <para>
/// The size of the structure, in bytes. Before calling the Thread32First function, set this member to . If you do not initialize
/// <c>dwSize</c>, <c>Thread32First</c> fails.
/// </para>
/// </summary>
public uint dwSize;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public uint cntUsage;
/// <summary>
/// <para>The thread identifier, compatible with the thread identifier returned by the CreateProcess function.</para>
/// </summary>
public uint th32ThreadID;
/// <summary>
/// <para>The identifier of the process that created the thread.</para>
/// </summary>
public uint th32OwnerProcessID;
/// <summary>
/// <para>
/// The kernel base priority level assigned to the thread. The priority is a number from 0 to 31, with 0 representing the lowest
/// possible thread priority. For more information, see <c>KeQueryPriorityThread</c>.
/// </para>
/// </summary>
public int tpBasePri;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public int tpDeltaPri;
/// <summary>
/// <para>This member is no longer used and is always set to zero.</para>
/// </summary>
public uint dwFlags;
}
}
}

6
PInvoke/Kernel32/Vanara.PInvoke.Kernel32.csproj
View File

File diff suppressed because one or more lines are too long

738
PInvoke/Kernel32/WerApi.cs Normal file
View File

@ -0,0 +1,738 @@
using System;
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>Flags used by WerGetFlags and WerSetFlags.</summary>
[PInvokeData("werapi.h", MSDNShortId = "8c5f08c0-e2d1-448c-9a57-ef19897f64c6")]
[Flags]
public enum WER_FAULT_REPORTING
{
/// <summary>Do not collect heap information in the event of an application crash or non-response.</summary>
WER_FAULT_REPORTING_FLAG_NOHEAP = 1,
/// <summary>Queue critical reports for the specified process. This does not show any UI.</summary>
WER_FAULT_REPORTING_FLAG_QUEUE = 2,
/// <summary>Do not suspend the process threads before reporting the error.</summary>
WER_FAULT_REPORTING_FLAG_DISABLE_THREAD_SUSPENSION = 4,
/// <summary>Queue critical reports and upload from the queue.</summary>
WER_FAULT_REPORTING_FLAG_QUEUE_UPLOAD = 8,
/// <summary>Always show error reporting UI for this process. This is applicable for interactive applications only.</summary>
WER_FAULT_REPORTING_ALWAYS_SHOW_UI = 16,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_NO_UI = 32,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_FLAG_NO_HEAP_ON_QUEUE = 64,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_DISABLE_SNAPSHOT_CRASH = 128,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_DISABLE_SNAPSHOT_HANG = 256,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_CRITICAL = 512,
/// <summary>Undocumented.</summary>
WER_FAULT_REPORTING_DURABLE = 1024,
}
public enum WER_FILE_TYPE
{
WerFileTypeMicrodump = 1,
WerFileTypeMinidump = 2,
WerFileTypeHeapdump = 3,
WerFileTypeUserDocument = 4,
WerFileTypeOther = 5,
WerFileTypeTriagedump = 6,
WerFileTypeCustomDump = 7,
WerFileTypeAuxiliaryDump = 8,
WerFileTypeEtlTrace = 9,
WerFileTypeMax
}
/// <summary>The file type.</summary>
[PInvokeData("werapi.h", MSDNShortId = "4b4bb1bb-6782-447a-901f-75702256d907")]
public enum WER_REGISTER_FILE_TYPE
{
/// <summary>
/// The document in use by the application at the time of the event. This document is only collected if the Watson server asks
/// for it.
/// </summary>
WerRegFileTypeUserDocument = 1,
/// <summary>Any other type of file.</summary>
WerRegFileTypeOther = 2,
/// <summary>The maximum value for the WER_REGISTER_FILE_TYPE enumeration type.</summary>
WerRegFileTypeMax
}
public enum WER_REPORT_TYPE
{
WerReportNonCritical = 0,
WerReportCritical = 1,
WerReportApplicationCrash = 2,
WerReportApplicationHang = 3,
WerReportKernel = 4,
WerReportInvalid
}
public enum WER_REPORT_UI
{
WerUIAdditionalDataDlgHeader = 1,
WerUIIconFilePath = 2,
WerUIConsentDlgHeader = 3,
WerUIConsentDlgBody = 4,
WerUIOnlineSolutionCheckText = 5,
WerUIOfflineSolutionCheckText = 6,
WerUICloseText = 7,
WerUICloseDlgHeader = 8,
WerUICloseDlgBody = 9,
WerUICloseDlgButtonText = 10,
WerUIMax
}
public enum WER_SUBMIT_RESULT
{
WerReportQueued = 1,
WerReportUploaded = 2,
WerReportDebug = 3,
WerReportFailed = 4,
WerDisabled = 5,
WerReportCancelled = 6,
WerDisabledQueue = 7,
WerReportAsync = 8,
WerCustomAction = 9,
WerThrottled = 10,
WerReportUploadedCab = 11,
WerStorageLocationNotFound = 12,
WerSubmitResultMax
}
/// <summary>
/// <para>Retrieves the fault reporting settings for the specified process.</para>
/// </summary>
/// <param name="hProcess">
/// <para>A handle to the process. This handle must have the PROCESS_VM_READ or PROCESS_QUERY_INFORMATION access right.</para>
/// </param>
/// <param name="pdwFlags">
/// <para>This parameter can contain one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_DISABLE_THREAD_SUSPENSION</term>
/// <term>Do not suspend the process threads before reporting the error.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_NOHEAP</term>
/// <term>Do not collect heap information in the event of an application crash or non-response.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_QUEUE</term>
/// <term>Queue critical reports for the specified process. This does not show any UI.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_QUEUE_UPLOAD</term>
/// <term>Queue critical reports and upload from the queue.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_ALWAYS_SHOW_UI</term>
/// <term>Always show error reporting UI for this process. This is applicable for interactive applications only.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-wergetflags HRESULT WerGetFlags( HANDLE hProcess, PDWORD
// pdwFlags );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "8c5f08c0-e2d1-448c-9a57-ef19897f64c6")]
public static extern HRESULT WerGetFlags(IntPtr hProcess, out WER_FAULT_REPORTING pdwFlags);
/// <summary>
/// Registers a process to be included in the error report along with the main application process. Optionally specifies a thread
/// within that registered process to get additional data from.
/// </summary>
/// <param name="processId">The Id of the process to register.</param>
/// <param name="captureExtraInfoForThreadId">The Id of a thread within the registered process from which more information is requested.</param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>E_INVALIDARG</term>
/// <term>The value of processId is 0.</term>
/// </item>
/// <item>
/// <term>E_OUTOFMEMORY</term>
/// <term>WER could not allocate a large enough heap for the data.</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>
/// Number of WER registered entries (memory blocks, metadata, files) exceeds max (WER_MAX_REGISTERED_ENTRIES) or number of processes
/// exceeds max (WER_MAX_REGISTERED_DUMPCOLLECTION)
/// </term>
/// </item>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// </list>
/// </para>
/// </returns>
// HRESULT WINAPI WerRegisterAdditionalProcess( DWORD processId, DWORD captureExtraInfoForThreadId); https://msdn.microsoft.com/en-us/library/windows/desktop/mt492585(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("Werapi.h", MSDNShortId = "mt492585")]
public static extern HRESULT WerRegisterAdditionalProcess(uint processId, uint captureExtraInfoForThreadId);
/// <summary>
/// <para>Registers app-specific metadata to be collected (in the form of key/value strings) when WER creates an error report.</para>
/// </summary>
/// <param name="key">
/// <para>The "key" string for the metadata element being registered.</para>
/// </param>
/// <param name="value">
/// <para>The value string for the metadata element being registered.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>E_INVALIDARG</term>
/// <term>
/// Strings were NULL, key length was greater than 64 characters or was an invalid xml element name, orvalue length was greater than
/// 128 characters or contained characters that were not ASCII printable characters.
/// </term>
/// </item>
/// <item>
/// <term>E_OUTOFMEMORY</term>
/// <term>WER could not allocate a large enough heap for the data</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>
/// The maximum number of registered entries (WER_MAX_REGISTERED_ENTRIES) or maximum amount of registered metadata
/// (WER_MAX_REGISTERED_METADATA) has been reached.
/// </term>
/// </item>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// This API allows apps to integrate their own app-level telemetry with system-level telemetry (WER) by associating app metadata
/// with crash reports corresponding to their processes.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werregistercustommetadata HRESULT WerRegisterCustomMetadata(
// PCWSTR key, PCWSTR value );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true, CharSet = CharSet.Unicode)]
[PInvokeData("werapi.h", MSDNShortId = "55FB3110-314A-4327-AA8F-3AF77B7006DD")]
public static extern HRESULT WerRegisterCustomMetadata(string key, string value);
/// <summary>
/// <para>Marks a memory block (that is normally included by default in error reports) to be excluded from the error report.</para>
/// </summary>
/// <param name="address">
/// <para>The starting address of the memory block.</para>
/// </param>
/// <param name="size">
/// <para>The size of the memory block, in bytes.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>E_INVALIDARG</term>
/// <term>address is NULL or size is 0.</term>
/// </item>
/// <item>
/// <term>E_OUTOFMEMORY</term>
/// <term>WER could not allocate a large enough heap for the data</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>The number of registered entries exceeds the limit (WER_MAX_REGISTERED_ENTRIES).</term>
/// </item>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// This mechanism is intended for applications that hold large amounts of data in memory that aren't useful for root cause debugging
/// and increase the size of the dump file unnecessarily. For example, some Xbox One games hold large amounts of texture data in
/// memory that is included in error dumps by default.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werregisterexcludedmemoryblock HRESULT
// WerRegisterExcludedMemoryBlock( const void *address, DWORD size );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "6CDA8EDD-C8A5-471D-9716-3AB29E571133")]
public static extern HRESULT WerRegisterExcludedMemoryBlock(IntPtr address, uint size);
/// <summary>
/// <para>Registers a file to be collected when WER creates an error report.</para>
/// </summary>
/// <param name="pwzFile">
/// <para>The full path to the file. The maximum length of this path is MAX_PATH characters.</para>
/// </param>
/// <param name="regFileType">
/// <para>The file type. This parameter can be one of the following values from the <c>WER_REGISTER_FILE_TYPE</c> enumeration type.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>WerRegFileTypeMax 3</term>
/// <term>The maximum value for the WER_REGISTER_FILE_TYPE enumeration type.</term>
/// </item>
/// <item>
/// <term>WerRegFileTypeOther 2</term>
/// <term>Any other type of file.</term>
/// </item>
/// <item>
/// <term>WerRegFileTypeUserDocument 1</term>
/// <term>
/// The document in use by the application at the time of the event. This document is only collected if the Watson server asks for it.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFlags">
/// <para>This parameter can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>WER_FILE_ANONYMOUS_DATA</term>
/// <term>The file does not contain personal information that could be used to identify or contact the user.</term>
/// </item>
/// <item>
/// <term>WER_FILE_DELETE_WHEN_DONE</term>
/// <term>Automatically deletes the file after it is added to the report.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>The number of registered memory blocks and files exceeds the limit.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>The registered file is added to the report only when additional data is requested by the server.</para>
/// <para>
/// For crashes and non-responses, the operating system automatically provides error reporting (you do not need to provide any error
/// reporting code in your application). If you use this function to register a file, the operating system will add the file to the
/// error report created at the time of a crash or non-response (this file is added in addition to the files the operating system
/// already collects).
/// </para>
/// <para>
/// For generic event reporting, the application has to use the WerReportAddFile function instead. Alternatively, calling the
/// WerReportSubmit function with the WER_SUBMIT_ADD_REGISTERED_DATA flag will include the files that the <c>WerRegisterFile</c>
/// function added.
/// </para>
/// <para>To remove the file from the list, call the WerUnregisterFile function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werregisterfile HRESULT WerRegisterFile( PCWSTR pwzFile,
// WER_REGISTER_FILE_TYPE regFileType, DWORD dwFlags );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "4b4bb1bb-6782-447a-901f-75702256d907")]
public static extern HRESULT WerRegisterFile([MarshalAs(UnmanagedType.LPWStr)] string pwzFile, WER_REGISTER_FILE_TYPE regFileType, uint dwFlags);
/// <summary>
/// <para>Registers a memory block to be collected when WER creates an error report.</para>
/// </summary>
/// <param name="pvAddress">
/// <para>The starting address of the memory block.</para>
/// </param>
/// <param name="dwSize">
/// <para>The size of the memory block, in bytes. The maximum value for this parameter is WER_MAX_MEM_BLOCK_SIZE bytes.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>The number of registered memory blocks and files exceeds the limit.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// Memory registered with this function is only added to heap or larger dump files. This memory is never added to mini dumps or
/// smaller dump files.
/// </para>
/// <para>
/// For crashes and no response, the operating system automatically provides error reporting (you do not need to provide any error
/// reporting code in your application). If you use this function to register a memory block, the operating system will add the
/// memory block information to the dump file at the time of the crash or non-response. The memory block is added to the dump file
/// for the report only when additional data is requested by the server.
/// </para>
/// <para>
/// For generic event reporting, the application has to call the WER generic event reporting functions directly. To add the memory
/// block to a generic report, call the WerReportAddDump function and then call the WerReportSubmit function and specify the
/// WER_SUBMIT_ADD_REGISTERED_DATA flag.
/// </para>
/// <para>To remove the block from this list, call the WerUnregisterMemoryBlock function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werregistermemoryblock HRESULT WerRegisterMemoryBlock( PVOID
// pvAddress, DWORD dwSize );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "10fa2bf3-ec12-4c7c-b986-9b22cdaa7319")]
public static extern HRESULT WerRegisterMemoryBlock(IntPtr pvAddress, uint dwSize);
/// <summary>
/// <para>Registers a custom runtime exception handler that is used to provide custom error reporting for crashes.</para>
/// </summary>
/// <param name="pwszOutOfProcessCallbackDll">
/// <para>The name of the exception handler DLL to register.</para>
/// </param>
/// <param name="pContext">
/// <para>A pointer to arbitrary context information that is passed to the handler's callback functions.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)</term>
/// <term>
/// The number of registered runtime exception modules exceeds the limit. A process can register up to
/// WER_MAX_REGISTERED_RUNTIME_EXCEPTION_MODULES handlers.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// The exception handler is an out-of-process DLL that the WER service loads when a crash or unhandled exception occurs. The DLL
/// must implement and export the following functions:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>OutOfProcessExceptionEventCallback</term>
/// </item>
/// <item>
/// <term>OutOfProcessExceptionEventSignatureCallback</term>
/// </item>
/// <item>
/// <term>OutOfProcessExceptionEventDebuggerLaunchCallback</term>
/// </item>
/// </list>
/// <para>(The DLL must also include the DllMain entry point.)</para>
/// <para>
/// Using an exception handler is more secure and reliable for reporting crash information than the current, in-process event
/// reporting feature. Also, the current generic event reporting feature is suited only for reporting non-fatal errors.
/// </para>
/// <para>
/// This function requires that the pwszOutOfProcessCallbackDll DLL be included in the WER exception handler module list in the
/// registry. After registering an exception handler, if the process crashes or raises an unhandled exception, the WER service loads
/// your exception handler and calls the OutOfProcessExceptionEventCallback callback function., which you use to state your claim on
/// the crash and provide the event name and report parameters count. Note that if the process registers more than one exception
/// handler, the service calls each handler until one of the handlers claims the crash. If no handlers claim the crash, WER defaults
/// to native crash reporting.
/// </para>
/// <para>
/// If an exception handler claims the exception, the WER service calls the OutOfProcessExceptionEventSignatureCallback callback
/// function, which provides the reporting parameters that uniquely define the problem. Then, the WER service calls the
/// OutOfProcessExceptionEventDebuggerLaunchCallback callback to determine whether to offer the user the option of launching a
/// debugger or launching the debugger automatically. The handler can also specify a custom debugger launch string, which will
/// override the default string (the default is the debugger specified in the AeDebug registry key).
/// </para>
/// <para>
/// After the handler has provided the event name, reporting parameters and debugger launch settings, the rest of the error reporting
/// flow continues in the usual way.
/// </para>
/// <para>
/// You must call the WerUnregisterRuntimeExceptionModule function to remove the registration before your process exits. A process
/// can register up to WER_MAX_REGISTERED_RUNTIME_EXCEPTION_MODULES handlers.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werregisterruntimeexceptionmodule HRESULT
// WerRegisterRuntimeExceptionModule( PCWSTR pwszOutOfProcessCallbackDll, PVOID pContext );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "b0fb2c0d-cc98-43cc-a508-e80545377b7f")]
public static extern HRESULT WerRegisterRuntimeExceptionModule([MarshalAs(UnmanagedType.LPWStr)] string pwszOutOfProcessCallbackDll, IntPtr pContext);
/// <summary>
/// <para>Sets the fault reporting settings for the current process.</para>
/// </summary>
/// <param name="dwFlags">
/// <para>The fault reporting settings. You can specify one or more of the following values:</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_DISABLE_THREAD_SUSPENSION</term>
/// <term>Do not suspend the process threads before reporting the error.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_NOHEAP</term>
/// <term>Do not collect heap information in the event of an application crash or non-response.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_QUEUE</term>
/// <term>Queue critical reports.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_FLAG_QUEUE_UPLOAD</term>
/// <term>Queue critical reports and upload from the queue.</term>
/// </item>
/// <item>
/// <term>WER_FAULT_REPORTING_ALWAYS_SHOW_UI</term>
/// <term>Always show error reporting UI for this process. This is applicable for interactive applications only.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-wersetflags HRESULT WerSetFlags( DWORD dwFlags );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "2a71203f-3a08-461f-a230-e3fee00d9d99")]
public static extern HRESULT WerSetFlags(WER_FAULT_REPORTING dwFlags);
/// <summary>
/// <para>Removes a process from the list of additional processes to be included in the error report.</para>
/// </summary>
/// <param name="processId">
/// <para>The Id of the process to remove. It must have been previously registered with WerRegisterAdditionalProcess.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>WER_E_NOT_FOUND</term>
/// <term>The list of registered processes does not contain the specified process.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werunregisteradditionalprocess HRESULT
// WerUnregisterAdditionalProcess( DWORD processId );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "CE840EE8-5EB6-4F0F-935E-5DA9097E950F")]
public static extern HRESULT WerUnregisterAdditionalProcess(uint processId);
/// <summary>
/// <para>Removes an item of app-specific metadata being collected during error reporting for the application.</para>
/// </summary>
/// <param name="key">
/// <para>
/// The "key" string for the metadata element being removed. It must have been previously registered with the
/// WerRegisterCustomMetadata function.
/// </para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error codes.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>WER_E_NOT_FOUND</term>
/// <term>WER could not find the metadata item to remove.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werunregistercustommetadata HRESULT
// WerUnregisterCustomMetadata( PCWSTR key );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "29DB2CE5-2A96-450B-96C8-082B786613F9")]
public static extern HRESULT WerUnregisterCustomMetadata([MarshalAs(UnmanagedType.LPWStr)] string key);
/// <summary>
/// <para>Removes a memory block that was previously marked as excluded (it will again be included in error reports).</para>
/// </summary>
/// <param name="address">
/// <para>
/// The starting address of the memory block. This memory block must have been registered using the WerRegisterExcludedMemoryBlock function.
/// </para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werunregisterexcludedmemoryblock HRESULT
// WerUnregisterExcludedMemoryBlock( const void *address );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "99FF746E-8EFC-47DB-AEE6-EC46F7BC7F0B")]
public static extern HRESULT WerUnregisterExcludedMemoryBlock(IntPtr address);
/// <summary>Removes a file from the list of files to be added to reports generated for the current process.</summary>
/// <param name="pwzFilePath">The full path to the file. This file must have been registered using the <c>WerRegisterFile</c> function.</param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error code.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>WER_E_NOT_FOUND</term>
/// <term>The list of registered files does not contain the specified file.</term>
/// </item>
/// </list>
/// </para>
/// </returns>
// HRESULT WINAPI WerUnregisterFile( _In_ PCWSTR pwzFilePath); https://msdn.microsoft.com/en-us/library/windows/desktop/bb513630(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("Werapi.h", MSDNShortId = "bb513630")]
public static extern HRESULT WerUnregisterFile([MarshalAs(UnmanagedType.LPWStr)] string pwzFilePath);
/// <summary>
/// <para>Removes a memory block from the list of data to be collected during error reporting for the application.</para>
/// </summary>
/// <param name="pvAddress">
/// <para>
/// The starting address of the memory block. This memory block must have been registered using the WerRegisterMemoryBlock function.
/// </para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>WER_E_NOT_FOUND</term>
/// <term>The list of registered memory blocks does not contain the specified memory block.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werunregistermemoryblock HRESULT WerUnregisterMemoryBlock(
// PVOID pvAddress );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "016800e8-4a03-40f6-9dba-54cd9082eb48")]
public static extern HRESULT WerUnregisterMemoryBlock(IntPtr pvAddress);
/// <summary>
/// <para>Removes the registration of your WER exception handler.</para>
/// </summary>
/// <param name="pwszOutOfProcessCallbackDll">
/// <para>The name of the exception handler DLL whose registration you want to remove.</para>
/// </param>
/// <param name="pContext">
/// <para>A pointer to arbitrary context information that was passed to the callback.</para>
/// </param>
/// <returns>
/// <para>This function returns <c>S_OK</c> on success or an error code on failure, including the following error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>WER_E_INVALID_STATE</term>
/// <term>The process state is not valid. For example, the process is in application recovery mode.</term>
/// </item>
/// <item>
/// <term>WER_E_NOT_FOUND</term>
/// <term>The list of registered runtime exception handlers does not contain the specified exception handler.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>To register your runtime exception handler, call the WerRegisterRuntimeExceptionModule function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/werapi/nf-werapi-werunregisterruntimeexceptionmodule HRESULT
// WerUnregisterRuntimeExceptionModule( PCWSTR pwszOutOfProcessCallbackDll, PVOID pContext );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("werapi.h", MSDNShortId = "1a315923-b554-4363-a607-076690fc76a1")]
public static extern HRESULT WerUnregisterRuntimeExceptionModule([MarshalAs(UnmanagedType.LPWStr)] string pwszOutOfProcessCallbackDll, IntPtr pContext);
}
}

60
PInvoke/Kernel32/WinBase.File.cs
View File

@ -92,33 +92,65 @@ namespace Vanara.PInvoke
CALLBACK_STREAM_SWITCH = 0x00000001,
}
/// <summary>Flags that specify how the file is to be copied.</summary>
/// <summary>Flags used by <see cref="COPYFILE2_EXTENDED_PARAMETERS"/>.</summary>
[PInvokeData("winbase.h", MSDNShortId = "a8da62e5-bc49-4aff-afaa-e774393b7120")]
[Flags]
public enum COPY_FILE
public enum COPY_FILE : uint
{
/// <summary>An attempt to copy an encrypted file will succeed even if the destination copy cannot be encrypted.</summary>
/// <summary>The copy will be attempted even if the destination file cannot be encrypted.</summary>
COPY_FILE_ALLOW_DECRYPTED_DESTINATION = 0x00000008,
/// <summary>
/// If the source file is a symbolic link, the destination file is also a symbolic link pointing to the same file that the source symbolic link is
/// pointing to.
/// <para>Windows Server 2003 and Windows XP: This value is not supported.</para>
/// If the source file is a symbolic link, the destination file is also a symbolic link pointing to the same file as the source
/// symbolic link.
/// </summary>
COPY_FILE_COPY_SYMLINK = 0x00000800,
/// <summary>The copy operation fails immediately if the target file already exists.</summary>
COPY_FILE_FAIL_IF_EXISTS = 0x00000001,
/// <summary>
/// The copy operation is performed using unbuffered I/O, bypassing system I/O cache resources. Recommended for very large file transfers.
/// <para>Windows Server 2003 and Windows XP: This value is not supported.</para>
/// If the destination file exists the copy operation fails immediately. If a file or directory exists with the destination name
/// then the CopyFile2 function call will fail with either HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS) or
/// HRESULT_FROM_WIN32(ERROR_FILE_EXISTS). If COPY_FILE_RESUME_FROM_PAUSE is also specified then a failure is only triggered if
/// the destination file does not have a valid restart header.
/// </summary>
COPY_FILE_FAIL_IF_EXISTS = 0x00000001,
/// <summary>
/// The copy is performed using unbuffered I/O, bypassing the system cache resources. This flag is recommended for very large
/// file copies. It is not recommended to pause copies that are using this flag.
/// </summary>
COPY_FILE_NO_BUFFERING = 0x00001000,
/// <summary>The file is copied and the original file is opened for write access.</summary>
/// <summary>Do not attempt to use the Windows Copy Offload mechanism. This is not generally recommended.</summary>
COPY_FILE_NO_OFFLOAD = 0x00040000,
/// <summary>The file is copied and the source file is opened for write access.</summary>
COPY_FILE_OPEN_SOURCE_FOR_WRITE = 0x00000004,
/// <summary>
/// Progress of the copy is tracked in the target file in case the copy fails. The failed copy can be restarted at a later time by specifying the
/// same values for lpExistingFileName and lpNewFileName as those used in the call that failed. This can significantly slow down the copy operation
/// as the new file may be flushed multiple times during the copy operation.
/// The file is copied in a manner that can be restarted if the same source and destination filenames are used again. This is slower.
/// </summary>
COPY_FILE_RESTARTABLE = 0x00000002,
/// <summary>
/// The copy is attempted, specifying ACCESS_SYSTEM_SECURITY for the source file and ACCESS_SYSTEM_SECURITY | WRITE_DAC |
/// WRITE_OWNER for the destination file. If these requests are denied the access request will be reduced to the highest
/// privilege level for which access is granted. For more information see SACL Access Right. This can be used to allow the
/// CopyFile2ProgressRoutine callback to perform operations requiring higher privileges, such as copying the security attributes
/// for the file.
/// </summary>
COPY_FILE_REQUEST_SECURITY_PRIVILEGES = 0x00002000,
/// <summary>
/// The destination file is examined to see if it was copied using COPY_FILE_RESTARTABLE. If so the copy is resumed. If not the
/// file will be fully copied.
/// </summary>
COPY_FILE_RESUME_FROM_PAUSE = 0x00004000,
/// <summary>Undocumented.</summary>
COPY_FILE_IGNORE_EDP_BLOCK = 0x00400000,
/// <summary>Undocumented.</summary>
COPY_FILE_IGNORE_SOURCE_ENCRYPTION = 0x00800000,
}
/// <summary>

45
PInvoke/Kernel32/WinBase.ProcessThread.cs
View File

@ -43,13 +43,17 @@ namespace Vanara.PInvoke
ES_USER_PRESENT = 0x00000004,
}
/// <summary>Flags for <c>CreateFiberEx</c>.</summary>
/// <summary>Flags used by <see cref="ConvertThreadToFiberEx"/>.</summary>
[PInvokeData("winbase.h", MSDNShortId = "cb0473f8-bc49-44c9-a8b7-6d5b55aa37a5")]
public enum FIBER_FLAG
{
/// <summary>The floating-point state on x86 systems is not switched and data can be corrupted if a fiber uses floating-point arithmetic.</summary>
FIBER_FLAG_UNSPECIFIED = 0,
/// <summary>
/// The floating-point state on x86 systems is not switched and data can be corrupted if a fiber uses floating-point arithmetic.
/// </summary>
FIBER_FLAG_NONE = 0,
/// <summary>The floating-point state is switched for the fiber.</summary>
FIBER_FLAG_FLOAT_SWITCH = 1
FIBER_FLAG_FLOAT_SWITCH = 1,
}
/// <summary>Converts the current fiber into a thread.</summary>
@ -76,6 +80,39 @@ namespace Vanara.PInvoke
[PInvokeData("WinBase.h", MSDNShortId = "ms682115")]
public static extern IntPtr ConvertThreadToFiber([In] IntPtr lpParameter);
/// <summary>
/// <para>Converts the current thread into a fiber. You must convert a thread into a fiber before you can schedule other fibers.</para>
/// </summary>
/// <param name="lpParameter">
/// <para>A pointer to a variable that is passed to the fiber. The fiber can retrieve this data by using the GetFiberData macro.</para>
/// </param>
/// <param name="dwFlags">
/// <para>
/// If this parameter is zero, the floating-point state on x86 systems is not switched and data can be corrupted if a fiber uses
/// floating-point arithmetic. If this parameter is FIBER_FLAG_FLOAT_SWITCH, the floating-point state is switched for the fiber.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the address of the fiber.</para>
/// <para>If the function fails, the return value is NULL. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// Only fibers can execute other fibers. If a thread needs to execute a fiber, it must call ConvertTheadToFiber or
/// <c>ConvertThreadToFiberEx</c> to create an area in which to save fiber state information. The thread is now the current fiber.
/// The state information for this fiber includes the fiber data specified by .
/// </para>
/// <para>
/// To compile an application that uses this function, define _WIN32_WINNT as 0x0400 or later. For more information, see Using the
/// Windows Headers.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-convertthreadtofiberex LPVOID ConvertThreadToFiberEx(
// LPVOID lpParameter, DWORD dwFlags );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "cb0473f8-bc49-44c9-a8b7-6d5b55aa37a5")]
public static extern IntPtr ConvertThreadToFiberEx(IntPtr lpParameter, FIBER_FLAG dwFlags);
/// <summary>
/// Allocates a fiber object, assigns it a stack, and sets up execution to begin at the specified start address, typically the fiber function. This
/// function does not schedule the fiber.

7100
PInvoke/Kernel32/WinBase.cs
View File

File diff suppressed because it is too large Load Diff

30
PInvoke/Kernel32/WinCon.cs
View File

@ -1371,22 +1371,40 @@ namespace Vanara.PInvoke
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetConsoleCursorInfo(IntPtr hConsoleOutput, ref CONSOLE_CURSOR_INFO lpConsoleCursorInfo);
/// <summary>Sets the cursor position in the specified console screen buffer.</summary>
/// <summary>
/// <para>Sets the cursor position in the specified console screen buffer.</para>
/// </summary>
/// <param name="hConsoleOutput">
/// A handle to the console screen buffer. The handle must have the <c>GENERIC_READ</c> access right. For more information, see Console Buffer Security
/// and Access Rights.
/// <para>
/// [in]A handle to the console screen buffer. The handle must have the <c>GENERIC_READ</c> access right. For more information, see
/// Console Buffer Security and Access Rights.
/// </para>
/// </param>
/// <param name="dwCursorPosition">
/// A <c>COORD</c> structure that specifies the new cursor position, in characters. The coordinates are the column and row of a screen buffer character
/// cell. The coordinates must be within the boundaries of the console screen buffer.
/// <para>
/// [in]A <c>COORD</c> structure that specifies the new cursor position, in characters. The coordinates are the column and row of a
/// screen buffer character cell. The coordinates must be within the boundaries of the console screen buffer.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// The cursor position determines where characters written by the <c>WriteFile</c> or <c>WriteConsole</c> function, or echoed by the
/// <c>ReadFile</c> or <c>ReadConsole</c> function, are displayed. To determine the current position of the cursor, use the
/// <c>GetConsoleScreenBufferInfo</c> function.
/// </para>
/// <para>
/// If the new cursor position is not within the boundaries of the console screen buffer's window, the window origin changes to make
/// the cursor visible.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/console/setconsolecursorposition
// BOOL WINAPI SetConsoleCursorPosition( _In_ HANDLE hConsoleOutput, _In_ COORD dwCursorPosition );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("Wincon.h", MSDNShortId = "")]
[PInvokeData("Wincon.h", MSDNShortId = "8e9abada-a64e-429f-8286-ced1169c7104")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetConsoleCursorPosition(IntPtr hConsoleOutput, COORD dwCursorPosition);

645
PInvoke/Kernel32/WinNT.cs
View File

@ -1,11 +1,216 @@
using System;
using System.Runtime.InteropServices;
using static Vanara.Extensions.BitHelper;
// ReSharper disable InconsistentNaming
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>
/// <para>
/// An application-defined function previously registered with the AddSecureMemoryCacheCallback function that is called when a
/// secured memory range is freed or its protections are changed.
/// </para>
/// <para>
/// The <c>PSECURE_MEMORY_CACHE_CALLBACK</c> type defines a pointer to this callback function. is a placeholder for the
/// application-defined function name.
/// </para>
/// </summary>
/// <param name="Addr">
/// <para>The starting address of the memory range.</para>
/// </param>
/// <param name="Range">
/// <para>The size of the memory range, in bytes.</para>
/// </param>
/// <returns>
/// <para>The return value indicates the success or failure of this function.</para>
/// <para>If the caller has secured the specified memory range, this function should unsecure the memory and return <c>TRUE</c>.</para>
/// <para>If the caller has not secured the specified memory range, this function should return <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// After the callback function is registered, it is called after any attempt to free the specified memory range or change its
/// protections. If the application has secured any part of the specified memory range, the callback function must invalidate all of
/// the application's cached memory mappings for the secured memory range, unsecure the secured parts of the memory range, and return
/// <c>TRUE</c>. Otherwise it must return <c>FALSE</c>.
/// </para>
/// <para>
/// The application secures and unsecures a memory range by sending requests to a device driver, which uses the MmSecureVirtualMemory
/// and MmUnsecureVirtualMemory functions to actually secure and unsecure the range. Operations on other types of secured or locked
/// memory do not trigger this callback.
/// </para>
/// <para>
/// Examples of function calls that trigger the callback function include calls to the VirtualFree, VirtualFreeEx, VirtualProtect,
/// VirtualProtectEx, and UnmapViewOfFile functions.
/// </para>
/// <para>
/// The callback function can also be triggered by a heap operation. In this case, the function must not perform any further
/// operations on the heap that triggered the callback. This includes calling heap functions on a private heap or the process's
/// default heap, or calling standard library functions such as <c>malloc</c> and <c>free</c>, which implicitly use the process's
/// default heap.
/// </para>
/// <para>To unregister the callback function, use the RemoveSecureMemoryCacheCallback function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/nc-winnt-psecure_memory_cache_callback
// BOOLEAN PsecureMemoryCacheCallback( PVOID Addr, SIZE_T Range ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("winnt.h", MSDNShortId = "abde4b6f-7cd8-4a4b-9b00-f035b2c29054")]
[return: MarshalAs(UnmanagedType.U1)]
public delegate bool PsecureMemoryCacheCallback(IntPtr Addr, SizeT Range);
/// <summary>
/// <para>The application-defined user-mode scheduling (UMS) scheduler entry point function associated with a UMS completion list.</para>
/// <para>
/// The <c>PUMS_SCHEDULER_ENTRY_POINT</c> type defines a pointer to this function. UmsSchedulerProc is a placeholder for the
/// application-defined function name.
/// </para>
/// </summary>
/// <param name="Reason">
/// <para>The reason the scheduler entry point is being called. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>UmsSchedulerStartup 0</term>
/// <term>
/// A UMS scheduler thread was created. The entry point is called with this reason once each time EnterUmsSchedulingMode is called.
/// </term>
/// </item>
/// <item>
/// <term>UmsSchedulerThreadBlocked 1</term>
/// <term>A UMS worker thread blocked.</term>
/// </item>
/// <item>
/// <term>UmsSchedulerThreadYield 2</term>
/// <term>An executing UMS worker thread yielded control by calling the UmsThreadYield function.</term>
/// </item>
/// </list>
/// </param>
/// <param name="ActivationPayload">
/// <para>If the Reason parameter is <c>UmsSchedulerStartup</c>, this parameter is NULL.</para>
/// <para>
/// If the Reason parameter is <c>UmsSchedulerThreadBlocked</c>, bit 0 of this parameter indicates the type of activity that was
/// being serviced when the UMS worker thread blocked.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0</term>
/// <term>
/// The thread blocked on a trap (for example, a hard page fault) or an interrupt (for example, an asynchronous procedure call).
/// </term>
/// </item>
/// <item>
/// <term>1</term>
/// <term>The thread blocked on a system call.</term>
/// </item>
/// </list>
/// <para>
/// If the Reason parameter is <c>UmsSchedulerThreadYield</c>, this parameter is a pointer to the UMS thread context of the UMS
/// worker thread that yielded.
/// </para>
/// </param>
/// <param name="SchedulerParam">
/// <para>
/// If the Reason parameter is <c>UmsSchedulerStartup</c>, this parameter is the <c>SchedulerParam</c> member of the
/// UMS_SCHEDULER_STARTUP_INFO structure passed to the EnterUmsSchedulingMode function that triggered the entry point call.
/// </para>
/// <para>
/// If the Reason parameter is <c>UmsSchedulerThreadYield</c> this parameter is the SchedulerParam parameter passed to the
/// UmsThreadYield function that triggered the entry point call.
/// </para>
/// <para>If the Reason parameter is <c>UmsSchedulerThreadBlocked</c>, this parameter is NULL.</para>
/// </param>
/// <returns>
/// <para>This function does not return a value.</para>
/// </returns>
/// <remarks>
/// <para>
/// The UmsSchedulerProc function pointer type is defined as <c>PUMS_SCHEDULER_ENTRY_POINT</c> in WinBase.h. The underlying function
/// type is defined as <c>RTL_UMS_SCHEDULER_ENTRY_POINT</c> in WinNT.h
/// </para>
/// <para>
/// Each UMS scheduler thread has an associated UmsSchedulerProc entry point function that is specified when the thread calls the
/// EnterUmsSchedulingMode function. The system calls the scheduler entry point function with a reason of <c>UmsSchedulerStartup</c>
/// when the scheduler thread is converted for UMS.
/// </para>
/// <para>
/// Subsequently, when a UMS worker thread that is running on the scheduler thread yields or blocks, the system calls the scheduler
/// thread's entry point function with a pointer to the UMS thread context of the worker thread.
/// </para>
/// <para>
/// The application's scheduler is responsible for selecting the next UMS worker thread to run. The scheduler implements all policies
/// that influence execution of its UMS threads, including processor affinity and thread priority. For example, a scheduler might
/// give priority to I/O-intensive threads, or it might run threads on a first-come, first-served basis. This logic can be
/// implemented in the scheduler entry point function or elsewhere in the application.
/// </para>
/// <para>
/// When a blocked UMS worker thread becomes unblocked, the system queues the unblocked thread to the associated completion list and
/// signals the completion list event. To retrieve UMS worker threads from the completion list, use the DequeueUmsCompletionListItems function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/nc-winnt-rtl_ums_scheduler_entry_point RTL_UMS_SCHEDULER_ENTRY_POINT
// RtlUmsSchedulerEntryPoint; void RtlUmsSchedulerEntryPoint( RTL_UMS_SCHEDULER_REASON Reason, ULONG_PTR ActivationPayload, PVOID
// SchedulerParam ) {...}
[PInvokeData("winnt.h", MSDNShortId = "10de1c48-255d-45c3-acf0-25f8a564b585")]
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
public delegate void RtlUmsSchedulerEntryPoint(RTL_UMS_SCHEDULER_REASON Reason, UIntPtr ActivationPayload, IntPtr SchedulerParam);
/// <summary>Used by thread context functions.</summary>
[PInvokeData("winnt.h")]
[Flags]
public enum CONTEXT_FLAG : uint
{
/// <summary>Undocumented.</summary>
CONTEXT_AMD64 = 0x00100000,
/// <summary>Undocumented.</summary>
CONTEXT_CONTROL = (CONTEXT_AMD64 | 0x00000001),
/// <summary>Undocumented.</summary>
CONTEXT_INTEGER = (CONTEXT_AMD64 | 0x00000002),
/// <summary>Undocumented.</summary>
CONTEXT_SEGMENTS = (CONTEXT_AMD64 | 0x00000004),
/// <summary>Undocumented.</summary>
CONTEXT_FLOATING_POINT = (CONTEXT_AMD64 | 0x00000008),
/// <summary>Undocumented.</summary>
CONTEXT_DEBUG_REGISTERS = (CONTEXT_AMD64 | 0x00000010),
/// <summary>Undocumented.</summary>
CONTEXT_FULL = (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT),
/// <summary>Undocumented.</summary>
CONTEXT_ALL = (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS),
/// <summary>Undocumented.</summary>
CONTEXT_XSTATE = (CONTEXT_AMD64 | 0x00000040),
/// <summary>Undocumented.</summary>
CONTEXT_KERNEL_DEBUGGER = 0x04000000,
/// <summary>Undocumented.</summary>
CONTEXT_EXCEPTION_ACTIVE = 0x08000000,
/// <summary>Undocumented.</summary>
CONTEXT_SERVICE_ACTIVE = 0x10000000,
/// <summary>Undocumented.</summary>
CONTEXT_EXCEPTION_REQUEST = 0x40000000,
/// <summary>Undocumented.</summary>
CONTEXT_EXCEPTION_REPORTING = 0x80000000
}
/// <summary>The flags that control the enforcement of the minimum and maximum working set sizes.</summary>
[PInvokeData("winnt.h")]
[Flags]
@ -13,74 +218,462 @@ namespace Vanara.PInvoke
{
/// <summary>The working set will not fall below the minimum working set limit.</summary>
QUOTA_LIMITS_HARDWS_MIN_ENABLE = 0x00000001,
/// <summary>The working set may fall below the minimum working set limit if memory demands are high.</summary>
QUOTA_LIMITS_HARDWS_MIN_DISABLE = 0x00000002,
/// <summary>The working set will not exceed the maximum working set limit.</summary>
QUOTA_LIMITS_HARDWS_MAX_ENABLE = 0x00000004,
/// <summary>The working set may exceed the maximum working set limit if there is abundant memory.</summary>
QUOTA_LIMITS_HARDWS_MAX_DISABLE = 0x00000008,
/// <summary>The quota limits use default limits</summary>
QUOTA_LIMITS_USE_DEFAULT_LIMITS = 0x00000010,
}
/// <summary>Used by <see cref="RtlUmsSchedulerEntryPoint"/>.</summary>
[PInvokeData("winnt.h", MSDNShortId = "10de1c48-255d-45c3-acf0-25f8a564b585")]
public enum RTL_UMS_SCHEDULER_REASON
{
/// <summary>
/// A UMS scheduler thread was created. The entry point is called with this reason once each time EnterUmsSchedulingMode is called.
/// </summary>
UmsSchedulerStartup = 0,
/// <summary>A UMS worker thread blocked.</summary>
UmsSchedulerThreadBlocked = 1,
/// <summary>An executing UMS worker thread yielded control by calling the UmsThreadYield function.</summary>
UmsSchedulerThreadYield = 2,
}
/// <summary>
/// <para>Represents classes of information about user-mode scheduling (UMS) threads.</para>
/// <para>This enumeration is used by the QueryUmsThreadInformation and SetUmsThreadInformation functions.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ne-winnt-_rtl_ums_thread_info_class typedef enum
// _RTL_UMS_THREAD_INFO_CLASS { UmsThreadInvalidInfoClass , UmsThreadUserContext , UmsThreadPriority , UmsThreadAffinity ,
// UmsThreadTeb , UmsThreadIsSuspended , UmsThreadIsTerminated , UmsThreadMaxInfoClass } RTL_UMS_THREAD_INFO_CLASS, *PRTL_UMS_THREAD_INFO_CLASS;
[PInvokeData("winnt.h", MSDNShortId = "2d6730b2-4d01-45f5-9514-0d91806f50d5")]
public enum RTL_UMS_THREAD_INFO_CLASS
{
/// <summary>Reserved.</summary>
UmsThreadInvalidInfoClass,
/// <summary>Application-defined information stored in a UMS thread context.</summary>
UmsThreadUserContext,
/// <summary>Reserved.</summary>
UmsThreadPriority,
/// <summary>Reserved.</summary>
UmsThreadAffinity,
/// <summary>
/// The thread execution block (TEB) for a UMS thread. This information class can only be queried; it cannot be set.
/// </summary>
UmsThreadTeb,
/// <summary>The suspension status of the thread. This information can only be queried; it cannot be set.</summary>
UmsThreadIsSuspended,
/// <summary>The termination status of the thread. This information can only be queried; it cannot be set.</summary>
UmsThreadIsTerminated,
/// <summary>Reserved.</summary>
UmsThreadMaxInfoClass,
}
[PInvokeData("winnt.h")]
[Flags]
public enum SECTION_MAP : uint
{
SECTION_QUERY = 0x0001,
SECTION_MAP_WRITE = 0x0002,
SECTION_MAP_READ = 0x0004,
SECTION_MAP_EXECUTE = 0x0008,
SECTION_EXTEND_SIZE = 0x0010,
SECTION_QUERY = 0x0001,
SECTION_MAP_WRITE = 0x0002,
SECTION_MAP_READ = 0x0004,
SECTION_MAP_EXECUTE = 0x0008,
SECTION_EXTEND_SIZE = 0x0010,
SECTION_MAP_EXECUTE_EXPLICIT = 0x0020,
SECTION_ALL_ACCESS = ACCESS_MASK.STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE,
}
/// <summary>
/// A mask that indicates the member of the OSVERSIONINFOEX structure whose comparison operator is being set. This value corresponds to one of the bits
/// specified in the dwTypeMask parameter for the VerifyVersionInfo function.
/// The operator to be used for the comparison. The VerifyVersionInfo function uses this operator to compare a specified attribute
/// value to the corresponding value for the currently running system.
/// </summary>
public enum VERSION_CONDITION : byte
{
/// <summary>The current value must be equal to the specified value.</summary>
VER_EQUAL = 1,
/// <summary>The current value must be greater than the specified value.</summary>
VER_GREATER,
/// <summary>The current value must be greater than or equal to the specified value.</summary>
VER_GREATER_EQUAL,
/// <summary>The current value must be less than the specified value.</summary>
VER_LESS,
/// <summary>The current value must be less than or equal to the specified value.</summary>
VER_LESS_EQUAL,
/// <summary>All product suites specified in the wSuiteMask member must be present in the current system.</summary>
VER_AND,
/// <summary>At least one of the specified product suites must be present in the current system.</summary>
VER_OR,
}
/// <summary>
/// A mask that indicates the member of the OSVERSIONINFOEX structure whose comparison operator is being set. This value corresponds
/// to one of the bits specified in the dwTypeMask parameter for the VerifyVersionInfo function.
/// </summary>
[Flags]
public enum VERSION_MASK : uint
{
/// <summary>dwMinorVersion</summary>
VER_MINORVERSION = 0x0000001,
/// <summary>dwMajorVersion</summary>
VER_MAJORVERSION = 0x0000002,
/// <summary>dwBuildNumber</summary>
VER_BUILDNUMBER = 0x0000004,
/// <summary>dwPlatformId</summary>
VER_PLATFORMID = 0x0000008,
/// <summary>wServicePackMinor</summary>
VER_SERVICEPACKMINOR = 0x0000010,
/// <summary>wServicePackMajor</summary>
VER_SERVICEPACKMAJOR = 0x0000020,
/// <summary>wSuiteMask</summary>
VER_SUITENAME = 0x0000040,
/// <summary>wProductType</summary>
VER_PRODUCT_TYPE = 0x0000080,
}
/// <summary>
/// The operator to be used for the comparison. The VerifyVersionInfo function uses this operator to compare a specified attribute value to the
/// corresponding value for the currently running system.
/// </summary>
public enum VERSION_CONDITION : byte
/// <summary>Contains the hardware counter value.</summary>
// typedef struct _HARDWARE_COUNTER_DATA { HARDWARE_COUNTER_TYPE Type; DWORD Reserved; DWORD64 Value;} HARDWARE_COUNTER_DATA,
// *PHARDWARE_COUNTER_DATA; https://msdn.microsoft.com/en-us/library/windows/desktop/dd796394(v=vs.85).aspx
[PInvokeData("Winnt.h", MSDNShortId = "dd796394")]
[StructLayout(LayoutKind.Sequential)]
public struct HARDWARE_COUNTER_DATA
{
/// <summary>The current value must be equal to the specified value.</summary>
VER_EQUAL = 1,
/// <summary>The current value must be greater than the specified value.</summary>
VER_GREATER,
/// <summary>The current value must be greater than or equal to the specified value.</summary>
VER_GREATER_EQUAL,
/// <summary>The current value must be less than the specified value.</summary>
VER_LESS,
/// <summary>The current value must be less than or equal to the specified value.</summary>
VER_LESS_EQUAL,
/// <summary>All product suites specified in the wSuiteMask member must be present in the current system.</summary>
VER_AND,
/// <summary>At least one of the specified product suites must be present in the current system.</summary>
VER_OR,
/// <summary>The type of hardware counter data collected. For possible values, see the <c>HARDWARE_COUNTER_TYPE</c> enumeration.</summary>
public HARDWARE_COUNTER_TYPE Type;
/// <summary>Reserved. Initialize to zero.</summary>
public uint Reserved;
/// <summary>
/// The counter index. Each hardware counter in a processor's performance monitoring unit (PMU) is identified by an index.
/// </summary>
public ulong Value;
}
/// <summary>Contains the thread profiling and hardware counter data that you requested.</summary>
// typedef struct _PERFORMANCE_DATA { WORD Size; BYTE Version; BYTE HwCountersCount; DWORD ContextSwitchCount; DWORD64
// WaitReasonBitMap; DWORD64 CycleTime; DWORD RetryCount; DWORD Reserved; HARDWARE_COUNTER_DATA HwCounters[MAX_HW_COUNTERS];}
// PERFORMANCE_DATA, *PPERFORMANCE_DATA; https://msdn.microsoft.com/en-us/library/windows/desktop/dd796401(v=vs.85).aspx
[PInvokeData("Winnt.h", MSDNShortId = "dd796401")]
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PERFORMANCE_DATA
{
private const int MAX_HW_COUNTERS = 16;
/// <summary>The size of this structure.</summary>
public ushort Size;
/// <summary>The version of this structure. Must be set to PERFORMANCE_DATA_VERSION.</summary>
public byte Version;
/// <summary>
/// The number of array elements in the <c>HwCounters</c> array that contain hardware counter data. A value of 3 means that the
/// array contains data for three hardware counters, not that elements 0 through 2 contain counter data.
/// </summary>
public byte HwCountersCount;
/// <summary>The number of context switches that occurred from the time profiling was enabled.</summary>
public uint ContextSwitchCount;
/// <summary>
/// A bitmask that identifies the reasons for the context switches that occurred since the last time the data was read. For
/// possible values, see the <c>KWAIT_REASON</c> enumeration (the enumeration is included in the Wdm.h file in the WDK).
/// </summary>
public ulong WaitReasonBitMap;
/// <summary>The cycle time of the thread (excludes the time spent interrupted) from the time profiling was enabled.</summary>
public ulong CycleTime;
/// <summary>The number of times that the read operation read the data to ensure a consistent snapshot of the data.</summary>
public uint RetryCount;
/// <summary>Reserved. Set to zero.</summary>
public uint Reserved;
/// <summary>
/// An array of <c>HARDWARE_COUNTER_DATA</c> structures that contain the counter values. The elements of the array that contain
/// counter data relate directly to the bits set in the HardwareCounters bitmask that you specified when you called the
/// <c>EnableThreadProfiling</c> function. For example, if you set bit 3 in the HardwareCounters bitmask, HwCounters[3] will
/// contain the counter data for that counter.
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_HW_COUNTERS)]
public HARDWARE_COUNTER_DATA[] HwCounters;
}
/// <summary>
/// <para>Represents a context frame on WOW64. Refer to the header file WinNT.h for the definition of this structure.</para>
/// </summary>
/// <remarks>
/// <para>
/// In the following versions of Windows, Slot 1 of Thread Local Storage (TLS) holds a pointer to a structure that contains a
/// <c>WOW64_CONTEXT</c> structure starting at offset 4. This might change in later versions of Windows.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Windows Vista</term>
/// <term>Windows Server 2008</term>
/// </listheader>
/// <item>
/// <term>Windows 7</term>
/// <term>Windows Server 2008 R2</term>
/// </item>
/// <item>
/// <term>Windows 8</term>
/// <term>Windows Server 2012</term>
/// </item>
/// <item>
/// <term>Windows 8.1</term>
/// <term>Windows Server 2012 R2</term>
/// </item>
/// </list>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_wow64_context
[PInvokeData("winnt.h", MSDNShortId = "b27205a2-2c33-4f45-8948-9919bcd2355a")]
[StructLayout(LayoutKind.Sequential)]
public struct WOW64_CONTEXT
{
/// <summary/>
public WOW64_CONTEXT_FLAGS ContextFlags;
/// <summary/>
public uint Dr0;
/// <summary/>
public uint Dr1;
/// <summary/>
public uint Dr2;
/// <summary/>
public uint Dr3;
/// <summary/>
public uint Dr6;
/// <summary/>
public uint Dr7;
/// <summary/>
public WOW64_FLOATING_SAVE_AREA FloatSave;
/// <summary/>
public uint SegGs;
/// <summary/>
public uint SegFs;
/// <summary/>
public uint SegEs;
/// <summary/>
public uint SegDs;
/// <summary/>
public uint Edi;
/// <summary/>
public uint Esi;
/// <summary/>
public uint Ebx;
/// <summary/>
public uint Edx;
/// <summary/>
public uint Ecx;
/// <summary/>
public uint Eax;
/// <summary/>
public uint Ebp;
/// <summary/>
public uint Eip;
/// <summary/>
public uint SegCs;
/// <summary/>
public uint EFlags;
/// <summary/>
public uint Esp;
/// <summary/>
public uint SegSs;
/// <summary/>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
public byte[] ExtendedRegisters;
}
/// <summary>
/// <para>Represents the 80387 save area on WOW64. Refer to the header file WinNT.h for the definition of this structure.</para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_wow64_floating_save_area
[PInvokeData("winnt.h", MSDNShortId = "56fba1c1-432b-40a8-b882-e4c637c03d5d")]
[StructLayout(LayoutKind.Sequential)]
public struct WOW64_FLOATING_SAVE_AREA
{
/// <summary/>
public uint ControlWord;
/// <summary/>
public uint StatusWord;
/// <summary/>
public uint TagWord;
/// <summary/>
public uint ErrorOffset;
/// <summary/>
public uint ErrorSelector;
/// <summary/>
public uint DataOffset;
/// <summary/>
public uint DataSelector;
/// <summary/>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)]
public byte[] RegisterArea;
/// <summary/>
public uint Cr0NpxState;
}
/// <summary>
/// <para>
/// Describes an entry in the descriptor table for a 32-bit thread on a 64-bit system. This structure is valid only on 64-bit systems.
/// </para>
/// </summary>
/// <remarks>
/// <para>
/// The Wow64GetThreadSelectorEntry function fills this structure with information from an entry in the descriptor table. You can use
/// this information to convert a segment-relative address to a linear virtual address.
/// </para>
/// <para>
/// The base address of a segment is the address of offset 0 in the segment. To calculate this value, combine the <c>BaseLow</c>,
/// <c>BaseMid</c>, and <c>BaseHi</c> members.
/// </para>
/// <para>
/// The limit of a segment is the address of the last byte that can be addressed in the segment. To calculate this value, combine the
/// <c>LimitLow</c> and <c>LimitHi</c> members.
/// </para>
/// <para>
/// The <c>WOW64_LDT_ENTRY</c> structure has the same layout for a 64-bit process as the LDT_ENTRY structure has for a 32-bit process.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_wow64_ldt_entry typedef struct _WOW64_LDT_ENTRY { WORD
// LimitLow; WORD BaseLow; union { struct { BYTE BaseMid; BYTE Flags1; BYTE Flags2; BYTE BaseHi; } Bytes; struct { DWORD BaseMid : 8;
// DWORD Type : 5; DWORD Dpl : 2; DWORD Pres : 1; DWORD LimitHi : 4; DWORD Sys : 1; DWORD Reserved_0 : 1; DWORD Default_Big : 1;
// DWORD Granularity : 1; DWORD BaseHi : 8; } Bits; } HighWord; } WOW64_LDT_ENTRY, *PWOW64_LDT_ENTRY;
[PInvokeData("winnt.h", MSDNShortId = "a571cd2f-0873-4ad5-bcb8-c0da2d47a820")]
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct WOW64_LDT_ENTRY
{
/// <summary>
/// <para>The low-order part of the address of the last byte in the segment.</para>
/// </summary>
public ushort LimitLow;
/// <summary>
/// <para>The low-order part of the base address of the segment.</para>
/// </summary>
public ushort BaseLow;
/// <summary>
/// <para>Middle bits (16-23) of the base address of the segment.</para>
/// </summary>
public byte BaseMid;
private ushort Flags;
/// <summary>
/// <para>The high bits (24-31) of the base address of the segment.</para>
/// </summary>
public byte BaseHi;
/// <summary>
/// <para>The type of segment. This member can be one of the following values:</para>
/// </summary>
public byte Type { get => (byte)GetBits(Flags, 0, 5); set => SetBits(ref Flags, 0, 5, value); }
/// <summary>
/// <para>
/// The privilege level of the descriptor. This member is an integer value in the range 0 (most privileged) through 3 (least privileged).
/// </para>
/// </summary>
public byte Dpl { get => (byte)GetBits(Flags, 5, 2); set => SetBits(ref Flags, 5, 2, value); }
/// <summary>
/// <para>The present flag. This member is 1 if the segment is present in physical memory or 0 if it is not.</para>
/// </summary>
public bool Pres { get => GetBit(Flags, 7); set => SetBit(ref Flags, 7, value); }
/// <summary>
/// <para>The high bits (16–19) of the address of the last byte in the segment.</para>
/// </summary>
public byte LimitHi { get => (byte)GetBits(Flags, 8, 4); set => SetBits(ref Flags, 8, 4, value); }
/// <summary>
/// <para>
/// The space that is available to system programmers. This member might be used for marking segments in some system-specific way.
/// </para>
/// </summary>
public bool Sys { get => GetBit(Flags, 12); set => SetBit(ref Flags, 12, value); }
/// <summary>
/// <para>Reserved.</para>
/// </summary>
public bool Reserved_0 { get => GetBit(Flags, 13); set => SetBit(ref Flags, 13, value); }
/// <summary>
/// <para>
/// The size of segment. If the segment is a data segment, this member contains 1 if the segment is larger than 64 kilobytes (KB)
/// or 0 if the segment is smaller than or equal to 64 KB.
/// </para>
/// <para>
/// If the segment is a code segment, this member contains 1. The segment runs with the default (native mode) instruction set.
/// </para>
/// </summary>
public bool Default_Big { get => GetBit(Flags, 14); set => SetBit(ref Flags, 14, value); }
/// <summary>
/// <para>The granularity. This member contains 0 if the segment is byte granular, 1 if the segment is page granular.</para>
/// </summary>
public bool Granularity { get => GetBit(Flags, 15); set => SetBit(ref Flags, 15, value); }
}
}
}

3023
PInvoke/Kernel32/WinNls.cs
View File

File diff suppressed because it is too large Load Diff

20
PInvoke/Kernel32/WindowsCeip.cs Normal file
View File

@ -0,0 +1,20 @@
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>
/// <para>Checks whether the user has opted in for SQM data collection as part of the Customer Experience Improvement Program (CEIP).</para>
/// </summary>
/// <returns>
/// <para>True if SQM data collection is opted in and the machine can send data. Otherwise, false.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/desktop/api/windowsceip/nf-windowsceip-ceipisoptedin
// BOOL CeipIsOptedIn( );
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("windowsceip.h", MSDNShortId = "4CDB5B09-B172-4E99-AB46-A08E32346266")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool CeipIsOptedIn();
}
}