/// <summary> /// Starts a child process as specified in <paramref name="startInfo"/>. /// </summary> /// <param name="startInfo"><see cref="ChildProcessStartInfo"/>.</param> /// <returns>The started process.</returns> /// <exception cref="ArgumentException"><paramref name="startInfo"/> has an invalid value.</exception> /// <exception cref="ArgumentNullException"><paramref name="startInfo"/> is null.</exception> /// <exception cref="FileNotFoundException">The executable not found.</exception> /// <exception cref="IOException">Failed to open a specified file.</exception> /// <exception cref="AsmichiChildProcessLibraryCrashedException">The operation failed due to critical disturbance.</exception> /// <exception cref="Win32Exception">Another kind of native errors.</exception> public static IChildProcess Start(ChildProcessStartInfo startInfo) { _ = startInfo ?? throw new ArgumentNullException(nameof(startInfo)); var startInfoInternal = new ChildProcessStartInfoInternal(startInfo); _ = startInfoInternal.FileName ?? throw new ArgumentException("ChildProcessStartInfo.FileName must not be null.", nameof(startInfo)); _ = startInfoInternal.Arguments ?? throw new ArgumentException("ChildProcessStartInfo.Arguments must not be null.", nameof(startInfo)); var flags = startInfoInternal.Flags; if (flags.HasUseCustomCodePage() && !flags.HasCreateNewConsole()) { throw new ArgumentException( $"{nameof(ChildProcessFlags.UseCustomCodePage)} requires {nameof(ChildProcessFlags.CreateNewConsole)}.", nameof(startInfo)); } var resolvedPath = ResolveExecutablePath(startInfoInternal.FileName, startInfoInternal.Flags); using var stdHandles = new PipelineStdHandleCreator(ref startInfoInternal); IChildProcessStateHolder processState; try { processState = ChildProcessContext.Shared.SpawnProcess( startInfo: ref startInfoInternal, resolvedPath: resolvedPath, stdIn: stdHandles.PipelineStdIn, stdOut: stdHandles.PipelineStdOut, stdErr: stdHandles.PipelineStdErr); } catch (Win32Exception ex) { if (EnvironmentPal.IsFileNotFoundError(ex.NativeErrorCode)) { ThrowHelper.ThrowExecutableNotFoundException(resolvedPath, startInfoInternal.Flags, ex); } // Win32Exception does not provide detailed information by its type. // The NativeErrorCode and Message property should be enough because normally there is // nothing we can do to programmatically recover from this error. throw; } var process = new ChildProcessImpl(processState, stdHandles.InputStream, stdHandles.OutputStream, stdHandles.ErrorStream); stdHandles.DetachStreams(); return(process); }
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 = environmentVariables != null?WindowsEnvironmentBlockUtil.MakeEnvironmentBlock(environmentVariables) : null; var pseudoConsole = startInfo.CreateNewConsole ? InputWriterOnlyPseudoConsole.Create() : null; try { if (pseudoConsole is { } && flags.HasUseCustomCodePage()) { ChangeCodePage(pseudoConsole, startInfo.CodePage, workingDirectory); } 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; Span <IntPtr> inheritableHandles = stackalloc IntPtr[inheritableHandleStore.Count]; inheritableHandleStore.DangerousGetHandles(inheritableHandles); fixed(IntPtr *pInheritableHandles = inheritableHandles) { using var attr = new ProcThreadAttributeList(2); if (pseudoConsole is { })
public 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; Span <int> fds = stackalloc int[3]; int handleCount = 0; uint flags = 0; if (stdIn != null) { fds[handleCount++] = stdIn.DangerousGetHandle().ToInt32(); flags |= RequestFlagsRedirectStdin; } if (stdOut != null) { fds[handleCount++] = stdOut.DangerousGetHandle().ToInt32(); flags |= RequestFlagsRedirectStdout; } if (stdErr != null) { fds[handleCount++] = stdErr.DangerousGetHandle().ToInt32(); flags |= RequestFlagsRedirectStderr; } using var bw = new MyBinaryWriter(InitialBufferCapacity); var stateHolder = UnixChildProcessState.Create(); try { bw.Write(0U); // Dummy length to be rewritten later bw.Write(stateHolder.State.Token); bw.Write(flags); bw.Write(workingDirectory); bw.Write(resolvedPath); bw.Write((uint)(arguments.Count + 1)); bw.Write(resolvedPath); foreach (var x in arguments) { bw.Write(x); } if (environmentVariables == null) { bw.Write(0U); } else { bw.Write((uint)environmentVariables.Count); foreach (var(name, value) in environmentVariables) { bw.WriteEnvironmentVariable(name, value); } } bw.RewritePrefixedLength(); var subchannel = _helperProcess.RentSubchannelAsync(default).AsTask().GetAwaiter().GetResult();
public PipelineStdHandleCreator(ref ChildProcessStartInfoInternal startInfo) { var stdInputRedirection = startInfo.StdInputRedirection; var stdOutputRedirection = startInfo.StdOutputRedirection; var stdErrorRedirection = startInfo.StdErrorRedirection; var stdInputFile = startInfo.StdInputFile; var stdOutputFile = startInfo.StdOutputFile; var stdErrorFile = startInfo.StdErrorFile; var stdInputHandle = startInfo.StdInputHandle; var stdOutputHandle = startInfo.StdOutputHandle; var stdErrorHandle = startInfo.StdErrorHandle; if (stdInputRedirection == InputRedirection.Handle && stdInputHandle == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdInputHandle)} must not be null.", nameof(startInfo)); } if (stdInputRedirection == InputRedirection.File && stdInputFile == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdInputFile)} must not be null.", nameof(startInfo)); } if (stdOutputRedirection == OutputRedirection.Handle && stdOutputHandle == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdOutputHandle)} must not be null.", nameof(startInfo)); } if (IsFileRedirection(stdOutputRedirection) && stdOutputFile == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdOutputFile)} must not be null.", nameof(startInfo)); } if (stdErrorRedirection == OutputRedirection.Handle && stdErrorHandle == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdErrorHandle)} must not be null.", nameof(startInfo)); } if (IsFileRedirection(stdErrorRedirection) && stdErrorFile == null) { throw new ArgumentException($"{nameof(ChildProcessStartInfo.StdErrorFile)} must not be null.", nameof(startInfo)); } bool redirectingToSameFile = IsFileRedirection(stdOutputRedirection) && IsFileRedirection(stdErrorRedirection) && stdOutputFile == stdErrorFile; if (redirectingToSameFile && stdErrorRedirection != stdOutputRedirection) { throw new ArgumentException( "StdOutputRedirection and StdErrorRedirection must be the same value when both stdout and stderr redirect to the same file.", nameof(startInfo)); } try { if (stdInputRedirection == InputRedirection.InputPipe) { (InputStream, _inputReadPipe) = FilePal.CreatePipePairWithAsyncServerSide(System.IO.Pipes.PipeDirection.Out); } if (stdOutputRedirection == OutputRedirection.OutputPipe || stdErrorRedirection == OutputRedirection.OutputPipe) { (OutputStream, _outputWritePipe) = FilePal.CreatePipePairWithAsyncServerSide(System.IO.Pipes.PipeDirection.In); } if (stdOutputRedirection == OutputRedirection.ErrorPipe || stdErrorRedirection == OutputRedirection.ErrorPipe) { (ErrorStream, _errorWritePipe) = FilePal.CreatePipePairWithAsyncServerSide(System.IO.Pipes.PipeDirection.In); } PipelineStdIn = ChooseInput( stdInputRedirection, stdInputFile, stdInputHandle, _inputReadPipe, startInfo.CreateNewConsole); PipelineStdOut = ChooseOutput( stdOutputRedirection, stdOutputFile, stdOutputHandle, _outputWritePipe, _errorWritePipe, startInfo.CreateNewConsole); if (redirectingToSameFile) { PipelineStdErr = PipelineStdOut; } else { PipelineStdErr = ChooseOutput( stdErrorRedirection, stdErrorFile, stdErrorHandle, _outputWritePipe, _errorWritePipe, startInfo.CreateNewConsole); } } catch { Dispose(); throw; } }