internal override void SendStopSignal()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignal, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), "stopsignal" });
base.CloseAsync();
this.stdInWriter.WriteLine(OutOfProcessUtils.CreateSignalPacket(base.powershellInstanceId));
this.signalTimeOutTimer.Start();
}
private void SendData(byte[] data, DataPriorityType priorityType)
{
BaseClientTransportManager.tracer.WriteLine("Command sending data of size : {0}", new object[] { data.Length });
byte[] buffer = data;
bool flag = true;
if (commandSendRedirect != null)
{
object[] objArray3 = new object[2];
objArray3[1] = buffer;
object[] args = objArray3;
flag = (bool)commandSendRedirect.DynamicInvoke(args);
buffer = (byte[])args[0];
}
if (flag)
{
using (WSManNativeApi.WSManData data2 = new WSManNativeApi.WSManData(buffer))
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputEx, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), data2.BufferLength.ToString(CultureInfo.InvariantCulture) });
lock (base.syncObject)
{
if (base.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]);
}
else
{
this.sendToRemoteCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdSendCallback);
WSManNativeApi.WSManSendShellInputEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, 0, (priorityType == DataPriorityType.Default) ? "stdin" : "pr", data2, (IntPtr)this.sendToRemoteCompleted, ref this.wsManSendOperationHandle);
}
}
}
}
}
internal override void CloseAsync()
{
bool flag = false;
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
base.isClosed = true;
if (this.stdInWriter == null)
{
flag = true;
}
}
base.CloseAsync();
if (!flag)
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseShell, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString() });
this._tracer.WriteMessage(string.Concat(new object[] { "OutOfProcessClientSessionTransportManager.CloseAsync, when sending close session packet, progress command count should be zero, current cmd count: ", this.cmdTransportManagers.Count, ", RunSpacePool Id : ", base.RunspacePoolInstanceId }));
this.stdInWriter.WriteLine(OutOfProcessUtils.CreateClosePacket(Guid.Empty));
this.closeTimeOutTimer.Start();
}
else
{
base.RaiseCloseCompleted();
}
}
internal void OnRemoteCmdSignalCompleted()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignalCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
this.StopSignalTimerAndDecrementOperations();
if (!base.isClosed)
{
base.EnqueueAndStartProcessingThread(null, null, true);
}
}
private static void OnRemoteCmdDataReceived(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
BaseClientTransportManager.tracer.WriteLine("Remote Command DataReceived callback.", new object[0]);
long cmdTMId = 0L;
WSManClientCommandTransportManager cmdTransportManager = null;
if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId))
{
BaseClientTransportManager.tracer.WriteLine("Unable to find a transport manager for the given command context {0}.", new object[] { cmdTMId });
}
else if (!shellOperationHandle.Equals(cmdTransportManager.wsManShellOperationHandle) || !commandOperationHandle.Equals(cmdTransportManager.wsManCmdOperationHandle))
{
BaseClientTransportManager.tracer.WriteLine("CmdReceive callback: ShellOperationHandles are not the same as the Receive is initiated with", new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.CommandReceiveExFailed);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveCommandOutputEx);
cmdTransportManager.ProcessWSManTransportError(eventArgs);
}
else
{
cmdTransportManager.ClearReceiveOrSendResources(flags, false);
if (cmdTransportManager.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]);
}
else
{
if (IntPtr.Zero != error)
{
WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error);
if (errorStruct.errorCode != 0)
{
BaseClientTransportManager.tracer.WriteLine("CmdReceive callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail });
TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.ReceiveCommandOutputEx, RemotingErrorIdStrings.CommandReceiveExCallBackError, new object[] { errorStruct.errorDetail });
cmdTransportManager.ProcessWSManTransportError(args2);
return;
}
}
if (flags == 0x2000)
{
cmdTransportManager.isDisconnectedOnInvoke = true;
cmdTransportManager.RaiseDelayStreamProcessedEvent();
}
else
{
WSManNativeApi.WSManReceiveDataResult result = WSManNativeApi.WSManReceiveDataResult.UnMarshal(data);
if (result.data != null)
{
BaseClientTransportManager.tracer.WriteLine("Cmd Received Data : {0}", new object[] { result.data.Length });
object[] args = new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString(), result.data.Length.ToString(CultureInfo.InvariantCulture) };
PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args);
cmdTransportManager.ProcessRawData(result.data, result.stream);
}
}
}
}
}
private static void OnRemoteCmdSignalCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
BaseClientTransportManager.tracer.WriteLine("Signal Completed callback received.", new object[0]);
long cmdTMId = 0L;
WSManClientCommandTransportManager cmdTransportManager = null;
if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId))
{
BaseClientTransportManager.tracer.WriteLine("Unable to find a transport manager for the given command context {0}.", new object[] { cmdTMId });
}
else
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignalCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() });
if (!shellOperationHandle.Equals(cmdTransportManager.wsManShellOperationHandle) || !commandOperationHandle.Equals(cmdTransportManager.wsManCmdOperationHandle))
{
BaseClientTransportManager.tracer.WriteLine("Cmd Signal callback: ShellOperationHandles are not the same as the signal is initiated with", new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.CommandSendExFailed);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.CommandInputEx);
cmdTransportManager.ProcessWSManTransportError(eventArgs);
}
else
{
if (IntPtr.Zero != cmdTransportManager.cmdSignalOperationHandle)
{
WSManNativeApi.WSManCloseOperation(cmdTransportManager.cmdSignalOperationHandle, 0);
cmdTransportManager.cmdSignalOperationHandle = IntPtr.Zero;
}
if (cmdTransportManager.signalCmdCompleted != null)
{
cmdTransportManager.signalCmdCompleted.Dispose();
cmdTransportManager.signalCmdCompleted = null;
}
if (cmdTransportManager.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]);
}
else
{
if (IntPtr.Zero != error)
{
WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error);
if (errorStruct.errorCode != 0)
{
BaseClientTransportManager.tracer.WriteLine("Cmd Signal callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail });
TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.CommandInputEx, RemotingErrorIdStrings.CommandSendExCallBackError, new object[] { WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) });
cmdTransportManager.ProcessWSManTransportError(args2);
return;
}
}
cmdTransportManager.EnqueueAndStartProcessingThread(null, null, true);
}
}
}
}
private void SendData(byte[] data, DataPriorityType priorityType)
{
object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), data.Length.ToString(CultureInfo.InvariantCulture) };
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputEx, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args);
lock (base.syncObject)
{
if (!base.isClosed)
{
this.stdInWriter.WriteLine(OutOfProcessUtils.CreateDataPacket(data, priorityType, base.powershellInstanceId));
}
}
}
internal void OnRemoteCmdSendCompleted()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputExCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
lock (base.syncObject)
{
if (base.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]);
return;
}
}
this.SendOneItem();
}
internal void OnRemoteCmdDataReceived(byte[] rawData, string stream)
{
object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), rawData.Length.ToString(CultureInfo.InvariantCulture) };
PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args);
if (base.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]);
}
else
{
this.ProcessRawData(rawData, stream);
}
}
internal override void CreateAsync()
{
byte[] firstArgument = base.serializedPipeline.ReadOrRegisterCallback(null);
if (firstArgument == null)
{
firstArgument = new byte[0];
}
bool flag = true;
if (commandCodeSendRedirect != null)
{
object[] objArray2 = new object[2];
objArray2[1] = firstArgument;
object[] objArray = objArray2;
flag = (bool)commandCodeSendRedirect.DynamicInvoke(objArray);
firstArgument = (byte[])objArray[0];
}
if (!flag)
{
return;
}
WSManNativeApi.WSManCommandArgSet set = new WSManNativeApi.WSManCommandArgSet(firstArgument);
this.cmdContextId = GetNextCmdTMHandleId();
AddCmdTransportManager(this.cmdContextId, this);
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommand, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
this.createCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdCreateCallback);
this.createCmdCompletedGCHandle = GCHandle.Alloc(this.createCmdCompleted);
this.reconnectCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdReconnectCallback);
using (set)
{
lock (base.syncObject)
{
if (!base.isClosed)
{
WSManNativeApi.WSManRunShellCommandEx(this.wsManShellOperationHandle, 0, base.PowershellInstanceId.ToString().ToUpper(CultureInfo.InvariantCulture), ((this.cmdLine == null) || (this.cmdLine.Length == 0)) ? " " : ((this.cmdLine.Length <= 0x100) ? this.cmdLine : this.cmdLine.Substring(0, 0xff)), (IntPtr)set, IntPtr.Zero, (IntPtr)this.createCmdCompleted, ref this.wsManCmdOperationHandle);
BaseClientTransportManager.tracer.WriteLine("Started cmd with command context : {0} Operation context: {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle });
}
}
}
if (this.wsManCmdOperationHandle == IntPtr.Zero)
{
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.RunShellCommandExFailed);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.RunShellCommandEx);
this.ProcessWSManTransportError(eventArgs);
}
}
internal override void CloseAsync()
{
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
base.isClosed = true;
}
base.CloseAsync();
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommand, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
if (this.stdInWriter != null)
{
this.stdInWriter.WriteLine(OutOfProcessUtils.CreateClosePacket(base.powershellInstanceId));
}
}
internal void OnDataAvailableCallback(RemoteDataObject <PSObject> remoteObject)
{
PSEtwLog.LogAnalyticInformational(PSEventId.TransportReceivedObject, PSOpcode.Open, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] {
remoteObject.RunspacePoolId.ToString(),
remoteObject.PowerShellId.ToString(),
(int)remoteObject.Destination,
(int)remoteObject.DataType,
(int)remoteObject.TargetInterface
});
this.PowerShellGuidObserver.SafeInvoke(remoteObject.PowerShellId, EventArgs.Empty);
RemoteDataEventArgs eventArgs = new RemoteDataEventArgs(remoteObject);
if (remoteObject.DataType == RemotingDataType.RunspacePoolStateInfo)
{
System.Diagnostics.Debug.WriteLine("RunspacePool State Opened Received");
Thread.Sleep(800); //HACK: Delay reception in local mode... TODO: Find why!!! cannot have a Wait somewhere
_slowed = true;
}
this.DataReceived.SafeInvoke <RemoteDataEventArgs>(this, eventArgs);
}
internal override void SendStopSignal()
{
lock (base.syncObject)
{
if (!base.isClosed)
{
if (!this.isCreateCallbackReceived)
{
this.isStopSignalPending = true;
}
else
{
this.isStopSignalPending = false;
BaseClientTransportManager.tracer.WriteLine("Sending stop signal with command context: {0} Operation Context {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle });
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignal, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), StopSignal });
this.signalCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdSignalCallback);
WSManNativeApi.WSManSignalShellEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, 0, StopSignal, (IntPtr)this.signalCmdCompleted, ref this.cmdSignalOperationHandle);
}
}
}
}
private static void OnCloseCmdCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
BaseClientTransportManager.tracer.WriteLine("OnCloseCmdCompleted callback received for operation context {0}", new object[] { commandOperationHandle });
long cmdTMId = 0L;
WSManClientCommandTransportManager cmdTransportManager = null;
if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId))
{
BaseClientTransportManager.tracer.WriteLine("OnCloseCmdCompleted: Unable to find a transport manager for the command context {0}.", new object[] { cmdTMId });
}
else
{
BaseClientTransportManager.tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Close completed callback received for command: {0}", new object[] { cmdTransportManager.cmdContextId }), new object[0]);
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommandCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() });
if (cmdTransportManager.isDisconnectPending)
{
cmdTransportManager.RaiseReadyForDisconnect();
}
cmdTransportManager.RaiseCloseCompleted();
}
}
internal override void StartReceivingData()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputEx, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
this.shouldStartReceivingData = false;
lock (base.syncObject)
{
if (base.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]);
}
else if (base.receiveDataInitiated)
{
BaseClientTransportManager.tracer.WriteLine("Client Session TM: Command ReceiveData has already been called.", new object[0]);
}
else
{
base.receiveDataInitiated = true;
this.receivedFromRemote = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdReceiveCallback);
WSManNativeApi.WSManReceiveShellOutputEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, base.startInDisconnectedMode ? 0x10 : 0, (IntPtr)WSManClientSessionTransportManager.wsManApiStaticData.OutputStreamSet, (IntPtr)this.receivedFromRemote, ref this.wsManRecieveOperationHandle);
}
}
}
private void OnDataPacketReceived(byte[] rawData, string stream, Guid psGuid)
{
string str = "stdout";
if (stream.Equals(DataPriorityType.PromptResponse.ToString(), StringComparison.OrdinalIgnoreCase))
{
str = "pr";
}
if (psGuid == Guid.Empty)
{
object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), Guid.Empty.ToString(), rawData.Length.ToString(CultureInfo.InvariantCulture) };
PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args);
base.ProcessRawData(rawData, str);
}
else
{
OutOfProcessClientCommandTransportManager commandTransportManager = this.GetCommandTransportManager(psGuid);
if (commandTransportManager != null)
{
commandTransportManager.OnRemoteCmdDataReceived(rawData, str);
}
}
}
internal override void CloseAsync()
{
BaseClientTransportManager.tracer.WriteLine("Closing command with command context: {0} Operation Context {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle });
bool flag = false;
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
base.isClosed = true;
if (IntPtr.Zero == this.wsManCmdOperationHandle)
{
flag = true;
}
}
base.CloseAsync();
if (!flag)
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommand, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
this.closeCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdCloseCallback);
WSManNativeApi.WSManCloseCommand(this.wsManCmdOperationHandle, 0, (IntPtr)this.closeCmdCompleted);
}
else
{
try
{
base.RaiseCloseCompleted();
}
finally
{
RemoveCmdTransportManager(this.cmdContextId);
}
}
}
internal override void CreateAsync()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommand, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
this.stdInWriter.WriteLine(OutOfProcessUtils.CreateCommandPacket(base.powershellInstanceId));
}
private static void OnCreateCmdCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted callback received", new object[0]);
long cmdTMId = 0L;
WSManClientCommandTransportManager cmdTransportManager = null;
if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId))
{
BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted: Unable to find a transport manager for the command context {0}.", new object[] { cmdTMId });
}
else
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommandCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() });
if (cmdTransportManager.createCmdCompleted != null)
{
cmdTransportManager.createCmdCompletedGCHandle.Free();
cmdTransportManager.createCmdCompleted.Dispose();
cmdTransportManager.createCmdCompleted = null;
}
cmdTransportManager.wsManCmdOperationHandle = commandOperationHandle;
if (IntPtr.Zero != error)
{
WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error);
if (errorStruct.errorCode != 0)
{
BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail });
TransportErrorOccuredEventArgs eventArgs = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.RunShellCommandEx, RemotingErrorIdStrings.RunShellCommandExCallBackError, new object[] { WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) });
cmdTransportManager.ProcessWSManTransportError(eventArgs);
return;
}
}
lock (cmdTransportManager.syncObject)
{
cmdTransportManager.isCreateCallbackReceived = true;
if (cmdTransportManager.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]);
if (cmdTransportManager.isDisconnectPending)
{
cmdTransportManager.RaiseReadyForDisconnect();
}
}
else if (cmdTransportManager.isDisconnectPending)
{
cmdTransportManager.RaiseReadyForDisconnect();
}
else
{
if (cmdTransportManager.serializedPipeline.Length == 0L)
{
cmdTransportManager.shouldStartReceivingData = true;
}
cmdTransportManager.SendOneItem();
if (cmdTransportManager.isStopSignalPending)
{
cmdTransportManager.SendStopSignal();
}
}
}
}
}
private void OnRemoteSessionSendCompleted()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputExCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), Guid.Empty.ToString() });
this.SendOneItem();
}
internal void OnCloseCmdCompleted()
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommandCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() });
base.RaiseCloseCompleted();
}
internal override void CreateAsync()
{
if (this.connectionInfo != null)
{
this._processInstance = this.connectionInfo.Process ?? new PowerShellProcessInstance(this.connectionInfo.PSVersion, this.connectionInfo.Credential, this.connectionInfo.InitializationScript, this.connectionInfo.RunAs32);
if (this.connectionInfo.Process != null)
{
this._processCreated = false;
}
}
PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateShell, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString() });
try
{
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
this.serverProcess = this._processInstance.Process;
if (this._processInstance.RunspacePool != null)
{
this._processInstance.RunspacePool.Close();
this._processInstance.RunspacePool.Dispose();
}
this.stdInWriter = this._processInstance.StdInWriter;
this.serverProcess.OutputDataReceived += new DataReceivedEventHandler(this.OnOutputDataReceived);
this.serverProcess.ErrorDataReceived += new DataReceivedEventHandler(this.OnErrorDataReceived);
this.serverProcess.Exited += new EventHandler(this.OnExited);
this._processInstance.Start();
if (this.stdInWriter != null)
{
this.serverProcess.CancelErrorRead();
this.serverProcess.CancelOutputRead();
}
this.serverProcess.BeginOutputReadLine();
this.serverProcess.BeginErrorReadLine();
this.stdInWriter = new OutOfProcessTextWriter(this.serverProcess.StandardInput);
this._processInstance.StdInWriter = this.stdInWriter;
}
}
catch (Win32Exception exception)
{
PSRemotingTransportException e = new PSRemotingTransportException(exception, RemotingErrorIdStrings.IPCExceptionLaunchingProcess, new object[] { exception.Message })
{
ErrorCode = exception.ErrorCode
};
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.CreateShellEx);
this.RaiseErrorHandler(eventArgs);
return;
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
PSRemotingTransportException exception4 = new PSRemotingTransportException(PSRemotingErrorId.IPCExceptionLaunchingProcess, RemotingErrorIdStrings.IPCExceptionLaunchingProcess, new object[] { exception3.Message });
TransportErrorOccuredEventArgs args2 = new TransportErrorOccuredEventArgs(exception4, TransportMethodEnum.CreateShellEx);
this.RaiseErrorHandler(args2);
return;
}
this.SendOneItem();
}
/// <summary>
/// Report session context to WSMan..this will let WSMan send ACK to
/// client and client can send data.
/// </summary>
internal void ReportContext()
{
int result = 0;
bool isRegisterWaitForSingleObjectFailed = false;
lock (_syncObject)
{
if (true == isClosed)
{
return;
}
if (!isContextReported)
{
isContextReported = true;
PSEtwLog.LogAnalyticInformational(PSEventId.ReportContext,
PSOpcode.Connect, PSTask.None,
PSKeyword.ManagedPlugin | PSKeyword.UseAlwaysAnalytic,
creationRequestDetails.ToString(), creationRequestDetails.ToString());
//RACE TO BE FIXED - As soon as this API is called, WinRM service will send CommandResponse back and Signal is expected anytime
// If Signal comes and executes before registering the notification handle, cleanup will be messed
result = WSManNativeApi.WSManPluginReportContext(creationRequestDetails.unmanagedHandle, 0, creationRequestDetails.unmanagedHandle);
if (Platform.IsWindows && (WSManPluginConstants.ExitCodeSuccess == result))
{
registeredShutdownNotification = 1;
// Wrap the provided handle so it can be passed to the registration function
SafeWaitHandle safeWaitHandle = new SafeWaitHandle(creationRequestDetails.shutdownNotificationHandle, false); // Owned by WinRM
EventWaitHandle eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
ClrFacade.SetSafeWaitHandle(eventWaitHandle, safeWaitHandle);
// Register shutdown notification handle
this.registeredShutDownWaitHandle = ThreadPool.RegisterWaitForSingleObject(
eventWaitHandle,
new WaitOrTimerCallback(WSManPluginManagedEntryWrapper.PSPluginOperationShutdownCallback),
shutDownContext,
-1, // INFINITE
true); // TODO: Do I need to worry not being able to set missing WT_TRANSFER_IMPERSONATION?
if (null == this.registeredShutDownWaitHandle)
{
isRegisterWaitForSingleObjectFailed = true;
registeredShutdownNotification = 0;
}
}
}
}
if ((WSManPluginConstants.ExitCodeSuccess != result) || (isRegisterWaitForSingleObjectFailed))
{
string errorMessage;
if (isRegisterWaitForSingleObjectFailed)
{
errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginShutdownRegistrationFailed);
}
else
{
errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginReportContextFailed);
}
// Report error and close the session
Exception mgdException = new InvalidOperationException(errorMessage);
Close(mgdException);
}
}
private void OnDataAvailable(byte[] dataToSend, bool isEndFragment)
{
object[] args = new object[] { this.runpacePoolInstanceId.ToString(), this.powerShellInstanceId.ToString(), dataToSend.Length.ToString(CultureInfo.InvariantCulture), (int)this.dataType, (int)this.targetInterface };
PSEtwLog.LogAnalyticInformational(PSEventId.ServerSendData, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args);
this.SendDataToClient(dataToSend, isEndFragment & this.shouldFlushData, this.reportAsPending, isEndFragment);
}
