refactor: add more native definitions, supporting Types

Some are platform-specific, hence the 32/64 suffixes.
Although PEB32 and PEB64 are done, plain ol'
  PEB isn't done yet.
I exploited FieldOffsetAttribute quite bit in these
  platform-specific definitions.
Additionally, some of the less important, platform
  specific type definitions were skipped to save time.

Author: BinToss

deadlock-dotnet-sdk/Domain/SafeBufferT.cs

@@ -0,0 +1,16 @@
+using System.Runtime.InteropServices;
+
+namespace deadlock_dotnet_sdk.Domain;
+
+public class SafeBuffer<T> : SafeBuffer
+{
+    public SafeBuffer(bool ownsHandle) : base(ownsHandle)
+    {
+    }
+
+    protected override bool ReleaseHandle()
+    {
+        Marshal.FreeHGlobal(handle);
+        return true;
+    }
+}

deadlock-dotnet-sdk/NativeMethods.txt

@@ -66,3 +66,10 @@ PUBLIC_OBJECT_TYPE_INFORMATION
 //VirtualQuery
 
 GENERIC_MAPPING
+LDR_DATA_TABLE_ENTRY
+PEB32
+PEB64
+ProcessCommandLineInformation
+NtWow64ReadVirtualMemory64
+LARGE_INTEGER
+RTL_CRITICAL_SECTION

deadlock-dotnet-sdk/Windows.Win32/32 and 64 suffixes.md

@@ -0,0 +1,4 @@
+The "32" and "64" suffixes indicate the bitness of the pointers (`UIntPtr32<T>`, `UIntPtr64<T>`¹) and the bitness of the pointers' owner process.
+
+
+¹ The generic Type `T` indicates the pointer type is a pointer to an object of type `T`. This is intended to mimic conventional pointer types' syntax. `UIntPtr32<int>` is intended to be equivalent to a 32-bit process's `int*`.

deadlock-dotnet-sdk/Windows.Win32/Foundation/HANDLE32.cs

@@ -0,0 +1,17 @@
+namespace Windows.Win32.Foundation;
+
+internal struct HANDLE32
+{
+    internal readonly UIntPtr32 Value { get; init; }
+
+    public static explicit operator HANDLE32(UIntPtr32 v) => new() { Value = v };
+    public static implicit operator UIntPtr32(HANDLE32 v) => v.Value;
+}
+
+internal struct HANDLE32<T> where T : unmanaged
+{
+    internal readonly UIntPtr32<T> Value { get; init; }
+
+    public static explicit operator HANDLE32<T>(UIntPtr32<T> v) => new() { Value = v };
+    public static implicit operator UIntPtr32<T>(HANDLE32<T> v) => v.Value;
+}

deadlock-dotnet-sdk/Windows.Win32/Foundation/HANDLE64.cs

@@ -0,0 +1,17 @@
+namespace Windows.Win32.Foundation;
+
+internal struct HANDLE64
+{
+    internal readonly UIntPtr64 Value { get; init; }
+
+    public static explicit operator HANDLE64(UIntPtr64 v) => new() { Value = v };
+    public static implicit operator UIntPtr64(HANDLE64 v) => v.Value;
+}
+
+internal struct HANDLE64<T> where T : unmanaged
+{
+    internal readonly UIntPtr64<T> Value { get; init; }
+
+    public static explicit operator HANDLE64<T>(UIntPtr64<T> v) => new() { Value = v };
+    public static implicit operator UIntPtr64<T>(HANDLE64<T> v) => v.Value;
+}

deadlock-dotnet-sdk/Windows.Win32/Foundation/NTSTATUS.cs

@@ -1,13 +1,22 @@
+using PInvoke;
+/// <summary>
 /// This file supplements code generated by CsWin32
-using NTStatusException = PInvoke.NTStatusException;
-
+/// </summary>
 namespace Windows.Win32.Foundation;
 
 readonly partial struct NTSTATUS
 {
-    public bool IsSuccessful => SeverityCode == Severity.Success;
+    public bool IsSuccessful => SeverityCode is Severity.Success;
+
+    /// <inheritdoc cref="Kernel32Extensions.ThrowOnError(PInvoke.NTSTATUS)"/>
+    public void ThrowOnError()
+    {
+        if (SeverityCode == Severity.Error)
+            throw new NTStatusException(this);
+    }
 
-    public NTStatusException GetNTStatusException() => new(this);
+    /// <inheritdoc cref="Kernel32Extensions.GetMessage(global::PInvoke.NTSTATUS)"/>
+    public string GetMessage() => ((global::PInvoke.NTSTATUS)this).GetMessage();
 
     public static implicit operator global::PInvoke.NTSTATUS(NTSTATUS v) => new(v.Value);
     public static implicit operator NTSTATUS(global::PInvoke.NTSTATUS v) => new(v.AsInt32);

deadlock-dotnet-sdk/Windows.Win32/Foundation/PCWSTR.cs

@@ -0,0 +1,14 @@
+/// This file supplements code generated by CsWin32
+using System.Runtime.InteropServices;
+
+namespace Windows.Win32.Foundation;
+
+unsafe readonly partial struct PCWSTR : IDisposable
+{
+    /// <summary>
+    /// Free the PWSTR's memory with Marshal.FreeHGlobal(IntPtr)
+    /// </summary>
+    public void Dispose() => Marshal.FreeHGlobal((IntPtr)Value);
+
+    public static explicit operator PCWSTR(IntPtr v) => new((char*)v);
+}

deadlock-dotnet-sdk/Windows.Win32/Foundation/UNICODE_STRING.cs

@@ -3,15 +3,43 @@
 
 namespace Windows.Win32.Foundation;
 
+/// <summary>
+/// The UNICODE_STRING structure is used to define Unicode strings.
+/// </summary>
+/// <remarks>
+/// <para>The UNICODE_STRING structure is used to pass Unicode strings. Use RtlUnicodeStringInit or RtlUnicodeStringInitEx to initialize a UNICODE_STRING structure.</para>
+/// <para>If the string is null-terminated, Length does not include the trailing null character.</para>
+/// <para>The MaximumLength is used to indicate the length of Buffer so that if the string is passed to a conversion routine such as RtlAnsiStringToUnicodeString the returned string does not exceed the buffer size.</para>
+/// <para>
+/// - Length -- the length of the string in bytes.
+/// - MaximumLength -- the length of Buffer in bytes.
+/// - Buffer -- the address of the string.
+/// </para>
+/// </remarks>
 partial struct UNICODE_STRING : IDisposable
 {
+    public UNICODE_STRING(ushort maximumLength, PWSTR buffer)
+    {
+        Length = (ushort)buffer.Length;
+        MaximumLength = maximumLength;
+        Buffer = buffer;
+    }
+    public UNICODE_STRING(ushort maximumLength)
+    {
+        Length = 0;
+        MaximumLength = maximumLength;
+        Buffer = Marshal.AllocHGlobal(maximumLength);
+    }
+
+    public uint CharCount => (uint)ToStringLength().Length;
+
     public void Dispose()
     {
         Buffer.Dispose();
     }
 
     /// <summary>
-    /// Allocates a managed string and copies a specified number of characters from an unmanaged Unicode string into it.
+    /// Allocates a managed string and copies `(Length / 2)` number of characters from an unmanaged Unicode string into it.
     /// </summary>
     public unsafe string ToStringLength() => Marshal.PtrToStringUni((IntPtr)Buffer.Value, Length / 2);
     public string? ToStringZ() => Buffer.ToString();

deadlock-dotnet-sdk/Windows.Win32/Foundation/UNICODE_STRING32.cs

@@ -0,0 +1,19 @@
+using System.Runtime.InteropServices;
+
+namespace Windows.Win32.Foundation;
+
+/// <summary>
+/// The UNICODE_STRING structure is used to define Unicode strings.
+/// </summary>
+/// <remarks>
+/// <para>The UNICODE_STRING structure is used to pass Unicode strings. Use RtlUnicodeStringInit or RtlUnicodeStringInitEx to initialize a UNICODE_STRING structure.</para>
+/// <para>If the string is null-terminated, Length does not include the trailing null character.</para>
+/// <para>The MaximumLength is used to indicate the length of Buffer so that if the string is passed to a conversion routine such as RtlAnsiStringToUnicodeString the returned string does not exceed the buffer size.</para>
+/// </remarks>
+[StructLayout(LayoutKind.Sequential, Size = 0x08)]
+internal struct UNICODE_STRING32
+{
+    public ushort Length;
+    public ushort MaximumLength;
+    public UIntPtr32<char> Buffer;
+}

deadlock-dotnet-sdk/Windows.Win32/Foundation/UNICODE_STRING64.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Windows.Win32.Foundation;
+
+[StructLayout(LayoutKind.Sequential, Size = 0x10)]
+internal struct UNICODE_STRING64
+{
+    public ushort Length;
+    public ushort MaximumLength;
+    public UIntPtr64<char> Buffer;
+}