Exemple #1
0
        internal static RemoteDataObject <T> CreateFrom(
            Stream serializedDataStream,
            Fragmentor defragmentor)
        {
            if (serializedDataStream.Length - serializedDataStream.Position < 40L)
            {
                throw new PSRemotingTransportException(PSRemotingErrorId.NotEnoughHeaderForRemoteDataObject, new object[1]
                {
                    (object)61
                });
            }
            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 = (object)null;

            if (serializedDataStream.Length - 40L > 0L)
            {
                valueToConvert = (object)defragmentor.DeserializeToPSObject(serializedDataStream);
            }
            T data = (T)LanguagePrimitives.ConvertTo(valueToConvert, typeof(T), (IFormatProvider)CultureInfo.CurrentCulture);

            return(new RemoteDataObject <T>(destination, dataType, runspacePoolId, powerShellId, data));
        }
Exemple #2
0
        /// <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));
        }
Exemple #3
0
        public override object ServiceMessage(IMessage message)
        {
            RemotingMessage     message2    = message as RemotingMessage;
            RemotingDestination destination = base.GetDestination(message) as RemotingDestination;

            return(destination.ServiceAdapter.Invoke(message));
        }
Exemple #4
0
        internal void DispatchInputQueueData(object sender, RemoteDataEventArgs dataArg)
        {
            using (ClientRemoteSessionDSHandlerImpl._trace.TraceMethod())
            {
                RemoteDataObject <PSObject> remoteDataObject    = dataArg != null ? dataArg.ReceivedData : throw ClientRemoteSessionDSHandlerImpl._trace.NewArgumentNullException(nameof(dataArg));
                RemotingDestination         remotingDestination = remoteDataObject != null ? remoteDataObject.Destination : throw ClientRemoteSessionDSHandlerImpl._trace.NewArgumentException(nameof(dataArg));
                if ((remotingDestination & RemotingDestination.Client) != RemotingDestination.Client)
                {
                    throw new PSRemotingDataStructureException(PSRemotingErrorId.RemotingDestinationNotForMe, new object[2]
                    {
                        (object)RemotingDestination.Client,
                        (object)remotingDestination
                    });
                }
                switch (remoteDataObject.TargetInterface)
                {
                case RemotingTargetInterface.Session:
                    this.ProcessSessionMessages(dataArg);
                    break;

                case RemotingTargetInterface.RunspacePool:
                case RemotingTargetInterface.PowerShell:
                    RemoteSessionStateMachineEventArgs machineEventArgs = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived, (Exception)null);
                    if (this.StateMachine.CanByPassRaiseEvent(machineEventArgs))
                    {
                        this.ProcessNonSessionMessages(dataArg.ReceivedData);
                        break;
                    }
                    this.StateMachine.RaiseEvent(machineEventArgs);
                    break;
                }
            }
        }
Exemple #5
0
        /// <summary>
        /// Dispatches data when it arrives from the input queue
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="dataArg">
        /// arg which contains the data received from input queue
        /// </param>
        internal void DispatchInputQueueData(object sender, RemoteDataEventArgs dataArg)
        {
            if (dataArg == null)
            {
                throw PSTraceSource.NewArgumentNullException("dataArg");
            }

            RemoteDataObject <PSObject> rcvdData = dataArg.ReceivedData;

            if (rcvdData == null)
            {
                throw PSTraceSource.NewArgumentException("dataArg");
            }

            RemotingDestination destination = rcvdData.Destination;

            if ((destination & RemotingDestination.Client) != RemotingDestination.Client)
            {
                throw new PSRemotingDataStructureException(RemotingErrorIdStrings.RemotingDestinationNotForMe, RemotingDestination.Client, destination);
            }

            RemotingTargetInterface targetInterface = rcvdData.TargetInterface;

            switch (targetInterface)
            {
            case RemotingTargetInterface.Session:
            {
                //Messages for session can cause statemachine state to change.
                //These messages are first processed by Sessiondata structure handler and depending
                //on the type of message, appropriate event is raised in state machine
                ProcessSessionMessages(dataArg);
                break;
            }

            case RemotingTargetInterface.RunspacePool:
            case RemotingTargetInterface.PowerShell:
                //Non Session messages do not change the state of the statemachine.
                //However instead of forwarding them to Runspace/pipeline here, an
                //event is raised in state machine which verified that state is
                //suitable for accepting these messages. if state is suitable statemachine
                //will call DoMessageForwading which will forward the messages appropriately
                RemoteSessionStateMachineEventArgs msgRcvArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived, null);
                if (StateMachine.CanByPassRaiseEvent(msgRcvArg))
                {
                    ProcessNonSessionMessages(dataArg.ReceivedData);
                }
                else
                {
                    StateMachine.RaiseEvent(msgRcvArg);
                }
                break;

            default:
            {
                Dbg.Assert(false, "we should not be encountering this");
            }
            break;
            }
        }
 protected RemoteDataObject(RemotingDestination destination, RemotingDataType dataType, Guid runspacePoolId, Guid powerShellId, T data)
 {
     this.destination    = destination;
     this.dataType       = dataType;
     this.runspacePoolId = runspacePoolId;
     this.powerShellId   = powerShellId;
     this.data           = data;
 }
Exemple #7
0
 /// <summary>
 /// </summary>
 /// <param name="destination"></param>
 /// <param name="dataType"></param>
 /// <param name="runspacePoolId"></param>
 /// <param name="powerShellId"></param>
 /// <param name="data"></param>
 /// <returns></returns>
 internal static RemoteDataObject <T> CreateFrom(RemotingDestination destination,
                                                 RemotingDataType dataType,
                                                 Guid runspacePoolId,
                                                 Guid powerShellId,
                                                 T data)
 {
     return(new RemoteDataObject <T>(destination, dataType, runspacePoolId, powerShellId, data));
 }
 private RemoteDataObject(
     RemotingDestination destination,
     RemotingDataType dataType,
     Guid runspacePoolId,
     Guid powerShellId,
     object data)
     : base(destination, dataType, runspacePoolId, powerShellId, data)
 {
 }
        public override object ServiceMessage(IMessage message)
        {
            RemotingMessage     remotingMessage = message as RemotingMessage;
            RemotingDestination destination     = GetDestination(message) as RemotingDestination;
            ServiceAdapter      adapter         = destination.ServiceAdapter;
            object result = adapter.Invoke(message);

            return(result);
        }
Exemple #10
0
 internal RemoteSessionCapability(RemotingDestination remotingDestination,
                                  Version protocolVersion,
                                  Version psVersion,
                                  Version serVersion)
 {
     _protocolVersion     = protocolVersion;
     _psversion           = psVersion;
     _serversion          = serVersion;
     _remotingDestination = remotingDestination;
 }
Exemple #11
0
        internal static RemoteDataObject GenerateMyPublicKey(
            Guid runspacePoolId,
            string publicKey,
            RemotingDestination destination)
        {
            PSObject emptyPsObject = RemotingEncoder.CreateEmptyPSObject();

            emptyPsObject.Properties.Add((PSPropertyInfo) new PSNoteProperty("PublicKey", (object)publicKey));
            return(RemoteDataObject.CreateFrom(destination, RemotingDataType.PublicKey, runspacePoolId, Guid.Empty, (object)emptyPsObject));
        }
        public override async Task <object> ServiceMessage(IMessage message)
        {
            RemotingMessage     remotingMessage = message as RemotingMessage;
            RemotingDestination destination     = GetDestination(message) as RemotingDestination;
            ServiceAdapter      adapter         = destination.ServiceAdapter;
            Task <object>       result          = adapter.Invoke(message);
            await result;

            return(result.Result);
        }
 /// <summary>
 /// Constructor for RemoteSessionCapability.
 /// </summary>
 /// <remarks>should not be called from outside, use create methods instead
 /// </remarks>
 internal RemoteSessionCapability(RemotingDestination remotingDestination)
 {
     ProtocolVersion = RemotingConstants.ProtocolVersion;
     // PS Version 3 is fully backward compatible with Version 2
     // In the remoting protocol sense, nothing is changing between PS3 and PS2
     // For negotiation to succeed with old client/servers we have to use 2.
     PSVersion            = new Version(2, 0); //PSVersionInfo.PSVersion;
     SerializationVersion = PSVersionInfo.SerializationVersion;
     RemotingDestination  = remotingDestination;
 }
 /// <summary>
 /// Constructor for RemoteSessionCapability.
 /// </summary>
 /// <remarks>should not be called from outside, use create methods instead
 /// </remarks>
 internal RemoteSessionCapability(RemotingDestination remotingDestination)
 {
     ProtocolVersion = RemotingConstants.ProtocolVersion;
     // PS Version 3 is fully backward compatible with Version 2
     // In the remoting protocol sense, nothing is changing between PS3 and PS2
     // For negotiation to succeed with old client/servers we have to use 2.
     PSVersion = new Version(2, 0); //PSVersionInfo.PSVersion;
     SerializationVersion = PSVersionInfo.SerializationVersion;
     RemotingDestination = remotingDestination;
 }
 internal RemoteSessionCapability(RemotingDestination remotingDestination,
                                  Version protocolVersion,
                                  Version psVersion,
                                  Version serVersion)
 {
     ProtocolVersion      = protocolVersion;
     PSVersion            = psVersion;
     SerializationVersion = serVersion;
     RemotingDestination  = remotingDestination;
 }
 internal RemoteSessionCapability(RemotingDestination remotingDestination,
     Version protocolVersion,
     Version psVersion,
     Version serVersion)
 {
     ProtocolVersion = protocolVersion;
     PSVersion = psVersion;
     SerializationVersion = serVersion;
     RemotingDestination = remotingDestination;
 }
Exemple #17
0
 /// <summary>
 /// Constructs a RemoteDataObject from its
 /// individual components.
 /// </summary>
 /// <param name="destination">
 /// Destination this object is going to.
 /// </param>
 /// <param name="dataType">
 /// Payload type this object represents.
 /// </param>
 /// <param name="runspacePoolId">
 /// Runspace id this object belongs to.
 /// </param>
 /// <param name="powerShellId">
 /// PowerShell (pipeline) id this object belongs to.
 /// This may be null if the payload belongs to runspace.
 /// </param>
 /// <param name="data">
 /// Actual payload.
 /// </param>
 protected RemoteDataObject(RemotingDestination destination,
                            RemotingDataType dataType,
                            Guid runspacePoolId,
                            Guid powerShellId,
                            T data)
 {
     Destination    = destination;
     DataType       = dataType;
     RunspacePoolId = runspacePoolId;
     PowerShellId   = powerShellId;
     Data           = data;
 }
 internal ClientRemoteSessionImpl(RemoteRunspacePoolInternal rsPool, ClientRemoteSession.URIDirectionReported uriRedirectionHandler)
 {
     base.RemoteRunspacePoolInternal = rsPool;
     base.Context.RemoteAddress      = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <Uri>(rsPool.ConnectionInfo, "ConnectionUri", null);
     this._cryptoHelper            = new PSRemotingCryptoHelperClient();
     this._cryptoHelper.Session    = this;
     base.Context.ClientCapability = RemoteSessionCapability.CreateClientCapability();
     base.Context.UserCredential   = rsPool.ConnectionInfo.Credential;
     base.Context.ShellName        = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>(rsPool.ConnectionInfo, "ShellUri", string.Empty);
     this._mySelf = RemotingDestination.InvalidDestination | RemotingDestination.Client;
     base.SessionDataStructureHandler                              = new ClientRemoteSessionDSHandlerImpl(this, this._cryptoHelper, rsPool.ConnectionInfo, uriRedirectionHandler);
     base.BaseSessionDataStructureHandler                          = base.SessionDataStructureHandler;
     this._waitHandleForConfigurationReceived                      = new ManualResetEvent(false);
     base.SessionDataStructureHandler.NegotiationReceived         += new EventHandler <RemoteSessionNegotiationEventArgs>(this.HandleNegotiationReceived);
     base.SessionDataStructureHandler.ConnectionStateChanged      += new EventHandler <RemoteSessionStateEventArgs>(this.HandleConnectionStateChanged);
     base.SessionDataStructureHandler.EncryptedSessionKeyReceived += new EventHandler <RemoteDataEventArgs <string> >(this.HandleEncryptedSessionKeyReceived);
     base.SessionDataStructureHandler.PublicKeyRequestReceived    += new EventHandler <RemoteDataEventArgs <string> >(this.HandlePublicKeyRequestReceived);
 }
 internal ClientRemoteSessionImpl(RemoteRunspacePoolInternal rsPool, ClientRemoteSession.URIDirectionReported uriRedirectionHandler)
 {
     base.RemoteRunspacePoolInternal = rsPool;
     base.Context.RemoteAddress = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo<Uri>(rsPool.ConnectionInfo, "ConnectionUri", null);
     this._cryptoHelper = new PSRemotingCryptoHelperClient();
     this._cryptoHelper.Session = this;
     base.Context.ClientCapability = RemoteSessionCapability.CreateClientCapability();
     base.Context.UserCredential = rsPool.ConnectionInfo.Credential;
     base.Context.ShellName = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo<string>(rsPool.ConnectionInfo, "ShellUri", string.Empty);
     this._mySelf = RemotingDestination.InvalidDestination | RemotingDestination.Client;
     base.SessionDataStructureHandler = new ClientRemoteSessionDSHandlerImpl(this, this._cryptoHelper, rsPool.ConnectionInfo, uriRedirectionHandler);
     base.BaseSessionDataStructureHandler = base.SessionDataStructureHandler;
     this._waitHandleForConfigurationReceived = new ManualResetEvent(false);
     base.SessionDataStructureHandler.NegotiationReceived += new EventHandler<RemoteSessionNegotiationEventArgs>(this.HandleNegotiationReceived);
     base.SessionDataStructureHandler.ConnectionStateChanged += new EventHandler<RemoteSessionStateEventArgs>(this.HandleConnectionStateChanged);
     base.SessionDataStructureHandler.EncryptedSessionKeyReceived += new EventHandler<RemoteDataEventArgs<string>>(this.HandleEncryptedSessionKeyReceived);
     base.SessionDataStructureHandler.PublicKeyRequestReceived += new EventHandler<RemoteDataEventArgs<string>>(this.HandlePublicKeyRequestReceived);
 }
Exemple #20
0
        internal void DispatchInputQueueData(object sender, RemoteDataEventArgs dataArg)
        {
            if (dataArg == null)
            {
                throw PSTraceSource.NewArgumentNullException("dataArg");
            }
            RemoteDataObject <PSObject> receivedData = dataArg.ReceivedData;

            if (receivedData == null)
            {
                throw PSTraceSource.NewArgumentException("dataArg");
            }
            RemotingDestination destination = receivedData.Destination;
            var d = receivedData.Data;

            if ((destination & (RemotingDestination.InvalidDestination | RemotingDestination.Client)) != (RemotingDestination.InvalidDestination | RemotingDestination.Client))
            {
                throw new PSRemotingDataStructureException(RemotingErrorIdStrings.RemotingDestinationNotForMe, new object[] { RemotingDestination.InvalidDestination | RemotingDestination.Client, destination });
            }
            switch (receivedData.TargetInterface)
            {
            case RemotingTargetInterface.Session:
                this.ProcessSessionMessages(dataArg);
                return;

            case RemotingTargetInterface.RunspacePool:
            case RemotingTargetInterface.PowerShell:
            {
                RemoteSessionStateMachineEventArgs arg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived, null);
                if (!this.StateMachine.CanByPassRaiseEvent(arg))
                {
                    this.StateMachine.RaiseEvent(arg, false);
                    return;
                }
                this.ProcessNonSessionMessages(dataArg.ReceivedData);
                return;
            }
            }
        }
        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)));
        }
        internal void DispatchInputQueueData(object sender, RemoteDataEventArgs dataEventArg)
        {
            if (dataEventArg == null)
            {
                throw PSTraceSource.NewArgumentNullException("dataEventArg");
            }
            RemoteDataObject <PSObject> receivedData = dataEventArg.ReceivedData;

            if (receivedData == null)
            {
                throw PSTraceSource.NewArgumentException("dataEventArg");
            }
            RemotingDestination destination = receivedData.Destination;

            if ((destination & this.MySelf) != this.MySelf)
            {
                throw new PSRemotingDataStructureException(RemotingErrorIdStrings.RemotingDestinationNotForMe, new object[] { this.MySelf, destination });
            }
            RemotingTargetInterface            targetInterface = receivedData.TargetInterface;
            RemotingDataType                   dataType        = receivedData.DataType;
            RemoteSessionStateMachineEventArgs arg             = null;

            switch (targetInterface)
            {
            case RemotingTargetInterface.Session:
                switch (dataType)
                {
                case RemotingDataType.SessionCapability:
                    this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                    return;

                case RemotingDataType.CloseSession:
                    this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                    return;

                case RemotingDataType.CreateRunspacePool:
                    arg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived);
                    if (this.SessionDataStructureHandler.StateMachine.CanByPassRaiseEvent(arg))
                    {
                        arg.RemoteData = receivedData;
                        this.SessionDataStructureHandler.StateMachine.DoMessageReceived(this, arg);
                        return;
                    }
                    this.SessionDataStructureHandler.StateMachine.RaiseEvent(arg);
                    return;

                case RemotingDataType.PublicKey:
                    this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                    return;
                }
                return;

            case RemotingTargetInterface.RunspacePool:
            case RemotingTargetInterface.PowerShell:
                arg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived);
                if (!this.SessionDataStructureHandler.StateMachine.CanByPassRaiseEvent(arg))
                {
                    this.SessionDataStructureHandler.StateMachine.RaiseEvent(arg);
                    return;
                }
                arg.RemoteData = receivedData;
                this.SessionDataStructureHandler.StateMachine.DoMessageReceived(this, arg);
                return;
            }
        }
Exemple #23
0
        internal void DispatchInputQueueData(object sender, RemoteDataEventArgs dataEventArg)
        {
            using (ServerRemoteSession._trace.TraceMethod())
            {
                RemoteDataObject <PSObject> remoteDataObject    = dataEventArg != null ? dataEventArg.ReceivedData : throw ServerRemoteSession._trace.NewArgumentNullException(nameof(dataEventArg));
                RemotingDestination         remotingDestination = remoteDataObject != null ? remoteDataObject.Destination : throw ServerRemoteSession._trace.NewArgumentException(nameof(dataEventArg));
                if ((remotingDestination & this.MySelf) != this.MySelf)
                {
                    throw new PSRemotingDataStructureException(PSRemotingErrorId.RemotingDestinationNotForMe, new object[2]
                    {
                        (object)this.MySelf,
                        (object)remotingDestination
                    });
                }
                RemotingTargetInterface targetInterface = remoteDataObject.TargetInterface;
                RemotingDataType        dataType        = remoteDataObject.DataType;
                switch (targetInterface)
                {
                case RemotingTargetInterface.Session:
                    switch (dataType)
                    {
                    case RemotingDataType.SessionCapability:
                        this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                        return;

                    case RemotingDataType.CloseSession:
                        this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                        return;

                    case RemotingDataType.CreateRunspacePool:
                        RemoteSessionStateMachineEventArgs fsmEventArg1 = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived);
                        if (this.SessionDataStructureHandler.StateMachine.CanByPassRaiseEvent(fsmEventArg1))
                        {
                            fsmEventArg1.RemoteData = remoteDataObject;
                            this.SessionDataStructureHandler.StateMachine.DoMessageReceived((object)this, fsmEventArg1);
                            return;
                        }
                        this.SessionDataStructureHandler.StateMachine.RaiseEvent(fsmEventArg1);
                        return;

                    case RemotingDataType.PublicKey:
                        this._sessionDSHandler.RaiseDataReceivedEvent(dataEventArg);
                        return;

                    default:
                        return;
                    }

                case RemotingTargetInterface.RunspacePool:
                case RemotingTargetInterface.PowerShell:
                    RemoteSessionStateMachineEventArgs fsmEventArg2 = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.MessageReceived);
                    if (this.SessionDataStructureHandler.StateMachine.CanByPassRaiseEvent(fsmEventArg2))
                    {
                        fsmEventArg2.RemoteData = remoteDataObject;
                        this.SessionDataStructureHandler.StateMachine.DoMessageReceived((object)this, fsmEventArg2);
                        break;
                    }
                    this.SessionDataStructureHandler.StateMachine.RaiseEvent(fsmEventArg2);
                    break;
                }
            }
        }
Exemple #24
0
        internal static RemoteDataObject GenerateMyPublicKey(Guid runspacePoolId, string publicKey, RemotingDestination destination)
        {
            PSObject data = CreateEmptyPSObject();

            data.Properties.Add(new PSNoteProperty("PublicKey", publicKey));
            return(RemoteDataObject.CreateFrom(destination, RemotingDataType.PublicKey, runspacePoolId, Guid.Empty, data));
        }
Exemple #25
0
		protected override Destination NewDestination(DestinationDefinition destinationDefinition) {
			RemotingDestination remotingDestination = new RemotingDestination(this, destinationDefinition);
			return remotingDestination;
		}
        protected override Destination NewDestination(DestinationSettings destinationSettings)
        {
            RemotingDestination remotingDestination = new RemotingDestination(this, destinationSettings);

            return(remotingDestination);
        }
Exemple #27
0
        protected override Destination NewDestination(DestinationDefinition destinationDefinition)
        {
            RemotingDestination remotingDestination = new RemotingDestination(this, destinationDefinition);

            return(remotingDestination);
        }