/// <summary>
/// Creates a RemoteDataObject by deserializing <paramref name="data"/>.
/// </summary>
/// <param name="serializedDataStream"></param>
/// <param name="defragmentor">
/// Defragmentor used to deserialize an object.
/// </param>
/// <returns></returns>
internal static RemoteDataObject <T> CreateFrom(Stream serializedDataStream, Fragmentor defragmentor)
{
Dbg.Assert(serializedDataStream != null, "cannot construct a RemoteDataObject from null data");
Dbg.Assert(defragmentor != null, "defragmentor cannot be null.");
if ((serializedDataStream.Length - serializedDataStream.Position) < headerLength)
{
PSRemotingTransportException e =
new PSRemotingTransportException(PSRemotingErrorId.NotEnoughHeaderForRemoteDataObject,
RemotingErrorIdStrings.NotEnoughHeaderForRemoteDataObject,
headerLength + FragmentedRemoteObject.HeaderLength);
throw e;
}
RemotingDestination destination = (RemotingDestination)DeserializeUInt(serializedDataStream);
RemotingDataType dataType = (RemotingDataType)DeserializeUInt(serializedDataStream);
Guid runspacePoolId = DeserializeGuid(serializedDataStream);
Guid powerShellId = DeserializeGuid(serializedDataStream);
object actualData = null;
if ((serializedDataStream.Length - headerLength) > 0)
{
actualData = defragmentor.DeserializeToPSObject(serializedDataStream);
}
T deserializedObject = (T)LanguagePrimitives.ConvertTo(actualData, typeof(T),
System.Globalization.CultureInfo.CurrentCulture);
return(new RemoteDataObject <T>(destination, dataType, runspacePoolId, powerShellId, deserializedObject));
}
internal static TransportErrorOccuredEventArgs ConstructTransportErrorEventArgs(IntPtr wsmanAPIHandle, WSManClientSessionTransportManager wsmanSessionTM, WSManNativeApi.WSManError errorStruct, TransportMethodEnum transportMethodReportingError, string resourceString, params object[] resourceArgs)
{
PSRemotingTransportException exception;
if ((errorStruct.errorCode == -2144108135) && (wsmanSessionTM != null))
{
string redirectLocation = WSManNativeApi.WSManGetSessionOptionAsString(wsmanSessionTM.SessionHandle, WSManNativeApi.WSManSessionOption.WSMAN_OPTION_REDIRECT_LOCATION);
string str2 = ParseEscapeWSManErrorMessage(WSManNativeApi.WSManGetErrorMessage(wsmanAPIHandle, errorStruct.errorCode)).Trim();
exception = new PSRemotingTransportRedirectException(redirectLocation, PSRemotingErrorId.URIEndPointNotResolved, RemotingErrorIdStrings.URIEndPointNotResolved, new object[] { str2, redirectLocation });
}
else if ((errorStruct.errorCode == -2144108485) && (wsmanSessionTM != null))
{
string str3 = wsmanSessionTM.ConnectionInfo.ShellUri.Replace("http://schemas.microsoft.com/powershell/", string.Empty);
string str4 = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.InvalidConfigurationName, new object[] { str3, wsmanSessionTM.ConnectionInfo.ComputerName });
exception = new PSRemotingTransportException(PSRemotingErrorId.InvalidConfigurationName, RemotingErrorIdStrings.ConnectExCallBackError, new object[] { wsmanSessionTM.ConnectionInfo.ComputerName, str4 }) {
TransportMessage = ParseEscapeWSManErrorMessage(WSManNativeApi.WSManGetErrorMessage(wsmanAPIHandle, errorStruct.errorCode))
};
}
else
{
string str5 = PSRemotingErrorInvariants.FormatResourceString(resourceString, resourceArgs);
exception = new PSRemotingTransportException(PSRemotingErrorId.TroubleShootingHelpTopic, RemotingErrorIdStrings.TroubleShootingHelpTopic, new object[] { str5 }) {
TransportMessage = ParseEscapeWSManErrorMessage(WSManNativeApi.WSManGetErrorMessage(wsmanAPIHandle, errorStruct.errorCode))
};
}
exception.ErrorCode = errorStruct.errorCode;
return new TransportErrorOccuredEventArgs(exception, transportMethodReportingError);
}
private void DoClose(object sender, RemoteSessionStateMachineEventArgs arg)
{
using (_trace.TraceEventHandlers())
{
switch (this._state)
{
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.Disconnecting:
case RemoteSessionState.Disconnected:
case RemoteSessionState.Reconnecting:
case RemoteSessionState.RCDisconnecting:
this.SetState(RemoteSessionState.ClosingConnection, arg.Reason);
break;
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
break;
default:
{
PSRemotingTransportException reason = new PSRemotingTransportException(arg.Reason, RemotingErrorIdStrings.ForceClosed, new object[0]);
this.SetState(RemoteSessionState.Closed, reason);
break;
}
}
this.CleanAll();
}
}
/// <summary>
/// Process data coming from the transport. This method analyses the data
/// and if an object can be created, it creates one and calls the
/// <paramref name="callback"/> with the deserialized object. This method
/// does not assume all fragments to be available. So if not enough fragments are
/// available it will simply return..
/// </summary>
/// <param name="data">
/// Data to process.
/// </param>
/// <param name="priorityType">
/// Priority stream this data belongs to.
/// </param>
/// <param name="callback">
/// Callback to call once a complete deserialized object is available.
/// </param>
/// <returns>
/// Defragmented Object if any, otherwise null.
/// </returns>
/// <exception cref="PSRemotingTransportException">
/// 1. Fragment Ids not in sequence
/// 2. Object Ids does not match
/// 3. The current deserialized object size of the received data exceeded
/// allowed maximum object size. The current deserialized object size is {0}.
/// Allowed maximum object size is {1}.
/// 4.The total data received from the remote machine exceeded allowed maximum.
/// The total data received from remote machine is {0}. Allowed maximum is {1}.
/// </exception>
/// <remarks>
/// Might throw other exceptions as the deserialized object is handled here.
/// </remarks>
internal void ProcessRawData(byte[] data,
DataPriorityType priorityType,
ReceiveDataCollection.OnDataAvailableCallback callback)
{
Dbg.Assert(data != null, "Cannot process null data");
try
{
_defragmentor.DeserializationContext.LogExtraMemoryUsage(data.Length);
}
catch (System.Xml.XmlException)
{
PSRemotingTransportException e = null;
if (_isCreateByClientTM)
{
e = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumClient,
RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumClient,
_defragmentor.DeserializationContext.MaximumAllowedMemory.Value);
}
else
{
e = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumServer,
RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumServer,
_defragmentor.DeserializationContext.MaximumAllowedMemory.Value);
}
throw e;
}
_recvdData[(int)priorityType].ProcessRawData(data, callback);
}
internal virtual void ProcessRawData(byte[] data, string stream)
{
try
{
this.ProcessRawData(data, stream, this.onDataAvailableCallback);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Exception processing data. {0}", new object[] { exception.Message }), new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(exception.Message, exception);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveShellOutputEx);
this.RaiseErrorHandler(eventArgs);
}
}
/// <summary>
/// This is the handler for Close event. It closes the connection.
/// </summary>
/// <param name="sender"></param>
/// <param name="fsmEventArg">
/// This parameter contains the FSM event.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If the parameter <paramref name="fsmEventArg"/> is null.
/// </exception>
private void DoClose(object sender, RemoteSessionStateMachineEventArgs fsmEventArg)
{
using (s_trace.TraceEventHandlers())
{
if (fsmEventArg == null)
{
throw PSTraceSource.NewArgumentNullException("fsmEventArg");
}
RemoteSessionState oldState = _state;
switch (oldState)
{
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
// do nothing
break;
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent: //server session will never be in this state.. TODO- remove this
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.EstablishedAndKeyExchanged:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationSending:
SetState(RemoteSessionState.ClosingConnection, fsmEventArg.Reason);
_session.SessionDataStructureHandler.CloseConnectionAsync(fsmEventArg.Reason);
break;
case RemoteSessionState.Idle:
case RemoteSessionState.UndefinedState:
default:
Exception forcedCloseException = new PSRemotingTransportException(fsmEventArg.Reason, RemotingErrorIdStrings.ForceClosed);
SetState(RemoteSessionState.Closed, forcedCloseException);
break;
}
CleanAll();
}
}
internal void ProcessRawData(byte[] data, DataPriorityType priorityType, ReceiveDataCollection.OnDataAvailableCallback callback)
{
try
{
this.defragmentor.DeserializationContext.LogExtraMemoryUsage(data.Length);
}
catch (XmlException)
{
PSRemotingTransportException exception = null;
if (this.isCreateByClientTM)
{
exception = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumClient, RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumClient, new object[] { this.defragmentor.DeserializationContext.MaximumAllowedMemory.Value });
}
else
{
exception = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumServer, RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumServer, new object[] { this.defragmentor.DeserializationContext.MaximumAllowedMemory.Value });
}
throw exception;
}
this.recvdData[(int)priorityType].ProcessRawData(data, callback);
}
internal void ProcessRawData(byte[] data, DataPriorityType priorityType, ReceiveDataCollection.OnDataAvailableCallback callback)
{
try
{
this.defragmentor.DeserializationContext.LogExtraMemoryUsage(data.Length);
}
catch (XmlException)
{
PSRemotingTransportException exception = null;
if (this.isCreateByClientTM)
{
exception = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumClient, RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumClient, new object[] { this.defragmentor.DeserializationContext.MaximumAllowedMemory.Value });
}
else
{
exception = new PSRemotingTransportException(PSRemotingErrorId.ReceivedDataSizeExceededMaximumServer, RemotingErrorIdStrings.ReceivedDataSizeExceededMaximumServer, new object[] { this.defragmentor.DeserializationContext.MaximumAllowedMemory.Value });
}
throw exception;
}
this.recvdData[(int) priorityType].ProcessRawData(data, callback);
}
/// <summary>
/// This is the handler for Close event.
/// </summary>
/// <param name="sender"></param>
/// <param name="arg">
/// This parameter contains the FSM event.
/// </param>
/// <exception cref="ArgumentNullException">
/// If the parameter <paramref name="arg"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the parameter <paramref name="arg"/> does not contain remote data.
/// </exception>
private void DoClose(object sender, RemoteSessionStateMachineEventArgs arg)
{
using (s_trace.TraceEventHandlers())
{
RemoteSessionState oldState = _state;
switch (oldState)
{
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
// do nothing
break;
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeyReceived: // TODO - Client session would never get into this state... to be removed
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.Disconnected:
case RemoteSessionState.Disconnecting:
case RemoteSessionState.Reconnecting:
case RemoteSessionState.RCDisconnecting:
SetState(RemoteSessionState.ClosingConnection, arg.Reason);
break;
case RemoteSessionState.Idle:
case RemoteSessionState.UndefinedState:
default:
PSRemotingTransportException forceClosedException = new PSRemotingTransportException(arg.Reason, RemotingErrorIdStrings.ForceClosed);
SetState(RemoteSessionState.Closed, forceClosedException);
break;
}
CleanAll();
}
}
internal static RemoteDataObject <T> CreateFrom(Stream serializedDataStream, Fragmentor defragmentor)
{
if ((serializedDataStream.Length - serializedDataStream.Position) < 40L)
{
PSRemotingTransportException exception = new PSRemotingTransportException(PSRemotingErrorId.NotEnoughHeaderForRemoteDataObject, RemotingErrorIdStrings.NotEnoughHeaderForRemoteDataObject, new object[] { 0x3d });
throw exception;
}
RemotingDestination destination = (RemotingDestination)RemoteDataObject <T> .DeserializeUInt(serializedDataStream);
RemotingDataType dataType = (RemotingDataType)RemoteDataObject <T> .DeserializeUInt(serializedDataStream);
Guid runspacePoolId = RemoteDataObject <T> .DeserializeGuid(serializedDataStream);
Guid powerShellId = RemoteDataObject <T> .DeserializeGuid(serializedDataStream);
object valueToConvert = null;
if ((serializedDataStream.Length - 40L) > 0L)
{
valueToConvert = defragmentor.DeserializeToPSObject(serializedDataStream);
}
return(new RemoteDataObject <T>(destination, dataType, runspacePoolId, powerShellId, (T)LanguagePrimitives.ConvertTo(valueToConvert, typeof(T), CultureInfo.CurrentCulture)));
}
private void DoClose(object sender, RemoteSessionStateMachineEventArgs fsmEventArg)
{
using (_trace.TraceEventHandlers())
{
if (fsmEventArg == null)
{
throw PSTraceSource.NewArgumentNullException("fsmEventArg");
}
switch (this._state)
{
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.EstablishedAndKeyExchanged:
this.SetState(RemoteSessionState.ClosingConnection, fsmEventArg.Reason);
this._session.SessionDataStructureHandler.CloseConnectionAsync(fsmEventArg.Reason);
break;
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
break;
default:
{
Exception reasion = new PSRemotingTransportException(fsmEventArg.Reason, RemotingErrorIdStrings.ForceClosed, new object[0]);
this.SetState(RemoteSessionState.Closed, reasion);
break;
}
}
this.CleanAll();
}
}
internal TransportErrorOccuredEventArgs(PSRemotingTransportException e, TransportMethodEnum m)
{
this.exception = e;
this.method = m;
}
internal override void ProcessRawData(byte[] data, string stream)
{
if (!this.isClosed)
{
try
{
base.ProcessRawData(data, stream, this.onDataAvailableCallback);
}
catch (PSRemotingTransportException exception)
{
tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Exception processing data. {0}", new object[] { exception.Message }), new object[0]);
TransportErrorOccuredEventArgs transportErrorArgs = new TransportErrorOccuredEventArgs(exception, TransportMethodEnum.ReceiveShellOutputEx);
this.EnqueueAndStartProcessingThread(null, transportErrorArgs, null);
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Exception processing data. {0}", new object[] { exception2.Message }), new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(exception2.Message);
TransportErrorOccuredEventArgs args2 = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveShellOutputEx);
this.EnqueueAndStartProcessingThread(null, args2, null);
}
}
}
internal void ServicePendingCallbacks(object objectToProcess)
{
tracer.WriteLine("ServicePendingCallbacks thread is starting", new object[0]);
PSEtwLog.ReplaceActivityIdForCurrentThread(this.runspacePoolInstanceId, PSEventId.OperationalTransferEventRunspacePool, PSEventId.AnalyticTransferEventRunspacePool, PSKeyword.Transport, PSTask.None);
try
{
while (!this.isClosed)
{
CallbackNotificationInformation information = null;
lock (this.callbackNotificationQueue)
{
if ((this.callbackNotificationQueue.Count <= 0) || this.suspendQueueServicing)
{
return;
}
information = this.callbackNotificationQueue.Dequeue();
}
if (information != null)
{
if (information.transportError != null)
{
this.RaiseErrorHandler(information.transportError);
return;
}
if (information.privateData != null)
{
this.ProcessPrivateData(information.privateData);
}
else
{
base.OnDataAvailableCallback(information.remoteObject);
}
}
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Exception processing data. {0}", new object[] { exception.Message }), new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(exception.Message, exception);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveShellOutputEx);
this.RaiseErrorHandler(eventArgs);
}
finally
{
lock (this.callbackNotificationQueue)
{
tracer.WriteLine("ServicePendingCallbacks thread is exiting", new object[0]);
this.isServicingCallbacks = false;
this.EnqueueAndStartProcessingThread(null, null, null);
}
}
}
/// <summary>
/// This is the handler for Close event. It closes the connection.
/// </summary>
/// <param name="sender"></param>
/// <param name="fsmEventArg">
/// This parameter contains the FSM event.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If the parameter <paramref name="fsmEventArg"/> is null.
/// </exception>
private void DoClose(object sender, RemoteSessionStateMachineEventArgs fsmEventArg)
{
using (s_trace.TraceEventHandlers())
{
if (fsmEventArg == null)
{
throw PSTraceSource.NewArgumentNullException("fsmEventArg");
}
RemoteSessionState oldState = _state;
switch (oldState)
{
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
// do nothing
break;
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent: //server session will never be in this state.. TODO- remove this
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.EstablishedAndKeyExchanged:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationSending:
SetState(RemoteSessionState.ClosingConnection, fsmEventArg.Reason);
_session.SessionDataStructureHandler.CloseConnectionAsync(fsmEventArg.Reason);
break;
case RemoteSessionState.Idle:
case RemoteSessionState.UndefinedState:
default:
Exception forcedCloseException = new PSRemotingTransportException(fsmEventArg.Reason, RemotingErrorIdStrings.ForceClosed);
SetState(RemoteSessionState.Closed, forcedCloseException);
break;
}
CleanAll();
}
}
private void OnOutputDataReceived(object sender, DataReceivedEventArgs e)
{
try
{
OutOfProcessUtils.ProcessData(e.Data, this.dataProcessingCallbacks);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
PSRemotingTransportException exception2 = new PSRemotingTransportException(PSRemotingErrorId.IPCErrorProcessingServerData, RemotingErrorIdStrings.IPCErrorProcessingServerData, new object[] { exception.Message });
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(exception2, TransportMethodEnum.ReceiveShellOutputEx));
}
}
/// <summary>
/// Handles a transport error since it is most likely that
/// the process crash
/// </summary>
/// <param name="transportException">the transport exception
/// that was raised</param>
/// <param name="onSetup">true indicates that the crash was
/// encountered when setting up the process and not when the
/// command was run</param>
private void HandleTransportError(PSRemotingTransportException transportException, bool onSetup)
{
_tracer.TraceException(transportException);
if (ProcessCrashed != null)
{
ActivityHostCrashedEventArgs eventArgs = new ActivityHostCrashedEventArgs
{FailureOnSetup = onSetup,
Invoker = _currentInvoker};
ProcessCrashed(this, eventArgs);
}
}
/// <summary>
/// Handler which handles transport errors.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
internal void HandleTransportError(object sender, TransportErrorOccuredEventArgs e)
{
Dbg.Assert(e != null, "HandleTransportError expects non-null eventargs");
// handle uri redirections
PSRemotingTransportRedirectException redirectException = e.Exception as PSRemotingTransportRedirectException;
if ((redirectException != null) && (_maxUriRedirectionCount > 0))
{
Exception exception = null;
try
{
// honor max redirection count given by the user.
_maxUriRedirectionCount--;
PerformURIRedirection(redirectException.RedirectLocation);
return;
}
catch (ArgumentNullException argumentException)
{
exception = argumentException;
}
catch (UriFormatException uriFormatException)
{
exception = uriFormatException;
}
// if we are here, there must be an exception constructing a uri
if (null != exception)
{
PSRemotingTransportException newException =
new PSRemotingTransportException(PSRemotingErrorId.RedirectedURINotWellFormatted, RemotingErrorIdStrings.RedirectedURINotWellFormatted,
_session.Context.RemoteAddress.OriginalString,
redirectException.RedirectLocation);
newException.TransportMessage = e.Exception.TransportMessage;
e.Exception = newException;
}
}
RemoteSessionEvent sessionEvent = RemoteSessionEvent.ConnectFailed;
switch (e.ReportingTransportMethod)
{
case TransportMethodEnum.CreateShellEx:
sessionEvent = RemoteSessionEvent.ConnectFailed;
break;
case TransportMethodEnum.SendShellInputEx:
case TransportMethodEnum.CommandInputEx:
sessionEvent = RemoteSessionEvent.SendFailed;
break;
case TransportMethodEnum.ReceiveShellOutputEx:
case TransportMethodEnum.ReceiveCommandOutputEx:
sessionEvent = RemoteSessionEvent.ReceiveFailed;
break;
case TransportMethodEnum.CloseShellOperationEx:
sessionEvent = RemoteSessionEvent.CloseFailed;
break;
case TransportMethodEnum.DisconnectShellEx:
sessionEvent = RemoteSessionEvent.DisconnectFailed;
break;
case TransportMethodEnum.ReconnectShellEx:
sessionEvent = RemoteSessionEvent.ReconnectFailed;
break;
}
RemoteSessionStateMachineEventArgs errorArgs =
new RemoteSessionStateMachineEventArgs(sessionEvent, e.Exception);
_stateMachine.RaiseEvent(errorArgs);
}
private void OnExited(object sender, EventArgs e)
{
TransportMethodEnum unknown = TransportMethodEnum.Unknown;
lock (base.syncObject)
{
if (base.isClosed)
{
unknown = TransportMethodEnum.CloseShellOperationEx;
}
this.stdInWriter.StopWriting();
}
PSRemotingTransportException exception = new PSRemotingTransportException(PSRemotingErrorId.IPCServerProcessExited, RemotingErrorIdStrings.IPCServerProcessExited, new object[0]);
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(exception, unknown));
}
/// <summary>
/// Process data coming from the transport. This method analyses the data
/// and if an object can be created, it creates one and calls the
/// <paramref name="callback"/> with the deserialized object. This method
/// does not assume all fragments to be available. So if not enough fragments are
/// available it will simply return..
/// </summary>
/// <param name="data">
/// Data to process.
/// </param>
/// <param name="callback">
/// Callback to call once a complete deserialized object is available.
/// </param>
/// <returns>
/// Defragmented Object if any, otherwise null.
/// </returns>
/// <exception cref="PSRemotingTransportException">
/// 1. Fragment Ids not in sequence
/// 2. Object Ids does not match
/// 3. The current deserialized object size of the received data exceeded
/// allowed maximum object size. The current deserialized object size is {0}.
/// Allowed maximum object size is {1}.
/// </exception>
/// <remarks>
/// Might throw other exceptions as the deserialized object is handled here.
/// </remarks>
internal void ProcessRawData(byte[] data, OnDataAvailableCallback callback)
{
Dbg.Assert(data != null, "Cannot process null data");
Dbg.Assert(callback != null, "Callback cannot be null");
lock (_syncObject)
{
if (_isDisposed)
{
return;
}
_numberOfThreadsProcessing++;
if (_numberOfThreadsProcessing > _maxNumberOfThreadsToAllowForProcessing)
{
Dbg.Assert(false, "Multiple threads are not allowed in ProcessRawData.");
}
}
try
{
_pendingDataStream.Write(data, 0, data.Length);
// this do loop will process one deserialized object.
// using a loop allows to process multiple objects within
// the same packet
while (true)
{
if (_pendingDataStream.Length <= FragmentedRemoteObject.HeaderLength)
{
// there is not enough data to be processed.
s_baseTracer.WriteLine("Not enough data to process. Data is less than header length. Data length is {0}. Header Length {1}.",
_pendingDataStream.Length, FragmentedRemoteObject.HeaderLength);
return;
}
byte[] dataRead = _pendingDataStream.ToArray();
// there is enough data to process here. get the fragment header
long objectId = FragmentedRemoteObject.GetObjectId(dataRead, 0);
if (objectId <= 0)
{
throw new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdCannotBeLessThanZero);
}
long fragmentId = FragmentedRemoteObject.GetFragmentId(dataRead, 0);
bool sFlag = FragmentedRemoteObject.GetIsStartFragment(dataRead, 0);
bool eFlag = FragmentedRemoteObject.GetIsEndFragment(dataRead, 0);
int blobLength = FragmentedRemoteObject.GetBlobLength(dataRead, 0);
if ((s_baseTracer.Options & PSTraceSourceOptions.WriteLine) != PSTraceSourceOptions.None)
{
s_baseTracer.WriteLine("Object Id: {0}", objectId);
s_baseTracer.WriteLine("Fragment Id: {0}", fragmentId);
s_baseTracer.WriteLine("Start Flag: {0}", sFlag);
s_baseTracer.WriteLine("End Flag: {0}", eFlag);
s_baseTracer.WriteLine("Blob Length: {0}", blobLength);
}
int totalLengthOfFragment = 0;
try
{
totalLengthOfFragment = checked (FragmentedRemoteObject.HeaderLength + blobLength);
}
catch (System.OverflowException)
{
s_baseTracer.WriteLine("Fragment too big.");
ResetReceiveData();
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIsTooBig);
throw e;
}
if (_pendingDataStream.Length < totalLengthOfFragment)
{
s_baseTracer.WriteLine("Not enough data to process packet. Data is less than expected blob length. Data length {0}. Expected Length {1}.",
_pendingDataStream.Length, totalLengthOfFragment);
return;
}
// ensure object size limit is not reached
if (_maxReceivedObjectSize.HasValue)
{
_totalReceivedObjectSizeSoFar = unchecked (_totalReceivedObjectSizeSoFar + totalLengthOfFragment);
if ((_totalReceivedObjectSizeSoFar < 0) || (_totalReceivedObjectSizeSoFar > _maxReceivedObjectSize.Value))
{
s_baseTracer.WriteLine("ObjectSize > MaxReceivedObjectSize. ObjectSize is {0}. MaxReceivedObjectSize is {1}",
_totalReceivedObjectSizeSoFar, _maxReceivedObjectSize);
PSRemotingTransportException e = null;
if (_isCreateByClientTM)
{
e = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumClient,
RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumClient,
_totalReceivedObjectSizeSoFar, _maxReceivedObjectSize);
}
else
{
e = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumServer,
RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumServer,
_totalReceivedObjectSizeSoFar, _maxReceivedObjectSize);
}
ResetReceiveData();
throw e;
}
}
// appears like stream doesn't have individual position marker for read and write
// since we are going to read from now...
_pendingDataStream.Seek(0, SeekOrigin.Begin);
// we have enough data to process..so read the data from the stream and process.
byte[] oneFragment = new byte[totalLengthOfFragment];
// this will change position back to totalLengthOfFragment
int dataCount = _pendingDataStream.Read(oneFragment, 0, totalLengthOfFragment);
Dbg.Assert(dataCount == totalLengthOfFragment, "Unable to read enough data from the stream. Read failed");
PSEtwLog.LogAnalyticVerbose(
PSEventId.ReceivedRemotingFragment, PSOpcode.Receive, PSTask.None,
PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic,
(Int64)objectId,
(Int64)fragmentId,
sFlag ? 1 : 0,
eFlag ? 1 : 0,
(UInt32)blobLength,
new PSETWBinaryBlob(oneFragment, FragmentedRemoteObject.HeaderLength, blobLength));
byte[] extraData = null;
if (totalLengthOfFragment < _pendingDataStream.Length)
{
// there is more data in the stream than fragment size..so save that data
extraData = new byte[_pendingDataStream.Length - totalLengthOfFragment];
_pendingDataStream.Read(extraData, 0, (int)(_pendingDataStream.Length - totalLengthOfFragment));
}
// reset incoming stream.
_pendingDataStream.Dispose();
_pendingDataStream = new MemoryStream();
if (extraData != null)
{
_pendingDataStream.Write(extraData, 0, extraData.Length);
}
if (sFlag)
{
_canIgnoreOffSyncFragments = false; // reset this upon receiving a start fragment of a fresh object
_currentObjectId = objectId;
// Memory streams created with an unsigned byte array provide a non-resizable stream view
// of the data, and can only be written to. When using a byte array, you can neither append
// to nor shrink the stream, although you might be able to modify the existing contents
// depending on the parameters passed into the constructor. Empty memory streams are
// resizable, and can be written to and read from.
_dataToProcessStream = new MemoryStream();
}
else
{
// check if the data belongs to the same object as the start fragment
if (objectId != _currentObjectId)
{
s_baseTracer.WriteLine("ObjectId != CurrentObjectId");
// TODO - drop an ETW event
ResetReceiveData();
if (!_canIgnoreOffSyncFragments)
{
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdsNotMatching);
throw e;
}
else
{
s_baseTracer.WriteLine("Ignoring ObjectId != CurrentObjectId");
continue;
}
}
if (fragmentId != (_currentFrgId + 1))
{
s_baseTracer.WriteLine("Fragment Id is not in sequence.");
// TODO - drop an ETW event
ResetReceiveData();
if (!_canIgnoreOffSyncFragments)
{
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.FragmentIdsNotInSequence);
throw e;
}
else
{
s_baseTracer.WriteLine("Ignoring Fragment Id is not in sequence.");
continue;
}
}
}
// make fragment id from this packet as the current fragment id
_currentFrgId = fragmentId;
// store the blob in a separate stream
_dataToProcessStream.Write(oneFragment, FragmentedRemoteObject.HeaderLength, blobLength);
if (eFlag)
{
try
{
// appears like stream doesn't individual position marker for read and write
// since we are going to read from now..i am resetting position to 0.
_dataToProcessStream.Seek(0, SeekOrigin.Begin);
RemoteDataObject <PSObject> remoteObject = RemoteDataObject <PSObject> .CreateFrom(_dataToProcessStream, _defragmentor);
s_baseTracer.WriteLine("Runspace Id: {0}", remoteObject.RunspacePoolId);
s_baseTracer.WriteLine("PowerShell Id: {0}", remoteObject.PowerShellId);
// notify the caller that a deserialized object is available.
callback(remoteObject);
}
finally
{
// Reset the receive data buffers and start the process again.
ResetReceiveData();
}
if (_isDisposed)
{
break;
}
}
}
}
finally
{
lock (_syncObject)
{
if (_isDisposed && (_numberOfThreadsProcessing == 1))
{
ReleaseResources();
}
_numberOfThreadsProcessing--;
}
}
}
internal override void ConnectAsync()
{
base.ReceivedDataCollection.PrepareForStreamConnect();
base.serializedPipeline.Read();
this.cmdContextId = GetNextCmdTMHandleId();
AddCmdTransportManager(this.cmdContextId, this);
this.connectCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdConnectCallback);
this.reconnectCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdReconnectCallback);
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
WSManNativeApi.WSManConnectShellCommandEx(this.wsManShellOperationHandle, 0, base.PowershellInstanceId.ToString().ToUpper(CultureInfo.InvariantCulture), IntPtr.Zero, IntPtr.Zero, (IntPtr) this.connectCmdCompleted, ref this.wsManCmdOperationHandle);
}
if (this.wsManCmdOperationHandle == IntPtr.Zero)
{
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.RunShellCommandExFailed);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ConnectShellCommandEx);
this.ProcessWSManTransportError(eventArgs);
}
}
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 void OnSignalTimeOutTimerElapsed(object source, ElapsedEventArgs e)
{
this.StopSignalTimerAndDecrementOperations();
if (!base.isClosed)
{
PSRemotingTransportException exception = new PSRemotingTransportException(RemotingErrorIdStrings.IPCSignalTimedOut);
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(exception, TransportMethodEnum.ReceiveShellOutputEx));
}
}
private void DoClose(object sender, RemoteSessionStateMachineEventArgs fsmEventArg)
{
using (_trace.TraceEventHandlers())
{
if (fsmEventArg == null)
{
throw PSTraceSource.NewArgumentNullException("fsmEventArg");
}
switch (this._state)
{
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.EstablishedAndKeyExchanged:
this.SetState(RemoteSessionState.ClosingConnection, fsmEventArg.Reason);
this._session.SessionDataStructureHandler.CloseConnectionAsync(fsmEventArg.Reason);
break;
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
break;
default:
{
Exception reasion = new PSRemotingTransportException(fsmEventArg.Reason, RemotingErrorIdStrings.ForceClosed, new object[0]);
this.SetState(RemoteSessionState.Closed, reasion);
break;
}
}
this.CleanAll();
}
}
internal void ProcessRawData(byte[] data, OnDataAvailableCallback callback)
{
lock (this.syncObject)
{
if (this.isDisposed)
{
return;
}
this.numberOfThreadsProcessing++;
int maxNumberOfThreadsToAllowForProcessing = this.maxNumberOfThreadsToAllowForProcessing;
int numberOfThreadsProcessing = this.numberOfThreadsProcessing;
}
try
{
this.pendingDataStream.Write(data, 0, data.Length);
Label_005A:
if (this.pendingDataStream.Length <= 0x15L)
{
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Not enough data to process. Data is less than header length. Data length is {0}. Header Length {1}.", new object[] { this.pendingDataStream.Length, 0x15 }), new object[0]);
}
else
{
byte[] fragmentBytes = this.pendingDataStream.GetBuffer();
long objectId = FragmentedRemoteObject.GetObjectId(fragmentBytes, 0);
if (objectId <= 0L)
{
throw new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdCannotBeLessThanZero);
}
long fragmentId = FragmentedRemoteObject.GetFragmentId(fragmentBytes, 0);
bool isStartFragment = FragmentedRemoteObject.GetIsStartFragment(fragmentBytes, 0);
bool isEndFragment = FragmentedRemoteObject.GetIsEndFragment(fragmentBytes, 0);
int blobLength = FragmentedRemoteObject.GetBlobLength(fragmentBytes, 0);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Object Id: {0}", new object[] { objectId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Fragment Id: {0}", new object[] { fragmentId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Start Flag: {0}", new object[] { isStartFragment }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "End Flag: {0}", new object[] { isEndFragment }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Blob Length: {0}", new object[] { blobLength }), new object[0]);
int count = 0;
try
{
count = 0x15 + blobLength;
}
catch (OverflowException)
{
baseTracer.WriteLine("Fragement too big.", new object[0]);
this.ResetRecieveData();
PSRemotingTransportException exception = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIsTooBig);
throw exception;
}
if (this.pendingDataStream.Length < count)
{
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Not enough data to process packet. Data is less than expected blob length. Data length {0}. Expected Length {1}.", new object[] { this.pendingDataStream.Length, count }), new object[0]);
}
else
{
if (this.maxReceivedObjectSize.HasValue)
{
this.totalReceivedObjectSizeSoFar += count;
if ((this.totalReceivedObjectSizeSoFar < 0) || (this.totalReceivedObjectSizeSoFar > this.maxReceivedObjectSize.Value))
{
baseTracer.WriteLine("ObjectSize > MaxReceivedObjectSize. ObjectSize is {0}. MaxReceivedObjectSize is {1}", new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
PSRemotingTransportException exception2 = null;
if (this.isCreateByClientTM)
{
exception2 = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumClient, RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumClient, new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
}
else
{
exception2 = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumServer, RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumServer, new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
}
this.ResetRecieveData();
throw exception2;
}
}
this.pendingDataStream.Seek(0L, SeekOrigin.Begin);
byte[] buffer = new byte[count];
this.pendingDataStream.Read(buffer, 0, count);
PSEtwLog.LogAnalyticVerbose(PSEventId.ReceivedRemotingFragment, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, objectId, fragmentId, isStartFragment ? 1 : 0, isEndFragment ? 1 : 0, (int) blobLength, new PSETWBinaryBlob(buffer, 0x15, blobLength));
byte[] buffer3 = null;
if (count < this.pendingDataStream.Length)
{
buffer3 = new byte[this.pendingDataStream.Length - count];
this.pendingDataStream.Read(buffer3, 0, ((int) this.pendingDataStream.Length) - count);
}
this.pendingDataStream.Close();
this.pendingDataStream = new MemoryStream();
if (buffer3 != null)
{
this.pendingDataStream.Write(buffer3, 0, buffer3.Length);
}
if (isStartFragment)
{
this.canIgnoreOffSyncFragments = false;
this.currentObjectId = objectId;
this.dataToProcessStream = new MemoryStream();
}
else
{
if (objectId != this.currentObjectId)
{
baseTracer.WriteLine("ObjectId != CurrentObjectId", new object[0]);
this.ResetRecieveData();
if (!this.canIgnoreOffSyncFragments)
{
PSRemotingTransportException exception3 = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdsNotMatching);
throw exception3;
}
baseTracer.WriteLine("Ignoring ObjectId != CurrentObjectId", new object[0]);
goto Label_005A;
}
if (fragmentId != (this.currentFrgId + 1L))
{
baseTracer.WriteLine("Fragment Id is not in sequence.", new object[0]);
this.ResetRecieveData();
if (!this.canIgnoreOffSyncFragments)
{
PSRemotingTransportException exception4 = new PSRemotingTransportException(RemotingErrorIdStrings.FragmetIdsNotInSequence);
throw exception4;
}
baseTracer.WriteLine("Ignoring Fragment Id is not in sequence.", new object[0]);
goto Label_005A;
}
}
this.currentFrgId = fragmentId;
this.dataToProcessStream.Write(buffer, 0x15, blobLength);
if (!isEndFragment)
{
goto Label_005A;
}
try
{
this.dataToProcessStream.Seek(0L, SeekOrigin.Begin);
RemoteDataObject<PSObject> obj2 = RemoteDataObject<PSObject>.CreateFrom(this.dataToProcessStream, this.defragmentor);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Runspace Id: {0}", new object[] { obj2.RunspacePoolId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "PowerShell Id: {0}", new object[] { obj2.PowerShellId }), new object[0]);
callback(obj2);
}
finally
{
this.ResetRecieveData();
}
if (!this.isDisposed && this.pendingDataStream.Length > 0x15L)
{
goto Label_005A;
}
}
}
}
finally
{
lock (this.syncObject)
{
if (this.isDisposed && (this.numberOfThreadsProcessing == 1))
{
this.ReleaseResources();
}
this.numberOfThreadsProcessing--;
}
}
}
internal void OnCloseTimeOutTimerElapsed(object source, ElapsedEventArgs e)
{
this.closeTimeOutTimer.Stop();
PSRemotingTransportException exception = new PSRemotingTransportException(PSRemotingErrorId.IPCCloseTimedOut, RemotingErrorIdStrings.IPCCloseTimedOut, new object[0]);
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(exception, TransportMethodEnum.CloseShellOperationEx));
}
internal void ProcessRawData(byte[] data, OnDataAvailableCallback callback)
{
lock (this.syncObject)
{
if (this.isDisposed)
{
return;
}
this.numberOfThreadsProcessing++;
int maxNumberOfThreadsToAllowForProcessing = this.maxNumberOfThreadsToAllowForProcessing;
int numberOfThreadsProcessing = this.numberOfThreadsProcessing;
}
try
{
this.pendingDataStream.Write(data, 0, data.Length);
Label_005A:
if (this.pendingDataStream.Length <= 0x15L)
{
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Not enough data to process. Data is less than header length. Data length is {0}. Header Length {1}.", new object[] { this.pendingDataStream.Length, 0x15 }), new object[0]);
}
else
{
byte[] fragmentBytes = this.pendingDataStream.GetBuffer();
long objectId = FragmentedRemoteObject.GetObjectId(fragmentBytes, 0);
if (objectId <= 0L)
{
throw new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdCannotBeLessThanZero);
}
long fragmentId = FragmentedRemoteObject.GetFragmentId(fragmentBytes, 0);
bool isStartFragment = FragmentedRemoteObject.GetIsStartFragment(fragmentBytes, 0);
bool isEndFragment = FragmentedRemoteObject.GetIsEndFragment(fragmentBytes, 0);
int blobLength = FragmentedRemoteObject.GetBlobLength(fragmentBytes, 0);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Object Id: {0}", new object[] { objectId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Fragment Id: {0}", new object[] { fragmentId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Start Flag: {0}", new object[] { isStartFragment }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "End Flag: {0}", new object[] { isEndFragment }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Blob Length: {0}", new object[] { blobLength }), new object[0]);
int count = 0;
try
{
count = 0x15 + blobLength;
}
catch (OverflowException)
{
baseTracer.WriteLine("Fragement too big.", new object[0]);
this.ResetRecieveData();
PSRemotingTransportException exception = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIsTooBig);
throw exception;
}
if (this.pendingDataStream.Length < count)
{
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Not enough data to process packet. Data is less than expected blob length. Data length {0}. Expected Length {1}.", new object[] { this.pendingDataStream.Length, count }), new object[0]);
}
else
{
if (this.maxReceivedObjectSize.HasValue)
{
this.totalReceivedObjectSizeSoFar += count;
if ((this.totalReceivedObjectSizeSoFar < 0) || (this.totalReceivedObjectSizeSoFar > this.maxReceivedObjectSize.Value))
{
baseTracer.WriteLine("ObjectSize > MaxReceivedObjectSize. ObjectSize is {0}. MaxReceivedObjectSize is {1}", new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
PSRemotingTransportException exception2 = null;
if (this.isCreateByClientTM)
{
exception2 = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumClient, RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumClient, new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
}
else
{
exception2 = new PSRemotingTransportException(PSRemotingErrorId.ReceivedObjectSizeExceededMaximumServer, RemotingErrorIdStrings.ReceivedObjectSizeExceededMaximumServer, new object[] { this.totalReceivedObjectSizeSoFar, this.maxReceivedObjectSize });
}
this.ResetRecieveData();
throw exception2;
}
}
this.pendingDataStream.Seek(0L, SeekOrigin.Begin);
byte[] buffer = new byte[count];
this.pendingDataStream.Read(buffer, 0, count);
PSEtwLog.LogAnalyticVerbose(PSEventId.ReceivedRemotingFragment, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, objectId, fragmentId, isStartFragment ? 1 : 0, isEndFragment ? 1 : 0, (int)blobLength, new PSETWBinaryBlob(buffer, 0x15, blobLength));
byte[] buffer3 = null;
if (count < this.pendingDataStream.Length)
{
buffer3 = new byte[this.pendingDataStream.Length - count];
this.pendingDataStream.Read(buffer3, 0, ((int)this.pendingDataStream.Length) - count);
}
this.pendingDataStream.Close();
this.pendingDataStream = new MemoryStream();
if (buffer3 != null)
{
this.pendingDataStream.Write(buffer3, 0, buffer3.Length);
}
if (isStartFragment)
{
this.canIgnoreOffSyncFragments = false;
this.currentObjectId = objectId;
this.dataToProcessStream = new MemoryStream();
}
else
{
if (objectId != this.currentObjectId)
{
baseTracer.WriteLine("ObjectId != CurrentObjectId", new object[0]);
this.ResetRecieveData();
if (!this.canIgnoreOffSyncFragments)
{
PSRemotingTransportException exception3 = new PSRemotingTransportException(RemotingErrorIdStrings.ObjectIdsNotMatching);
throw exception3;
}
baseTracer.WriteLine("Ignoring ObjectId != CurrentObjectId", new object[0]);
goto Label_005A;
}
if (fragmentId != (this.currentFrgId + 1L))
{
baseTracer.WriteLine("Fragment Id is not in sequence.", new object[0]);
this.ResetRecieveData();
if (!this.canIgnoreOffSyncFragments)
{
PSRemotingTransportException exception4 = new PSRemotingTransportException(RemotingErrorIdStrings.FragmetIdsNotInSequence);
throw exception4;
}
baseTracer.WriteLine("Ignoring Fragment Id is not in sequence.", new object[0]);
goto Label_005A;
}
}
this.currentFrgId = fragmentId;
this.dataToProcessStream.Write(buffer, 0x15, blobLength);
if (!isEndFragment)
{
goto Label_005A;
}
try
{
this.dataToProcessStream.Seek(0L, SeekOrigin.Begin);
RemoteDataObject <PSObject> obj2 = RemoteDataObject <PSObject> .CreateFrom(this.dataToProcessStream, this.defragmentor);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Runspace Id: {0}", new object[] { obj2.RunspacePoolId }), new object[0]);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "PowerShell Id: {0}", new object[] { obj2.PowerShellId }), new object[0]);
callback(obj2);
}
finally
{
this.ResetRecieveData();
}
if (!this.isDisposed && this.pendingDataStream.Length > 0x15L)
{
goto Label_005A;
}
}
}
}
finally
{
lock (this.syncObject)
{
if (this.isDisposed && (this.numberOfThreadsProcessing == 1))
{
this.ReleaseResources();
}
this.numberOfThreadsProcessing--;
}
}
}
internal void HandleTransportError(object sender, TransportErrorOccuredEventArgs e)
{
PSRemotingTransportRedirectException exception = e.Exception as PSRemotingTransportRedirectException;
if ((exception != null) && (this.maxUriRedirectionCount > 0))
{
Exception exception2 = null;
try
{
this.maxUriRedirectionCount--;
this.PerformURIRedirection(exception.RedirectLocation);
return;
}
catch (ArgumentNullException exception3)
{
exception2 = exception3;
}
catch (UriFormatException exception4)
{
exception2 = exception4;
}
if (exception2 != null)
{
PSRemotingTransportException exception5 = new PSRemotingTransportException(PSRemotingErrorId.RedirectedURINotWellFormatted, RemotingErrorIdStrings.RedirectedURINotWellFormatted, new object[] { this._session.Context.RemoteAddress.OriginalString, exception.RedirectLocation })
{
TransportMessage = e.Exception.TransportMessage
};
e.Exception = exception5;
}
}
RemoteSessionEvent connectFailed = RemoteSessionEvent.ConnectFailed;
switch (e.ReportingTransportMethod)
{
case TransportMethodEnum.CreateShellEx:
connectFailed = RemoteSessionEvent.ConnectFailed;
break;
case TransportMethodEnum.SendShellInputEx:
case TransportMethodEnum.CommandInputEx:
connectFailed = RemoteSessionEvent.SendFailed;
break;
case TransportMethodEnum.ReceiveShellOutputEx:
case TransportMethodEnum.ReceiveCommandOutputEx:
connectFailed = RemoteSessionEvent.ReceiveFailed;
break;
case TransportMethodEnum.CloseShellOperationEx:
connectFailed = RemoteSessionEvent.CloseFailed;
break;
case TransportMethodEnum.DisconnectShellEx:
connectFailed = RemoteSessionEvent.DisconnectFailed;
break;
case TransportMethodEnum.ReconnectShellEx:
connectFailed = RemoteSessionEvent.ReconnectFailed;
break;
}
RemoteSessionStateMachineEventArgs arg = new RemoteSessionStateMachineEventArgs(connectFailed, e.Exception);
this._stateMachine.RaiseEvent(arg, false);
}
internal void HandleTransportError(object sender, TransportErrorOccuredEventArgs e)
{
PSRemotingTransportRedirectException exception = e.Exception as PSRemotingTransportRedirectException;
if ((exception != null) && (this.maxUriRedirectionCount > 0))
{
Exception exception2 = null;
try
{
this.maxUriRedirectionCount--;
this.PerformURIRedirection(exception.RedirectLocation);
return;
}
catch (ArgumentNullException exception3)
{
exception2 = exception3;
}
catch (UriFormatException exception4)
{
exception2 = exception4;
}
if (exception2 != null)
{
PSRemotingTransportException exception5 = new PSRemotingTransportException(PSRemotingErrorId.RedirectedURINotWellFormatted, RemotingErrorIdStrings.RedirectedURINotWellFormatted, new object[] { this._session.Context.RemoteAddress.OriginalString, exception.RedirectLocation }) {
TransportMessage = e.Exception.TransportMessage
};
e.Exception = exception5;
}
}
RemoteSessionEvent connectFailed = RemoteSessionEvent.ConnectFailed;
switch (e.ReportingTransportMethod)
{
case TransportMethodEnum.CreateShellEx:
connectFailed = RemoteSessionEvent.ConnectFailed;
break;
case TransportMethodEnum.SendShellInputEx:
case TransportMethodEnum.CommandInputEx:
connectFailed = RemoteSessionEvent.SendFailed;
break;
case TransportMethodEnum.ReceiveShellOutputEx:
case TransportMethodEnum.ReceiveCommandOutputEx:
connectFailed = RemoteSessionEvent.ReceiveFailed;
break;
case TransportMethodEnum.CloseShellOperationEx:
connectFailed = RemoteSessionEvent.CloseFailed;
break;
case TransportMethodEnum.DisconnectShellEx:
connectFailed = RemoteSessionEvent.DisconnectFailed;
break;
case TransportMethodEnum.ReconnectShellEx:
connectFailed = RemoteSessionEvent.ReconnectFailed;
break;
}
RemoteSessionStateMachineEventArgs arg = new RemoteSessionStateMachineEventArgs(connectFailed, e.Exception);
this._stateMachine.RaiseEvent(arg, false);
}
/// <summary>
/// This is the handler for Close event.
/// </summary>
/// <param name="sender"></param>
/// <param name="arg">
/// This parameter contains the FSM event.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If the parameter <paramref name="arg"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the parameter <paramref name="arg"/> does not contain remote data.
/// </exception>
private void DoClose(object sender, RemoteSessionStateMachineEventArgs arg)
{
using (s_trace.TraceEventHandlers())
{
RemoteSessionState oldState = _state;
switch (oldState)
{
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
// do nothing
break;
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeyReceived: //TODO - Client session would never get into this state... to be removed
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.Disconnected:
case RemoteSessionState.Disconnecting:
case RemoteSessionState.Reconnecting:
case RemoteSessionState.RCDisconnecting:
SetState(RemoteSessionState.ClosingConnection, arg.Reason);
break;
case RemoteSessionState.Idle:
case RemoteSessionState.UndefinedState:
default:
PSRemotingTransportException forceClosedException = new PSRemotingTransportException(arg.Reason, RemotingErrorIdStrings.ForceClosed);
SetState(RemoteSessionState.Closed, forceClosedException);
break;
}
CleanAll();
}
}
private void HandleTransportError(PSRemotingTransportException transportException, bool onSetup)
{
this._tracer.TraceException(transportException);
if (this.ProcessCrashed != null)
{
ActivityHostCrashedEventArgs activityHostCrashedEventArg = new ActivityHostCrashedEventArgs();
activityHostCrashedEventArg.FailureOnSetup = onSetup;
activityHostCrashedEventArg.Invoker = this._currentInvoker;
ActivityHostCrashedEventArgs activityHostCrashedEventArg1 = activityHostCrashedEventArg;
this.ProcessCrashed(this, activityHostCrashedEventArg1);
}
}
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();
}
private void DoClose(object sender, RemoteSessionStateMachineEventArgs arg)
{
using (_trace.TraceEventHandlers())
{
switch (this._state)
{
case RemoteSessionState.Connecting:
case RemoteSessionState.Connected:
case RemoteSessionState.NegotiationSending:
case RemoteSessionState.NegotiationSent:
case RemoteSessionState.NegotiationReceived:
case RemoteSessionState.Established:
case RemoteSessionState.EstablishedAndKeySent:
case RemoteSessionState.EstablishedAndKeyReceived:
case RemoteSessionState.Disconnecting:
case RemoteSessionState.Disconnected:
case RemoteSessionState.Reconnecting:
case RemoteSessionState.RCDisconnecting:
this.SetState(RemoteSessionState.ClosingConnection, arg.Reason);
break;
case RemoteSessionState.ClosingConnection:
case RemoteSessionState.Closed:
break;
default:
{
PSRemotingTransportException reason = new PSRemotingTransportException(arg.Reason, RemotingErrorIdStrings.ForceClosed, new object[0]);
this.SetState(RemoteSessionState.Closed, reason);
break;
}
}
this.CleanAll();
}
}
/// <summary>
/// Handler which handles transport errors.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
internal void HandleTransportError(object sender, TransportErrorOccuredEventArgs e)
{
Dbg.Assert(e != null, "HandleTransportError expects non-null eventargs");
// handle uri redirections
PSRemotingTransportRedirectException redirectException = e.Exception as PSRemotingTransportRedirectException;
if ((redirectException != null) && (_maxUriRedirectionCount > 0))
{
Exception exception = null;
try
{
// honor max redirection count given by the user.
_maxUriRedirectionCount--;
PerformURIRedirection(redirectException.RedirectLocation);
return;
}
catch (ArgumentNullException argumentException)
{
exception = argumentException;
}
catch (UriFormatException uriFormatException)
{
exception = uriFormatException;
}
// if we are here, there must be an exception constructing a uri
if (exception != null)
{
PSRemotingTransportException newException =
new PSRemotingTransportException(PSRemotingErrorId.RedirectedURINotWellFormatted, RemotingErrorIdStrings.RedirectedURINotWellFormatted,
_session.Context.RemoteAddress.OriginalString,
redirectException.RedirectLocation);
newException.TransportMessage = e.Exception.TransportMessage;
e.Exception = newException;
}
}
RemoteSessionEvent sessionEvent = RemoteSessionEvent.ConnectFailed;
switch (e.ReportingTransportMethod)
{
case TransportMethodEnum.CreateShellEx:
sessionEvent = RemoteSessionEvent.ConnectFailed;
break;
case TransportMethodEnum.SendShellInputEx:
case TransportMethodEnum.CommandInputEx:
sessionEvent = RemoteSessionEvent.SendFailed;
break;
case TransportMethodEnum.ReceiveShellOutputEx:
case TransportMethodEnum.ReceiveCommandOutputEx:
sessionEvent = RemoteSessionEvent.ReceiveFailed;
break;
case TransportMethodEnum.CloseShellOperationEx:
sessionEvent = RemoteSessionEvent.CloseFailed;
break;
case TransportMethodEnum.DisconnectShellEx:
sessionEvent = RemoteSessionEvent.DisconnectFailed;
break;
case TransportMethodEnum.ReconnectShellEx:
sessionEvent = RemoteSessionEvent.ReconnectFailed;
break;
}
RemoteSessionStateMachineEventArgs errorArgs =
new RemoteSessionStateMachineEventArgs(sessionEvent, e.Exception);
_stateMachine.RaiseEvent(errorArgs);
}
private void OnErrorDataReceived(object sender, DataReceivedEventArgs e)
{
lock (base.syncObject)
{
if (base.isClosed)
{
return;
}
}
PSRemotingTransportException exception = new PSRemotingTransportException(PSRemotingErrorId.IPCServerProcessReportedError, RemotingErrorIdStrings.IPCServerProcessReportedError, new object[] { e.Data });
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(exception, TransportMethodEnum.Unknown));
}
private static void OnReconnectCmdCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
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("Cmd Signal callback: ShellOperationHandles are not the same as the signal is initiated with", new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.ReconnectShellCommandExCallBackError);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReconnectShellCommandEx);
cmdTransportManager.ProcessWSManTransportError(eventArgs);
}
else
{
if (IntPtr.Zero != error)
{
WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error);
if (errorStruct.errorCode != 0)
{
BaseClientTransportManager.tracer.WriteLine("OnReconnectCmdCompleted callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail });
TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.ReconnectShellCommandEx, RemotingErrorIdStrings.ReconnectShellCommandExCallBackError, new object[] { WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) });
cmdTransportManager.ProcessWSManTransportError(args2);
return;
}
}
cmdTransportManager.shouldStartReceivingData = true;
cmdTransportManager.SendOneItem();
cmdTransportManager.RaiseReconnectCompleted();
}
}
private static void OnRemoteSessionSendCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data)
{
BaseClientTransportManager.tracer.WriteLine("Client Session TM: SendComplete callback received", new object[0]);
long sessnTMId = 0L;
WSManClientSessionTransportManager sessnTransportManager = null;
if (!TryGetSessionTransportManager(operationContext, out sessnTransportManager, out sessnTMId))
{
BaseClientTransportManager.tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Unable to find a transport manager for context {0}.", new object[] { sessnTMId }), new object[0]);
}
else
{
PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputExCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { sessnTransportManager.RunspacePoolInstanceId.ToString(), Guid.Empty.ToString() });
if (!shellOperationHandle.Equals(sessnTransportManager.wsManShellOperationHandle))
{
PSRemotingTransportException e = new PSRemotingTransportException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.SendExFailed, new object[] { sessnTransportManager.ConnectionInfo.ComputerName }));
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.SendShellInputEx);
sessnTransportManager.ProcessWSManTransportError(eventArgs);
}
else
{
sessnTransportManager.ClearReceiveOrSendResources(flags, true);
if (sessnTransportManager.isClosed)
{
BaseClientTransportManager.tracer.WriteLine("Client Session 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) && (errorStruct.errorCode != 0x3e3))
{
BaseClientTransportManager.tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Got error with error code {0}. Message {1}", new object[] { errorStruct.errorCode, errorStruct.errorDetail }), new object[0]);
TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(wsManApiStaticData.WSManAPIHandle, sessnTransportManager, errorStruct, TransportMethodEnum.SendShellInputEx, RemotingErrorIdStrings.SendExCallBackError, new object[] { sessnTransportManager.ConnectionInfo.ComputerName, WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) });
sessnTransportManager.ProcessWSManTransportError(args2);
return;
}
}
sessnTransportManager.SendOneItem();
}
}
}
}
internal TransportErrorOccuredEventArgs(PSRemotingTransportException e, TransportMethodEnum m)
{
this.exception = e;
this.method = m;
}
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);
}
}
}
}
internal virtual void ProcessRawData(byte[] data, string stream)
{
try
{
this.ProcessRawData(data, stream, this.onDataAvailableCallback);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
baseTracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Exception processing data. {0}", new object[] { exception.Message }), new object[0]);
PSRemotingTransportException e = new PSRemotingTransportException(exception.Message, exception);
TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveShellOutputEx);
this.RaiseErrorHandler(eventArgs);
}
}