StartWithCreateProcess()

unsafe bool System.Diagnostics.Process.StartWithCreateProcess ( ProcessStartInfo startInfo )

inlineprivate

Definition at line 1739 of file Process.cs.

    {
        Span<char> initialBuffer = stackalloc char[256];
        System.Text.ValueStringBuilder commandLine = new System.Text.ValueStringBuilder(initialBuffer);
        BuildCommandLine(startInfo, ref commandLine);
        global::Interop.Kernel32.STARTUPINFO lpStartupInfo = default(global::Interop.Kernel32.STARTUPINFO);
        global::Interop.Kernel32.PROCESS_INFORMATION lpProcessInformation = default(global::Interop.Kernel32.PROCESS_INFORMATION);
        global::Interop.Kernel32.SECURITY_ATTRIBUTES procSecAttrs = default(global::Interop.Kernel32.SECURITY_ATTRIBUTES);
        SafeProcessHandle safeProcessHandle = new SafeProcessHandle();
        SafeFileHandle parentHandle = null;
        SafeFileHandle childHandle = null;
        SafeFileHandle parentHandle2 = null;
        SafeFileHandle childHandle2 = null;
        SafeFileHandle parentHandle3 = null;
        SafeFileHandle childHandle3 = null;
        lock (s_createProcessLock)
        {
            try
            {
                lpStartupInfo.cb = sizeof(global::Interop.Kernel32.STARTUPINFO);
                if (startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError)
                {
                    if (startInfo.RedirectStandardInput)
                    {
                        CreatePipe(out parentHandle, out childHandle, parentInputs: true);
                    }
                    else
                    {
                        childHandle = new SafeFileHandle(global::Interop.Kernel32.GetStdHandle(-10), ownsHandle: false);
                    }
                    if (startInfo.RedirectStandardOutput)
                    {
                        CreatePipe(out parentHandle2, out childHandle2, parentInputs: false);
                    }
                    else
                    {
                        childHandle2 = new SafeFileHandle(global::Interop.Kernel32.GetStdHandle(-11), ownsHandle: false);
                    }
                    if (startInfo.RedirectStandardError)
                    {
                        CreatePipe(out parentHandle3, out childHandle3, parentInputs: false);
                    }
                    else
                    {
                        childHandle3 = new SafeFileHandle(global::Interop.Kernel32.GetStdHandle(-12), ownsHandle: false);
                    }
                    lpStartupInfo.hStdInput = childHandle.DangerousGetHandle();
                    lpStartupInfo.hStdOutput = childHandle2.DangerousGetHandle();
                    lpStartupInfo.hStdError = childHandle3.DangerousGetHandle();
                    lpStartupInfo.dwFlags = 256;
                }
                int num = 0;
                if (startInfo.CreateNoWindow)
                {
                    num |= 0x8000000;
                }
                string text = null;
                if (startInfo._environmentVariables != null)
                {
                    num |= 0x400;
                    text = GetEnvironmentVariablesBlock(startInfo._environmentVariables);
                }
                string text2 = startInfo.WorkingDirectory;
                if (text2.Length == 0)
                {
                    text2 = null;
                }
                int num2 = 0;
                bool flag;
                if (startInfo.UserName.Length != 0)
                {
                    if (startInfo.Password != null && startInfo.PasswordInClearText != null)
                    {
                        throw new ArgumentException(System.SR.CantSetDuplicatePassword);
                    }
                    global::Interop.Advapi32.LogonFlags logonFlags = (global::Interop.Advapi32.LogonFlags)0;
                    if (startInfo.LoadUserProfile)
                    {
                        logonFlags = global::Interop.Advapi32.LogonFlags.LOGON_WITH_PROFILE;
                    }
                    fixed (char* ptr = startInfo.PasswordInClearText ?? string.Empty)
                    {
                        fixed (char* ptr2 = text)
                        {
                            fixed (char* cmdLine = &commandLine.GetPinnableReference(terminate: true))
                            {
                                IntPtr intPtr = ((startInfo.Password != null) ? Marshal.SecureStringToGlobalAllocUnicode(startInfo.Password) : IntPtr.Zero);
                                try
                                {
                                    flag = global::Interop.Advapi32.CreateProcessWithLogonW(startInfo.UserName, startInfo.Domain, (intPtr != IntPtr.Zero) ? intPtr : ((IntPtr)ptr), logonFlags, null, cmdLine, num, (IntPtr)ptr2, text2, ref lpStartupInfo, ref lpProcessInformation);
                                    if (!flag)
                                    {
                                        num2 = Marshal.GetLastWin32Error();
                                    }
                                }
                                finally
                                {
                                    if (intPtr != IntPtr.Zero)
                                    {
                                        Marshal.ZeroFreeGlobalAllocUnicode(intPtr);
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    fixed (char* ptr3 = text)
                    {
                        fixed (char* lpCommandLine = &commandLine.GetPinnableReference(terminate: true))
                        {
                            flag = global::Interop.Kernel32.CreateProcess(null, lpCommandLine, ref procSecAttrs, ref procSecAttrs, bInheritHandles: true, num, (IntPtr)ptr3, text2, ref lpStartupInfo, ref lpProcessInformation);
                            if (!flag)
                            {
                                num2 = Marshal.GetLastWin32Error();
                            }
                        }
                    }
                }
                if (lpProcessInformation.hProcess != IntPtr.Zero && lpProcessInformation.hProcess != new IntPtr(-1))
                {
                    Marshal.InitHandle(safeProcessHandle, lpProcessInformation.hProcess);
                }
                if (lpProcessInformation.hThread != IntPtr.Zero && lpProcessInformation.hThread != new IntPtr(-1))
                {
                    global::Interop.Kernel32.CloseHandle(lpProcessInformation.hThread);
                }
                if (!flag)
                {
                    string errorMessage = ((num2 == 193 || num2 == 216) ? System.SR.InvalidApplication : GetErrorMessage(num2));
                    throw CreateExceptionForErrorStartingProcess(errorMessage, num2, startInfo.FileName, text2);
                }
            }
            finally
            {
                childHandle?.Dispose();
                childHandle2?.Dispose();
                childHandle3?.Dispose();
            }
        }
        if (startInfo.RedirectStandardInput)
        {
            Encoding encoding = startInfo.StandardInputEncoding ?? GetEncoding((int)global::Interop.Kernel32.GetConsoleCP());
            _standardInput = new StreamWriter(new FileStream(parentHandle, FileAccess.Write, 4096, isAsync: false), encoding, 4096);
            _standardInput.AutoFlush = true;
        }
        if (startInfo.RedirectStandardOutput)
        {
            Encoding encoding2 = startInfo.StandardOutputEncoding ?? GetEncoding((int)global::Interop.Kernel32.GetConsoleOutputCP());
            _standardOutput = new StreamReader(new FileStream(parentHandle2, FileAccess.Read, 4096, isAsync: false), encoding2, detectEncodingFromByteOrderMarks: true, 4096);
        }
        if (startInfo.RedirectStandardError)
        {
            Encoding encoding3 = startInfo.StandardErrorEncoding ?? GetEncoding((int)global::Interop.Kernel32.GetConsoleOutputCP());
            _standardError = new StreamReader(new FileStream(parentHandle3, FileAccess.Read, 4096, isAsync: false), encoding3, detectEncodingFromByteOrderMarks: true, 4096);
        }
        commandLine.Dispose();
        if (safeProcessHandle.IsInvalid)
        {
            return false;
        }
        SetProcessHandle(safeProcessHandle);
        SetProcessId(lpProcessInformation.dwProcessId);
        return true;
    }

References System.Diagnostics.Process._standardError, System.Diagnostics.Process._standardInput, System.Diagnostics.Process._standardOutput, System.Diagnostics.Process.BuildCommandLine(), System.SR.CantSetDuplicatePassword, System.Diagnostics.Process.CreateExceptionForErrorStartingProcess(), System.Diagnostics.Process.CreatePipe(), System.Runtime.Serialization.Dictionary, System.Diagnostics.Process.GetEncoding(), System.Diagnostics.Process.GetEnvironmentVariablesBlock(), System.Diagnostics.Process.GetErrorMessage(), System.Runtime.InteropServices.Marshal.GetLastWin32Error(), System.Runtime.InteropServices.Marshal.InitHandle(), System.SR.InvalidApplication, System.Diagnostics.Process.s_createProcessLock, System.Runtime.InteropServices.Marshal.SecureStringToGlobalAllocUnicode(), System.Diagnostics.Process.SetProcessHandle(), System.Diagnostics.Process.SetProcessId(), System.text, System.IntPtr.Zero, and System.Runtime.InteropServices.Marshal.ZeroFreeGlobalAllocUnicode().

Referenced by System.Diagnostics.Process.StartCore().