843 lines
26 KiB
C#
843 lines
26 KiB
C#
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Microsoft.Win32.SafeHandles;
|
|
|
|
namespace AcDream.Launcher.Core.Launching;
|
|
|
|
/// <summary>
|
|
/// Windows launcher child created without a shell as a true console process-
|
|
/// group leader. The native start is deliberately narrow: it exists only
|
|
/// because <see cref="ProcessStartInfo"/> does not expose
|
|
/// CREATE_NEW_PROCESS_GROUP while the launcher must retain redirected stdin.
|
|
/// </summary>
|
|
internal sealed class WindowsSystemChildProcess : ILauncherChildProcess
|
|
{
|
|
private readonly LauncherProcessSpec _spec;
|
|
private readonly IWindowsConsoleControl _consoleControl;
|
|
private Process? _process;
|
|
private TextWriter? _standardInput;
|
|
private int _processGroupId;
|
|
private bool _raisingEnabled;
|
|
|
|
internal WindowsSystemChildProcess(
|
|
LauncherProcessSpec spec,
|
|
IWindowsConsoleControl? consoleControl = null)
|
|
{
|
|
_spec = spec ?? throw new ArgumentNullException(nameof(spec));
|
|
_consoleControl = consoleControl ?? WindowsConsoleControl.Instance;
|
|
}
|
|
|
|
public bool HasExited => RequireProcess().HasExited;
|
|
|
|
public int ExitCode => RequireProcess().ExitCode;
|
|
|
|
public TextWriter StandardInput => _standardInput
|
|
?? throw new InvalidOperationException("The child process has not started.");
|
|
|
|
public event EventHandler? Exited;
|
|
|
|
public void Start()
|
|
{
|
|
if (_process is not null)
|
|
{
|
|
throw new InvalidOperationException("The child process already started.");
|
|
}
|
|
|
|
WindowsProcessStartResult started = WindowsProcessNative.Start(_spec);
|
|
try
|
|
{
|
|
_process = Process.GetProcessById(started.ProcessId);
|
|
_process.EnableRaisingEvents = true;
|
|
_process.Exited += OnExited;
|
|
_raisingEnabled = true;
|
|
_standardInput = started.TakeStandardInput();
|
|
_processGroupId = started.ProcessId;
|
|
started.Resume();
|
|
}
|
|
catch
|
|
{
|
|
started.Terminate();
|
|
_standardInput?.Dispose();
|
|
_standardInput = null;
|
|
if (_process is not null)
|
|
{
|
|
if (_raisingEnabled)
|
|
{
|
|
_process.Exited -= OnExited;
|
|
}
|
|
|
|
_process.Dispose();
|
|
_process = null;
|
|
}
|
|
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
started.Dispose();
|
|
}
|
|
}
|
|
|
|
public bool TryRequestGracefulStop()
|
|
{
|
|
try
|
|
{
|
|
if (!_spec.SupportsConsoleGracefulStop
|
|
|| _process is not { HasExited: false } process
|
|
|| _processGroupId <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return _consoleControl.TrySendBreak(process.Id, _processGroupId);
|
|
}
|
|
catch
|
|
{
|
|
// The process may have exited between the state check and the
|
|
// control request. Graceful-stop attempts never escape Stop().
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool CloseMainWindow() => RequireProcess().CloseMainWindow();
|
|
|
|
public void Kill() => RequireProcess().Kill(entireProcessTree: true);
|
|
|
|
public bool WaitForExit(TimeSpan timeout) => RequireProcess().WaitForExit(timeout);
|
|
|
|
public void Dispose()
|
|
{
|
|
_standardInput?.Dispose();
|
|
_standardInput = null;
|
|
if (_process is not null)
|
|
{
|
|
if (_raisingEnabled)
|
|
{
|
|
_process.Exited -= OnExited;
|
|
}
|
|
|
|
_process.Dispose();
|
|
_process = null;
|
|
}
|
|
}
|
|
|
|
private Process RequireProcess() => _process
|
|
?? throw new InvalidOperationException("The child process has not started.");
|
|
|
|
private void OnExited(object? sender, EventArgs e) =>
|
|
Exited?.Invoke(this, EventArgs.Empty);
|
|
}
|
|
|
|
internal interface IWindowsConsoleControl
|
|
{
|
|
bool TrySendBreak(int childProcessId, int childProcessGroupId);
|
|
}
|
|
|
|
internal sealed class WindowsConsoleControl : IWindowsConsoleControl
|
|
{
|
|
private const uint CtrlBreakEvent = 1;
|
|
|
|
internal static WindowsConsoleControl Instance { get; } = new();
|
|
|
|
private WindowsConsoleControl()
|
|
{
|
|
}
|
|
|
|
public bool TrySendBreak(int childProcessId, int childProcessGroupId)
|
|
{
|
|
if (!OperatingSystem.IsWindows()
|
|
|| childProcessId <= 0
|
|
|| childProcessGroupId <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
lock (WindowsConsoleSynchronization.Gate)
|
|
{
|
|
bool attachedHere = false;
|
|
try
|
|
{
|
|
uint[] processes = new uint[1];
|
|
if (Native.GetConsoleProcessList(processes, 1) == 0)
|
|
{
|
|
if (!Native.AttachConsole((uint)childProcessId))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
attachedHere = true;
|
|
}
|
|
|
|
return Native.GenerateConsoleCtrlEvent(
|
|
CtrlBreakEvent,
|
|
(uint)childProcessGroupId);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
if (attachedHere)
|
|
{
|
|
_ = Native.FreeConsole();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class Native
|
|
{
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
internal static extern bool AttachConsole(uint processId);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
internal static extern bool FreeConsole();
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
internal static extern bool GenerateConsoleCtrlEvent(
|
|
uint controlEvent,
|
|
uint processGroupId);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
internal static extern uint GetConsoleProcessList(
|
|
[Out] uint[] processList,
|
|
uint processCount);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A process can be attached to only one console. Child creation and targeted
|
|
/// control-event attachment therefore share one process-wide gate.
|
|
/// </summary>
|
|
internal static class WindowsConsoleSynchronization
|
|
{
|
|
internal static object Gate { get; } = new();
|
|
}
|
|
|
|
internal sealed class WindowsProcessStartResult : IDisposable
|
|
{
|
|
private readonly SafeKernelHandle _processHandle;
|
|
private readonly SafeKernelHandle _threadHandle;
|
|
private SafeFileHandle? _standardInput;
|
|
private bool _resumed;
|
|
|
|
internal WindowsProcessStartResult(
|
|
int processId,
|
|
SafeKernelHandle processHandle,
|
|
SafeKernelHandle threadHandle,
|
|
SafeFileHandle standardInput)
|
|
{
|
|
ProcessId = processId;
|
|
_processHandle = processHandle;
|
|
_threadHandle = threadHandle;
|
|
_standardInput = standardInput;
|
|
}
|
|
|
|
internal int ProcessId { get; }
|
|
|
|
internal TextWriter TakeStandardInput()
|
|
{
|
|
SafeFileHandle handle = _standardInput
|
|
?? throw new InvalidOperationException("Standard input was already claimed.");
|
|
var stream = new FileStream(handle, FileAccess.Write, 4096, isAsync: false);
|
|
_standardInput = null;
|
|
try
|
|
{
|
|
return new StreamWriter(
|
|
stream,
|
|
new UTF8Encoding(encoderShouldEmitUTF8Identifier: false))
|
|
{
|
|
AutoFlush = true,
|
|
};
|
|
}
|
|
catch
|
|
{
|
|
stream.Dispose();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
internal void Resume()
|
|
{
|
|
if (WindowsProcessNative.ResumeThread(_threadHandle) == uint.MaxValue)
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
"The Windows launcher child could not be resumed.");
|
|
}
|
|
|
|
_resumed = true;
|
|
}
|
|
|
|
internal void Terminate()
|
|
{
|
|
if (!_processHandle.IsInvalid)
|
|
{
|
|
_ = WindowsProcessNative.TerminateProcess(_processHandle, 74);
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (!_resumed)
|
|
{
|
|
Terminate();
|
|
}
|
|
|
|
_standardInput?.Dispose();
|
|
_threadHandle.Dispose();
|
|
_processHandle.Dispose();
|
|
}
|
|
}
|
|
|
|
internal static class WindowsProcessNative
|
|
{
|
|
private const uint CreateSuspended = 0x00000004;
|
|
private const uint CreateNewProcessGroup = 0x00000200;
|
|
private const uint ExtendedStartupInfoPresent = 0x00080000;
|
|
private const uint StartfUseStdHandles = 0x00000100;
|
|
private const short SwHide = 0;
|
|
private const uint HandleFlagInherit = 0x00000001;
|
|
private const uint DuplicateSameAccess = 0x00000002;
|
|
private const uint GenericWrite = 0x40000000;
|
|
private const uint FileShareRead = 0x00000001;
|
|
private const uint FileShareWrite = 0x00000002;
|
|
private const uint OpenExisting = 3;
|
|
private const uint FileAttributeNormal = 0x00000080;
|
|
private const int StdOutputHandle = -11;
|
|
private const int StdErrorHandle = -12;
|
|
private static readonly IntPtr ProcThreadAttributeHandleList = new(0x00020002);
|
|
|
|
internal static WindowsProcessStartResult Start(LauncherProcessSpec spec)
|
|
{
|
|
ArgumentException.ThrowIfNullOrWhiteSpace(spec.ExecutablePath);
|
|
ArgumentNullException.ThrowIfNull(spec.Arguments);
|
|
|
|
lock (WindowsConsoleSynchronization.Gate)
|
|
{
|
|
bool allocatedConsole = false;
|
|
try
|
|
{
|
|
// An Avalonia launcher started from Explorer has no console.
|
|
// CREATE_NEW_PROCESS_GROUP alone does not allocate one, and a
|
|
// console-less group cannot receive GenerateConsoleCtrlEvent.
|
|
// Allocate one only for the creation transaction, hide it,
|
|
// let the group leader inherit it, then detach the launcher.
|
|
// Each such child consequently owns a distinct console as
|
|
// well as a distinct process group.
|
|
if (!HasConsole())
|
|
{
|
|
if (!AllocConsole())
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
"The Windows launcher could not allocate the child console.");
|
|
}
|
|
|
|
allocatedConsole = true;
|
|
IntPtr consoleWindow = GetConsoleWindow();
|
|
if (consoleWindow != IntPtr.Zero)
|
|
{
|
|
_ = ShowWindow(consoleWindow, SwHide);
|
|
}
|
|
}
|
|
|
|
return StartCore(spec);
|
|
}
|
|
finally
|
|
{
|
|
if (allocatedConsole)
|
|
{
|
|
_ = FreeConsole();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static WindowsProcessStartResult StartCore(LauncherProcessSpec spec)
|
|
{
|
|
SafeFileHandle? parentInput = null;
|
|
try
|
|
{
|
|
using SafeFileHandle childInput = CreateChildInputPipe(
|
|
out SafeFileHandle createdParentInput);
|
|
parentInput = createdParentInput;
|
|
using SafeKernelHandle childOutput = DuplicateOrOpenNull(StdOutputHandle);
|
|
using SafeKernelHandle childError = DuplicateOrOpenNull(StdErrorHandle);
|
|
using var attributes = new ProcessThreadAttributeList(
|
|
childInput.DangerousGetHandle(),
|
|
childOutput.DangerousGetHandle(),
|
|
childError.DangerousGetHandle());
|
|
|
|
var startup = new StartupInfoEx
|
|
{
|
|
StartupInfo = new StartupInfo
|
|
{
|
|
Size = Marshal.SizeOf<StartupInfoEx>(),
|
|
Flags = StartfUseStdHandles,
|
|
StandardInput = childInput.DangerousGetHandle(),
|
|
StandardOutput = childOutput.DangerousGetHandle(),
|
|
StandardError = childError.DangerousGetHandle(),
|
|
},
|
|
AttributeList = attributes.Pointer,
|
|
};
|
|
string executable = ResolveExecutable(spec.ExecutablePath);
|
|
string commandLineText = BuildCommandLine(executable, spec.Arguments);
|
|
var commandLine = new StringBuilder(commandLineText, commandLineText.Length + 1);
|
|
string? workingDirectory = string.IsNullOrWhiteSpace(spec.WorkingDirectory)
|
|
? null
|
|
: Path.GetFullPath(spec.WorkingDirectory);
|
|
|
|
if (!CreateProcessW(
|
|
executable,
|
|
commandLine,
|
|
IntPtr.Zero,
|
|
IntPtr.Zero,
|
|
inheritHandles: true,
|
|
CreateSuspended | CreateNewProcessGroup | ExtendedStartupInfoPresent,
|
|
IntPtr.Zero,
|
|
workingDirectory,
|
|
ref startup,
|
|
out ProcessInformation information))
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
"The Windows launcher child could not be created.");
|
|
}
|
|
|
|
var processHandle = new SafeKernelHandle(
|
|
information.Process,
|
|
ownsHandle: true);
|
|
var threadHandle = new SafeKernelHandle(
|
|
information.Thread,
|
|
ownsHandle: true);
|
|
try
|
|
{
|
|
var result = new WindowsProcessStartResult(
|
|
checked((int)information.ProcessId),
|
|
processHandle,
|
|
threadHandle,
|
|
parentInput);
|
|
parentInput = null;
|
|
return result;
|
|
}
|
|
catch
|
|
{
|
|
_ = TerminateProcess(processHandle, 74);
|
|
threadHandle.Dispose();
|
|
processHandle.Dispose();
|
|
throw;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
parentInput?.Dispose();
|
|
}
|
|
}
|
|
|
|
private static bool HasConsole()
|
|
{
|
|
uint[] processes = new uint[1];
|
|
return GetConsoleProcessList(processes, 1) != 0;
|
|
}
|
|
|
|
internal static uint ResumeThread(SafeKernelHandle thread) =>
|
|
NativeResumeThread(thread);
|
|
|
|
internal static bool TerminateProcess(SafeKernelHandle process, uint exitCode) =>
|
|
NativeTerminateProcess(process, exitCode);
|
|
|
|
internal static string BuildCommandLine(
|
|
string executable,
|
|
IReadOnlyList<string> arguments)
|
|
{
|
|
var builder = new StringBuilder();
|
|
AppendQuotedArgument(builder, executable);
|
|
foreach (string argument in arguments)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(argument);
|
|
builder.Append(' ');
|
|
AppendQuotedArgument(builder, argument);
|
|
}
|
|
|
|
return builder.ToString();
|
|
}
|
|
|
|
private static void AppendQuotedArgument(StringBuilder builder, string value)
|
|
{
|
|
builder.Append('"');
|
|
int backslashes = 0;
|
|
foreach (char character in value)
|
|
{
|
|
if (character == '\\')
|
|
{
|
|
backslashes++;
|
|
continue;
|
|
}
|
|
|
|
if (character == '"')
|
|
{
|
|
builder.Append('\\', backslashes * 2 + 1);
|
|
builder.Append('"');
|
|
backslashes = 0;
|
|
continue;
|
|
}
|
|
|
|
builder.Append('\\', backslashes);
|
|
backslashes = 0;
|
|
builder.Append(character);
|
|
}
|
|
|
|
builder.Append('\\', backslashes * 2);
|
|
builder.Append('"');
|
|
}
|
|
|
|
private static SafeFileHandle CreateChildInputPipe(out SafeFileHandle parentInput)
|
|
{
|
|
var security = new SecurityAttributes
|
|
{
|
|
Length = Marshal.SizeOf<SecurityAttributes>(),
|
|
InheritHandle = true,
|
|
};
|
|
if (!CreatePipe(out IntPtr read, out IntPtr write, ref security, 0))
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
"The launcher child stdin pipe could not be created.");
|
|
}
|
|
|
|
var child = new SafeFileHandle(read, ownsHandle: true);
|
|
parentInput = new SafeFileHandle(write, ownsHandle: true);
|
|
if (!SetHandleInformation(
|
|
parentInput,
|
|
HandleFlagInherit,
|
|
0))
|
|
{
|
|
int error = Marshal.GetLastWin32Error();
|
|
child.Dispose();
|
|
parentInput.Dispose();
|
|
throw new Win32Exception(error,
|
|
"The launcher child stdin pipe could not be isolated.");
|
|
}
|
|
|
|
return child;
|
|
}
|
|
|
|
private static SafeKernelHandle DuplicateOrOpenNull(int standardHandle)
|
|
{
|
|
IntPtr source = GetStdHandle(standardHandle);
|
|
if (source != IntPtr.Zero && source != new IntPtr(-1))
|
|
{
|
|
IntPtr current = GetCurrentProcess();
|
|
if (DuplicateHandle(
|
|
current,
|
|
source,
|
|
current,
|
|
out IntPtr duplicate,
|
|
0,
|
|
inheritHandle: true,
|
|
DuplicateSameAccess))
|
|
{
|
|
return new SafeKernelHandle(duplicate, ownsHandle: true);
|
|
}
|
|
}
|
|
|
|
IntPtr nul = CreateFileW(
|
|
"NUL",
|
|
GenericWrite,
|
|
FileShareRead | FileShareWrite,
|
|
IntPtr.Zero,
|
|
OpenExisting,
|
|
FileAttributeNormal,
|
|
IntPtr.Zero);
|
|
if (nul == IntPtr.Zero || nul == new IntPtr(-1))
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
"The launcher child fallback output handle could not be opened.");
|
|
}
|
|
|
|
var handle = new SafeKernelHandle(nul, ownsHandle: true);
|
|
if (!SetHandleInformation(handle, HandleFlagInherit, HandleFlagInherit))
|
|
{
|
|
int error = Marshal.GetLastWin32Error();
|
|
handle.Dispose();
|
|
throw new Win32Exception(error,
|
|
"The launcher child fallback output handle could not be inherited.");
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
private static string ResolveExecutable(string executable)
|
|
{
|
|
if (Path.IsPathFullyQualified(executable))
|
|
{
|
|
return Path.GetFullPath(executable);
|
|
}
|
|
|
|
var buffer = new StringBuilder(32_768);
|
|
uint length = SearchPathW(
|
|
null,
|
|
executable,
|
|
null,
|
|
(uint)buffer.Capacity,
|
|
buffer,
|
|
IntPtr.Zero);
|
|
if (length == 0 || length >= buffer.Capacity)
|
|
{
|
|
throw new Win32Exception(Marshal.GetLastWin32Error(),
|
|
$"Launcher child executable '{executable}' was not found.");
|
|
}
|
|
|
|
return Path.GetFullPath(buffer.ToString());
|
|
}
|
|
|
|
private sealed class ProcessThreadAttributeList : IDisposable
|
|
{
|
|
private IntPtr _pointer;
|
|
private IntPtr _handles;
|
|
private bool _initialized;
|
|
|
|
internal ProcessThreadAttributeList(params IntPtr[] handles)
|
|
{
|
|
nuint size = 0;
|
|
_ = InitializeProcThreadAttributeList(
|
|
IntPtr.Zero,
|
|
1,
|
|
0,
|
|
ref size);
|
|
_pointer = Marshal.AllocHGlobal(checked((nint)size));
|
|
if (!InitializeProcThreadAttributeList(_pointer, 1, 0, ref size))
|
|
{
|
|
int error = Marshal.GetLastWin32Error();
|
|
Dispose();
|
|
throw new Win32Exception(error,
|
|
"The launcher child handle list could not be initialized.");
|
|
}
|
|
_initialized = true;
|
|
|
|
_handles = Marshal.AllocHGlobal(handles.Length * IntPtr.Size);
|
|
for (int index = 0; index < handles.Length; index++)
|
|
{
|
|
Marshal.WriteIntPtr(_handles, index * IntPtr.Size, handles[index]);
|
|
}
|
|
|
|
if (!UpdateProcThreadAttribute(
|
|
_pointer,
|
|
0,
|
|
ProcThreadAttributeHandleList,
|
|
_handles,
|
|
checked((nuint)(handles.Length * IntPtr.Size)),
|
|
IntPtr.Zero,
|
|
IntPtr.Zero))
|
|
{
|
|
int error = Marshal.GetLastWin32Error();
|
|
Dispose();
|
|
throw new Win32Exception(error,
|
|
"The launcher child inherited-handle list could not be set.");
|
|
}
|
|
}
|
|
|
|
internal IntPtr Pointer => _pointer;
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_pointer != IntPtr.Zero)
|
|
{
|
|
if (_initialized)
|
|
{
|
|
DeleteProcThreadAttributeList(_pointer);
|
|
_initialized = false;
|
|
}
|
|
Marshal.FreeHGlobal(_pointer);
|
|
_pointer = IntPtr.Zero;
|
|
}
|
|
|
|
if (_handles != IntPtr.Zero)
|
|
{
|
|
Marshal.FreeHGlobal(_handles);
|
|
_handles = IntPtr.Zero;
|
|
}
|
|
}
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct SecurityAttributes
|
|
{
|
|
internal int Length;
|
|
internal IntPtr SecurityDescriptor;
|
|
[MarshalAs(UnmanagedType.Bool)] internal bool InheritHandle;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
private struct StartupInfo
|
|
{
|
|
internal int Size;
|
|
internal string? Reserved;
|
|
internal string? Desktop;
|
|
internal string? Title;
|
|
internal int X;
|
|
internal int Y;
|
|
internal int XSize;
|
|
internal int YSize;
|
|
internal int XCountChars;
|
|
internal int YCountChars;
|
|
internal int FillAttribute;
|
|
internal uint Flags;
|
|
internal short ShowWindow;
|
|
internal short Reserved2Size;
|
|
internal IntPtr Reserved2;
|
|
internal IntPtr StandardInput;
|
|
internal IntPtr StandardOutput;
|
|
internal IntPtr StandardError;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct StartupInfoEx
|
|
{
|
|
internal StartupInfo StartupInfo;
|
|
internal IntPtr AttributeList;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct ProcessInformation
|
|
{
|
|
internal IntPtr Process;
|
|
internal IntPtr Thread;
|
|
internal uint ProcessId;
|
|
internal uint ThreadId;
|
|
}
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool CreateProcessW(
|
|
string applicationName,
|
|
StringBuilder commandLine,
|
|
IntPtr processAttributes,
|
|
IntPtr threadAttributes,
|
|
[MarshalAs(UnmanagedType.Bool)] bool inheritHandles,
|
|
uint creationFlags,
|
|
IntPtr environment,
|
|
string? currentDirectory,
|
|
ref StartupInfoEx startupInfo,
|
|
out ProcessInformation processInformation);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool CreatePipe(
|
|
out IntPtr readPipe,
|
|
out IntPtr writePipe,
|
|
ref SecurityAttributes pipeAttributes,
|
|
uint size);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool SetHandleInformation(
|
|
SafeHandle handle,
|
|
uint mask,
|
|
uint flags);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool AllocConsole();
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool FreeConsole();
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
private static extern uint GetConsoleProcessList(
|
|
[Out] uint[] processList,
|
|
uint processCount);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
private static extern IntPtr GetConsoleWindow();
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool ShowWindow(IntPtr window, int commandShow);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
private static extern IntPtr GetStdHandle(int standardHandle);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
private static extern IntPtr GetCurrentProcess();
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool DuplicateHandle(
|
|
IntPtr sourceProcess,
|
|
IntPtr sourceHandle,
|
|
IntPtr targetProcess,
|
|
out IntPtr targetHandle,
|
|
uint desiredAccess,
|
|
[MarshalAs(UnmanagedType.Bool)] bool inheritHandle,
|
|
uint options);
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
private static extern IntPtr CreateFileW(
|
|
string fileName,
|
|
uint desiredAccess,
|
|
uint shareMode,
|
|
IntPtr securityAttributes,
|
|
uint creationDisposition,
|
|
uint flagsAndAttributes,
|
|
IntPtr templateFile);
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
private static extern uint SearchPathW(
|
|
string? path,
|
|
string fileName,
|
|
string? extension,
|
|
uint bufferLength,
|
|
StringBuilder buffer,
|
|
IntPtr filePart);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool InitializeProcThreadAttributeList(
|
|
IntPtr attributeList,
|
|
int attributeCount,
|
|
int flags,
|
|
ref nuint size);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool UpdateProcThreadAttribute(
|
|
IntPtr attributeList,
|
|
uint flags,
|
|
IntPtr attribute,
|
|
IntPtr value,
|
|
nuint size,
|
|
IntPtr previousValue,
|
|
IntPtr returnSize);
|
|
|
|
[DllImport("kernel32.dll")]
|
|
private static extern void DeleteProcThreadAttributeList(IntPtr attributeList);
|
|
|
|
[DllImport("kernel32.dll", EntryPoint = "ResumeThread", SetLastError = true)]
|
|
private static extern uint NativeResumeThread(SafeKernelHandle thread);
|
|
|
|
[DllImport("kernel32.dll", EntryPoint = "TerminateProcess", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool NativeTerminateProcess(
|
|
SafeKernelHandle process,
|
|
uint exitCode);
|
|
}
|
|
|
|
internal sealed class SafeKernelHandle : SafeHandleZeroOrMinusOneIsInvalid
|
|
{
|
|
internal SafeKernelHandle(IntPtr handle, bool ownsHandle)
|
|
: base(ownsHandle)
|
|
{
|
|
SetHandle(handle);
|
|
}
|
|
|
|
protected override bool ReleaseHandle() => CloseHandle(handle);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private static extern bool CloseHandle(IntPtr handle);
|
|
}
|