//
// METHODS
//
/// <devdoc>
/// Helper to close a thread handle.
/// </devdoc>
/// <internalonly/>
private static void CloseThreadHandle(SafeThreadHandle handle)
{
if (handle != null)
{
handle.Dispose();
}
}
public static SafeThreadHandle OpenThread(int threadId, int access)
{
SafeThreadHandle threadHandle = Interop.Kernel32.OpenThread(access, false, threadId);
int result = Marshal.GetLastWin32Error();
if (threadHandle.IsInvalid)
{
threadHandle.Dispose();
if (result == Interop.Errors.ERROR_INVALID_PARAMETER)
{
throw new InvalidOperationException(SR.Format(SR.ThreadExited, threadId.ToString()));
}
throw new Win32Exception(result);
}
return(threadHandle);
}
/// <summary>
/// Calls <see cref="CreateProcessAsUserW"/> and safely stores the obtained handles.
/// </summary>
/// <param name="userToken">Token to impersonate the external process</param>
/// <param name="createFlags">Flags used to create the external process</param>
/// <param name="startupInfo">Startup information used to create the external process</param>
/// <returns><c>true</c> if the call to <see cref="CreateProcessAsUserW"/> was successful; otherwise <c>false</c></returns>
private bool SafeCreateProcessAsUserW(IntPtr userToken, CreateProcessFlags createFlags, StartupInfo startupInfo)
{
var threadHandle = new SafeThreadHandle();
bool success;
// The following is necessary to make sure that processInformation.hProcess and processInformation.hThread
// are safely stored in the respective SafeHandle classes. It is, unfortunately, not possible to define
// processInformation.hProcess and processInformation.hThread as SafeHandles and use processInformation
// as an out parameter, because the unmanaged code is not able to create these objects. We therefore use
// IntPtr and ensure in the following that the IntPtrs are stored in SafeHandle objects immediately after
// they have been obtained.
// For details see here: https://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.runtimehelpers.prepareconstrainedregions(v=vs.110).aspx
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
ProcessInformation processInformation;
success = CreateProcessAsUserW(userToken, null, GetCommandLine(), IntPtr.Zero, IntPtr.Zero, true, createFlags, IntPtr.Zero, null, startupInfo, out processInformation);
if (success)
{
_processHandle = new SafeProcessHandle(processInformation.hProcess, true);
threadHandle.InitialSetHandle(processInformation.hThread);
_processId = processInformation.dwProcessId;
}
}
// We don't need the threadHandle and therefore immediately dispose it.
threadHandle.Dispose();
if (success)
{
return(true);
}
if (_processHandle != null)
{
_processHandle.Dispose();
}
var error = Marshal.GetLastWin32Error();
_debugLogger.Error("AsyncImpersonationProcess ({0}): Cannot start process. ErrorCode: {1} ({2})", StartInfo.FileName, error, new Win32Exception(error).Message);
return(false);
}
/// <summary>Starts the process using the supplied start info.</summary>
/// <param name="startInfo">The start info with which to start the process.</param>
private unsafe bool StartWithCreateProcess(ProcessStartInfo startInfo)
{
// See knowledge base article Q190351 for an explanation of the following code. Noteworthy tricky points:
// * The handles are duplicated as non-inheritable before they are passed to CreateProcess so
// that the child process can not close them
// * CreateProcess allows you to redirect all or none of the standard IO handles, so we use
// GetStdHandle for the handles that are not being redirected
StringBuilder commandLine = BuildCommandLine(startInfo.FileName, StartInfo.Arguments);
Process.AppendArguments(commandLine, StartInfo.ArgumentList);
Interop.Kernel32.STARTUPINFO startupInfo = new Interop.Kernel32.STARTUPINFO();
Interop.Kernel32.PROCESS_INFORMATION processInfo = new Interop.Kernel32.PROCESS_INFORMATION();
Interop.Kernel32.SECURITY_ATTRIBUTES unused_SecAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES();
SafeProcessHandle procSH = new SafeProcessHandle();
SafeThreadHandle threadSH = new SafeThreadHandle();
// handles used in parent process
SafeFileHandle parentInputPipeHandle = null;
SafeFileHandle childInputPipeHandle = null;
SafeFileHandle parentOutputPipeHandle = null;
SafeFileHandle childOutputPipeHandle = null;
SafeFileHandle parentErrorPipeHandle = null;
SafeFileHandle childErrorPipeHandle = null;
lock (s_createProcessLock)
{
try
{
startupInfo.cb = sizeof(Interop.Kernel32.STARTUPINFO);
// set up the streams
if (startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError)
{
if (startInfo.RedirectStandardInput)
{
CreatePipe(out parentInputPipeHandle, out childInputPipeHandle, true);
}
else
{
childInputPipeHandle = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_INPUT_HANDLE), false);
}
if (startInfo.RedirectStandardOutput)
{
CreatePipe(out parentOutputPipeHandle, out childOutputPipeHandle, false);
}
else
{
childOutputPipeHandle = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_OUTPUT_HANDLE), false);
}
if (startInfo.RedirectStandardError)
{
CreatePipe(out parentErrorPipeHandle, out childErrorPipeHandle, false);
}
else
{
childErrorPipeHandle = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_ERROR_HANDLE), false);
}
startupInfo.hStdInput = childInputPipeHandle.DangerousGetHandle();
startupInfo.hStdOutput = childOutputPipeHandle.DangerousGetHandle();
startupInfo.hStdError = childErrorPipeHandle.DangerousGetHandle();
startupInfo.dwFlags = Interop.Advapi32.StartupInfoOptions.STARTF_USESTDHANDLES;
}
// set up the creation flags parameter
int creationFlags = 0;
if (startInfo.CreateNoWindow)
{
creationFlags |= Interop.Advapi32.StartupInfoOptions.CREATE_NO_WINDOW;
}
// set up the environment block parameter
string environmentBlock = null;
if (startInfo._environmentVariables != null)
{
creationFlags |= Interop.Advapi32.StartupInfoOptions.CREATE_UNICODE_ENVIRONMENT;
environmentBlock = GetEnvironmentVariablesBlock(startInfo._environmentVariables);
}
string workingDirectory = startInfo.WorkingDirectory;
if (workingDirectory == string.Empty)
{
workingDirectory = Directory.GetCurrentDirectory();
}
bool retVal;
int errorCode = 0;
if (startInfo.UserName.Length != 0)
{
if (startInfo.Password != null && startInfo.PasswordInClearText != null)
{
throw new ArgumentException(SR.CantSetDuplicatePassword);
}
Interop.Advapi32.LogonFlags logonFlags = (Interop.Advapi32.LogonFlags) 0;
if (startInfo.LoadUserProfile)
{
logonFlags = Interop.Advapi32.LogonFlags.LOGON_WITH_PROFILE;
}
fixed(char *passwordInClearTextPtr = startInfo.PasswordInClearText ?? string.Empty)
fixed(char *environmentBlockPtr = environmentBlock)
{
IntPtr passwordPtr = (startInfo.Password != null) ?
Marshal.SecureStringToGlobalAllocUnicode(startInfo.Password) : IntPtr.Zero;
try
{
retVal = Interop.Advapi32.CreateProcessWithLogonW(
startInfo.UserName,
startInfo.Domain,
(passwordPtr != IntPtr.Zero) ? passwordPtr : (IntPtr)passwordInClearTextPtr,
logonFlags,
null, // we don't need this since all the info is in commandLine
commandLine,
creationFlags,
(IntPtr)environmentBlockPtr,
workingDirectory,
ref startupInfo, // pointer to STARTUPINFO
ref processInfo // pointer to PROCESS_INFORMATION
);
if (!retVal)
{
errorCode = Marshal.GetLastWin32Error();
}
}
finally
{
if (passwordPtr != IntPtr.Zero)
{
Marshal.ZeroFreeGlobalAllocUnicode(passwordPtr);
}
}
}
}
else
{
fixed(char *environmentBlockPtr = environmentBlock)
{
retVal = Interop.Kernel32.CreateProcess(
null, // we don't need this since all the info is in commandLine
commandLine, // pointer to the command line string
ref unused_SecAttrs, // address to process security attributes, we don't need to inherit the handle
ref unused_SecAttrs, // address to thread security attributes.
true, // handle inheritance flag
creationFlags, // creation flags
(IntPtr)environmentBlockPtr, // pointer to new environment block
workingDirectory, // pointer to current directory name
ref startupInfo, // pointer to STARTUPINFO
ref processInfo // pointer to PROCESS_INFORMATION
);
if (!retVal)
{
errorCode = Marshal.GetLastWin32Error();
}
}
}
if (processInfo.hProcess != IntPtr.Zero && processInfo.hProcess != new IntPtr(-1))
{
procSH.InitialSetHandle(processInfo.hProcess);
}
if (processInfo.hThread != IntPtr.Zero && processInfo.hThread != new IntPtr(-1))
{
threadSH.InitialSetHandle(processInfo.hThread);
}
if (!retVal)
{
if (errorCode == Interop.Errors.ERROR_BAD_EXE_FORMAT || errorCode == Interop.Errors.ERROR_EXE_MACHINE_TYPE_MISMATCH)
{
throw new Win32Exception(errorCode, SR.InvalidApplication);
}
throw new Win32Exception(errorCode);
}
}
finally
{
childInputPipeHandle?.Dispose();
childOutputPipeHandle?.Dispose();
childErrorPipeHandle?.Dispose();
threadSH?.Dispose();
}
}
if (startInfo.RedirectStandardInput)
{
Encoding enc = startInfo.StandardInputEncoding ?? GetEncoding((int)Interop.Kernel32.GetConsoleCP());
_standardInput = new StreamWriter(new FileStream(parentInputPipeHandle, FileAccess.Write, 4096, false), enc, 4096);
_standardInput.AutoFlush = true;
}
if (startInfo.RedirectStandardOutput)
{
Encoding enc = startInfo.StandardOutputEncoding ?? GetEncoding((int)Interop.Kernel32.GetConsoleOutputCP());
_standardOutput = new StreamReader(new FileStream(parentOutputPipeHandle, FileAccess.Read, 4096, false), enc, true, 4096);
}
if (startInfo.RedirectStandardError)
{
Encoding enc = startInfo.StandardErrorEncoding ?? GetEncoding((int)Interop.Kernel32.GetConsoleOutputCP());
_standardError = new StreamReader(new FileStream(parentErrorPipeHandle, FileAccess.Read, 4096, false), enc, true, 4096);
}
if (procSH.IsInvalid)
{
return(false);
}
SetProcessHandle(procSH);
SetProcessId((int)processInfo.dwProcessId);
return(true);
}
public void Dispose() => handle.Dispose();
/// <summary>Starts the process using the supplied start info.</summary>
/// <param name="startInfo">The start info with which to start the process.</param>
private bool StartCore(ProcessStartInfo startInfo)
{
// See knowledge base article Q190351 for an explanation of the following code. Noteworthy tricky points:
// * The handles are duplicated as non-inheritable before they are passed to CreateProcess so
// that the child process can not close them
// * CreateProcess allows you to redirect all or none of the standard IO handles, so we use
// GetStdHandle for the handles that are not being redirected
StringBuilder commandLine = BuildCommandLine(startInfo.FileName, startInfo.Arguments);
Interop.Kernel32.STARTUPINFO startupInfo = new Interop.Kernel32.STARTUPINFO();
Interop.Kernel32.PROCESS_INFORMATION processInfo = new Interop.Kernel32.PROCESS_INFORMATION();
Interop.Kernel32.SECURITY_ATTRIBUTES unused_SecAttrs = new Interop.Kernel32.SECURITY_ATTRIBUTES();
SafeProcessHandle procSH = new SafeProcessHandle();
SafeThreadHandle threadSH = new SafeThreadHandle();
bool retVal;
int errorCode = 0;
// handles used in parent process
SafeFileHandle standardInputWritePipeHandle = null;
SafeFileHandle standardOutputReadPipeHandle = null;
SafeFileHandle standardErrorReadPipeHandle = null;
GCHandle environmentHandle = new GCHandle();
lock (s_createProcessLock)
{
try
{
// set up the streams
if (startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError)
{
if (startInfo.RedirectStandardInput)
{
CreatePipe(out standardInputWritePipeHandle, out startupInfo.hStdInput, true);
}
else
{
startupInfo.hStdInput = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_INPUT_HANDLE), false);
}
if (startInfo.RedirectStandardOutput)
{
CreatePipe(out standardOutputReadPipeHandle, out startupInfo.hStdOutput, false);
}
else
{
startupInfo.hStdOutput = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_OUTPUT_HANDLE), false);
}
if (startInfo.RedirectStandardError)
{
CreatePipe(out standardErrorReadPipeHandle, out startupInfo.hStdError, false);
}
else
{
startupInfo.hStdError = new SafeFileHandle(Interop.Kernel32.GetStdHandle(Interop.Kernel32.HandleTypes.STD_ERROR_HANDLE), false);
}
startupInfo.dwFlags = Interop.Advapi32.StartupInfoOptions.STARTF_USESTDHANDLES;
}
// set up the creation flags parameter
int creationFlags = 0;
if (startInfo.CreateNoWindow)
{
creationFlags |= Interop.Advapi32.StartupInfoOptions.CREATE_NO_WINDOW;
}
// set up the environment block parameter
IntPtr environmentPtr = (IntPtr)0;
if (startInfo._environmentVariables != null)
{
creationFlags |= Interop.Advapi32.StartupInfoOptions.CREATE_UNICODE_ENVIRONMENT;
byte[] environmentBytes = EnvironmentVariablesToByteArray(startInfo._environmentVariables);
environmentHandle = GCHandle.Alloc(environmentBytes, GCHandleType.Pinned);
environmentPtr = environmentHandle.AddrOfPinnedObject();
}
string workingDirectory = startInfo.WorkingDirectory;
if (workingDirectory == string.Empty)
{
workingDirectory = Directory.GetCurrentDirectory();
}
if (startInfo.UserName.Length != 0)
{
Interop.Advapi32.LogonFlags logonFlags = (Interop.Advapi32.LogonFlags) 0;
if (startInfo.LoadUserProfile)
{
logonFlags = Interop.Advapi32.LogonFlags.LOGON_WITH_PROFILE;
}
try { }
finally
{
retVal = Interop.Advapi32.CreateProcessWithLogonW(
startInfo.UserName,
startInfo.Domain,
startInfo.PasswordInClearText,
logonFlags,
null, // we don't need this since all the info is in commandLine
commandLine,
creationFlags,
environmentPtr,
workingDirectory,
startupInfo, // pointer to STARTUPINFO
processInfo // pointer to PROCESS_INFORMATION
);
if (!retVal)
{
errorCode = Marshal.GetLastWin32Error();
}
if (processInfo.hProcess != IntPtr.Zero && processInfo.hProcess != (IntPtr)INVALID_HANDLE_VALUE)
{
procSH.InitialSetHandle(processInfo.hProcess);
}
if (processInfo.hThread != IntPtr.Zero && processInfo.hThread != (IntPtr)INVALID_HANDLE_VALUE)
{
threadSH.InitialSetHandle(processInfo.hThread);
}
}
if (!retVal)
{
if (errorCode == Interop.Errors.ERROR_BAD_EXE_FORMAT || errorCode == Interop.Errors.ERROR_EXE_MACHINE_TYPE_MISMATCH)
{
throw new Win32Exception(errorCode, SR.InvalidApplication);
}
throw new Win32Exception(errorCode);
}
}
else
{
try { }
finally
{
retVal = Interop.Kernel32.CreateProcess(
null, // we don't need this since all the info is in commandLine
commandLine, // pointer to the command line string
ref unused_SecAttrs, // address to process security attributes, we don't need to inherit the handle
ref unused_SecAttrs, // address to thread security attributes.
true, // handle inheritance flag
creationFlags, // creation flags
environmentPtr, // pointer to new environment block
workingDirectory, // pointer to current directory name
startupInfo, // pointer to STARTUPINFO
processInfo // pointer to PROCESS_INFORMATION
);
if (!retVal)
{
errorCode = Marshal.GetLastWin32Error();
}
if (processInfo.hProcess != (IntPtr)0 && processInfo.hProcess != (IntPtr)INVALID_HANDLE_VALUE)
{
procSH.InitialSetHandle(processInfo.hProcess);
}
if (processInfo.hThread != (IntPtr)0 && processInfo.hThread != (IntPtr)INVALID_HANDLE_VALUE)
{
threadSH.InitialSetHandle(processInfo.hThread);
}
}
if (!retVal)
{
if (errorCode == Interop.Errors.ERROR_BAD_EXE_FORMAT || errorCode == Interop.Errors.ERROR_EXE_MACHINE_TYPE_MISMATCH)
{
throw new Win32Exception(errorCode, SR.InvalidApplication);
}
throw new Win32Exception(errorCode);
}
}
}
finally
{
// free environment block
if (environmentHandle.IsAllocated)
{
environmentHandle.Free();
}
startupInfo.Dispose();
}
}
if (startInfo.RedirectStandardInput)
{
Encoding enc = GetEncoding((int)Interop.Kernel32.GetConsoleCP());
_standardInput = new StreamWriter(new FileStream(standardInputWritePipeHandle, FileAccess.Write, 4096, false), enc, 4096);
_standardInput.AutoFlush = true;
}
if (startInfo.RedirectStandardOutput)
{
Encoding enc = startInfo.StandardOutputEncoding ?? GetEncoding((int)Interop.Kernel32.GetConsoleOutputCP());
_standardOutput = new StreamReader(new FileStream(standardOutputReadPipeHandle, FileAccess.Read, 4096, false), enc, true, 4096);
}
if (startInfo.RedirectStandardError)
{
Encoding enc = startInfo.StandardErrorEncoding ?? GetEncoding((int)Interop.Kernel32.GetConsoleOutputCP());
_standardError = new StreamReader(new FileStream(standardErrorReadPipeHandle, FileAccess.Read, 4096, false), enc, true, 4096);
}
bool ret = false;
if (!procSH.IsInvalid)
{
SetProcessHandle(procSH);
SetProcessId((int)processInfo.dwProcessId);
threadSH.Dispose();
ret = true;
}
return(ret);
}
public void Start(
Guid payloadGuid,
ArraySegment <byte> payloadData,
SafeFileHandle inheritableReportHandle,
string dllNameX64,
string dllNameX86)
{
using (m_syncSemaphore.AcquireSemaphore())
{
if (m_starting || m_disposed)
{
throw new InvalidOperationException("Cannot invoke start process more than once or after this instance has been Disposed.");
}
m_starting = true;
// The process creation flags
// We use CREATE_DEFAULT_ERROR_MODE to ensure that the hard error mode of the child process (i.e., GetErrorMode)
// is deterministic. Inheriting error mode is the default, but there may be some concurrent operation that temporarily
// changes it (process global). The CLR has been observed to do so.
// We use CREATE_NO_WINDOW in case BuildXL is attached to a console windows to prevent child processes from messing up
// the console window. If BuildXL itself is started without a console window the flag is not set to prevent creating
// extra conhost.exe processes.
int creationFlags =
((s_consoleWindow == IntPtr.Zero && !this.m_disableConHostSharing) ?
0 : Native.Processes.ProcessUtilities.CREATE_NO_WINDOW) | Native.Processes.ProcessUtilities.CREATE_DEFAULT_ERROR_MODE;
SafeFileHandle standardInputWritePipeHandle = null;
SafeFileHandle standardOutputReadPipeHandle = null;
SafeFileHandle standardErrorReadPipeHandle = null;
try
{
// set up the environment block parameter
var environmentHandle = default(GCHandle);
var payloadHandle = default(GCHandle);
SafeFileHandle hStdInput = null;
SafeFileHandle hStdOutput = null;
SafeFileHandle hStdError = null;
SafeThreadHandle threadHandle = null;
try
{
IntPtr environmentPtr = IntPtr.Zero;
if (m_unicodeEnvironmentBlock != null)
{
creationFlags |= Native.Processes.ProcessUtilities.CREATE_UNICODE_ENVIRONMENT;
environmentHandle = GCHandle.Alloc(m_unicodeEnvironmentBlock, GCHandleType.Pinned);
environmentPtr = environmentHandle.AddrOfPinnedObject();
}
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritRead,
Pipes.PipeFlags.WriteSideAsync,
readHandle: out hStdInput,
writeHandle: out standardInputWritePipeHandle);
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritWrite,
Pipes.PipeFlags.ReadSideAsync,
readHandle: out standardOutputReadPipeHandle,
writeHandle: out hStdOutput);
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritWrite,
Pipes.PipeFlags.ReadSideAsync,
readHandle: out standardErrorReadPipeHandle,
writeHandle: out hStdError);
// We want a per-process job primarily. If nested job support is not available, then we make sure to not have a BuildXL-level job.
if (JobObject.OSSupportsNestedJobs)
{
JobObject.SetTerminateOnCloseOnCurrentProcessJob();
}
// Initialize the injector
m_processInjector = new ProcessTreeContext(payloadGuid, inheritableReportHandle, payloadData, dllNameX64, dllNameX86, m_loggingContext);
// If path remapping is enabled then we wrap the job object in a container, so the filter drivers get
// configured (and they get cleaned up when the container is disposed)
if (m_containerConfiguration.IsIsolationEnabled)
{
m_job = new Container(
name: null,
containerConfiguration: m_containerConfiguration,
loggingContext: m_loggingContext);
}
else
{
m_job = new JobObject(null);
}
// We want the effects of SEM_NOGPFAULTERRORBOX on all children (but can't set that with CreateProcess).
// That's not set otherwise (even if set in this process) due to CREATE_DEFAULT_ERROR_MODE above.
m_job.SetLimitInformation(terminateOnClose: true, failCriticalErrors: false);
m_processInjector.Listen();
if (m_containerConfiguration.IsIsolationEnabled)
{
// After calling SetLimitInformation, start up the container if present
// This will throw if the container is not set up properly
m_job.StartContainerIfPresent();
}
// The call to the CreateDetouredProcess below will add a newly created process to the job.
System.Diagnostics.Stopwatch m_startUpTimeWatch = System.Diagnostics.Stopwatch.StartNew();
var detouredProcessCreationStatus =
Native.Processes.ProcessUtilities.CreateDetouredProcess(
m_commandLine,
creationFlags,
environmentPtr,
m_workingDirectory,
hStdInput,
hStdOutput,
hStdError,
m_job,
m_processInjector.Injector,
m_containerConfiguration.IsIsolationEnabled,
out m_processHandle,
out threadHandle,
out m_processId,
out int errorCode);
m_startUpTimeWatch.Stop();
m_startUpTime = m_startUpTimeWatch.ElapsedMilliseconds;
if (detouredProcessCreationStatus != CreateDetouredProcessStatus.Succeeded)
{
// TODO: Indicating user vs. internal errors (and particular phase failures e.g. adding to job object or injecting detours)
// is good progress on the transparency into these failures. But consider making this indication visible beyond this
// function without throwing exceptions; consider returning a structured value or logging events.
string message;
if (detouredProcessCreationStatus.IsDetoursSpecific())
{
message = string.Format(
CultureInfo.InvariantCulture,
"Internal error during process creation: {0:G}",
detouredProcessCreationStatus);
}
else if (detouredProcessCreationStatus == CreateDetouredProcessStatus.ProcessCreationFailed)
{
message = "Process creation failed";
}
else
{
message = string.Format(
CultureInfo.InvariantCulture,
"Process creation failed: {0:G}",
detouredProcessCreationStatus);
}
throw new BuildXLException(
message,
new NativeWin32Exception(errorCode));
}
// TODO: We should establish good post-conditions for CreateDetouredProcess. As a temporary measure, it would be nice
// to determine if we are sometimes getting invalid process handles with retVal == true. So for now we differentiate
// that possible case with a unique error string.
if (m_processHandle.IsInvalid)
{
throw new BuildXLException("Unable to start or detour a process (process handle invalid)", new NativeWin32Exception(errorCode));
}
}
finally
{
if (environmentHandle.IsAllocated)
{
environmentHandle.Free();
}
if (payloadHandle.IsAllocated)
{
payloadHandle.Free();
}
if (hStdInput != null && !hStdInput.IsInvalid)
{
hStdInput.Dispose();
}
if (hStdOutput != null && !hStdOutput.IsInvalid)
{
hStdOutput.Dispose();
}
if (hStdError != null && !hStdError.IsInvalid)
{
hStdError.Dispose();
}
if (inheritableReportHandle != null && !inheritableReportHandle.IsInvalid)
{
inheritableReportHandle.Dispose();
}
if (threadHandle != null && !threadHandle.IsInvalid)
{
threadHandle.Dispose();
}
}
var standardInputStream = new FileStream(standardInputWritePipeHandle, FileAccess.Write, m_bufferSize, isAsync: true);
m_standardInputWriter = new StreamWriter(standardInputStream, m_standardInputEncoding, m_bufferSize)
{
AutoFlush = true
};
var standardOutputFile = AsyncFileFactory.CreateAsyncFile(
standardOutputReadPipeHandle,
FileDesiredAccess.GenericRead,
ownsHandle: true,
kind: FileKind.Pipe);
m_outputReader = new AsyncPipeReader(standardOutputFile, m_outputDataReceived, m_standardOutputEncoding, m_bufferSize);
m_outputReader.BeginReadLine();
var standardErrorFile = AsyncFileFactory.CreateAsyncFile(
standardErrorReadPipeHandle,
FileDesiredAccess.GenericRead,
ownsHandle: true,
kind: FileKind.Pipe);
m_errorReader = new AsyncPipeReader(standardErrorFile, m_errorDataReceived, m_standardErrorEncoding, m_bufferSize);
m_errorReader.BeginReadLine();
Contract.Assert(!m_processHandle.IsInvalid);
m_processWaitHandle = new SafeWaitHandleFromSafeHandle(m_processHandle);
m_waiting = true;
TimeSpan timeout = m_timeout ?? Timeout.InfiniteTimeSpan;
m_registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(
m_processWaitHandle,
CompletionCallback,
null,
timeout,
true);
m_started = true;
}
catch (Exception)
{
// Dispose pipe handles in case they are not assigned to streams.
if (m_standardInputWriter == null)
{
standardInputWritePipeHandle?.Dispose();
}
if (m_outputReader == null)
{
standardOutputReadPipeHandle?.Dispose();
}
if (m_errorReader == null)
{
standardErrorReadPipeHandle?.Dispose();
}
throw;
}
}
}
/// <summary>
/// Calls <see cref="CreateProcessAsUserW"/> and safely stores the obtained handles.
/// </summary>
/// <param name="userToken">Token to impersonate the external process</param>
/// <param name="createFlags">Flags used to create the external process</param>
/// <param name="startupInfo">Startup information used to create the external process</param>
/// <returns><c>true</c> if the call to <see cref="CreateProcessAsUserW"/> was successful; otherwise <c>false</c></returns>
private bool SafeCreateProcessAsUserW(IntPtr userToken, CreateProcessFlags createFlags, StartupInfo startupInfo)
{
_processHandle = new SafeProcessHandle();
var threadHandle = new SafeThreadHandle();
bool success;
// The following is necessary to make sure that processInformation.hProcess and processInformation.hThread
// are safely stored in the respective SafeHandle classes. It is, unfortunately, not possible to define
// processInformation.hProcess and processInformation.hThread as SafeHandles and use processInformation
// as an out parameter, because the unmanaged code is not able to create these objects. We therefore use
// IntPtr and ensure in the following that the IntPtrs are stored in SafeHandle objects immediately after
// they have been obtained.
// For details see here: https://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.runtimehelpers.prepareconstrainedregions(v=vs.110).aspx
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally
{
ProcessInformation processInformation;
success = CreateProcessAsUserW(userToken, null, GetCommandLine(), IntPtr.Zero, IntPtr.Zero, true, createFlags, IntPtr.Zero, null, startupInfo, out processInformation);
if (success)
{
_processHandle.InitialSetHandle(processInformation.hProcess);
threadHandle.InitialSetHandle(processInformation.hThread);
_processId = processInformation.dwProcessId;
}
}
// We don't need the threadHandle and therefore immediately dispose it.
threadHandle.Dispose();
if (success)
return true;
_processHandle.Dispose();
var error = Marshal.GetLastWin32Error();
_debugLogger.Error("AsyncImpersonationProcess ({0}): Cannot start process. ErrorCode: {1} ({2})", StartInfo.FileName, error, new Win32Exception(error).Message);
return false;
}
public unsafe IChildProcessStateHolder SpawnProcess(
ref ChildProcessStartInfoInternal startInfo,
string resolvedPath,
SafeHandle stdIn,
SafeHandle stdOut,
SafeHandle stdErr)
{
var arguments = startInfo.Arguments;
var environmentVariables = startInfo.EnvironmentVariables;
var workingDirectory = startInfo.WorkingDirectory;
var flags = startInfo.Flags;
Debug.Assert(startInfo.CreateNewConsole || ConsolePal.HasConsoleWindow());
var commandLine = WindowsCommandLineUtil.MakeCommandLine(resolvedPath, arguments ?? Array.Empty <string>(), !flags.HasDisableArgumentQuoting());
var environmentBlock = startInfo.UseCustomEnvironmentVariables ? WindowsEnvironmentBlockUtil.MakeEnvironmentBlock(environmentVariables.Span) : null;
// Objects that need cleanup
InputWriterOnlyPseudoConsole?pseudoConsole = null;
SafeJobObjectHandle? jobObjectHandle = null;
SafeProcessHandle? processHandle = null;
SafeThreadHandle? threadHandle = null;
try
{
pseudoConsole = startInfo.CreateNewConsole ? InputWriterOnlyPseudoConsole.Create() : null;
if (pseudoConsole is not null && flags.HasUseCustomCodePage())
{
ChangeCodePage(pseudoConsole, startInfo.CodePage, workingDirectory);
}
bool killOnClose = startInfo.AllowSignal && WindowsVersion.NeedsWorkaroundForWindows1809;
jobObjectHandle = CreateJobObject(killOnClose, startInfo.DisableWindowsErrorReportingDialog);
using var inheritableHandleStore = new InheritableHandleStore(3);
var childStdIn = stdIn != null?inheritableHandleStore.Add(stdIn) : null;
var childStdOut = stdOut != null?inheritableHandleStore.Add(stdOut) : null;
var childStdErr = stdErr != null?inheritableHandleStore.Add(stdErr) : null;
IntPtr jobObjectHandles = jobObjectHandle.DangerousGetHandle();
Span <IntPtr> inheritableHandles = stackalloc IntPtr[inheritableHandleStore.Count];
inheritableHandleStore.DangerousGetHandles(inheritableHandles);
fixed(IntPtr *pInheritableHandles = inheritableHandles)
{
using var attr = new ProcThreadAttributeList(3);
if (pseudoConsole is not null)
{
attr.UpdatePseudoConsole(pseudoConsole.Handle.DangerousGetHandle());
}
attr.UpdateHandleList(pInheritableHandles, inheritableHandles.Length);
attr.UpdateJobList(&jobObjectHandles, 1);
const int CreationFlags =
Kernel32.CREATE_UNICODE_ENVIRONMENT
| Kernel32.EXTENDED_STARTUPINFO_PRESENT;
int processId;
(processId, processHandle, threadHandle) = InvokeCreateProcess(
commandLine,
CreationFlags,
environmentBlock,
workingDirectory,
childStdIn,
childStdOut,
childStdErr,
attr);
return(new WindowsChildProcessState(processId, processHandle, jobObjectHandle, pseudoConsole, startInfo.AllowSignal));
}
}
catch
{
if (processHandle is not null)
{
Kernel32.TerminateProcess(processHandle, -1);
processHandle.Dispose();
}
pseudoConsole?.Dispose();
jobObjectHandle?.Dispose();
throw;
}
finally
{
threadHandle?.Dispose();
}
}
