private void CreatePipe(out SafeFileHandle parentHandle, out SafeFileHandle childHandle, bool parentInputs)
{
NativeMethods.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES = new NativeMethods.SECURITY_ATTRIBUTES();
sECURITY_ATTRIBUTES.bInheritHandle = true;
SafeFileHandle safeFileHandle = null;
try
{
if (parentInputs)
{
Process2.CreatePipeWithSecurityAttributes(out childHandle, out safeFileHandle, sECURITY_ATTRIBUTES, 0);
}
else
{
Process2.CreatePipeWithSecurityAttributes(out safeFileHandle, out childHandle, sECURITY_ATTRIBUTES, 0);
}
if (!NativeMethods.DuplicateHandle(new HandleRef(this, NativeMethods.GetCurrentProcess()), safeFileHandle, new HandleRef(this, NativeMethods.GetCurrentProcess()), out parentHandle, 0, false, 2))
{
throw new Win32Exception();
}
}
finally
{
if (safeFileHandle != null && !safeFileHandle.IsInvalid)
{
safeFileHandle.Close();
}
}
}
public void StartProcessAndWait(ProcessStartInfo info, IProcessOutputReader processReader)
{
Process2.Process2 process = new Process2.Process2() { StartInfo = info };
process.OutputDataReceived += (sender, args) => processReader.OnDataReceived(args.Data);
process.Start();
process.BeginOutputReadLine();
process.WaitForExit();
}
private void Init(Process2 process, Stream stream, UserCallBack callback, Encoding encoding, int bufferSize)
{
this.process = process;
this.stream = stream;
this.encoding = encoding;
userCallBack = callback;
decoder = encoding.GetDecoder();
if (bufferSize < 128)
{
bufferSize = 128;
}
byteBuffer = new byte[bufferSize];
maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize);
charBuffer = new char[maxCharsPerBuffer];
cancelOperation = false;
eofEvent = new ManualResetEvent(false);
sb = null;
lastCarriageReturn = false;
}
internal AsyncStreamReader(Process2 process, Stream stream, UserCallBack callback, Encoding encoding, int bufferSize)
{
Init(process, stream, callback, encoding, bufferSize);
messageQueue = new Queue();
}
internal AsyncStreamReader(Process2 process, Stream stream, UserCallBack callback, Encoding encoding)
: this(process, stream, callback, encoding, 1024)
{
}
private bool StartWithCreateProcess(ProcessStartInfo startInfo)
{
if (startInfo.StandardOutputEncoding != null && !startInfo.RedirectStandardOutput)
{
throw new InvalidOperationException("StandardOutputEncodingNotAllowed");
}
if (startInfo.StandardErrorEncoding != null && !startInfo.RedirectStandardError)
{
throw new InvalidOperationException("StandardErrorEncodingNotAllowed");
}
StringBuilder stringBuilder = Process2.BuildCommandLine(startInfo.FileName, startInfo.Arguments);
NativeMethods.STARTUPINFO sTARTUPINFO = new NativeMethods.STARTUPINFO();
SafeNativeMethods.PROCESS_INFORMATION pROCESS_INFORMATION = new SafeNativeMethods.PROCESS_INFORMATION();
SafeProcessHandle safeProcessHandle = new SafeProcessHandle();
SafeThreadHandle safeThreadHandle = new SafeThreadHandle();
int num = 0;
SafeFileHandle handle = null;
SafeFileHandle handle2 = null;
SafeFileHandle handle3 = null;
GCHandle gCHandle = default(GCHandle);
lock (Process2.s_CreateProcessLock)
{
try
{
if (startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError)
{
if (startInfo.RedirectStandardInput)
{
CreatePipe(out handle, out sTARTUPINFO.hStdInput, true);
}
else
{
sTARTUPINFO.hStdInput = new SafeFileHandle(NativeMethods.GetStdHandle(-10), false);
}
if (startInfo.RedirectStandardOutput)
{
CreatePipe(out handle2, out sTARTUPINFO.hStdOutput, false);
}
else
{
sTARTUPINFO.hStdOutput = new SafeFileHandle(NativeMethods.GetStdHandle(-11), false);
}
if (startInfo.RedirectStandardError)
{
CreatePipe(out handle3, out sTARTUPINFO.hStdError, false);
}
else
{
sTARTUPINFO.hStdError = sTARTUPINFO.hStdOutput;
}
sTARTUPINFO.dwFlags = 256;
}
int num2 = 0;
if (startInfo.CreateNoWindow)
{
num2 |= 134217728;
}
IntPtr intPtr = (IntPtr)0;
//if (startInfo.environmentVariables != null)
//{
// bool unicode = false;
// if (ProcessManager.IsNt)
// {
// num2 |= 1024;
// unicode = true;
// }
// byte[] value = EnvironmentBlock.ToByteArray(startInfo.environmentVariables, unicode);
// gCHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
// intPtr = gCHandle.AddrOfPinnedObject();
//}
string text = startInfo.WorkingDirectory;
if (text == string.Empty)
{
text = Environment.CurrentDirectory;
}
bool flag2;
//if (startInfo.UserName.Length != 0)
//{
// NativeMethods.LogonFlags logonFlags = (NativeMethods.LogonFlags)0;
// if (startInfo.LoadUserProfile)
// {
// logonFlags = NativeMethods.LogonFlags.LOGON_WITH_PROFILE;
// }
// IntPtr intPtr2 = IntPtr.Zero;
// try
// {
// if (startInfo.Password == null)
// {
// intPtr2 = Marshal.StringToCoTaskMemUni(string.Empty);
// }
// else
// {
// intPtr2 = Marshal.SecureStringToCoTaskMemUnicode(startInfo.Password);
// }
// RuntimeHelpers.PrepareConstrainedRegions();
// try
// {
// }
// finally
// {
// flag2 = NativeMethods.CreateProcessWithLogonW(startInfo.UserName, startInfo.Domain, intPtr2, logonFlags, null, stringBuilder, num2, intPtr, text, sTARTUPINFO, pROCESS_INFORMATION);
// if (!flag2)
// {
// num = Marshal.GetLastWin32Error();
// }
// if (pROCESS_INFORMATION.hProcess != (IntPtr)0 && pROCESS_INFORMATION.hProcess != NativeMethods.INVALID_HANDLE_VALUE)
// {
// safeProcessHandle.InitialSetHandle(pROCESS_INFORMATION.hProcess);
// }
// if (pROCESS_INFORMATION.hThread != (IntPtr)0 && pROCESS_INFORMATION.hThread != NativeMethods.INVALID_HANDLE_VALUE)
// {
// safeThreadHandle.InitialSetHandle(pROCESS_INFORMATION.hThread);
// }
// }
// if (flag2)
// {
// goto IL_3B9;
// }
// if (num == 193 || num == 216)
// {
// throw new Win32Exception(num, SR.GetString("InvalidApplication"));
// }
// throw new Win32Exception(num);
// }
// finally
// {
// if (intPtr2 != IntPtr.Zero)
// {
// Marshal.ZeroFreeCoTaskMemUnicode(intPtr2);
// }
// }
//}
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
flag2 = NativeMethods.CreateProcess(null, stringBuilder, null, null, true, num2, intPtr, text, sTARTUPINFO, pROCESS_INFORMATION);
if (!flag2)
{
num = Marshal.GetLastWin32Error();
}
if (pROCESS_INFORMATION.hProcess != (IntPtr)0 && pROCESS_INFORMATION.hProcess != NativeMethods.INVALID_HANDLE_VALUE)
{
safeProcessHandle.InitialSetHandle(pROCESS_INFORMATION.hProcess);
}
if (pROCESS_INFORMATION.hThread != (IntPtr)0 && pROCESS_INFORMATION.hThread != NativeMethods.INVALID_HANDLE_VALUE)
{
safeThreadHandle.InitialSetHandle(pROCESS_INFORMATION.hThread);
}
}
if (!flag2)
{
if (num == 193 || num == 216)
{
throw new Win32Exception(num, "InvalidApplication");
}
throw new Win32Exception(num);
}
}
finally
{
if (gCHandle.IsAllocated)
{
gCHandle.Free();
}
sTARTUPINFO.Dispose();
}
}
if (startInfo.RedirectStandardInput)
{
standardInput = new StreamWriter(new FileStream(handle, FileAccess.Write, 4096, false), Console.InputEncoding, 4096);
standardInput.AutoFlush = true;
}
if (startInfo.RedirectStandardOutput)
{
Encoding encoding = (startInfo.StandardOutputEncoding != null) ? startInfo.StandardOutputEncoding : Console.OutputEncoding;
standardOutput = new StreamReader(new FileStream(handle2, FileAccess.Read, 4096, false), encoding, true, 4096);
}
if (startInfo.RedirectStandardError)
{
Encoding encoding2 = (startInfo.StandardErrorEncoding != null) ? startInfo.StandardErrorEncoding : Console.OutputEncoding;
standardError = new StreamReader(new FileStream(handle3, FileAccess.Read, 4096, false), encoding2, true, 4096);
}
bool result = false;
if (!safeProcessHandle.IsInvalid)
{
SetProcessHandle(safeProcessHandle);
SetProcessId(pROCESS_INFORMATION.dwProcessId);
safeThreadHandle.Close();
result = true;
}
return(result);
}
private void EnsureState(Process2.State state)
{
if ((state & Process2.State.IsWin2k) != (Process2.State)0 && (OperatingSystem.Platform != PlatformID.Win32NT || OperatingSystem.Version.Major < 5))
{
throw new PlatformNotSupportedException("Win2kRequired");
}
if ((state & Process2.State.IsNt) != (Process2.State)0 && OperatingSystem.Platform != PlatformID.Win32NT)
{
throw new PlatformNotSupportedException("WinNTRequired");
}
if ((state & Process2.State.Associated) != (Process2.State)0 && !Associated)
{
throw new InvalidOperationException("NoAssociatedProcess");
}
if ((state & Process2.State.HaveId) != (Process2.State)0 && !haveProcessId)
{
if (!haveProcessHandle)
{
EnsureState(Process2.State.Associated);
throw new InvalidOperationException("ProcessIdRequired");
}
SetProcessId(ProcessManager.GetProcessIdFromHandle(m_processHandle));
}
if ((state & Process2.State.IsLocal) != (Process2.State)0 && isRemoteMachine)
{
throw new NotSupportedException("NotSupportedRemote");
}
if ((state & Process2.State.HaveProcessInfo) != (Process2.State)0 && processInfo == null)
{
if ((state & Process2.State.HaveId) == (Process2.State)0)
{
EnsureState(Process2.State.HaveId);
}
ProcessInfo[] processInfos = ProcessManager.GetProcessInfos(machineName);
for (int i = 0; i < processInfos.Length; i++)
{
if (processInfos[i].processId == processId)
{
processInfo = processInfos[i];
break;
}
}
if (processInfo == null)
{
throw new InvalidOperationException("NoProcessInfo");
}
}
if ((state & Process2.State.Exited) != (Process2.State)0)
{
if (!HasExited)
{
throw new InvalidOperationException("WaitTillExit");
}
if (!haveProcessHandle)
{
throw new InvalidOperationException("NoProcessHandle");
}
}
}
