public override InitialSessionStateEntry Clone()
{
SessionStateFunctionEntry stateFunctionEntry = new SessionStateFunctionEntry(this.Name, this._definition, this._options, this.Visibility);
stateFunctionEntry._scriptBlock = this._scriptBlock;
stateFunctionEntry.SetModule(this.Module);
return((InitialSessionStateEntry)stateFunctionEntry);
}
/// <summary>
/// Add an new SessionState function entry to this session state object...
/// </summary>
/// <param name="entry">The entry to add.</param>
internal void AddSessionStateEntry(SessionStateFunctionEntry entry)
{
ScriptBlock sb = entry.ScriptBlock.Clone();
FunctionInfo fn = this.SetFunction(entry.Name, sb, null, entry.Options, false, CommandOrigin.Internal, this.ExecutionContext, entry.HelpFile, true);
fn.Visibility = entry.Visibility;
fn.Module = entry.Module;
fn.ScriptBlock.LanguageMode = entry.ScriptBlock.LanguageMode ?? PSLanguageMode.FullLanguage;
}
/// <summary>
/// Add all of the default built-in functions to this session state instance...
/// </summary>
internal void AddBuiltInEntries(bool addSetStrictMode)
{
// Other built-in variables
AddBuiltInVariables();
AddBuiltInFunctions();
AddBuiltInAliases();
if (addSetStrictMode)
{
SessionStateFunctionEntry f = new SessionStateFunctionEntry("Set-StrictMode", "");
this.AddSessionStateEntry(f);
}
}
private bool DoesInitialSessionStateIncludeGetCommandWithListImportedSwitch()
{
if (!this._initialSessionStateIncludesGetCommandWithListImportedSwitch.HasValue)
{
lock (this._initialSessionStateIncludesGetCommandWithListImportedSwitchLock)
{
if (!this._initialSessionStateIncludesGetCommandWithListImportedSwitch.HasValue)
{
bool flag = false;
InitialSessionState initialSessionState = this.RunspacePool.InitialSessionState;
if (initialSessionState != null)
{
IEnumerable <SessionStateCommandEntry> source = from entry in initialSessionState.Commands["Get-Command"]
where entry.Visibility == SessionStateEntryVisibility.Public
select entry;
SessionStateFunctionEntry e = source.OfType <SessionStateFunctionEntry>().FirstOrDefault <SessionStateFunctionEntry>();
if (e != null)
{
if (e.ScriptBlock.ParameterMetadata.BindableParameters.ContainsKey("ListImported"))
{
flag = true;
}
}
else
{
SessionStateCmdletEntry entry2 = source.OfType <SessionStateCmdletEntry>().FirstOrDefault <SessionStateCmdletEntry>();
if ((entry2 != null) && entry2.ImplementingType.Equals(typeof(GetCommandCommand)))
{
flag = true;
}
}
}
this._initialSessionStateIncludesGetCommandWithListImportedSwitch = new bool?(flag);
}
}
}
return(this._initialSessionStateIncludesGetCommandWithListImportedSwitch.Value);
}
private static List <string> GetSingleAstRequiredModules(Ast ast, Token[] tokens)
{
List <string> modules = new List <string>();
List <string> resources = new List <string>();
var imports = tokens.Where(token =>
String.Compare(token.Text, "Import-DscResource", StringComparison.OrdinalIgnoreCase) == 0);
//
// Create a function with the same name as Import-DscResource keyword and use powershell
// argument function binding to emulate Import-DscResource argument binding.
//
InitialSessionState initialSessionState = InitialSessionState.Create();
SessionStateFunctionEntry importDscResourcefunctionEntry = new SessionStateFunctionEntry(
"Import-DscResource", @"param($Name, $ModuleName)
if ($ModuleName)
{
foreach ($m in $ModuleName) { $global:modules.Add($m) }
} else {
foreach ($n in $Name) { $global:resources.Add($n) }
}
");
initialSessionState.Commands.Add(importDscResourcefunctionEntry);
initialSessionState.LanguageMode = PSLanguageMode.RestrictedLanguage;
var moduleVarEntry = new SessionStateVariableEntry("modules", modules, "");
var resourcesVarEntry = new SessionStateVariableEntry("resources", resources, "");
initialSessionState.Variables.Add(moduleVarEntry);
initialSessionState.Variables.Add(resourcesVarEntry);
using (System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create(initialSessionState))
{
foreach (var import in imports)
{
int startOffset = import.Extent.StartOffset;
var asts = ast.FindAll(a => IsCandidateForImportDscResourceAst(a, startOffset), true);
int longestLen = -1;
Ast longestCandidate = null;
foreach (var candidatAst in asts)
{
int curLen = candidatAst.Extent.EndOffset - candidatAst.Extent.StartOffset;
if (curLen > longestLen)
{
longestCandidate = candidatAst;
longestLen = curLen;
}
}
// longestCandidate should contain AST for import-dscresource, like "Import-DSCResource -Module x -Name y".
if (longestCandidate != null)
{
string importText = longestCandidate.Extent.Text;
// We invoke-command "importText" here. Script injection is prevented:
// We checked that file represents a valid AST without errors.
powerShell.AddScript(importText);
powerShell.Invoke();
powerShell.Commands.Clear();
}
}
}
modules.AddRange(resources.Select(GetModuleNameForDscResource));
return(modules);
}
public static InitialSessionState GetSessionStateForCommands(CommandInfo[] commands)
{
InitialSessionState iss = InitialSessionState.CreateDefault();
Dictionary <string, SessionStateCommandEntry> commandCache = new Dictionary <string, SessionStateCommandEntry>();
foreach (SessionStateCommandEntry ssce in iss.Commands)
{
commandCache[ssce.Name] = ssce;
}
iss.ApartmentState = ApartmentState.STA;
iss.ThreadOptions = PSThreadOptions.ReuseThread;
if (commands.Length == 0)
{
return(iss);
}
foreach (CommandInfo cmd in commands)
{
if (cmd.Module != null)
{
string manifestPath = cmd.Module.Path.Replace(".psm1", ".psd1").Replace(".dll", ".psd1");
if (System.IO.File.Exists(manifestPath))
{
iss.ImportPSModule(new string[] { manifestPath });
}
else
{
iss.ImportPSModule(new string[] { cmd.Module.Path });
}
continue;
}
if (cmd is AliasInfo)
{
CommandInfo loopCommand = cmd;
while (loopCommand is AliasInfo)
{
SessionStateAliasEntry alias = new SessionStateAliasEntry(loopCommand.Name, loopCommand.Definition);
iss.Commands.Add(alias);
loopCommand = (loopCommand as AliasInfo).ReferencedCommand;
}
if (loopCommand is FunctionInfo)
{
SessionStateFunctionEntry func = new SessionStateFunctionEntry(loopCommand.Name, loopCommand.Definition);
iss.Commands.Add(func);
}
if (loopCommand is CmdletInfo)
{
CmdletInfo cmdletData = loopCommand as CmdletInfo;
SessionStateCmdletEntry cmdlet = new SessionStateCmdletEntry(cmd.Name,
cmdletData.ImplementingType,
cmdletData.HelpFile);
iss.Commands.Add(cmdlet);
}
}
if (cmd is FunctionInfo)
{
SessionStateFunctionEntry func = new SessionStateFunctionEntry(cmd.Name, cmd.Definition);
iss.Commands.Add(func);
}
if (cmd is CmdletInfo)
{
CmdletInfo cmdletData = cmd as CmdletInfo;
SessionStateCmdletEntry cmdlet = new SessionStateCmdletEntry(cmd.Name,
cmdletData.ImplementingType,
cmdletData.HelpFile);
iss.Commands.Add(cmdlet);
}
}
return(iss);
}
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);
}
