internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo, string initializationScriptForOutOfProcessRunspace, AbstractServerSessionTransportManager transportManager)
{
ServerRemoteSession session = CreateServerRemoteSession(senderInfo, "Microsoft.PowerShell", "", transportManager);
session._initScriptForOutOfProcRS = initializationScriptForOutOfProcessRunspace;
return(session);
}
public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
if (sessionConfigurationData == null)
{
throw new ArgumentNullException("sessionConfigurationData");
}
if (senderInfo == null)
{
throw new ArgumentNullException("senderInfo");
}
if (configProviderId == null)
{
throw new ArgumentNullException("configProviderId");
}
InitialSessionState state = InitialSessionState.CreateDefault();
if ((sessionConfigurationData != null) && (sessionConfigurationData.ModulesToImport != null))
{
foreach (string str in sessionConfigurationData.ModulesToImport)
{
state.ImportPSModulesFromPath(str);
}
}
if ((senderInfo.ConnectionString != null) && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return state;
}
private PSSenderInfo(SerializationInfo info, StreamingContext context)
{
if (info != null)
{
string source = null;
try
{
source = info.GetValue("CliXml", typeof(string)) as string;
}
catch (Exception)
{
return;
}
if (source != null)
{
try
{
PSSenderInfo info2 = DeserializingTypeConverter.RehydratePSSenderInfo(PSObject.AsPSObject(PSSerializer.Deserialize(source)));
this.userPrinicpal = info2.userPrinicpal;
this.clientTimeZone = info2.ClientTimeZone;
this.connectionString = info2.connectionString;
this.applicationArguments = info2.applicationArguments;
}
catch (Exception)
{
return;
}
}
}
}
public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
Tracer tracer = new Tracer();
tracer.Correlate();
if (sessionConfigurationData != null)
{
if (senderInfo != null)
{
if (!string.IsNullOrEmpty(configProviderId))
{
if (Interlocked.CompareExchange(ref PSWorkflowSessionConfiguration._modulesLoaded, 1, 0) == 0)
{
try
{
PSWorkflowConfigurationProvider configuration = WorkflowJobSourceAdapter.GetInstance().GetPSWorkflowRuntime().Configuration;
if (configuration != null)
{
configuration.Populate(sessionConfigurationData.PrivateData, configProviderId, senderInfo);
if (sessionConfigurationData.ModulesToImport != null)
{
foreach (string modulesToImport in sessionConfigurationData.ModulesToImport)
{
PSWorkflowSessionConfiguration.InitialSessionState.ImportPSModulesFromPath(modulesToImport);
}
}
}
else
{
throw new InvalidOperationException("PSWorkflowConfigurationProvider is null");
}
}
catch (Exception exception)
{
Interlocked.CompareExchange(ref PSWorkflowSessionConfiguration._modulesLoaded, 0, 1);
throw;
}
}
if (configProviderId.ToLower(CultureInfo.InvariantCulture).Equals("http://schemas.microsoft.com/powershell/microsoft.windows.servermanagerworkflows"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return PSWorkflowSessionConfiguration.InitialSessionState;
}
else
{
throw new ArgumentNullException("configProviderId");
}
}
else
{
throw new ArgumentNullException("senderInfo");
}
}
else
{
throw new ArgumentNullException("sessionConfigurationData");
}
}
private OutOfProcessServerSessionTransportManager CreateSessionTransportManager()
{
WindowsIdentity current = WindowsIdentity.GetCurrent();
PSPrincipal userPrincipal = new PSPrincipal(new PSIdentity("", true, current.Name, null), current);
PSSenderInfo senderInfo = new PSSenderInfo(userPrincipal, "http://localhost");
OutOfProcessServerSessionTransportManager transportManager = new OutOfProcessServerSessionTransportManager(this.originalStdOut);
ServerRemoteSession.CreateServerRemoteSession(senderInfo, this._initialCommand, transportManager);
return transportManager;
}
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
InitialSessionState state = InitialSessionState.CreateDefault();
if ((senderInfo.ConnectionString != null) && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return state;
}
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
InitialSessionState state = InitialSessionState.CreateDefault();
if ((senderInfo.ConnectionString != null) && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return(state);
}
internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo, string configurationProviderId, string initializationParameters, AbstractServerSessionTransportManager transportManager)
{
_trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Finding InitialSessionState provider for id : {0}", new object[] { configurationProviderId }), new object[0]);
if (string.IsNullOrEmpty(configurationProviderId))
{
throw PSTraceSource.NewInvalidOperationException("remotingerroridstrings", "NonExistentInitialSessionStateProvider", new object[] { configurationProviderId });
}
ServerRemoteSession session = new ServerRemoteSession(senderInfo, configurationProviderId, initializationParameters, transportManager);
RemoteSessionStateMachineEventArgs fsmEventArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.CreateSession);
session._sessionDSHandler.StateMachine.RaiseEvent(fsmEventArg);
return session;
}
public Guid CreateSession(string connection, string username, string password, int authMechanism, int protocolVersion)
{
Guid sessionId = Guid.NewGuid ();
var identity = new PSIdentity ("", true, username, null);
var principal = new PSPrincipal (identity, WindowsIdentity.GetCurrent ());
var sender = new PSSenderInfo (principal, connection);
var session = ServerRemoteSession.CreateServerRemoteSession (sender, null, new WSManServerSessionTransportManager());
lock (_lock) {
_sessions.Add (sessionId, session);
}
return sessionId;
}
public Guid CreateSession ()
{
var username = System.Threading.Thread.CurrentPrincipal.Identity.Name;
string connection = OperationContext.Current.Host.Description.Endpoints[0].Address.Uri.ToString ();
var identity = new PSIdentity ("", true, username, null);
var principal = new PSPrincipal (identity, WindowsIdentity.GetCurrent ());
var sender = new PSSenderInfo (principal, connection);
var session = ServerRemoteSession.CreateServerRemoteSession (sender, null, sessionTransportManager);
lock (_lock) {
_sessions.Add (session.InstanceId, session);
}
return session.InstanceId;
}
internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo, string configurationProviderId, string initializationParameters, AbstractServerSessionTransportManager transportManager)
{
_trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Finding InitialSessionState provider for id : {0}", new object[] { configurationProviderId }), new object[0]);
if (string.IsNullOrEmpty(configurationProviderId))
{
throw PSTraceSource.NewInvalidOperationException("remotingerroridstrings", "NonExistentInitialSessionStateProvider", new object[] { configurationProviderId });
}
ServerRemoteSession session = new ServerRemoteSession(senderInfo, configurationProviderId, initializationParameters, transportManager);
RemoteSessionStateMachineEventArgs fsmEventArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.CreateSession);
session._sessionDSHandler.StateMachine.RaiseEvent(fsmEventArg);
return(session);
}
/// <summary>
/// Gets custom initial session state
/// It relies on the RBAC system to give list of commands allowed for a user
/// and creates Initial Session state from that
/// </summary>
/// <param name="senderInfo">Sender information</param>
/// <returns>Custom initial Session state</returns>
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
if (senderInfo == null)
{
throw new ArgumentNullException("senderInfo");
}
if (senderInfo.UserInfo == null)
{
throw new ArgumentException("senderInfo.UserInfo is null");
}
InitialSessionState initialSessionState = InitialSessionState.CreateDefault();
foreach (SessionStateCommandEntry command in initialSessionState.Commands)
{
command.Visibility = SessionStateEntryVisibility.Private;
}
List<string> scripts = RbacSystem.Current.GetScripts(senderInfo.UserInfo);
foreach (string script in scripts)
{
initialSessionState.Commands.Add(new SessionStateScriptEntry(script));
}
List<string> modules = RbacSystem.Current.GetModules(senderInfo.UserInfo);
if (modules.Count > 0)
{
initialSessionState.ImportPSModule(modules.ToArray());
}
// enable execution of scripts in this process
System.Environment.SetEnvironmentVariable("PSExecutionPolicyPreference", "unrestricted");
List<string> cmdletsFromRbac = RbacSystem.Current.GetCmdlets(senderInfo.UserInfo);
// Add all commands from Rbac system to Initial Session State commands
foreach (string cmdlet in cmdletsFromRbac)
{
SessionStateCommandEntry cmdletFromRbac = initialSessionState.Commands.FirstOrDefault(item => string.Equals(item.Name, cmdlet, StringComparison.OrdinalIgnoreCase));
if (cmdletFromRbac == null)
{
throw new ArgumentException("Command not found in InitialSessionState " + cmdlet);
}
cmdletFromRbac.Visibility = SessionStateEntryVisibility.Public;
}
return initialSessionState;
}
/// <summary>
/// Gets custom initial session state
/// </summary>
/// <param name="senderInfo">Sender information</param>
/// <returns>Custom initial Session state</returns>
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
var initialSessionState = InitialSessionState.CreateDefault();
var dir = HttpContext.Current != null ? HttpContext.Current.Server.MapPath(".") : Directory.GetCurrentDirectory();
initialSessionState.ImportPSModule(Directory.EnumerateFiles(dir, "*.psm1")
.Select(s => Path.Combine(dir, Path.GetFileNameWithoutExtension(s))).ToArray());
foreach (var cmdletFileName in Directory.EnumerateFiles(dir, "*-*.ps1"))
{
initialSessionState.Commands.Add(
new SessionStateFunctionEntry(Path.GetFileNameWithoutExtension(cmdletFileName), File.ReadAllText(Path.Combine(dir, cmdletFileName))));
}
return initialSessionState;
}
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 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;
}
/// <summary>
/// Deserialization constructor
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
private PSSenderInfo(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
return;
}
string serializedData = null;
try
{
serializedData = info.GetValue("CliXml", typeof(string)) as string;
}
catch (Exception)
{
// When a workflow is run locally, there won't be PSSenderInfo
return;
}
if (serializedData == null)
{
return;
}
try
{
PSObject result = PSObject.AsPSObject(PSSerializer.Deserialize(serializedData));
PSSenderInfo senderInfo = DeserializingTypeConverter.RehydratePSSenderInfo(result);
UserInfo = senderInfo.UserInfo;
ConnectionString = senderInfo.ConnectionString;
_applicationArguments = senderInfo._applicationArguments;
#if !CORECLR // TimeZone Not In CoreCLR
this.clientTimeZone = senderInfo.ClientTimeZone;
#endif
}
catch (Exception)
{
// Ignore conversion errors
return;
}
}
/// <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>
/// Creates a server remote session for the supplied <paramref name="configurationProviderId"/>
/// and <paramref name="transportManager"/>.
/// </summary>
/// <param name="senderInfo"></param>
/// <param name="configurationProviderId"></param>
/// <param name="initializationParameters">
/// Initialization Parameters xml passed by WSMan API. This data is read from the config
/// xml.
/// </param>
/// <param name="transportManager"></param>
/// <param name="configurationName">Optional configuration endpoint name for OutOfProc sessions</param>
/// <returns></returns>
/// <exception cref="InvalidOperationException">
/// InitialSessionState provider with <paramref name="configurationProviderId"/> does
/// not exist on the remote server.
/// </exception>
/*
<InitializationParameters>
<Param Name="PSVersion" Value="2.0" />
<Param Name="ApplicationBase" Value="<folder path>" />
...
</InitializationParameters>
*/
internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo,
string configurationProviderId,
string initializationParameters,
AbstractServerSessionTransportManager transportManager,
string configurationName = null)
{
Dbg.Assert((senderInfo != null) & (senderInfo.UserInfo != null),
"senderInfo and userInfo cannot be null.");
s_trace.WriteLine("Finding InitialSessionState provider for id : {0}", configurationProviderId);
if (string.IsNullOrEmpty(configurationProviderId))
{
throw PSTraceSource.NewInvalidOperationException("RemotingErrorIdStrings.NonExistentInitialSessionStateProvider", configurationProviderId);
}
ServerRemoteSession result = new ServerRemoteSession(senderInfo,
configurationProviderId,
initializationParameters,
transportManager)
{
_configurationName = configurationName
};
// start state machine.
RemoteSessionStateMachineEventArgs startEventArg = new RemoteSessionStateMachineEventArgs(RemoteSessionEvent.CreateSession);
result.SessionDataStructureHandler.StateMachine.RaiseEvent(startEventArg);
return result;
}
/// <summary>
/// Gets application private data
/// </summary>
/// <param name="senderInfo">Sender information</param>
/// <returns>Always returns null</returns>
public override PSPrimitiveDictionary GetApplicationPrivateData(PSSenderInfo senderInfo)
{
return null;
}
public virtual int?GetMaximumReceivedObjectSize(PSSenderInfo senderInfo)
{
return(0xa00000);
}
/// <summary>
///
/// </summary>
/// <param name="sessionConfigurationData"></param>
/// <param name="senderInfo"></param>
/// <param name="configProviderId"></param>
/// <returns></returns>
public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
Tracer structuredTracer = new Tracer();
structuredTracer.Correlate();
if (sessionConfigurationData == null)
throw new ArgumentNullException("sessionConfigurationData");
if (senderInfo == null)
throw new ArgumentNullException("senderInfo");
if (string.IsNullOrEmpty(configProviderId))
throw new ArgumentNullException("configProviderId");
if (Interlocked.CompareExchange(ref _modulesLoaded, ModulesLoaded, ModulesNotLoaded) == ModulesNotLoaded)
{
// it is sufficient if Populate() is called the first time and
// modules are loaded once
try
{
IsWorkflowTypeEndpoint = true;
PSWorkflowConfigurationProvider workflowConfiguration = WorkflowJobSourceAdapter.GetInstance().GetPSWorkflowRuntime().Configuration;
if (workflowConfiguration == null)
throw new InvalidOperationException("PSWorkflowConfigurationProvider is null");
workflowConfiguration.Populate(sessionConfigurationData.PrivateData, configProviderId, senderInfo);
// now get all the modules in the specified path and import the same
if (sessionConfigurationData.ModulesToImport != null)
{
foreach (var module in sessionConfigurationData.ModulesToImport)
{
ModuleSpecification moduleSpec = null;
if (ModuleSpecification.TryParse(module, out moduleSpec))
{
var modulesToImport = new Collection<ModuleSpecification> { moduleSpec };
InitialSessionState.ImportPSModule(modulesToImport);
}
else
{
InitialSessionState.ImportPSModule(new[] { Environment.ExpandEnvironmentVariables(module) });
}
}
}
// Start the workflow job manager, if not started, to add an event handler for zero active sessions changed events
// This is required to auto shutdown the workflow type shared process when no workflow jobs have scheduled/inprogress and when no active sessions
WorkflowJobSourceAdapter.GetInstance().GetJobManager();
}
catch(Exception)
{
// if there is an exception in either Populate() or Importing modules
// we consider that it is not loaded
Interlocked.CompareExchange(ref _modulesLoaded, ModulesNotLoaded, ModulesLoaded);
throw;
}
}
if (configProviderId.ToLower(CultureInfo.InvariantCulture).Equals("http://schemas.microsoft.com/powershell/microsoft.windows.servermanagerworkflows"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return InitialSessionState;
}
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
InitialSessionState state = null;
bool flag = false;
string str = TryGetValue(this.configHash, ConfigFileContants.SessionType);
SessionType type = SessionType.Default;
bool flag2 = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleCmdlets);
bool flag3 = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleFunctions);
bool flag4 = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleAliases);
bool flag5 = this.IsNonDefaultVisibiltySpecified(ConfigFileContants.VisibleProviders);
if (!string.IsNullOrEmpty(str))
{
type = (SessionType)Enum.Parse(typeof(SessionType), str, true);
switch (type)
{
case SessionType.Empty:
state = InitialSessionState.Create();
goto Label_00AD;
case SessionType.RestrictedRemoteServer:
state = InitialSessionState.CreateRestricted(SessionCapabilities.RemoteServer);
if (flag5)
{
InitialSessionState state2 = InitialSessionState.CreateDefault2();
state.Providers.Add(state2.Providers);
}
goto Label_00AD;
}
state = InitialSessionState.CreateDefault2();
}
else
{
state = InitialSessionState.CreateDefault2();
}
Label_00AD:
if (this.configHash.ContainsKey(ConfigFileContants.AssembliesToLoad))
{
string[] strArray = TryGetStringArray(this.configHash[ConfigFileContants.AssembliesToLoad]);
if (strArray != null)
{
foreach (string str2 in strArray)
{
state.Assemblies.Add(new SessionStateAssemblyEntry(str2));
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.ModulesToImport))
{
object[] objArray = TryGetObjectsOfType <object>(this.configHash[ConfigFileContants.ModulesToImport], new Type[] { typeof(string), typeof(Hashtable) });
if ((this.configHash[ConfigFileContants.ModulesToImport] != null) && (objArray == null))
{
PSInvalidOperationException exception = new PSInvalidOperationException(StringUtil.Format(RemotingErrorIdStrings.DISCTypeMustBeStringOrHashtableArray, ConfigFileContants.ModulesToImport));
exception.SetErrorId("InvalidModulesToImportKeyEntries");
throw exception;
}
if (objArray != null)
{
Collection <ModuleSpecification> modules = new Collection <ModuleSpecification>();
foreach (object obj2 in objArray)
{
ModuleSpecification item = null;
string str4 = obj2 as string;
if (!string.IsNullOrEmpty(str4))
{
item = new ModuleSpecification(str4);
}
else
{
Hashtable moduleSpecification = obj2 as Hashtable;
if (moduleSpecification != null)
{
item = new ModuleSpecification(moduleSpecification);
}
}
if (item != null)
{
if (string.Equals(InitialSessionState.CoreModule, item.Name, StringComparison.OrdinalIgnoreCase))
{
if (type == SessionType.Empty)
{
state.ImportCorePSSnapIn();
}
}
else
{
modules.Add(item);
}
}
}
state.ImportPSModule(modules);
}
}
if (this.configHash.ContainsKey(ConfigFileContants.AliasDefinitions))
{
Hashtable[] hashtableArray = TryGetHashtableArray(this.configHash[ConfigFileContants.AliasDefinitions]);
if (hashtableArray != null)
{
foreach (Hashtable hashtable2 in hashtableArray)
{
SessionStateAliasEntry entry = this.CreateSessionStateAliasEntry(hashtable2);
if (entry != null)
{
state.Commands.Add(entry);
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.FunctionDefinitions))
{
Hashtable[] hashtableArray2 = TryGetHashtableArray(this.configHash[ConfigFileContants.FunctionDefinitions]);
if (hashtableArray2 != null)
{
foreach (Hashtable hashtable3 in hashtableArray2)
{
SessionStateFunctionEntry entry2 = this.CreateSessionStateFunctionEntry(hashtable3);
if (entry2 != null)
{
state.Commands.Add(entry2);
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.VariableDefinitions))
{
Hashtable[] hashtableArray3 = TryGetHashtableArray(this.configHash[ConfigFileContants.VariableDefinitions]);
if (hashtableArray3 != null)
{
foreach (Hashtable hashtable4 in hashtableArray3)
{
if (!hashtable4.ContainsKey(ConfigFileContants.VariableValueToken) || !(hashtable4[ConfigFileContants.VariableValueToken] is ScriptBlock))
{
SessionStateVariableEntry entry3 = this.CreateSessionStateVariableEntry(hashtable4);
if (entry3 != null)
{
state.Variables.Add(entry3);
}
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.TypesToProcess))
{
string[] strArray2 = TryGetStringArray(this.configHash[ConfigFileContants.TypesToProcess]);
if (strArray2 != null)
{
foreach (string str5 in strArray2)
{
if (!string.IsNullOrEmpty(str5))
{
state.Types.Add(new SessionStateTypeEntry(str5));
}
}
}
}
if (this.configHash.ContainsKey(ConfigFileContants.FormatsToProcess))
{
string[] strArray3 = TryGetStringArray(this.configHash[ConfigFileContants.FormatsToProcess]);
if (strArray3 != null)
{
foreach (string str6 in strArray3)
{
if (!string.IsNullOrEmpty(str6))
{
state.Formats.Add(new SessionStateFormatEntry(str6));
}
}
}
}
if ((flag2 || flag3) || (flag4 || flag5))
{
flag = true;
}
if (flag)
{
state.Variables.Add(new SessionStateVariableEntry("PSModuleAutoLoadingPreference", PSModuleAutoLoadingPreference.None, string.Empty, ScopedItemOptions.None));
if (type == SessionType.Default)
{
state.ImportPSCoreModule(InitialSessionState.EngineModules.ToArray <string>());
}
if (!flag2)
{
state.Commands.Remove("Import-Module", typeof(SessionStateCmdletEntry));
}
if (!flag4)
{
state.Commands.Remove("ipmo", typeof(SessionStateAliasEntry));
}
}
return(state);
}
public override InitialSessionState GetInitialSessionState(
PSSenderInfo senderInfo)
{
return(InitialSessionState.CreateDefault());
}
public virtual int?GetMaximumReceivedDataSizePerCommand(PSSenderInfo senderInfo) => new int?(52428800);
public virtual int? GetMaximumReceivedObjectSize(PSSenderInfo senderInfo)
{
return 0xa00000;
}
public abstract InitialSessionState GetInitialSessionState(
PSSenderInfo senderInfo);
public virtual int? GetMaximumReceivedDataSizePerCommand(PSSenderInfo senderInfo)
{
return 0x3200000;
}
public virtual int?GetMaximumReceivedDataSizePerCommand(PSSenderInfo senderInfo)
{
return(0x3200000);
}
public virtual int?GetMaximumReceivedObjectSize(PSSenderInfo senderInfo) => new int?(10485760);
/// <summary>
/// Used by OutOfProcessServerMediator to create a remote session.
/// </summary>
/// <param name="senderInfo"></param>
/// <param name="initializationScriptForOutOfProcessRunspace"></param>
/// <param name="transportManager"></param>
/// <param name="configurationName"></param>
/// <returns></returns>
internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo,
string initializationScriptForOutOfProcessRunspace,
AbstractServerSessionTransportManager transportManager,
string configurationName)
{
ServerRemoteSession result = CreateServerRemoteSession(senderInfo,
"Microsoft.PowerShell", "", transportManager, configurationName);
result._initScriptForOutOfProcRS = initializationScriptForOutOfProcessRunspace;
return result;
}
internal static ServerRemoteSession CreateServerRemoteSession(PSSenderInfo senderInfo, string initializationScriptForOutOfProcessRunspace, AbstractServerSessionTransportManager transportManager)
{
ServerRemoteSession session = CreateServerRemoteSession(senderInfo, "Microsoft.PowerShell", "", transportManager);
session._initScriptForOutOfProcRS = initializationScriptForOutOfProcessRunspace;
return session;
}
public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
if (sessionConfigurationData == null)
{
throw new ArgumentNullException("sessionConfigurationData");
}
if (senderInfo == null)
{
throw new ArgumentNullException("senderInfo");
}
if (configProviderId == null)
{
throw new ArgumentNullException("configProviderId");
}
InitialSessionState state = InitialSessionState.CreateDefault();
if ((sessionConfigurationData != null) && (sessionConfigurationData.ModulesToImport != null))
{
foreach (string str in sessionConfigurationData.ModulesToImport)
{
state.ImportPSModulesFromPath(str);
}
}
if ((senderInfo.ConnectionString != null) && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8"))
{
PSSessionConfigurationData.IsServerManager = true;
}
return(state);
}
public virtual PSPrimitiveDictionary GetApplicationPrivateData(
PSSenderInfo senderInfo)
{
return((PSPrimitiveDictionary)null);
}
/// <summary>
/// used to create PSPrincipal object from senderDetails struct.
/// </summary>
/// <param name="senderDetails"></param>
/// <returns></returns>
private PSSenderInfo GetPSSenderInfo(
WSManNativeApi.WSManSenderDetails senderDetails)
{
// senderDetails will not be null.
Dbg.Assert(null != senderDetails, "senderDetails cannot be null");
// Construct PSIdentity
PSCertificateDetails psCertDetails = null;
// Construct Certificate Details
if (null != senderDetails.certificateDetails)
{
psCertDetails = new PSCertificateDetails(
senderDetails.certificateDetails.subject,
senderDetails.certificateDetails.issuerName,
senderDetails.certificateDetails.issuerThumbprint);
}
// Construct PSPrincipal
PSIdentity psIdentity = new PSIdentity(senderDetails.authenticationMechanism, true, senderDetails.senderName, psCertDetails);
// For Virtual and RunAs accounts WSMan specifies the client token via an environment variable and
// senderDetails.clientToken should not be used.
IntPtr clientToken = GetRunAsClientToken();
clientToken = (clientToken != IntPtr.Zero) ? clientToken : senderDetails.clientToken;
WindowsIdentity windowsIdentity = null;
if (clientToken != IntPtr.Zero)
{
try
{
windowsIdentity = new WindowsIdentity(clientToken, senderDetails.authenticationMechanism);
}
// Suppress exceptions..So windowsIdentity = null in these cases
catch (ArgumentException)
{
// userToken is 0.
// -or-
// userToken is duplicated and invalid for impersonation.
}
catch (System.Security.SecurityException)
{
// The caller does not have the correct permissions.
// -or-
// A Win32 error occurred.
}
}
PSPrincipal userPrincipal = new PSPrincipal(psIdentity, windowsIdentity);
PSSenderInfo result = new PSSenderInfo(userPrincipal, senderDetails.httpUrl);
return result;
}
public virtual PSPrimitiveDictionary GetApplicationPrivateData(PSSenderInfo senderInfo)
{
return null;
}
public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
{
throw new NotImplementedException();
}
public abstract InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo);
public virtual InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
throw new NotImplementedException();
}
public virtual InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
{
throw new NotImplementedException();
}
