/// <summary> /// Parse ps command using script block. /// </summary> private PSCommand ParsePsCommandUsingScriptBlock(string line, bool?useLocalScope) { try { // Extract execution context from local runspace. Runspace localRunspace = _runspaceRef.OldValue; ExecutionContext context = localRunspace.ExecutionContext; // This is trusted input as long as we're in FullLanguage mode // and if we are not in a loopback configuration mode, in which case we always force remote script commands // to be parsed and evaluated on the remote session (not in the current local session). RemoteRunspace remoteRunspace = _runspaceRef.Value as RemoteRunspace; bool isConfiguredLoopback = (remoteRunspace != null) ? remoteRunspace.IsConfiguredLoopBack : false; bool isTrustedInput = !isConfiguredLoopback && (localRunspace.ExecutionContext.LanguageMode == PSLanguageMode.FullLanguage); // Create PowerShell from ScriptBlock. ScriptBlock scriptBlock = ScriptBlock.Create(context, line); PowerShell powerShell = scriptBlock.GetPowerShell(context, isTrustedInput, useLocalScope, null); return(powerShell.Commands); } catch (ScriptBlockToPowerShellNotSupportedException) { } catch (RuntimeException) { } // If parsing failed return null. return(null); }
/// <summary> /// Push runspace to use for remote command execution. /// </summary> /// <param name="runspace">RemoteRunspace.</param> public override void PushRunspace(Runspace runspace) { if (_debugger == null) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostNoDebuggerToPush); } if (_pushedRunspace != null) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostAlreadyPushed); } if (!(runspace is RemoteRunspace remoteRunspace)) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostNotRemoteRunspace); } // PSEdit support. Existence of RemoteSessionOpenFileEvent event indicates host supports PSEdit _hostSupportsPSEdit = false; PSEventManager localEventManager = Runspace?.Events; _hostSupportsPSEdit = (localEventManager != null) ? localEventManager.GetEventSubscribers(HostUtilities.RemoteSessionOpenFileEvent).GetEnumerator().MoveNext() : false; if (_hostSupportsPSEdit) { AddPSEditForRunspace(remoteRunspace); } _debugger.PushDebugger(runspace.Debugger); _pushedRunspace = remoteRunspace; }
internal PSSession(RemoteRunspace remoteRunspace) { this.remoteRunspace = remoteRunspace; if (remoteRunspace.Id != -1) { this.sessionid = remoteRunspace.Id; } else { this.sessionid = Interlocked.Increment(ref seed); remoteRunspace.Id = this.sessionid; } if (!string.IsNullOrEmpty(remoteRunspace.Name)) { this.name = remoteRunspace.Name; } else { this.name = this.AutoGenerateRunspaceName(); remoteRunspace.Name = this.name; } string shell = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>(remoteRunspace.ConnectionInfo, "ShellUri", string.Empty); this.shell = this.GetDisplayShellName(shell); }
internal ExecutionCmdletHelperComputerName(RemoteRunspace remoteRunspace, Pipeline pipeline) { this.remoteRunspace = remoteRunspace; remoteRunspace.StateChanged += new EventHandler <RunspaceStateEventArgs>(this.HandleRunspaceStateChanged); this.pipeline = pipeline; pipeline.StateChanged += new EventHandler <PipelineStateEventArgs>(this.HandlePipelineStateChanged); }
private void RemovePSEditFromRunspace(RemoteRunspace remoteRunspace) { if (remoteRunspace.Events == null) { return; } // It is possible for the popped runspace to be in a bad state after an error. if ((remoteRunspace.RunspaceStateInfo.State != RunspaceState.Opened) || (remoteRunspace.RunspaceAvailability != RunspaceAvailability.Available)) { return; } // Remove event handler. remoteRunspace.Events.ReceivedEvents.PSEventReceived -= HandleRemoteSessionForwardedEvent; // Remove script function. using (PowerShell powershell = PowerShell.Create()) { powershell.Runspace = remoteRunspace; powershell.AddScript(HostUtilities.RemovePSEditFunction); try { powershell.Invoke(); } catch (RemoteException) { } } }
private RemoteRunspace CreateRunspaceWhenComputerNameParameterSpecified() { RemoteRunspace runspace = null; string computerName = base.ResolveComputerName(this.computerName); try { WSManConnectionInfo connectionInfo = new WSManConnectionInfo(this.UseSSL.IsPresent, computerName, this.Port, this.ApplicationName, this.ConfigurationName, this.Credential) { AuthenticationMechanism = this.Authentication }; base.UpdateConnectionInfo(connectionInfo); connectionInfo.EnableNetworkAccess = (bool)this.EnableNetworkAccess; runspace = this.CreateTemporaryRemoteRunspace(base.Host, connectionInfo); } catch (InvalidOperationException exception) { this.WriteErrorCreateRemoteRunspaceFailed(exception, computerName); } catch (ArgumentException exception2) { this.WriteErrorCreateRemoteRunspaceFailed(exception2, computerName); } catch (PSRemotingTransportException exception3) { this.WriteErrorCreateRemoteRunspaceFailed(exception3, computerName); } return(runspace); }
private RemoteRunspace CreateTemporaryRemoteRunspace(PSHost host, WSManConnectionInfo connectionInfo) { int num; string name = PSSession.GenerateRunspaceName(out num); RemoteRunspace runspace = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(), connectionInfo, host, this.SessionOption.ApplicationArguments, name, num); runspace.URIRedirectionReported += new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported); this.stream = new ObjectStream(); try { runspace.Open(); runspace.ShouldCloseOnPop = true; } finally { runspace.URIRedirectionReported -= new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported); this.stream.ObjectWriter.Close(); if (runspace.RunspaceStateInfo.State != RunspaceState.Opened) { runspace.Dispose(); runspace = null; } } return(runspace); }
} // CoreBeginProcessing /// <summary> /// Create a throttle operation using NewProcessConnectionInfo /// ie., Out-Of-Process runspace. /// </summary> protected override void CreateHelpersForSpecifiedComputerNames() { // If we're in ConstrainedLanguage mode and the system is in lockdown mode, // ensure that they haven't specified a ScriptBlock or InitScript - as // we can't protect that boundary if ((Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) && (SystemPolicy.GetSystemLockdownPolicy() != SystemEnforcementMode.Enforce) && ((ScriptBlock != null) || (InitializationScript != null))) { ThrowTerminatingError( new ErrorRecord( new PSNotSupportedException(RemotingErrorIdStrings.CannotStartJobInconsistentLanguageMode), "CannotStartJobInconsistentLanguageMode", ErrorCategory.PermissionDenied, Context.LanguageMode)); } NewProcessConnectionInfo connectionInfo = new NewProcessConnectionInfo(this.Credential); connectionInfo.RunAs32 = _shouldRunAs32; connectionInfo.InitializationScript = _initScript; connectionInfo.AuthenticationMechanism = this.Authentication; connectionInfo.PSVersion = this.PSVersion; RemoteRunspace remoteRunspace = (RemoteRunspace)RunspaceFactory.CreateRunspace(connectionInfo, this.Host, Utils.GetTypeTableFromExecutionContextTLS()); remoteRunspace.Events.ReceivedEvents.PSEventReceived += OnRunspacePSEventReceived; Pipeline pipeline = CreatePipeline(remoteRunspace); IThrottleOperation operation = new ExecutionCmdletHelperComputerName(remoteRunspace, pipeline); Operations.Add(operation); }
/// <summary> /// This constructor will be used to created a remote runspace info /// object with a auto generated name. /// </summary> /// <param name="remoteRunspace">Remote runspace object for which /// the info object need to be created</param> internal PSSession(RemoteRunspace remoteRunspace) { _remoteRunspace = remoteRunspace; // Use passed in session Id, if available. if (remoteRunspace.PSSessionId != -1) { Id = remoteRunspace.PSSessionId; } else { Id = System.Threading.Interlocked.Increment(ref s_seed); remoteRunspace.PSSessionId = Id; } // Use passed in friendly name, if available. if (!string.IsNullOrEmpty(remoteRunspace.PSSessionName)) { Name = remoteRunspace.PSSessionName; } else { Name = "Runspace" + Id; remoteRunspace.PSSessionName = Name; } switch (remoteRunspace.ConnectionInfo) { case WSManConnectionInfo _: ComputerType = TargetMachineType.RemoteMachine; string fullShellName = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>( remoteRunspace.ConnectionInfo, "ShellUri", string.Empty); ConfigurationName = GetDisplayShellName(fullShellName); break; case VMConnectionInfo vmConnectionInfo: ComputerType = TargetMachineType.VirtualMachine; ConfigurationName = vmConnectionInfo.ConfigurationName; break; case ContainerConnectionInfo containerConnectionInfo: ComputerType = TargetMachineType.Container; ConfigurationName = containerConnectionInfo.ContainerProc.ConfigurationName; break; case SSHConnectionInfo _: ComputerType = TargetMachineType.RemoteMachine; ConfigurationName = "DefaultShell"; break; case NewProcessConnectionInfo _: ComputerType = TargetMachineType.RemoteMachine; break; default: Dbg.Assert(false, "Invalid Runspace"); break; } }
private PSRemotingJob FindJobForSession(PSSession session) { PSRemotingJob job = null; RemoteRunspace runspace = session.Runspace as RemoteRunspace; if ((runspace == null) || (runspace.RemoteCommand != null)) { return(null); } foreach (Job job2 in base.JobRepository.Jobs) { if (!(job2 is PSRemotingJob)) { continue; } foreach (PSRemotingChildJob job3 in job2.ChildJobs) { if (job3.Runspace.InstanceId.Equals(session.InstanceId) && (job3.JobStateInfo.State == JobState.Disconnected)) { job = (PSRemotingJob)job2; break; } } if (job != null) { return(job); } } return(job); }
protected void UpdateRunspaceAvailability(RunspaceState runspaceState, bool raiseEvent) { System.Management.Automation.Runspaces.RunspaceAvailability runspaceAvailability = this.RunspaceAvailability; RemoteRunspace runspace = this as RemoteRunspace; ConnectCommandInfo info = (runspace != null) ? runspace.RemoteCommand : null; switch (runspaceAvailability) { case System.Management.Automation.Runspaces.RunspaceAvailability.None: if (runspaceState == RunspaceState.Opened) { this.RunspaceAvailability = ((info == null) && (this.GetCurrentlyRunningPipeline() == null)) ? System.Management.Automation.Runspaces.RunspaceAvailability.Available : System.Management.Automation.Runspaces.RunspaceAvailability.Busy; } break; case System.Management.Automation.Runspaces.RunspaceAvailability.Available: case System.Management.Automation.Runspaces.RunspaceAvailability.AvailableForNestedCommand: case System.Management.Automation.Runspaces.RunspaceAvailability.Busy: switch (runspaceState) { case RunspaceState.Closed: case RunspaceState.Closing: case RunspaceState.Broken: case RunspaceState.Disconnected: this.RunspaceAvailability = System.Management.Automation.Runspaces.RunspaceAvailability.None; goto Label_007D; } break; } Label_007D: if (raiseEvent && (this.RunspaceAvailability != runspaceAvailability)) { this.OnAvailabilityChanged(new RunspaceAvailabilityEventArgs(this.RunspaceAvailability)); } }
/// <summary> /// Execute void method. /// </summary> internal void ExecuteVoidMethod(PSHost clientHost) { // The clientHost can be null if the user creates a runspace object without providing // a host parameter. if (clientHost == null) { return; } RemoteRunspace remoteRunspaceToClose = null; if (this.IsSetShouldExitOrPopRunspace) { remoteRunspaceToClose = GetRemoteRunspaceToClose(clientHost); } try { object targetObject = this.SelectTargetObject(clientHost); MyMethodBase.Invoke(targetObject, Parameters); } finally { if (remoteRunspaceToClose != null) { remoteRunspaceToClose.Close(); } } }
private List <RemoteRunspace> CreateRunspacesWhenRunspaceParameterSpecified() { List <RemoteRunspace> list = new List <RemoteRunspace>(); base.ValidateRemoteRunspacesSpecified(); int rsIndex = 0; foreach (PSSession session in this.remoteRunspaceInfos) { if ((session == null) || (session.Runspace == null)) { base.ThrowTerminatingError(new ErrorRecord(new ArgumentNullException("PSSession"), "PSSessionArgumentNull", ErrorCategory.InvalidArgument, null)); } else { try { int num2; RemoteRunspace runspace = (RemoteRunspace)session.Runspace; WSManConnectionInfo connectionInfo = runspace.ConnectionInfo as WSManConnectionInfo; WSManConnectionInfo info2 = null; if (connectionInfo != null) { info2 = connectionInfo.Copy(); info2.EnableNetworkAccess = info2.EnableNetworkAccess || (this.EnableNetworkAccess != false); } else { Uri uri = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <Uri>(runspace.ConnectionInfo, "ConnectionUri", null); string shellUri = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>(runspace.ConnectionInfo, "ShellUri", string.Empty); info2 = new WSManConnectionInfo(uri, shellUri, runspace.ConnectionInfo.Credential); base.UpdateConnectionInfo(info2); info2.EnableNetworkAccess = (bool)this.EnableNetworkAccess; } RemoteRunspacePoolInternal remoteRunspacePoolInternal = runspace.RunspacePool.RemoteRunspacePoolInternal; TypeTable typeTable = null; if (((remoteRunspacePoolInternal != null) && (remoteRunspacePoolInternal.DataStructureHandler != null)) && (remoteRunspacePoolInternal.DataStructureHandler.TransportManager != null)) { typeTable = remoteRunspacePoolInternal.DataStructureHandler.TransportManager.Fragmentor.TypeTable; } string runspaceName = this.GetRunspaceName(rsIndex, out num2); RemoteRunspace item = new RemoteRunspace(typeTable, info2, base.Host, this.SessionOption.ApplicationArguments, runspaceName, num2); list.Add(item); } catch (UriFormatException exception) { PipelineWriter objectWriter = this.stream.ObjectWriter; ErrorRecord errorRecord = new ErrorRecord(exception, "CreateRemoteRunspaceFailed", ErrorCategory.InvalidArgument, session); Action <Cmdlet> action = delegate(Cmdlet cmdlet) { cmdlet.WriteError(errorRecord); }; objectWriter.Write(action); } } rsIndex++; } return(list); }
private Runspace CreateNamedPipeRunspace(NamedPipeConnectionInfo connectionInfo) { TypeTable typeTable = TypeTable.LoadDefaultTypeFiles(); RemoteRunspace remoteRunspace = RunspaceFactory.CreateRunspace(connectionInfo, this.Host, typeTable) as RemoteRunspace; remoteRunspace.Name = NamedPipeRunspaceName; remoteRunspace.ShouldCloseOnPop = true; _connectingRemoteRunspace = remoteRunspace; try { remoteRunspace.Open(); remoteRunspace.Debugger?.SetDebugMode(DebugModes.LocalScript | DebugModes.RemoteScript); } catch (RuntimeException e) { // Unwrap inner exception for original error message, if any. string errorMessage = (e.InnerException != null) ? (e.InnerException.Message ?? string.Empty) : string.Empty; if (connectionInfo.CustomPipeName != null) { ThrowTerminatingError( new ErrorRecord( new RuntimeException( StringUtil.Format( RemotingErrorIdStrings.EnterPSHostProcessCannotConnectToPipe, connectionInfo.CustomPipeName, errorMessage), e.InnerException), "EnterPSHostProcessCannotConnectToPipe", ErrorCategory.OperationTimeout, this)); } else { string msgAppDomainName = connectionInfo.AppDomainName ?? NamedPipeUtils.DefaultAppDomainName; ThrowTerminatingError( new ErrorRecord( new RuntimeException( StringUtil.Format( RemotingErrorIdStrings.EnterPSHostProcessCannotConnectToProcess, msgAppDomainName, connectionInfo.ProcessId, errorMessage), e.InnerException), "EnterPSHostProcessCannotConnectToProcess", ErrorCategory.OperationTimeout, this)); } } finally { _connectingRemoteRunspace = null; } return(remoteRunspace); }
private void WriteRCFailedError() { RemoteRunspace runspace = this._runspaceRef.Value as RemoteRunspace; if ((runspace != null) && (runspace.RunspacePool.RemoteRunspacePoolInternal.Host != null)) { runspace.RunspacePool.RemoteRunspacePoolInternal.Host.UI.WriteErrorLine(StringUtil.Format(RemotingErrorIdStrings.RCAutoDisconnectingError, runspace.ConnectionInfo.ComputerName)); } }
private void StartProgressBar(long sourceId, string computerName, int totalSeconds) { RemoteRunspace runspace = this._runspaceRef.Value as RemoteRunspace; if (runspace != null) { RCProgress.StartProgress(sourceId, computerName, totalSeconds, runspace.RunspacePool.RemoteRunspacePoolInternal.Host); } }
/// <summary> /// Stop Processing. /// </summary> protected override void StopProcessing() { RemoteRunspace connectingRunspace = _connectingRemoteRunspace; if (connectingRunspace != null) { connectingRunspace.AbortOpen(); } }
internal bool InsertRunspace(RemoteRunspace remoteRunspace) { if ((remoteRunspace == null) || (remoteRunspace.InstanceId != this.remoteRunspace.InstanceId)) { return(false); } this.remoteRunspace = remoteRunspace; return(true); }
internal Pipeline CreatePipeline(string line, bool addToHistory, bool useNestedPipelines) { Pipeline pipeline = null; EventHandler <DataAddedEventArgs> handler = null; if (this.IsRunspaceOverridden) { if (((this._runspaceRef.Value is RemoteRunspace) && !string.IsNullOrEmpty(line)) && string.Equals(line.Trim(), "exit", StringComparison.OrdinalIgnoreCase)) { line = "Exit-PSSession"; } PSCommand command = this.ParsePsCommandUsingScriptBlock(line, null); if (command != null) { pipeline = useNestedPipelines ? this._runspaceRef.Value.CreateNestedPipeline(command.Commands[0].CommandText, addToHistory) : this._runspaceRef.Value.CreatePipeline(command.Commands[0].CommandText, addToHistory); pipeline.Commands.Clear(); foreach (Command command2 in command.Commands) { pipeline.Commands.Add(command2); } } } if (pipeline == null) { pipeline = useNestedPipelines ? this._runspaceRef.Value.CreateNestedPipeline(line, addToHistory) : this._runspaceRef.Value.CreatePipeline(line, addToHistory); } RemotePipeline pipeline2 = pipeline as RemotePipeline; if (this.IsRunspaceOverridden && (pipeline2 != null)) { PowerShell powerShell = pipeline2.PowerShell; if (powerShell.RemotePowerShell != null) { powerShell.RemotePowerShell.RCConnectionNotification += new EventHandler <PSConnectionRetryStatusEventArgs>(this.HandleRCConnectionNotification); } if (handler == null) { handler = delegate(object sender, DataAddedEventArgs eventArgs) { RemoteRunspace runspace = this._runspaceRef.Value as RemoteRunspace; PSDataCollection <ErrorRecord> datas = sender as PSDataCollection <ErrorRecord>; if (((runspace != null) && (datas != null)) && (runspace.RunspacePool.RemoteRunspacePoolInternal.Host != null)) { foreach (ErrorRecord record in datas.ReadAll()) { runspace.RunspacePool.RemoteRunspacePoolInternal.Host.UI.WriteErrorLine(record.ToString()); } } }; } powerShell.ErrorBuffer.DataAdded += handler; } pipeline.SetHistoryString(line); return(pipeline); }
internal void Override(RemoteRunspace remoteRunspace, object syncObject, out bool isRunspacePushed) { lock (this._localSyncObject) { this._stopInvoke = false; } try { if (syncObject != null) { lock (syncObject) { this._runspaceRef.Override(remoteRunspace); isRunspacePushed = true; goto Label_0063; } } this._runspaceRef.Override(remoteRunspace); isRunspacePushed = true; Label_0063: using (PowerShell shell = PowerShell.Create()) { shell.AddCommand("Get-Command"); shell.AddParameter("Name", new string[] { "Out-Default", "Exit-PSSession" }); shell.Runspace = this._runspaceRef.Value; bool flag2 = this._runspaceRef.Value.GetRemoteProtocolVersion() == RemotingConstants.ProtocolVersionWin7RC; shell.IsGetCommandMetadataSpecialPipeline = !flag2; int num = flag2 ? 2 : 3; shell.RemotePowerShell.HostCallReceived += new EventHandler <RemoteDataEventArgs <RemoteHostCall> >(this.HandleHostCall); IAsyncResult asyncResult = shell.BeginInvoke(); PSDataCollection <PSObject> datas = new PSDataCollection <PSObject>(); while (!this._stopInvoke) { asyncResult.AsyncWaitHandle.WaitOne(0x3e8); if (asyncResult.IsCompleted) { datas = shell.EndInvoke(asyncResult); break; } } if ((shell.Streams.Error.Count > 0) || (datas.Count < num)) { throw RemoteHostExceptions.NewRemoteRunspaceDoesNotSupportPushRunspaceException(); } return; } } catch (Exception) { this._runspaceRef.Revert(); isRunspacePushed = false; throw; } }
/// <summary> /// Internal method to insert a runspace into a PSSession object. /// This is used only for Disconnect/Reconnect scenarios where the /// new runspace is a reconstructed runspace having the same Guid /// as the existing runspace. /// </summary> /// <param name="remoteRunspace">Runspace to insert.</param> /// <returns>Boolean indicating if runspace was inserted.</returns> internal bool InsertRunspace(RemoteRunspace remoteRunspace) { if (remoteRunspace == null || remoteRunspace.InstanceId != _remoteRunspace.InstanceId) { return(false); } _remoteRunspace = remoteRunspace; return(true); }
private List <PSSession> GetDisconnectedSessions(PSInvokeExpressionSyncJob job) { List <PSSession> list = new List <PSSession>(); foreach (PowerShell shell in job.GetPowerShells()) { string cmdStr = ((shell.Commands != null) && (shell.Commands.Commands.Count > 0)) ? shell.Commands.Commands[0].CommandText : string.Empty; ConnectCommandInfo info = new ConnectCommandInfo(shell.InstanceId, cmdStr); RunspacePool runspacePool = null; if (shell.RunspacePool != null) { runspacePool = shell.RunspacePool; } else { object runspaceConnection = shell.GetRunspaceConnection(); RunspacePool pool2 = runspaceConnection as RunspacePool; if (pool2 != null) { runspacePool = pool2; } else { RemoteRunspace runspace = runspaceConnection as RemoteRunspace; if (runspace != null) { runspacePool = runspace.RunspacePool; } } } if (runspacePool != null) { if (runspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Disconnected) { if (!base.InvokeAndDisconnect || (runspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opened)) { continue; } runspacePool.Disconnect(); } string name = runspacePool.RemoteRunspacePoolInternal.Name; if (string.IsNullOrEmpty(name)) { int num; name = PSSession.GenerateRunspaceName(out num); } RunspacePool pool3 = new RunspacePool(true, runspacePool.RemoteRunspacePoolInternal.InstanceId, name, new ConnectCommandInfo[] { info }, runspacePool.RemoteRunspacePoolInternal.ConnectionInfo, base.Host, base.Context.TypeTable); RemoteRunspace remoteRunspace = new RemoteRunspace(pool3); list.Add(new PSSession(remoteRunspace)); } } return(list); }
internal Pipeline CreatePipeline(RemoteRunspace remoteRunspace) { PowerShell shell = remoteRunspace.GetCapabilities().Equals(RunspaceCapability.Default) ? this.GetPowerShellForPSv2() : this.GetPowerShellForPSv3(); Pipeline pipeline = remoteRunspace.CreatePipeline(shell.Commands.Commands[0].CommandText, true); pipeline.Commands.Clear(); foreach (Command command in shell.Commands.Commands) { pipeline.Commands.Add(command); } pipeline.RedirectShellErrorOutputPipe = true; return(pipeline); }
private RemoteRunspace GetRemoteRunspaceToClose(PSHost clientHost) { IHostSupportsInteractiveSession session = clientHost as IHostSupportsInteractiveSession; if ((session != null) && session.IsRunspacePushed) { RemoteRunspace runspace = session.Runspace as RemoteRunspace; if ((runspace != null) && runspace.ShouldCloseOnPop) { return(runspace); } } return(null); }
private List <RemoteRunspace> CreateRunspacesWhenComputerNameParameterSpecified() { string[] strArray; List <RemoteRunspace> list = new List <RemoteRunspace>(); base.ResolveComputerNames(this.ComputerName, out strArray); base.ValidateComputerName(strArray); for (int i = 0; i < strArray.Length; i++) { try { int num2; WSManConnectionInfo connectionInfo = null; connectionInfo = new WSManConnectionInfo(); string str = this.UseSSL.IsPresent ? "https" : "http"; connectionInfo.ComputerName = strArray[i]; connectionInfo.Port = this.Port; connectionInfo.AppName = this.ApplicationName; connectionInfo.ShellUri = this.ConfigurationName; connectionInfo.Scheme = str; if (this.CertificateThumbprint != null) { connectionInfo.CertificateThumbprint = this.CertificateThumbprint; } else { connectionInfo.Credential = this.Credential; } connectionInfo.AuthenticationMechanism = this.Authentication; base.UpdateConnectionInfo(connectionInfo); connectionInfo.EnableNetworkAccess = (bool)this.EnableNetworkAccess; string runspaceName = this.GetRunspaceName(i, out num2); RemoteRunspace item = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(), connectionInfo, base.Host, this.SessionOption.ApplicationArguments, runspaceName, num2); list.Add(item); } catch (UriFormatException exception) { PipelineWriter objectWriter = this.stream.ObjectWriter; ErrorRecord errorRecord = new ErrorRecord(exception, "CreateRemoteRunspaceFailed", ErrorCategory.InvalidArgument, strArray[i]); Action <Cmdlet> action = delegate(Cmdlet cmdlet) { cmdlet.WriteError(errorRecord); }; objectWriter.Write(action); } } return(list); }
private List <RemoteRunspace> CreateRunspacesWhenUriParameterSpecified() { List <RemoteRunspace> list = new List <RemoteRunspace>(); for (int i = 0; i < this.ConnectionUri.Length; i++) { try { int num2; WSManConnectionInfo connectionInfo = new WSManConnectionInfo { ConnectionUri = this.ConnectionUri[i], ShellUri = this.ConfigurationName }; if (this.CertificateThumbprint != null) { connectionInfo.CertificateThumbprint = this.CertificateThumbprint; } else { connectionInfo.Credential = this.Credential; } connectionInfo.AuthenticationMechanism = this.Authentication; base.UpdateConnectionInfo(connectionInfo); connectionInfo.EnableNetworkAccess = (bool)this.EnableNetworkAccess; string runspaceName = this.GetRunspaceName(i, out num2); RemoteRunspace item = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(), connectionInfo, base.Host, this.SessionOption.ApplicationArguments, runspaceName, num2); list.Add(item); } catch (UriFormatException exception) { this.WriteErrorCreateRemoteRunspaceFailed(exception, this.ConnectionUri[i]); } catch (InvalidOperationException exception2) { this.WriteErrorCreateRemoteRunspaceFailed(exception2, this.ConnectionUri[i]); } catch (ArgumentException exception3) { this.WriteErrorCreateRemoteRunspaceFailed(exception3, this.ConnectionUri[i]); } catch (NotSupportedException exception4) { this.WriteErrorCreateRemoteRunspaceFailed(exception4, this.ConnectionUri[i]); } } return(list); }
private RemoteRunspace GetRunspaceMatchingCondition(Predicate <PSSession> condition, PSRemotingErrorId tooFew, PSRemotingErrorId tooMany, string tooFewResourceString, string tooManyResourceString, object errorArgument) { List <PSSession> list = base.RunspaceRepository.Runspaces.FindAll(condition); RemoteRunspace runspace = null; if (list.Count == 0) { this.WriteInvalidArgumentError(tooFew, tooFewResourceString, errorArgument); return(runspace); } if (list.Count > 1) { this.WriteInvalidArgumentError(tooMany, tooManyResourceString, errorArgument); return(runspace); } return((RemoteRunspace)list[0].Runspace); }
protected void CreateHelpersForSpecifiedRunspaces() { int length = this.Session.Length; RemoteRunspace[] runspaceArray = new RemoteRunspace[length]; for (int i = 0; i < length; i++) { runspaceArray[i] = (RemoteRunspace)this.Session[i].Runspace; } Pipeline[] pipelineArray = new Pipeline[length]; for (int j = 0; j < length; j++) { pipelineArray[j] = this.CreatePipeline(runspaceArray[j]); IThrottleOperation item = new ExecutionCmdletHelperRunspace(pipelineArray[j]); this.Operations.Add(item); } }
internal void ExecuteVoidMethod(PSHost clientHost) { RemoteRunspace remoteRunspace = (RemoteRunspace)null; if (this.IsSetShouldExitOrPopRunspace) { remoteRunspace = this.GetRemoteRunspaceToClose(clientHost); } try { this.MyMethodBase.Invoke(this.SelectTargetObject(clientHost), this._parameters); } finally { remoteRunspace?.Close(); } }
protected void CreateHelpersForSpecifiedUris() { RemoteRunspace remoteRunspace = null; for (int i = 0; i < this.ConnectionUri.Length; i++) { try { WSManConnectionInfo connectionInfo = new WSManConnectionInfo { ConnectionUri = this.ConnectionUri[i], ShellUri = this.ConfigurationName }; if (this.CertificateThumbprint != null) { connectionInfo.CertificateThumbprint = this.CertificateThumbprint; } else { connectionInfo.Credential = this.Credential; } connectionInfo.AuthenticationMechanism = this.Authentication; base.UpdateConnectionInfo(connectionInfo); connectionInfo.EnableNetworkAccess = (bool)this.EnableNetworkAccess; remoteRunspace = (RemoteRunspace)RunspaceFactory.CreateRunspace(connectionInfo, base.Host, Utils.GetTypeTableFromExecutionContextTLS(), this.SessionOption.ApplicationArguments); remoteRunspace.Events.ReceivedEvents.PSEventReceived += new PSEventReceivedEventHandler(this.OnRunspacePSEventReceived); } catch (UriFormatException exception) { this.WriteErrorCreateRemoteRunspaceFailed(exception, this.ConnectionUri[i]); continue; } catch (InvalidOperationException exception2) { this.WriteErrorCreateRemoteRunspaceFailed(exception2, this.ConnectionUri[i]); continue; } catch (ArgumentException exception3) { this.WriteErrorCreateRemoteRunspaceFailed(exception3, this.ConnectionUri[i]); continue; } Pipeline pipeline = this.CreatePipeline(remoteRunspace); IThrottleOperation item = new ExecutionCmdletHelperComputerName(remoteRunspace, pipeline, this.invokeAndDisconnect); this.Operations.Add(item); } }
/// <summary> /// Internal constructor /// </summary> /// <param name="remoteRunspace"></param> internal CloseOrDisconnectRunspaceOperationHelper(RemoteRunspace remoteRunspace) { _remoteRunspace = remoteRunspace; _remoteRunspace.StateChanged += new EventHandler<RunspaceStateEventArgs>(HandleRunspaceStateChanged); }
/// <summary> /// Internal method to insert a runspace into a PSSession object. /// This is used only for Disconnect/Reconnect scenarios where the /// new runspace is a reconstructed runspace having the same Guid /// as the existing runspace. /// </summary> /// <param name="remoteRunspace">Runspace to insert</param> /// <returns>Boolean indicating if runspace was inserted.</returns> internal bool InsertRunspace(RemoteRunspace remoteRunspace) { if (remoteRunspace == null || remoteRunspace.InstanceId != _remoteRunspace.InstanceId) { return false; } _remoteRunspace = remoteRunspace; return true; }
/// <summary> /// This constructor will be used to created a remote runspace info /// object with a auto generated name /// </summary> /// <param name="remoteRunspace">Remote runspace object for which /// the info object need to be created</param> internal PSSession(RemoteRunspace remoteRunspace) { _remoteRunspace = remoteRunspace; // Use passed in session Id, if available. if (remoteRunspace.PSSessionId != -1) { Id = remoteRunspace.PSSessionId; } else { Id = System.Threading.Interlocked.Increment(ref s_seed); remoteRunspace.PSSessionId = Id; } // Use passed in friendly name, if available. if (!string.IsNullOrEmpty(remoteRunspace.PSSessionName)) { Name = remoteRunspace.PSSessionName; } else { Name = AutoGenerateRunspaceName(Id); remoteRunspace.PSSessionName = Name; } // WSMan session if (remoteRunspace.ConnectionInfo is WSManConnectionInfo) { ComputerType = TargetMachineType.RemoteMachine; string fullShellName = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo<string>( remoteRunspace.ConnectionInfo, "ShellUri", string.Empty); ConfigurationName = GetDisplayShellName(fullShellName); return; } // VM session VMConnectionInfo vmConnectionInfo = remoteRunspace.ConnectionInfo as VMConnectionInfo; if (vmConnectionInfo != null) { ComputerType = TargetMachineType.VirtualMachine; ConfigurationName = vmConnectionInfo.ConfigurationName; return; } // Container session ContainerConnectionInfo containerConnectionInfo = remoteRunspace.ConnectionInfo as ContainerConnectionInfo; if (containerConnectionInfo != null) { ComputerType = TargetMachineType.Container; ConfigurationName = containerConnectionInfo.ContainerProc.ConfigurationName; return; } // SSH session SSHConnectionInfo sshConnectionInfo = remoteRunspace.ConnectionInfo as SSHConnectionInfo; if (sshConnectionInfo != null) { ComputerType = TargetMachineType.RemoteMachine; ConfigurationName = "DefaultShell"; return; } // We only support WSMan/VM/Container sessions now. Dbg.Assert(false, "Invalid Runspace"); }
/// <summary> /// Override inside a safe lock /// </summary> /// <param name="remoteRunspace">runspace to override</param> /// <param name="syncObject">object to use in synchronization</param> /// <param name="isRunspacePushed">set is runspace pushed</param> internal void Override(RemoteRunspace remoteRunspace, object syncObject, out bool isRunspacePushed) { lock (_localSyncObject) { _stopInvoke = false; } try { if (syncObject != null) { lock (syncObject) { _runspaceRef.Override(remoteRunspace); isRunspacePushed = true; } } else { _runspaceRef.Override(remoteRunspace); isRunspacePushed = true; } if ((remoteRunspace.GetCurrentlyRunningPipeline() != null)) { // Don't execute command if pushed runspace is already running one. return; } using (PowerShell powerShell = PowerShell.Create()) { powerShell.AddCommand("Get-Command"); powerShell.AddParameter("Name", new string[] { "Out-Default", "Exit-PSSession" }); powerShell.Runspace = _runspaceRef.Value; bool isReleaseCandidateBackcompatibilityMode = _runspaceRef.Value.GetRemoteProtocolVersion() == RemotingConstants.ProtocolVersionWin7RC; powerShell.IsGetCommandMetadataSpecialPipeline = !isReleaseCandidateBackcompatibilityMode; int expectedNumberOfResults = isReleaseCandidateBackcompatibilityMode ? 2 : 3; powerShell.RemotePowerShell.HostCallReceived += new EventHandler<RemoteDataEventArgs<RemoteHostCall>>(HandleHostCall); IAsyncResult asyncResult = powerShell.BeginInvoke(); PSDataCollection<PSObject> results = new PSDataCollection<PSObject>(); while (!_stopInvoke) { asyncResult.AsyncWaitHandle.WaitOne(1000); if (asyncResult.IsCompleted) { results = powerShell.EndInvoke(asyncResult); break; } } if (powerShell.Streams.Error.Count > 0 || results.Count < expectedNumberOfResults) { throw RemoteHostExceptions.NewRemoteRunspaceDoesNotSupportPushRunspaceException(); } } } catch (Exception) { _runspaceRef.Revert(); isRunspacePushed = false; throw; } }
/// <summary> /// Override. /// </summary> internal void Override(RemoteRunspace remoteRunspace) { bool isRunspacePushed = false; Override(remoteRunspace, null, out isRunspacePushed); }
/// <summary> /// Push runspace to use for remote command execution /// </summary> /// <param name="runspace">RemoteRunspace</param> public override void PushRunspace(Runspace runspace) { // Double session hop is currently allowed only for WSMan (non-OutOfProc) sessions, where // the second session is either through a named pipe or hyperV socket connection. if (!AllowPushRunspace && ((_transportManager is OutOfProcessServerSessionTransportManager) || !(runspace.ConnectionInfo is NamedPipeConnectionInfo || runspace.ConnectionInfo is VMConnectionInfo || runspace.ConnectionInfo is ContainerConnectionInfo)) ) { throw new PSNotSupportedException(); } if (_debugger == null) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostNoDebuggerToPush); } if (_pushedRunspace != null) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostAlreadyPushed); } RemoteRunspace remoteRunspace = runspace as RemoteRunspace; if (remoteRunspace == null) { throw new PSInvalidOperationException(RemotingErrorIdStrings.ServerDriverRemoteHostNotRemoteRunspace); } // PSEdit support. Existence of RemoteSessionOpenFileEvent event indicates host supports PSEdit _hostSupportsPSEdit = false; PSEventManager localEventManager = (Runspace != null) ? Runspace.Events : null; _hostSupportsPSEdit = (localEventManager != null) ? localEventManager.GetEventSubscribers(HostUtilities.RemoteSessionOpenFileEvent).GetEnumerator().MoveNext() : false; if (_hostSupportsPSEdit) { AddPSEditForRunspace(remoteRunspace); } _debugger.PushDebugger(runspace.Debugger); _pushedRunspace = remoteRunspace; }
/// <summary> /// Pop runspace /// </summary> public override void PopRunspace() { if (_pushedRunspace != null) { if (_debugger != null) { _debugger.PopDebugger(); } if (_hostSupportsPSEdit) { RemovePSEditFromRunspace(_pushedRunspace); } if (_pushedRunspace.ShouldCloseOnPop) { _pushedRunspace.Close(); } _pushedRunspace = null; } }
private void AddPSEditForRunspace(RemoteRunspace remoteRunspace) { if (remoteRunspace.Events == null) { return; } // Add event handler. remoteRunspace.Events.ReceivedEvents.PSEventReceived += HandleRemoteSessionForwardedEvent; // Add script function. using (PowerShell powershell = PowerShell.Create()) { powershell.Runspace = remoteRunspace; powershell.AddScript(HostUtilities.CreatePSEditFunction).AddParameter("PSEditFunction", HostUtilities.PSEditFunction); try { powershell.Invoke(); } catch (RemoteException) { } } }