internal ServerRemoteSession(PSSenderInfo senderInfo, string configurationProviderId, string initializationParameters, AbstractServerSessionTransportManager transportManager) { NativeCommandProcessor.IsServerSide = true; this._senderInfo = senderInfo; this._configProviderId = configurationProviderId; this._initParameters = initializationParameters; this._cryptoHelper = (PSRemotingCryptoHelperServer) transportManager.CryptoHelper; this._cryptoHelper.Session = this; this._context = new ServerRemoteSessionContext(); this._sessionDSHandler = new ServerRemoteSessionDSHandlerlImpl(this, transportManager); base.BaseSessionDataStructureHandler = this._sessionDSHandler; this._sessionDSHandler.CreateRunspacePoolReceived += new EventHandler<RemoteDataEventArgs>(this.HandleCreateRunspacePool); this._sessionDSHandler.NegotiationReceived += new EventHandler<RemoteSessionNegotiationEventArgs>(this.HandleNegotiationReceived); this._sessionDSHandler.SessionClosing += new EventHandler<EventArgs>(this.HandleSessionDSHandlerClosing); this._sessionDSHandler.PublicKeyReceived += new EventHandler<RemoteDataEventArgs<string>>(this.HandlePublicKeyReceived); transportManager.Closing += new EventHandler(this.HandleResourceClosing); transportManager.ReceivedDataCollection.MaximumReceivedObjectSize = 0xa00000; transportManager.ReceivedDataCollection.MaximumReceivedDataSize = null; }
internal OutOfProcessServerSessionTransportManager(OutOfProcessTextWriter outWriter, OutOfProcessTextWriter errWriter, PSRemotingCryptoHelperServer cryptoHelper) : base(BaseTransportManager.DefaultFragmentSize, cryptoHelper) { Dbg.Assert(null != outWriter, "outWriter cannot be null."); Dbg.Assert(null != errWriter, "errWriter cannot be null."); _stdOutWriter = outWriter; _stdErrWriter = errWriter; _cmdTransportManagers = new Dictionary<Guid, OutOfProcessServerTransportManager>(); }
/// <summary> /// This constructor instantiates a ServerRemoteSession object and /// a ServerRemoteSessionDataStructureHandler object. /// </summary> /// <param name="senderInfo"> /// Details about the user creating this session. /// </param> /// <param name="configurationProviderId"> /// The resource URI for which this session is being created /// </param> /// <param name="initializationParameters"> /// Initialization Parameters xml passed by WSMan API. This data is read from the config /// xml. /// </param> /// <param name="transportManager"> /// The transport manager this session should use to send/receive data /// </param> /// <returns></returns> internal ServerRemoteSession(PSSenderInfo senderInfo, string configurationProviderId, string initializationParameters, AbstractServerSessionTransportManager transportManager) { Dbg.Assert(null != transportManager, "transportManager cannot be null."); // let input,output and error from native commands redirect as we have // to send (or receive) them back to client for action. NativeCommandProcessor.IsServerSide = true; _senderInfo = senderInfo; _configProviderId = configurationProviderId; _initParameters = initializationParameters; #if !UNIX _cryptoHelper = (PSRemotingCryptoHelperServer)transportManager.CryptoHelper; _cryptoHelper.Session = this; #else _cryptoHelper = null; #endif Context = new ServerRemoteSessionContext(); SessionDataStructureHandler = new ServerRemoteSessionDSHandlerlImpl(this, transportManager); BaseSessionDataStructureHandler = SessionDataStructureHandler; SessionDataStructureHandler.CreateRunspacePoolReceived += HandleCreateRunspacePool; SessionDataStructureHandler.NegotiationReceived += HandleNegotiationReceived; SessionDataStructureHandler.SessionClosing += HandleSessionDSHandlerClosing; SessionDataStructureHandler.PublicKeyReceived += new EventHandler<RemoteDataEventArgs<string>>(HandlePublicKeyReceived); transportManager.Closing += HandleResourceClosing; // update the quotas from sessionState..start with default size..and // when Custom Session Configuration is loaded (during runspace creation) update this. transportManager.ReceivedDataCollection.MaximumReceivedObjectSize = BaseTransportManager.MaximumReceivedObjectSize; // session transport manager can receive unlimited data..however each object is limited // by maxRecvdObjectSize. this is to allow clients to use a session for an unlimited time.. // also the messages that can be sent to a session are limited and very controlled. // However a command transport manager can be restricted to receive only a fixed amount of data // controlled by maxRecvdDataSizeCommand..This is because commands can accept any number of input // objects transportManager.ReceivedDataCollection.MaximumReceivedDataSize = null; }
/// <summary> /// Gets a helper with a test session /// </summary> /// <returns>helper for testing</returns> /// <remarks>To be used only for testing</remarks> internal static PSRemotingCryptoHelperServer GetTestRemotingCryptHelperServer() { PSRemotingCryptoHelperServer helper = new PSRemotingCryptoHelperServer(); helper.Session = new TestHelperSession(); return helper; }
/// <summary> /// /// </summary> /// <param name="initialCommand"></param> internal static void Run(string initialCommand) { lock (SyncObject) { if (s_singletonInstance != null) { Dbg.Assert(false, "Run should not be called multiple times"); return; } s_singletonInstance = new SSHProcessMediator(); } PSRemotingCryptoHelperServer cryptoHelper; #if !UNIX cryptoHelper = new PSRemotingCryptoHelperServer(); #else cryptoHelper = null; #endif s_singletonInstance.Start(initialCommand, cryptoHelper); }
protected void Start(string initialCommand, PSRemotingCryptoHelperServer cryptoHelper, string configurationName = null) { _initialCommand = initialCommand; sessionTM = CreateSessionTransportManager(configurationName, cryptoHelper); try { do { string data = originalStdIn.ReadLine(); lock (_syncObject) { if (sessionTM == null) { sessionTM = CreateSessionTransportManager(configurationName, cryptoHelper); } } if (string.IsNullOrEmpty(data)) { lock (_syncObject) { // give a chance to runspace/pipelines to close (as it looks like the client died // intermittently) sessionTM.Close(null); sessionTM = null; } throw new PSRemotingTransportException(PSRemotingErrorId.IPCUnknownElementReceived, RemotingErrorIdStrings.IPCUnknownElementReceived, string.Empty); } // process data in a thread pool thread..this way Runspace, Command // data can be processed concurrently. #if CORECLR ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessingThreadStart), data); #else Utils.QueueWorkItemWithImpersonation( _windowsIdentityToImpersonate, new WaitCallback(ProcessingThreadStart), data); #endif } while (true); } catch (Exception e) { CommandProcessorBase.CheckForSevereException(e); PSEtwLog.LogOperationalError( PSEventId.TransportError, PSOpcode.Open, PSTask.None, PSKeyword.UseAlwaysOperational, Guid.Empty.ToString(), Guid.Empty.ToString(), OutOfProcessUtils.EXITCODE_UNHANDLED_EXCEPTION, e.Message, e.StackTrace); PSEtwLog.LogAnalyticError( PSEventId.TransportError_Analytic, PSOpcode.Open, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, Guid.Empty.ToString(), Guid.Empty.ToString(), OutOfProcessUtils.EXITCODE_UNHANDLED_EXCEPTION, e.Message, e.StackTrace); if (_exitProcessOnError) { // notify the remote client of any errors and fail gracefully originalStdErr.WriteLine(e.Message); Environment.Exit(OutOfProcessUtils.EXITCODE_UNHANDLED_EXCEPTION); } } }
protected OutOfProcessServerSessionTransportManager CreateSessionTransportManager(string configurationName, PSRemotingCryptoHelperServer cryptoHelper) { PSSenderInfo senderInfo; #if !UNIX WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent(); PSPrincipal userPrincipal = new PSPrincipal(new PSIdentity("", true, currentIdentity.Name, null), currentIdentity); senderInfo = new PSSenderInfo(userPrincipal, "http://localhost"); #else PSPrincipal userPrincipal = new PSPrincipal(new PSIdentity("", true, "", null), null); senderInfo = new PSSenderInfo(userPrincipal, "http://localhost"); #endif OutOfProcessServerSessionTransportManager tm = new OutOfProcessServerSessionTransportManager(originalStdOut, originalStdErr, cryptoHelper); ServerRemoteSession srvrRemoteSession = ServerRemoteSession.CreateServerRemoteSession(senderInfo, _initialCommand, tm, configurationName); return tm; }