internal RemoteSessionStateInfo(RemoteSessionState state, Exception reason)
{
State = state;
Reason = reason;
}
internal abstract void SendNegotiationAsync(RemoteSessionState sessionState);
internal RemoteSessionStateInfo(RemoteSessionState state)
: this(state, null)
{
}
internal RemoteSessionStateInfo(RemoteSessionStateInfo sessionStateInfo)
{
this._state = sessionStateInfo.State;
this._reason = sessionStateInfo.Reason;
}
internal RemoteSessionStateInfo(RemoteSessionState state, Exception reason)
{
this._state = state;
this._reason = reason;
}
internal override void SendNegotiationAsync(RemoteSessionState sessionState)
{
RemoteSessionStateMachineEventArgs arg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.NegotiationSendCompleted);
this._stateMachine.RaiseEvent(arg, false);
if (sessionState == RemoteSessionState.NegotiationSending)
{
this._transportManager.CreateAsync();
}
else if (sessionState == RemoteSessionState.NegotiationSendingOnConnect)
{
this._transportManager.ConnectCompleted += new EventHandler<EventArgs>(this.HandleConnectComplete);
this._transportManager.ConnectAsync();
}
}
internal void ExecuteConnect(byte[] connectData, out byte[] connectResponseData)
{
RemoteSessionCapability sessionCapability;
connectResponseData = null;
Fragmentor fragmentor = new Fragmentor(0x7fffffff, null);
Fragmentor defragmentor = fragmentor;
int length = connectData.Length;
if (length < 0x15)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
FragmentedRemoteObject.GetFragmentId(connectData, 0);
bool isStartFragment = FragmentedRemoteObject.GetIsStartFragment(connectData, 0);
bool isEndFragment = FragmentedRemoteObject.GetIsEndFragment(connectData, 0);
int blobLength = FragmentedRemoteObject.GetBlobLength(connectData, 0);
if (blobLength > (length - 0x15))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
if (!isStartFragment || !isEndFragment)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
RemoteSessionState state = this.SessionDataStructureHandler.StateMachine.State;
if ((state != RemoteSessionState.Established) && (state != RemoteSessionState.EstablishedAndKeyExchanged))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnServerStateValidation);
}
MemoryStream serializedDataStream = new MemoryStream();
serializedDataStream.Write(connectData, 0x15, blobLength);
serializedDataStream.Seek(0L, SeekOrigin.Begin);
RemoteDataObject <PSObject> obj2 = RemoteDataObject <PSObject> .CreateFrom(serializedDataStream, defragmentor);
if (obj2 == null)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
if ((obj2.Destination != (RemotingDestination.InvalidDestination | RemotingDestination.Server)) || (obj2.DataType != RemotingDataType.SessionCapability))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
int num3 = (length - 0x15) - blobLength;
if (num3 < 0x15)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
byte[] destinationArray = new byte[num3];
Array.Copy(connectData, 0x15 + blobLength, destinationArray, 0, num3);
FragmentedRemoteObject.GetFragmentId(destinationArray, 0);
isStartFragment = FragmentedRemoteObject.GetIsStartFragment(destinationArray, 0);
isEndFragment = FragmentedRemoteObject.GetIsEndFragment(destinationArray, 0);
blobLength = FragmentedRemoteObject.GetBlobLength(destinationArray, 0);
if (blobLength != (num3 - 0x15))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
if (!isStartFragment || !isEndFragment)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
serializedDataStream = new MemoryStream();
serializedDataStream.Write(destinationArray, 0x15, blobLength);
serializedDataStream.Seek(0L, SeekOrigin.Begin);
RemoteDataObject <PSObject> obj3 = RemoteDataObject <PSObject> .CreateFrom(serializedDataStream, defragmentor);
if (obj3 == null)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnServerStateValidation);
}
if ((obj3.Destination != (RemotingDestination.InvalidDestination | RemotingDestination.Server)) || (obj3.DataType != RemotingDataType.ConnectRunspacePool))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
try
{
sessionCapability = RemotingDecoder.GetSessionCapability(obj2.Data);
}
catch (PSRemotingDataStructureException)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
try
{
this.RunServerNegotiationAlgorithm(sessionCapability, true);
}
catch (PSRemotingDataStructureException exception)
{
throw exception;
}
int minRunspaces = -1;
int maxRunspaces = -1;
bool flag3 = false;
if ((obj3.Data.Properties["MinRunspaces"] != null) && (obj3.Data.Properties["MinRunspaces"] != null))
{
try
{
minRunspaces = RemotingDecoder.GetMinRunspaces(obj3.Data);
maxRunspaces = RemotingDecoder.GetMaxRunspaces(obj3.Data);
flag3 = true;
}
catch (PSRemotingDataStructureException)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
}
if (flag3 && (((minRunspaces == -1) || (maxRunspaces == -1)) || (minRunspaces > maxRunspaces)))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
if (this._runspacePoolDriver == null)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnServerStateValidation);
}
if (obj3.RunspacePoolId != this._runspacePoolDriver.InstanceId)
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnInputValidation);
}
if ((flag3 && (this._runspacePoolDriver.RunspacePool.GetMaxRunspaces() != maxRunspaces)) && (this._runspacePoolDriver.RunspacePool.GetMinRunspaces() != minRunspaces))
{
throw new PSRemotingDataStructureException(RemotingErrorIdStrings.ServerConnectFailedOnMismatchedRunspacePoolProperties);
}
RemoteDataObject obj4 = RemotingEncoder.GenerateServerSessionCapability(this._context.ServerCapability, this._runspacePoolDriver.InstanceId);
RemoteDataObject obj5 = RemotingEncoder.GenerateRunspacePoolInitData(this._runspacePoolDriver.InstanceId, this._runspacePoolDriver.RunspacePool.GetMaxRunspaces(), this._runspacePoolDriver.RunspacePool.GetMinRunspaces());
SerializedDataStream streamToWriteTo = new SerializedDataStream(0x1000);
streamToWriteTo.Enter();
obj4.Serialize(streamToWriteTo, fragmentor);
streamToWriteTo.Exit();
streamToWriteTo.Enter();
obj5.Serialize(streamToWriteTo, fragmentor);
streamToWriteTo.Exit();
byte[] buffer2 = streamToWriteTo.Read();
streamToWriteTo.Dispose();
connectResponseData = buffer2;
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object s) {
RemoteSessionStateMachineEventArgs fsmEventArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.ConnectSession);
this._sessionDSHandler.StateMachine.RaiseEvent(fsmEventArg);
}));
this._runspacePoolDriver.DataStructureHandler.ProcessConnect();
}
internal RemoteSessionStateInfo(RemoteSessionState state)
: this(state, null)
{
}
internal RemoteSessionStateInfo(RemoteSessionState state, Exception reason)
{
State = state;
Reason = reason;
}
public bool SetConnectionState(Guid connectionId, string IPAddress, Guid VMGuid, RemoteSessionState state)
{
var connection = connections[connectionId] as Connection;
if (connection != null)
{
Trace.TraceInformation("SetConnectionState: {0}, ip={1}, vm={2}, state={3}", connectionId, IPAddress, VMGuid != Guid.Empty ? VMGuid.ToString() : string.Empty, state);
connection.State = state;
return(true);
}
Trace.TraceInformation("invalid connection: {0}", connectionId);
return(false);
}
internal abstract void SendNegotiationAsync(RemoteSessionState sessionState);
public bool SetConnectionState(Guid connectionId, string IPAddress, Guid vmGuid, RemoteSessionState state)
{
// don't resend an unchanged connection state
var send = true;
lock (connectionsLock)
{
if (!connectionsState.ContainsKey(connectionId))
{
connectionsState.Add(connectionId, state);
}
else
{
send = connectionsState[connectionId] != state;
connectionsState[connectionId] = state;
}
}
if (!send)
{
return(true);
}
var restRequest = new RestRequest($"SetConnectionState?connectionId={connectionId}&IPAddress={IPAddress}&vmGuid={vmGuid}&state={state}", Method.GET);
var restResponse = restClient.Execute(restRequest);
if (restResponse.ResponseStatus != ResponseStatus.Completed)
{
throw new Exception(string.Format("Failed to call SetConnectionState; response status: {0}, code: {1}, message: {2}", restResponse.ResponseStatus, restResponse.StatusCode, restResponse.ErrorMessage));
}
return(JsonConvert.DeserializeObject <bool>(restResponse.Content));
}
internal RemoteSessionStateInfo(RemoteSessionState state, Exception reason)
{
this._state = state;
this._reason = reason;
}
internal RemoteSessionStateInfo(RemoteSessionState state)
: this(state, (Exception)null)
{
}
/// <summary>
/// Sets the state of the state machine. Since only
/// one thread can be manipulating the state at a time
/// the state is not synchronized
/// </summary>
/// <param name="newState">new state of the state machine</param>
/// <param name="reason">reason why the state machine is set
/// to the new state</param>
private void SetState(RemoteSessionState newState, Exception reason)
{
RemoteSessionState oldState = _state;
if (newState != oldState)
{
_state = newState;
s_trace.WriteLine("state machine state transition: from state {0} to state {1}", oldState, _state);
RemoteSessionStateInfo stateInfo = new RemoteSessionStateInfo(_state, reason);
RemoteSessionStateEventArgs sessionStateEventArg = new RemoteSessionStateEventArgs(stateInfo);
_clientRemoteSessionStateChangeQueue.Enqueue(sessionStateEventArg);
}
}
/// <summary>
/// Sends the negotiation package asynchronously
/// </summary>
internal override void SendNegotiationAsync(RemoteSessionState sessionState)
{
// This state change is made before the call to CreateAsync to ensure the state machine
// is prepared for a NegotiationReceived response. Otherwise a race condition can
// occur when the transport NegotiationReceived arrives too soon, breaking the session.
// This race condition was observed for OutOfProc transport when reusing the OutOfProc process.
//this will change StateMachine to NegotiationSent.
RemoteSessionStateMachineEventArgs negotiationSendCompletedArg =
new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.NegotiationSendCompleted);
_stateMachine.RaiseEvent(negotiationSendCompletedArg);
if (sessionState == RemoteSessionState.NegotiationSending)
{
_transportManager.CreateAsync();
}
else if (sessionState == RemoteSessionState.NegotiationSendingOnConnect)
{
_transportManager.ConnectCompleted += HandleConnectComplete;
_transportManager.ConnectAsync();
}
else
{
Dbg.Assert(false, "SendNegotiationAsync called in unexpected session state");
}
}
private void SetState(RemoteSessionState newState, Exception reason)
{
RemoteSessionState state = this._state;
if (newState != state)
{
this._state = newState;
_trace.WriteLine("state machine state transition: from state {0} to state {1}", new object[] { state, this._state });
RemoteSessionStateInfo remoteSessionStateInfo = new RemoteSessionStateInfo(this._state, reason);
RemoteSessionStateEventArgs item = new RemoteSessionStateEventArgs(remoteSessionStateInfo);
this._clientRemoteSessionStateChangeQueue.Enqueue(item);
}
}
private void SetState(RemoteSessionState newState, Exception reasion)
{
RemoteSessionState state = this._state;
if (newState != state)
{
if (newState == RemoteSessionState.ClosingConnection || state == RemoteSessionState.ClosingConnection)
{
_trace.WriteLine ("Closing Server Session");
}
this._state = newState;
_trace.WriteLine("state machine state transition: from state {0} to state {1}", new object[] { state, this._state });
}
}
/// <summary>
/// Set the FSM state to a new state.
/// </summary>
/// <param name="newState">
/// The new state.
/// </param>
/// <param name="reasion">
/// Optional parameter that can provide additional information. This is currently not used.
/// </param>
private void SetState(RemoteSessionState newState, Exception reasion)
{
RemoteSessionState oldState = _state;
if (newState != oldState)
{
_state = newState;
s_trace.WriteLine("state machine state transition: from state {0} to state {1}", oldState, _state);
}
// TODO: else should we close the session here?
}
public bool SetConnectionState(Guid connectionId, string IPAddress, Guid vmGuid, RemoteSessionState state)
{
if (string.IsNullOrWhiteSpace(IPAddress) && vmGuid == Guid.Empty)
{
throw new ArgumentException("ipAddress and VmGuid cannot both be null");
}
if (!Enum.IsDefined(typeof(RemoteSessionState), state))
{
throw new ArgumentException(nameof(state));
}
return(_connectionService.SetConnectionState(connectionId, IPAddress, vmGuid, state));
}
