/// <summary> /// Each Shell ( minishell ) will have its own path specified by the /// application base folder, which should be the same as $pshome. /// </summary> /// <returns>String representing base directory of the executing shell.</returns> internal string GetDefaultShellSearchPath() { string shellID = this.HelpSystem.ExecutionContext.ShellID; // Beginning in PowerShell 6.0.0.12, the $pshome is no longer registry specified, we search the application base instead. // We use executing assemblies location in case registry entry not found return(Utils.GetApplicationBase(shellID) ?? Path.GetDirectoryName(PsUtils.GetMainModule(System.Diagnostics.Process.GetCurrentProcess()).FileName)); }
/// <summary> /// /// Initializes a new instance of the InformationRecord class. /// /// </summary> /// <param name="messageData">The object to be transmitted to the host.</param> /// <param name="source">The source of the message (i.e.: script path, function name, etc.)</param> public InformationRecord(Object messageData, string source) { this.MessageData = messageData; this.Source = source; this.TimeGenerated = DateTime.Now; this.NativeThreadId = PsUtils.GetNativeThreadId(); this.ManagedThreadId = (uint)System.Threading.Thread.CurrentThread.ManagedThreadId; }
/// <summary> /// Initializes a new instance of the InformationRecord class. /// </summary> /// <param name="messageData">The object to be transmitted to the host.</param> /// <param name="source">The source of the message (i.e.: script path, function name, etc.).</param> public InformationRecord(object messageData, string source) { this.MessageData = messageData; this.Source = source; this.TimeGenerated = DateTime.Now; this.NativeThreadId = PsUtils.GetNativeThreadId(); this.ManagedThreadId = (uint)Environment.CurrentManagedThreadId; }
/// <summary> /// Get using values as dictionary for the Foreach-Object parallel cmdlet. /// Ignore any using expressions that are associated with inner nested Foreach-Object parallel calls, /// since they are only effective in the nested call scope and not the current outer scope. /// </summary> /// <param name = "scriptBlock">Scriptblock to search.</param> /// <param name = "isTrustedInput">True when input is trusted.</param> /// <param name = "context">Execution context.</param> /// <param name = "foreachNames">List of foreach command names and aliases.</param> /// <returns>Dictionary of using variable map.</returns> internal static Dictionary <string, object> GetUsingValuesForEachParallel( ScriptBlock scriptBlock, bool isTrustedInput, ExecutionContext context, string[] foreachNames) { // Using variables for Foreach-Object -Parallel use are restricted to be within the // Foreach-Object -Parallel call scope. This will filter the using variable map to variables // only within the current (outer) Foreach-Object -Parallel call scope. var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressions(scriptBlock.Ast).ToList(); UsingExpressionAst usingAst = null; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); Version oldStrictVersion = null; try { if (context != null) { oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < usingAsts.Count; ++i) { usingAst = (UsingExpressionAst)usingAsts[i]; if (IsInForeachParallelCallingScope(usingAst, foreachNames)) { var value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); usingValueMap.TryAdd(usingAstKey, value); } } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException( targetObject: null, exceptionType: typeof(RuntimeException), errorPosition: usingAst.Extent, resourceIdAndErrorId: "UsingVariableIsUndefined", resourceString: AutomationExceptions.UsingVariableIsUndefined, args: rte.ErrorRecord.TargetObject); } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } return(usingValueMap); }
/// <summary> /// Get a temporary directory to use for the current process /// </summary> internal static string GetTemporaryDirectory() { if (_tempDirectory != null) { return(_tempDirectory); } _tempDirectory = PsUtils.GetTemporaryDirectory(); return(_tempDirectory); }
private static void FindStaticInformation() { versionOfPowerShellLibraries = FileVersionInfo.GetVersionInfo(typeof(PSObject).Assembly.Location).FileVersion; currentProcess = Process.GetCurrentProcess(); ProcessModule mainModule = PsUtils.GetMainModule(currentProcess); if (mainModule != null) { applicationPath = mainModule.FileName; } nameOfExe = Path.GetFileName(applicationPath); hCurrentProcess = currentProcess.Handle; hwndMainWindow = currentProcess.MainWindowHandle; applicationName = currentProcess.ProcessName; }
internal static ExecutionPolicy GetExecutionPolicy( string shellId, ExecutionPolicyScope scope) { switch (scope) { case ExecutionPolicyScope.Process: string environmentVariable = Environment.GetEnvironmentVariable("PSExecutionPolicyPreference"); return(!string.IsNullOrEmpty(environmentVariable) ? SecuritySupport.ParseExecutionPolicy(environmentVariable) : ExecutionPolicy.Undefined); case ExecutionPolicyScope.CurrentUser: case ExecutionPolicyScope.LocalMachine: string localPreferenceValue = SecuritySupport.GetLocalPreferenceValue(shellId, scope); return(!string.IsNullOrEmpty(localPreferenceValue) ? SecuritySupport.ParseExecutionPolicy(localPreferenceValue) : ExecutionPolicy.Undefined); case ExecutionPolicyScope.UserPolicy: case ExecutionPolicyScope.MachinePolicy: string groupPolicyValue = SecuritySupport.GetGroupPolicyValue(shellId, scope); if (!string.IsNullOrEmpty(groupPolicyValue)) { Process process = Process.GetCurrentProcess(); string a = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "gpscript.exe"); bool flag = false; try { for (; process != null; process = PsUtils.GetParentProcess(process)) { if (string.Equals(a, PsUtils.GetMainModule(process).FileName, StringComparison.OrdinalIgnoreCase)) { flag = true; break; } } } catch (Win32Exception ex) { } if (!flag) { return(SecuritySupport.ParseExecutionPolicy(groupPolicyValue)); } } return(ExecutionPolicy.Undefined); default: return(ExecutionPolicy.Restricted); } }
private static bool FileSystemIsDotNetFrameworkVersionInstalled(Version requiredVersion) { string path1 = Path.Combine(Environment.GetEnvironmentVariable("SystemRoot"), "Microsoft.NET"); try { string path2 = "Framework"; if (PsUtils.GetProcessorArchitecture() != ProcessorArchitecture.X86 && requiredVersion >= new Version(2, 0)) { path2 = "Framework64"; } string[] directories = Directory.GetDirectories(Path.Combine(path1, path2), string.Format((IFormatProvider)null, "v{0}.{1}*", (object)requiredVersion.Major, (object)requiredVersion.Minor)); if (directories == null || directories.Length == 0) { return(false); } if (requiredVersion.Build != -1 || requiredVersion.Revision != -1) { string str = Path.Combine(directories[0], "mscorlib.dll"); if (File.Exists(str)) { FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(str); if (new Version(versionInfo.FileMajorPart < 0 ? 0 : versionInfo.FileMajorPart, versionInfo.FileMinorPart < 0 ? 0 : versionInfo.FileMinorPart, versionInfo.FileBuildPart < 0 ? 0 : versionInfo.FileBuildPart, versionInfo.FilePrivatePart < 0 ? 0 : versionInfo.FilePrivatePart) < requiredVersion) { return(false); } } } return(true); } catch (UnauthorizedAccessException ex) { return(false); } catch (ArgumentException ex) { return(false); } catch (PathTooLongException ex) { return(false); } catch (IOException ex) { return(false); } }
internal string GetDefaultShellSearchPath() { string shellPathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(this.HelpSystem.ExecutionContext.ShellID); if (shellPathFromRegistry == null) { return(Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName)); } if (OSHelper.IsWindows) { shellPathFromRegistry = Path.GetDirectoryName(shellPathFromRegistry); } if (!Directory.Exists(shellPathFromRegistry)) { shellPathFromRegistry = Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName); } return(shellPathFromRegistry); }
/// <summary> /// /// Initializes a new instance of the InformationRecord class. /// /// </summary> /// <param name="messageData">The object to be transmitted to the host.</param> /// <param name="source">The source of the message (i.e.: script path, function name, etc.)</param> public InformationRecord(Object messageData, string source) { this.MessageData = messageData; this.Source = source; this.TimeGenerated = DateTime.Now; this.Tags = new List <string>(); // domain\user on Windows, just user on Unix #if UNIX this.User = Platform.Unix.UserName; #else this.User = System.Security.Principal.WindowsIdentity.GetCurrent().Name; #endif this.Computer = PsUtils.GetHostName(); this.ProcessId = (uint)System.Diagnostics.Process.GetCurrentProcess().Id; this.NativeThreadId = PsUtils.GetNativeThreadId(); this.ManagedThreadId = (uint)System.Threading.Thread.CurrentThread.ManagedThreadId; }
private static void FindStaticInformation() { WindowsErrorReporting.versionOfPowerShellLibraries = FileVersionInfo.GetVersionInfo(typeof(PSObject).Assembly.Location).FileVersion; WindowsErrorReporting.currentProcess = Process.GetCurrentProcess(); ProcessModule mainModule = PsUtils.GetMainModule(WindowsErrorReporting.currentProcess); if (mainModule != null) { WindowsErrorReporting.applicationPath = mainModule.FileName; } else { WindowsErrorReporting.applicationName = "GetMainModErr"; } WindowsErrorReporting.nameOfExe = Path.GetFileName(WindowsErrorReporting.applicationPath); WindowsErrorReporting.hCurrentProcess = WindowsErrorReporting.currentProcess.Handle; WindowsErrorReporting.hwndMainWindow = WindowsErrorReporting.currentProcess.MainWindowHandle; WindowsErrorReporting.applicationName = WindowsErrorReporting.currentProcess.ProcessName; }
/// <exception cref="NotSupportedException"> /// You are trying to access the MainModule property for a process that is running /// on a remote computer. This property is available only for processes that are /// running on the local computer. /// </exception> /// <exception cref="InvalidOperationException"> /// The process Id is not available (or) The process has exited. /// </exception> /// <exception cref="System.ComponentModel.Win32Exception"> /// /// </exception> private static void FindStaticInformation() { string sma = typeof(PSObject).Assembly.Location; FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(sma); s_versionOfPowerShellLibraries = fvi.FileVersion; s_currentProcess = Process.GetCurrentProcess(); ProcessModule mainModule = PsUtils.GetMainModule(s_currentProcess); if (mainModule != null) { s_applicationPath = mainModule.FileName; } s_nameOfExe = Path.GetFileName(s_applicationPath); s_hCurrentProcess = s_currentProcess.Handle; s_hwndMainWindow = s_currentProcess.MainWindowHandle; s_applicationName = s_currentProcess.ProcessName; }
private void ConstructParentId() { try { this.parentId = -1; Process parentProcess = PsUtils.GetParentProcess(this.OriginalProcessInstance); if (parentProcess != null) { this.parentId = parentProcess.Id; } } catch (Win32Exception) { } catch (InvalidOperationException) { } catch (ManagementException) { } }
internal string GetDefaultShellSearchPath() { string shellId = this.HelpSystem.ExecutionContext.ShellID; string pathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(shellId); string directoryName; if (pathFromRegistry == null) { directoryName = Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName); this.HelpSystem.LastErrors.Add(new ErrorRecord((Exception)HelpProvider.tracer.NewArgumentException("DefaultSearchPath", "HelpErrors", "RegistryPathNotFound", (object)Utils.GetRegistryConfigurationPath(shellId), (object)"\\Path", (object)directoryName), "LoadHelpFileForTargetFailed", ErrorCategory.OpenError, (object)null)); } else { directoryName = Path.GetDirectoryName(pathFromRegistry); if (!Directory.Exists(directoryName)) { directoryName = Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName); this.HelpSystem.LastErrors.Add(new ErrorRecord((Exception)HelpProvider.tracer.NewArgumentException("DefaultSearchPath", "HelpErrors", "RegistryPathNotFound", (object)Utils.GetRegistryConfigurationPath(shellId), (object)"\\Path", (object)"\\Path", (object)directoryName), "LoadHelpFileForTargetFailed", ErrorCategory.OpenError, (object)null)); } } return(directoryName); }
/// <summary> /// Each Shell ( minishell ) will have its own path specified by the /// registry HKLM\software\microsoft\msh\1\ShellIds\<ShellID>\path. Every help /// provider should search this path for content. /// </summary> /// <returns>string representing base directory of the executing shell.</returns> internal string GetDefaultShellSearchPath() { string shellID = this.HelpSystem.ExecutionContext.ShellID; string returnValue = CommandDiscovery.GetShellPathFromRegistry(shellID); if (returnValue == null) { // use executing assemblies location in case registry entry not found returnValue = Path.GetDirectoryName(PsUtils.GetMainModule(System.Diagnostics.Process.GetCurrentProcess()).FileName); } else { // Get the directory path of the executing shell returnValue = Path.GetDirectoryName(returnValue); if (!Directory.Exists(returnValue)) { // use executing assemblies location in case registry entry not found returnValue = Path.GetDirectoryName(PsUtils.GetMainModule(System.Diagnostics.Process.GetCurrentProcess()).FileName); } } return(returnValue); }
private void ConvertCommand(CommandAst commandAst, bool isTrustedInput) { // First need command name. var commandName = GetCommandName(commandAst.CommandElements[0], isTrustedInput); var command = new Command(commandName, isScript: false, useLocalScope: _createLocalScope); // Handle redirections, if any (there can really be just 0 or 1). if (commandAst.Redirections.Count > 0) { Diagnostics.Assert(commandAst.Redirections.Count == 1, "only 1 kind of redirection is supported"); Diagnostics.Assert(commandAst.Redirections[0] is MergingRedirectionAst, "unexpected redirection type"); PipelineResultTypes toType = PipelineResultTypes.Output; PipelineResultTypes fromType; switch (commandAst.Redirections[0].FromStream) { case RedirectionStream.Error: fromType = PipelineResultTypes.Error; break; case RedirectionStream.Warning: fromType = PipelineResultTypes.Warning; break; case RedirectionStream.Verbose: fromType = PipelineResultTypes.Verbose; break; case RedirectionStream.Debug: fromType = PipelineResultTypes.Debug; break; case RedirectionStream.Information: fromType = PipelineResultTypes.Information; break; case RedirectionStream.All: fromType = PipelineResultTypes.All; break; default: // Default to Error->Output to be compatible with V2. fromType = PipelineResultTypes.Error; break; } command.MergeMyResults(fromType, toType); } _powershell.AddCommand(command); // Now the parameters and arguments. foreach (var ast in commandAst.CommandElements.Skip(1)) { var exprAst = ast as ExpressionAst; if (exprAst != null) { VariableExpressionAst variableAst = null; var usingExprAst = ast as UsingExpressionAst; if (usingExprAst != null) { string usingAstKey = PsUtils.GetUsingExpressionKey(usingExprAst); object usingValue = _usingValueMap[usingAstKey]; variableAst = usingExprAst.SubExpression as VariableExpressionAst; if (variableAst != null && variableAst.Splatted) { // Support the splatting of a dictionary var parameters = usingValue as System.Collections.IDictionary; if (parameters != null) { _powershell.AddParameters(parameters); } else { // Support the splatting of an array var arguments = usingValue as System.Collections.IEnumerable; if (arguments != null) { foreach (object argument in arguments) { _powershell.AddArgument(argument); } } else { // Splat the object directly. _powershell.AddArgument(usingValue); } } } else { _powershell.AddArgument(usingValue); } continue; } variableAst = ast as VariableExpressionAst; if (variableAst != null && variableAst.Splatted) { GetSplattedVariable(variableAst); } else { var constantExprAst = ast as ConstantExpressionAst; object argument; if (constantExprAst != null && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(constantExprAst.StaticType))) { var commandArgumentText = constantExprAst.Extent.Text; argument = constantExprAst.Value; if (!commandArgumentText.Equals(constantExprAst.Value.ToString(), StringComparison.Ordinal)) { // The wrapped number will actually return a PSObject which could end holding a reference to // a typetable, making the object runspace specific. We should find a better way to avoid // any possibility of sharing problems, though this is unlikely to cause problems. argument = ParserOps.WrappedNumber(argument, commandArgumentText); } } else { if (!isTrustedInput) { try { argument = GetSafeValueVisitor.GetSafeValue(exprAst, _context, GetSafeValueVisitor.SafeValueContext.GetPowerShell); } catch (System.Exception) { throw new ScriptBlockToPowerShellNotSupportedException( "CantConvertWithDynamicExpression", null, AutomationExceptions.CantConvertWithDynamicExpression, exprAst.Extent.Text); } } else { argument = GetExpressionValue(exprAst, isTrustedInput); } } _powershell.AddArgument(argument); } } else { AddParameter((CommandParameterAst)ast, isTrustedInput); } } }
/// <summary> /// Collect values for UsingExpressions, in the form of a dictionary and an array. /// - The dictionary form is used when the remote server is PSv5 and later version for handling UsingExpression in Invoke-Command/Start-Job /// - The array form is used when the remote server is PSv3 and PSv4 for handling UsingExpression in Invoke-Command. /// </summary> /// <remarks> /// We still keep the array-form using values because we want to avoid any breaking changes when running Invoke-Command /// targeting PSv3 or PSv4 remote end -- if UsingExpressions are all in the same scope, then we still pass an array of using /// values to the remote end; otherwise, we will handle UsingExpression as if the remote end is PSv2. /// </remarks> /// <returns> /// A tuple of the dictionary-form and the array-form using values. /// If the array-form using value is null, then there are UsingExpressions used in different scopes. /// </returns> private static Tuple <Dictionary <string, object>, object[]> GetUsingValues(Ast body, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { Diagnostics.Assert(context != null || variables != null, "can't retrieve variables with no context and no variables"); var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList(); var usingValueArray = new object[usingAsts.Count]; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); HashSet <string> usingVarNames = (variables != null && filterNonUsingVariables) ? new HashSet <string>() : null; // Used to check if the PSv3/PSv4 way of handling UsingExpression can continue to be used. bool hasUsingExprInDifferentScope = false; ScriptBlockAst sbClosestToPreUsingExpr = null; UsingExpressionAst usingAst = null; Version oldStrictVersion = null; try { if (context != null) { oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < usingAsts.Count; ++i) { usingAst = (UsingExpressionAst)usingAsts[i]; object value = null; // This happens only when GetUsingValues gets called outside the ScriptBlockToPowerShellConverter class if (!hasUsingExprInDifferentScope && HasUsingExpressionsInDifferentScopes(usingAst, body, ref sbClosestToPreUsingExpr)) { // If there are UsingExpressions in different scopes, the array-form using values will not be useful // even if the remote end is PSv3 or PSv4, because the way we handle using expression in PSv3 and PSv4 // doesn't support UsingExpression in different scopes. In this case, we will set the array-form using // value to be null before return. // // Note that this check only affect array-form using value. In PSv5, we change the way to handle UsingExpression // on both client and server sides. The dictionary-form using values is used and UsingExpression in different // scope is supported. hasUsingExprInDifferentScope = true; } if (variables != null) { var variableAst = usingAst.SubExpression as VariableExpressionAst; if (variableAst == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, usingAst.Extent.Text); } string varName = variableAst.VariablePath.UserPath; if (varName != null && variables.TryGetValue(varName, out value) && usingVarNames != null) { usingVarNames.Add(varName); } } else { value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); } // Collect UsingExpression value as an array usingValueArray[i] = value; // Collect UsingExpression value as a dictionary string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); usingValueMap.TryAdd(usingAstKey, value); } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, rte.ErrorRecord.TargetObject); } else if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } if (usingVarNames != null) { string[] keys = variables.Keys.ToArray(); foreach (string key in keys) { if (!usingVarNames.Contains(key)) { variables.Remove(key); } } } if (hasUsingExprInDifferentScope) { usingValueArray = null; } return(Tuple.Create(usingValueMap, usingValueArray)); }
internal static ExecutionPolicy GetExecutionPolicy(string shellId, ExecutionPolicyScope scope) { string groupPolicyValue; bool flag; switch (scope) { case ExecutionPolicyScope.Process: { string environmentVariable = Environment.GetEnvironmentVariable("PSExecutionPolicyPreference"); if (string.IsNullOrEmpty(environmentVariable)) { return(ExecutionPolicy.Undefined); } return(ParseExecutionPolicy(environmentVariable)); } case ExecutionPolicyScope.CurrentUser: case ExecutionPolicyScope.LocalMachine: { string localPreferenceValue = GetLocalPreferenceValue(shellId, scope); if (string.IsNullOrEmpty(localPreferenceValue)) { return(ExecutionPolicy.Undefined); } return(ParseExecutionPolicy(localPreferenceValue)); } case ExecutionPolicyScope.UserPolicy: case ExecutionPolicyScope.MachinePolicy: { groupPolicyValue = GetGroupPolicyValue(shellId, scope); if (string.IsNullOrEmpty(groupPolicyValue)) { goto Label_00BA; } if (OSHelper.IsUnix) { flag = true; } else { Process currentProcess = Process.GetCurrentProcess(); string a = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "gpscript.exe"); flag = false; try { while (currentProcess != null) { if (string.Equals(a, PsUtils.GetMainModule(currentProcess).FileName, StringComparison.OrdinalIgnoreCase)) { flag = true; break; } currentProcess = PsUtils.GetParentProcess(currentProcess); } } catch (Win32Exception) { } } break; } default: return(ExecutionPolicy.Restricted); } if (!flag) { return(ParseExecutionPolicy(groupPolicyValue)); } Label_00BA: return(ExecutionPolicy.Undefined); }
internal static bool IsDotNetFrameworkVersionInstalled(Version requiredVersion) { int majorVersion; int minorVersion; int minimumSpVersion; return(PsUtils.FrameworkRegistryInstallation.CanCheckFrameworkInstallation(requiredVersion, out majorVersion, out minorVersion, out minimumSpVersion) ? PsUtils.FrameworkRegistryInstallation.IsFrameworkInstalled(majorVersion, minorVersion, minimumSpVersion) : PsUtils.FileSystemIsDotNetFrameworkVersionInstalled(requiredVersion)); }
private static ConcurrentDictionary <string, CommandTypes> AnalyzeManifestModule(string modulePath, ExecutionContext context, DateTime lastWriteTime, bool etwEnabled) { ConcurrentDictionary <string, CommandTypes> result = null; try { var moduleManifestProperties = PsUtils.GetModuleManifestProperties(modulePath, PsUtils.FastModuleManifestAnalysisPropertyNames); if (moduleManifestProperties != null) { Version version; if (ModuleUtils.IsModuleInVersionSubdirectory(modulePath, out version)) { var versionInManifest = LanguagePrimitives.ConvertTo <Version>(moduleManifestProperties["ModuleVersion"]); if (version != versionInManifest) { ModuleIntrinsics.Tracer.WriteLine("ModuleVersion in manifest does not match versioned module directory, skipping module: {0}", modulePath); return(null); } } result = new ConcurrentDictionary <string, CommandTypes>(3, moduleManifestProperties.Count, StringComparer.OrdinalIgnoreCase); var sawWildcard = false; var hadCmdlets = AddPsd1EntryToResult(result, moduleManifestProperties["CmdletsToExport"], CommandTypes.Cmdlet, ref sawWildcard); var hadFunctions = AddPsd1EntryToResult(result, moduleManifestProperties["FunctionsToExport"], CommandTypes.Function, ref sawWildcard); var hadAliases = AddPsd1EntryToResult(result, moduleManifestProperties["AliasesToExport"], CommandTypes.Alias, ref sawWildcard); var analysisSucceeded = hadCmdlets && hadFunctions && hadAliases; if (!analysisSucceeded && !sawWildcard && (hadCmdlets || hadFunctions)) { // If we're missing CmdletsToExport, that might still be OK, but only if we have a script module. // Likewise, if we're missing FunctionsToExport, that might be OK, but only if we have a binary module. analysisSucceeded = !CheckModulesTypesInManifestAgainstExportedCommands(moduleManifestProperties, hadCmdlets, hadFunctions, hadAliases); } if (analysisSucceeded) { var moduleCacheEntry = new ModuleCacheEntry { ModulePath = modulePath, LastWriteTime = lastWriteTime, Commands = result, TypesAnalyzed = false, Types = new ConcurrentDictionary <string, TypeAttributes>(1, 8, StringComparer.OrdinalIgnoreCase) }; s_cacheData.Entries[modulePath] = moduleCacheEntry; } else { result = null; } } } catch (Exception e) { if (etwEnabled) { CommandDiscoveryEventSource.Log.ModuleManifestAnalysisException(modulePath, e.Message); } // Ignore the errors, proceed with the usual module analysis ModuleIntrinsics.Tracer.WriteLine("Exception on fast-path analysis of module {0}", modulePath); } if (etwEnabled) { CommandDiscoveryEventSource.Log.ModuleManifestAnalysisResult(modulePath, result != null); } return(result ?? AnalyzeTheOldWay(modulePath, context, lastWriteTime)); }