err...

Dalamud.Bootstrap/OS/Windows/Process.cs

@@ -0,0 +1,228 @@
+using Dalamud.Bootstrap.OS.Windows.Raw;
+using Dalamud.Bootstrap.Windows;
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Dalamud.Bootstrap.OS
+{
+    /// <summary>
+    /// A class that provides a wrapper over operations on Win32 process.
+    /// </summary>
+    internal sealed class Process : IDisposable
+    {
+        private SafeProcessHandle m_handle;
+
+        /// <summary>
+        /// Creates a process object that can be used to manipulate process's internal state.
+        /// </summary>
+        /// <param name="handle">A process handle. Note that this functinon will take the ownership of the handle.</param>
+        public Process(SafeProcessHandle handle)
+        {
+            m_handle = handle;
+        }
+
+        public void Dispose()
+        {
+            m_handle?.Dispose();
+            m_handle = null!;
+        }
+
+        public static Process Open(uint pid, PROCESS_ACCESS_RIGHTS access)
+        {
+            var handle = OpenHandle(pid, access);
+
+            return new Process(handle);
+        }
+
+        private static SafeProcessHandle OpenHandle(uint pid, PROCESS_ACCESS_RIGHTS access)
+        {
+            var handle = Kernel32.OpenProcess((uint)access, false, pid);
+            
+            if (handle.IsInvalid)
+            {
+                ProcessException.ThrowLastOsError($"Could not open process {pid}");
+            }
+
+            return handle;
+        }
+
+        private static uint GetProcessId(SafeProcessHandle handle) => Kernel32.GetProcessId(handle);
+
+        public uint GetProcessId() => GetProcessId(m_handle);
+
+        public void Terminate(int exitCode = 0)
+        {
+            if (!Kernel32.TerminateProcess(m_handle, exitCode))
+            {
+                ProcessException.ThrowLastOsError($"Could not terminate process {GetProcessId()}");
+            }
+        }
+
+        /// <summary>
+        /// Reads the process memory.
+        /// </summary>
+        /// <returns>
+        /// The number of bytes that is actually read.
+        /// </returns>
+        public int ReadMemory(IntPtr address, Span<byte> destination)
+        {
+            unsafe
+            {
+                fixed (byte* pDest = destination)
+                {
+                    if (!Kernel32.ReadProcessMemory(m_handle, address, pDest, (IntPtr)destination.Length, out var bytesRead))
+                    {
+                        ProcessException.ThrowLastOsError($"Could not read process {GetProcessId()} memory at 0x{address.ToInt64():X8}");
+                    }
+
+                    // This is okay because destination will never be longer than int.Max
+                    return bytesRead.ToInt32();
+                }
+            }
+        }
+
+        public void ReadMemoryExact(IntPtr address, Span<byte> destination)
+        {
+            var totalBytesRead = 0;
+
+            while (totalBytesRead < destination.Length)
+            {
+                var bytesRead = ReadMemory(address + totalBytesRead, destination[totalBytesRead..]);
+
+                if (bytesRead == 0)
+                {
+                    // prolly page fault; there's not much we can do here
+                    var readBeginAddr = address.ToInt64() + totalBytesRead;
+                    var readEndAddr = address.ToInt64() + destination.Length;
+
+                    ProcessException.ThrowLastOsError($"Could not read process {GetProcessId()} memory at 0x{readBeginAddr:X8} .. 0x{readEndAddr:X8}; This likely means that page fault was hit.");
+                }
+
+                totalBytesRead += bytesRead;
+            }
+        }
+
+        private byte[] ReadMemoryExact(IntPtr address, int length)
+        {
+            var buffer = new byte[length];
+            ReadMemoryExact(address, buffer);
+
+            return buffer;
+        }
+
+        private T ReadMemoryValue<T>(IntPtr address) where T : unmanaged
+        {
+            unsafe
+            {
+                // This assumes that size of T is small enough to be safely allocated on the stack.
+                Span<byte> buffer = stackalloc byte[sizeof(T)];
+                ReadMemoryExact(address, buffer);
+
+                // this is still far better than allocating the temporary buffer on the heap when sizeof(T) is small enough.
+                return MemoryMarshal.Read<T>(buffer);
+            }
+        }
+
+        private IntPtr ReadPebAddress()
+        {
+            unsafe
+            {
+                var info = new PROCESS_BASIC_INFORMATION();
+                var status = Ntdll.NtQueryInformationProcess(m_handle, PROCESSINFOCLASS.ProcessBasicInformation, &info, sizeof(PROCESS_BASIC_INFORMATION), (IntPtr*)IntPtr.Zero);
+
+                if (!status.Success)
+                {
+                    throw new ProcessException($"Could not query information on process {GetProcessId()} (Status: {status})");
+                }
+
+                return info.PebBaseAddress;
+            }
+        }
+
+        /// <summary>
+        /// Reads command-line arguments from the process.
+        /// </summary>
+        public string[] GetProcessArguments()
+        {
+            unsafe
+            {
+                // Find where the command line is allocated
+                var pebAddr = ReadPebAddress();
+                var peb = ReadMemoryValue<PEB>(pebAddr);
+                var procParam = ReadMemoryValue<RTL_USER_PROCESS_PARAMETERS>(peb.ProcessParameters);
+
+                // Read the command line (which is utf16-like string)
+                var commandLine = ReadMemoryExact(procParam.CommandLine.Buffer, procParam.CommandLine.Length);
+                
+                return ParseCommandLineToArguments(commandLine);
+            }
+        }
+
+        /// <summary>
+        /// Returns a time when the process was started.
+        /// </summary>
+        public DateTime GetCreationTime()
+        {
+            if (!Kernel32.GetProcessTimes(m_handle, out var creationTime, out var _, out var _, out var _))
+            {
+                ProcessException.ThrowLastOsError($"Could not read process creation time from process {GetProcessId()}");
+            }
+
+            return creationTime.ToDateTime();
+        }
+
+        private string[] ParseCommandLineToArguments(ReadOnlySpan<byte> commandLine)
+        {
+            unsafe
+            {
+                char** argv;
+                int argc;
+
+                fixed (byte* pCommandLine = commandLine)
+                {
+                    argv = Shell32.CommandLineToArgvW(pCommandLine, out argc);
+                }
+
+                if (argv == null)
+                {
+                    ProcessException.ThrowLastOsError($"Could not parse a command-line.");
+                }
+
+                try
+                {
+                    var arguments = new string[argc];
+
+                    for (var i = 0; i < argc; i++)
+                    {
+                        arguments[i] = new string(argv[i]);
+                    }
+
+                    return arguments;
+                }
+                finally
+                {
+                    Kernel32.LocalFree(argv);
+                }
+            }
+        }
+
+        public string GetImageFilePath()
+        {
+            var buffer = new StringBuilder(300);
+
+            // From docs:
+            // On input, specifies the size of the lpExeName buffer, in characters.
+            // On success, receives the number of characters written to the buffer, not including the null-terminating character.
+            var size = buffer.Capacity;
+
+            if (!Kernel32.QueryFullProcessImageNameW(m_handle, 0, buffer, ref size))
+            {
+                ProcessException.ThrowLastOsError($"Could not read image path from process {GetProcessId()}");
+            }
+
+            return buffer.ToString();
+        }
+    }
+}

Dalamud.Bootstrap/OS/Windows/ProcessCreationOptions.cs

@@ -0,0 +1,11 @@
+namespace Dalamud.Bootstrap.Windows
+{
+    internal sealed class ProcessCreationOptions
+    {
+        public string ImagePath { get; set; } = null!;
+
+        public string? CommandLine { get; set; } = null;
+
+        public bool CreateSuspended { get; set; }
+    }
+}

Dalamud.Bootstrap/OS/Windows/ProcessException.cs

@@ -0,0 +1,23 @@
+using System;
+using System.ComponentModel;
+
+namespace Dalamud.Bootstrap.Windows
+{
+    /// <summary>
+    /// An exception that is thrown when there was an error while interacting with the process.
+    /// </summary>
+    internal sealed class ProcessException : Exception
+    {
+        internal ProcessException() : base() { }
+
+        internal ProcessException(string message) : base(message) { }
+
+        internal ProcessException(string message, Exception innerException) : base(message, innerException) { }
+
+        internal static void ThrowLastOsError(string message)
+        {
+            var inner = new Win32Exception();
+            throw new ProcessException(message, inner);
+        }
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Constants.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace Dalamud.Bootstrap.OS.Windows.Raw
+{
+    // https://github.com/processhacker/processhacker/blob/c1a8c103f8afa1561dbac416f87523ea8f70b15e/phnt/include/ntpsapi.h#L96-L199
+    internal enum PROCESSINFOCLASS : uint
+    {
+        ProcessBasicInformation = 0,
+    }
+
+    // https://github.com/processhacker/processhacker/blob/0e9cf471e06a59cdb3a7c89f0b92b253a6a93999/phnt/include/ntpsapi.h#L5-L17
+    [Flags]
+    internal enum PROCESS_ACCESS_RIGHTS : uint
+    {
+        PROCESS_TERMINATE = 0x1,
+        PROCESS_CREATE_THREAD = 0x2,
+        PROCESS_VM_OPERATION = 0x8,
+        PROCESS_VM_READ = 0x10,
+        PROCESS_VM_WRITE = 0x20,
+        PROCESS_DUP_HANDLE = 0x40,
+        PROCESS_CREATE_PROCESS = 0x80,
+        PROCESS_SET_QUOTA = 0x100,
+        PROCESS_SET_INFORMATION = 0x200,
+        PROCESS_QUERY_INFORMATION = 0x400,
+        PROCESS_SUSPEND_RESUME = 0x800,
+        PROCESS_QUERY_LIMITED_INFORMATION = 0x1000,
+        SYNCHRONIZE = 0x100000,
+    }
+
+    [Flags]
+    internal enum PROCESS_CREATION_FLAGS : uint
+    {
+        CREATE_BREAKAWAY_FROM_JOB = 0x01000000,
+        CREATE_DEFAULT_ERROR_MODE = 0x04000000,
+        CREATE_NEW_CONSOLE = 0x00000010,
+        CREATE_NEW_PROCESS_GROUP = 0x00000200,
+        CREATE_NO_WINDOW = 0x08000000,
+        CREATE_PROTECTED_PROCESS = 0x00040000,
+        CREATE_PRESERVE_CODE_AUTHZ_LEVEL = 0x02000000,
+        CREATE_SECURE_PROCESS = 0x00400000,
+        CREATE_SEPARATE_WOW_VDM = 0x00000800,
+        CREATE_SHARED_WOW_VDM = 0x00001000,
+        CREATE_SUSPENDED = 0x00000004,
+        CREATE_UNICODE_ENVIRONMENT = 0x00000400,
+        DEBUG_ONLY_THIS_PROCESS = 0x00000002,
+        DEBUG_PROCESS = 0x00000001,
+        DETACHED_PROCESS = 0x00000008,
+        EXTENDED_STARTUPINFO_PRESENT = 0x00080000,
+        INHERIT_PARENT_AFFINITY = 0x00010000,
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Kernel32.cs

@@ -0,0 +1,49 @@
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Dalamud.Bootstrap.OS.Windows.Raw
+{
+    internal static unsafe class Kernel32
+    {
+        private const string Name = "kernel32";
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        public static extern SafeProcessHandle OpenProcess(uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwProcessId);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool TerminateProcess(SafeProcessHandle hProcess, int uExitCode);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool ReadProcessMemory(SafeProcessHandle hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesRead);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool WriteProcessMemory(SafeProcessHandle hProcess, IntPtr lpBaseAddress, void* lpBuffer, IntPtr nSize, out IntPtr lpNumberOfBytesWritten);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        public static extern void* LocalFree(void* hMem);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi)]
+        public static extern uint GetProcessId(SafeProcessHandle hProcess);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool GetProcessTimes(SafeProcessHandle hProcess, out FILETIME lpCreationTime, out FILETIME lpExitTime, out FILETIME lpKernelTime, out FILETIME lpUserTime);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool QueryFullProcessImageNameW(SafeProcessHandle hProcess, uint dwFlags, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpExeName, ref int lpdwSize);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool CreateProcessW(void* lpApplicationName, void* lpCommandLine, SECURITY_ATTRIBUTES* lpProcessAttributes, SECURITY_ATTRIBUTES* lpThreadAttributes, uint bInheritHandles, uint dwCreationFlags, void* lpEnvironment, void* lpCurrentDirectory, void* lpStartupInfo, void* lpProcessInformation);
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool CloseHandle(IntPtr hObject);
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Ntdll.cs

@@ -0,0 +1,14 @@
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bootstrap.OS.Windows.Raw
+{
+    internal static unsafe class Ntdll
+    {
+        private const string Name = "ntdll";
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true)]
+        public static extern NTSTATUS NtQueryInformationProcess(SafeProcessHandle processHandle, PROCESSINFOCLASS processInfoClass, void* processInformation, int processInformationLength, IntPtr* returnLength);
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Shell32.cs

@@ -0,0 +1,12 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bootstrap.OS.Windows.Raw
+{
+    internal static unsafe class Shell32
+    {
+        private const string Name = "shell32";
+
+        [DllImport(Name, CallingConvention = CallingConvention.Winapi, SetLastError = true, ExactSpelling = true)]
+        public static extern char** CommandLineToArgvW(void* lpCmdLine, out int pNumArgs);
+    }
+}

Dalamud.Bootstrap/OS/Windows/Raw/Structures.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bootstrap.OS.Windows.Raw
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct NTSTATUS
+    {
+        public uint Code;
+
+        public NTSTATUS(uint value)
+        {
+            Code = value;
+        }
+
+        /// <summary>
+        /// Equivalent to NT_SUCCESS
+        /// </summary>
+        public bool Success => Code <= 0x7FFFFFFF;
+
+        /// <summary>
+        /// Equivalent to NT_INFORMATION
+        /// </summary>
+        public bool Information => 0x40000000 <= Code && Code <= 0x7FFFFFFF;
+
+        /// <summary>
+        /// Equivalent to NT_WARNING
+        /// </summary>
+        public bool Warning => 0x80000000 <= Code && Code <= 0xBFFFFFFF;
+
+        /// <summary>
+        /// Equivalent to NT_ERROR
+        /// </summary>
+        public bool Error => 0xC0000000 <= Code;
+
+        public override string ToString() => $"{Code:X8}";
+
+        public static implicit operator uint(NTSTATUS status) => status.Code;
+
+        public static implicit operator NTSTATUS(uint code) => new NTSTATUS(code);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct FILETIME
+    {
+        public uint LowDateTime;
+
+        public uint HighDateTime;
+
+        public long FileTime => ((long)HighDateTime << 32) | LowDateTime;
+
+        public DateTime ToDateTime() => DateTime.FromFileTime(FileTime);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct UNICODE_STRING
+    {
+        public ushort Length;
+        public ushort MaximumLength;
+        public IntPtr Buffer;
+    }
+
+    // https://github.com/processhacker/processhacker/blob/e43d7c0513ec5368c3309a58c9f2c2a3ca5de367/phnt/include/ntpsapi.h#L272
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PROCESS_BASIC_INFORMATION
+    {
+        public NTSTATUS ExitStatus;
+        public IntPtr PebBaseAddress;
+        public IntPtr AffinityMask;
+        public IntPtr BasePriority;
+        public IntPtr UniqueProcessId;
+        public IntPtr InheritedFromUniqueProcessId;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PEB
+    {
+        // https://github.com/processhacker/processhacker/blob/238287786b80abad647b988e60f69090cab4c8fe/phnt/include/ntpebteb.h#L57-L218
+        public byte InheritedAddressSpace;
+        public byte ReadImageFileExecOptions;
+        public byte BeingDebugged;
+        public byte BitField;
+        public IntPtr Mutant;
+        public IntPtr ImageBaseAddress;
+        public IntPtr Ldr;
+        public IntPtr ProcessParameters;
+        // ..snip.. we don't care about others
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct RTL_USER_PROCESS_PARAMETERS
+    {
+
+        public uint MaximumLength;
+        public uint LengthInitialized;
+        public uint Flags;
+        public uint DebugFlags;
+        public IntPtr ConsoleHandle;
+        public uint ConsoleFlags;
+        public IntPtr StandardInput;
+        public IntPtr StandardOutput;
+        public IntPtr StandardError;
+        public UNICODE_STRING CurrentDirectory_DosPath;
+        public IntPtr CurrentDirectory_Handle;
+        public UNICODE_STRING DllPath;
+        public UNICODE_STRING ImagePathName;
+        public UNICODE_STRING CommandLine;
+        // ..snip.. don't care
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct SECURITY_ATTRIBUTES
+    {
+        public uint Length;
+
+        public SECURITY_DESCRIPTOR* SecurityDescriptor;
+
+        [MarshalAs(UnmanagedType.Bool)]
+        public bool InheritHandle;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct SECURITY_DESCRIPTOR
+    {
+
+    }
+}