/// <summary> /// Clears the specified property on the specified item. /// </summary> /// <param name="paths"> /// The path(s) to the item(s) to clear the property on. /// </param> /// <param name="propertyToClear"> /// The name of the property to clear. /// </param> /// <param name="force"> /// Passed on to providers to force operations. /// </param> /// <param name="literalPath"> /// If true, globbing is not done on paths. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> or <paramref name="propertyToClear"/> is null. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If the <paramref name="path"/> refers to a provider that could not be found. /// </exception> /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> refers to does /// not support this operation. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider threw an exception. /// </exception> internal void ClearProperty( string[] paths, Collection<string> propertyToClear, bool force, bool literalPath) { if (paths == null) { throw PSTraceSource.NewArgumentNullException(nameof(paths)); } if (propertyToClear == null) { throw PSTraceSource.NewArgumentNullException(nameof(propertyToClear)); } CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext); context.Force = force; context.SuppressWildcardExpansion = literalPath; ClearProperty(paths, propertyToClear, context); context.ThrowFirstErrorOrDoNothing(); }
/// <summary> /// Constructs the context under which the core command providers /// operate. /// </summary> /// <param name="command"> /// The command object that is running. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="command"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="command"/> contains a null Host or Context reference. /// </exception> internal CmdletProviderContext( Cmdlet command) { // verify the command parameter if (command == null) { throw PSTraceSource.NewArgumentNullException(nameof(command)); } _command = command; Origin = command.CommandOrigin; if (command.Context == null) { throw PSTraceSource.NewArgumentException("command.Context"); } ExecutionContext = command.Context; // Stream will default to true because command methods will be used. PassThru = true; _streamErrors = true; }
/// <summary> /// Clears the specified item. Depending on the provider that the path /// maps to, this could mean the properties and/or content and/or value is /// cleared. /// </summary> /// <param name="paths"> /// The path(s) to the object. It can be either a relative (most common) /// or absolute path. /// </param> /// <param name="context"> /// The context which the core command is running. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If the <paramref name="path"/> refers to a provider that could not be found. /// </exception> /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> refers to does /// not support this operation. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider threw an exception. /// </exception> /// <exception cref="ItemNotFoundException"> /// If <paramref name="path"/> does not contain glob characters and /// could not be found. /// </exception> internal void ClearItem( string[] paths, CmdletProviderContext context) { if (paths == null) { throw PSTraceSource.NewArgumentNullException("paths"); } ProviderInfo provider = null; CmdletProvider providerInstance = null; foreach (string path in paths) { if (path == null) { throw PSTraceSource.NewArgumentNullException("paths"); } Collection <string> providerPaths = Globber.GetGlobbedProviderPathsFromMonadPath( path, false, context, out provider, out providerInstance); if (providerPaths != null) { foreach (string providerPath in providerPaths) { ClearItemPrivate(providerInstance, providerPath, context); } } } }
/// <summary> /// Sets the specified properties on the specified item. /// </summary> /// <param name="paths"> /// The path(s) to the item(s) to set the properties on. /// </param> /// <param name="property"> /// A PSObject containing the properties to be changed. /// </param> /// <param name="force"> /// Passed on to providers to force operations. /// </param> /// <param name="literalPath"> /// If true, globbing is not done on paths. /// </param> /// <returns> /// An array of PSObjects representing the properties that were set on each item. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> or <paramref name="property"/> is null. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If the <paramref name="path"/> refers to a provider that could not be found. /// </exception> /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> refers to does /// not support this operation. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider threw an exception. /// </exception> internal Collection<PSObject> SetProperty(string[] paths, PSObject property, bool force, bool literalPath) { if (paths == null) { throw PSTraceSource.NewArgumentNullException(nameof(paths)); } if (property == null) { throw PSTraceSource.NewArgumentNullException("properties"); } CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext); context.Force = force; context.SuppressWildcardExpansion = literalPath; SetProperty(paths, property, context); context.ThrowFirstErrorOrDoNothing(); Collection<PSObject> results = context.GetAccumulatedObjects(); return results; }
/// <summary> /// LogPipelineExecutionDetailEvent: Log a pipeline execution detail event. /// /// This is a form of PipelineExecutionDetailEvent which takes a scriptName and commandLine /// instead of invocationInfo. This will save the need to fill in the commandName for /// this event. /// </summary> /// <param name="executionContext">Execution Context for the current running engine.</param> /// <param name="detail">Detail to be logged for this pipeline execution detail.</param> /// <param name="scriptName">Script that is currently running.</param> /// <param name="commandLine">Command line that is currently running.</param> internal static void LogPipelineExecutionDetailEvent(ExecutionContext executionContext, List <string> detail, string scriptName, string commandLine) { if (executionContext == null) { PSTraceSource.NewArgumentNullException(nameof(executionContext)); return; } LogContext logContext = GetLogContext(executionContext, null); logContext.CommandLine = commandLine; logContext.ScriptName = scriptName; foreach (LogProvider provider in GetLogProvider(executionContext)) { if (NeedToLogPipelineExecutionDetailEvent(provider, executionContext)) { provider.LogPipelineExecutionDetailEvent(logContext, detail); } } }
/// <summary> /// /// </summary> /// <param name="sessionState"></param> /// <param name="scriptBlock"></param> /// <param name="args"></param> /// <returns></returns> public Collection <PSObject> InvokeScript( SessionState sessionState, ScriptBlock scriptBlock, params object[] args) { if (scriptBlock == null) { throw PSTraceSource.NewArgumentNullException("scriptBlock"); } if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } SessionStateInternal _oldSessionState = _context.EngineSessionState; try { _context.EngineSessionState = sessionState.Internal; return(InvokeScript(scriptBlock, false, PipelineResultTypes.None, null, args)); } finally { _context.EngineSessionState = _oldSessionState; } }
internal static IEnumerable <KeyValuePair <KeyType, ValueType> > EnumerateHashtableProperty <KeyType, ValueType>(PSObject psObject, string propertyName) { if (psObject == null) { throw PSTraceSource.NewArgumentNullException("psObject"); } if (propertyName == null) { throw PSTraceSource.NewArgumentNullException("propertyName"); } Hashtable propertyValue = GetPropertyValue <Hashtable>(psObject, propertyName); if (propertyValue != null) { IDictionaryEnumerator enumerator = propertyValue.GetEnumerator(); while (enumerator.MoveNext()) { DictionaryEntry current = (DictionaryEntry)enumerator.Current; KeyType key = ConvertPropertyValueTo <KeyType>(propertyName, current.Key); ValueType iteratorVariable3 = ConvertPropertyValueTo <ValueType>(propertyName, current.Value); yield return(new KeyValuePair <KeyType, ValueType>(key, iteratorVariable3)); } } }
/// <summary> /// Unescapes any escaped characters in the input string. /// </summary> /// <param name="pattern"> /// The input string containing the text to convert. /// </param> /// <returns> /// A string of characters with any escaped characters /// converted to their unescaped form. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="pattern"/> is null. /// </exception> public static string Unescape(string pattern) { if (pattern == null) { throw PSTraceSource.NewArgumentNullException(nameof(pattern)); } if (pattern == string.Empty) { return(pattern); } Span <char> temp = pattern.Length < StackAllocThreshold ? stackalloc char[pattern.Length] : new char[pattern.Length]; int tempIndex = 0; bool prevCharWasEscapeChar = false; for (int i = 0; i < pattern.Length; i++) { char ch = pattern[i]; if (ch == escapeChar) { if (prevCharWasEscapeChar) { temp[tempIndex++] = ch; prevCharWasEscapeChar = false; } else { prevCharWasEscapeChar = true; } continue; } if (prevCharWasEscapeChar) { if (!IsWildcardChar(ch)) { temp[tempIndex++] = escapeChar; } } temp[tempIndex++] = ch; prevCharWasEscapeChar = false; } // Need to account for a trailing escape character as a real // character if (prevCharWasEscapeChar) { temp[tempIndex++] = escapeChar; prevCharWasEscapeChar = false; } string s = null; if (tempIndex == pattern.Length) { s = pattern; } else { s = new string(temp.Slice(0, tempIndex)); } return(s); }
/// <summary> /// Load help file provided. /// </summary> /// <remarks> /// This will load providerHelpInfo from help file into help cache. /// </remarks> /// <param name="providerInfo">providerInfo for which to locate help.</param> private void LoadHelpFile(ProviderInfo providerInfo) { if (providerInfo == null) { throw PSTraceSource.NewArgumentNullException("providerInfo"); } string helpFile = providerInfo.HelpFile; if (String.IsNullOrEmpty(helpFile) || _helpFiles.Contains(helpFile)) { return; } string helpFileToLoad = helpFile; // Get the mshsnapinfo object for this cmdlet. PSSnapInInfo mshSnapInInfo = providerInfo.PSSnapIn; // Search fallback // 1. If PSSnapInInfo exists, then always look in the application base // of the mshsnapin // Otherwise, // Look in the default search path and cmdlet assembly path Collection <String> searchPaths = new Collection <String>(); if (mshSnapInInfo != null) { Diagnostics.Assert(!string.IsNullOrEmpty(mshSnapInInfo.ApplicationBase), "Application Base is null or empty."); // not minishell case.. // we have to search only in the application base for a mshsnapin... // if you create an absolute path for helpfile, then MUIFileSearcher // will look only in that path. helpFileToLoad = Path.Combine(mshSnapInInfo.ApplicationBase, helpFile); } else if ((providerInfo.Module != null) && (!string.IsNullOrEmpty(providerInfo.Module.Path))) { helpFileToLoad = Path.Combine(providerInfo.Module.ModuleBase, helpFile); } else { searchPaths.Add(GetDefaultShellSearchPath()); searchPaths.Add(GetProviderAssemblyPath(providerInfo)); } string location = MUIFileSearcher.LocateFile(helpFileToLoad, searchPaths); if (String.IsNullOrEmpty(location)) { throw new FileNotFoundException(helpFile); } XmlDocument doc = InternalDeserializer.LoadUnsafeXmlDocument( new FileInfo(location), false, /* ignore whitespace, comments, etc. */ null); /* default maxCharactersInDocument */ // Add this file into _helpFiles hashtable to prevent it to be loaded again. _helpFiles[helpFile] = 0; XmlNode helpItemsNode = null; if (doc.HasChildNodes) { for (int i = 0; i < doc.ChildNodes.Count; i++) { XmlNode node = doc.ChildNodes[i]; if (node.NodeType == XmlNodeType.Element && String.Compare(node.Name, "helpItems", StringComparison.OrdinalIgnoreCase) == 0) { helpItemsNode = node; break; } } } if (helpItemsNode == null) { return; } using (this.HelpSystem.Trace(location)) { if (helpItemsNode.HasChildNodes) { for (int i = 0; i < helpItemsNode.ChildNodes.Count; i++) { XmlNode node = helpItemsNode.ChildNodes[i]; if (node.NodeType == XmlNodeType.Element && String.Compare(node.Name, "providerHelp", StringComparison.OrdinalIgnoreCase) == 0) { HelpInfo helpInfo = ProviderHelpInfo.Load(node); if (helpInfo != null) { this.HelpSystem.TraceErrors(helpInfo.Errors); // Add snapin qualified type name for this command.. // this will enable customizations of the help object. helpInfo.FullHelp.TypeNames.Insert(0, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}#{1}", providerInfo.PSSnapInName, helpInfo.Name)); if (!string.IsNullOrEmpty(providerInfo.PSSnapInName)) { helpInfo.FullHelp.Properties.Add(new PSNoteProperty("PSSnapIn", providerInfo.PSSnapIn)); helpInfo.FullHelp.TypeNames.Insert(1, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}", providerInfo.PSSnapInName)); } AddCache(providerInfo.PSSnapInName + "\\" + helpInfo.Name, helpInfo); } } } } } }
/// <summary> /// Constructs an instance of the CompiledCommandAttribute using the specified /// runtime-defined parameter. /// </summary> /// <param name="runtimeDefinedParameter"> /// A runtime defined parameter that contains the definition of the parameter and its metadata. /// </param> /// <param name="processingDynamicParameters"> /// True if dynamic parameters are being processed, or false otherwise. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="runtimeDefinedParameter"/> is null. /// </exception> /// <exception cref="MetadataException"> /// If the parameter has more than one <see cref="ParameterAttribute">ParameterAttribute</see> /// that defines the same parameter-set name. /// </exception> internal CompiledCommandParameter(RuntimeDefinedParameter runtimeDefinedParameter, bool processingDynamicParameters) { if (runtimeDefinedParameter == null) { throw PSTraceSource.NewArgumentNullException("runtimeDefinedParameter"); } this.Name = runtimeDefinedParameter.Name; this.Type = runtimeDefinedParameter.ParameterType; this.IsDynamic = processingDynamicParameters; this.CollectionTypeInformation = new ParameterCollectionTypeInformation(runtimeDefinedParameter.ParameterType); this.CompiledAttributes = new Collection <Attribute>(); this.ParameterSetData = new Dictionary <string, ParameterSetSpecificMetadata>(StringComparer.OrdinalIgnoreCase); Collection <ValidateArgumentsAttribute> validationAttributes = null; Collection <ArgumentTransformationAttribute> argTransformationAttributes = null; string[] aliases = null; // First, process attributes that aren't type conversions foreach (Attribute attribute in runtimeDefinedParameter.Attributes) { if (processingDynamicParameters) { // When processing dynamic parameters, the attribute list may contain experimental attributes // and disabled parameter attributes. We should ignore those attributes. // When processing non-dynamic parameters, the experimental attributes and disabled parameter // attributes have already been filtered out when constructing the RuntimeDefinedParameter. if (attribute is ExperimentalAttribute || attribute is ParameterAttribute param && param.ToHide) { continue; } } if (!(attribute is ArgumentTypeConverterAttribute)) { ProcessAttribute(runtimeDefinedParameter.Name, attribute, ref validationAttributes, ref argTransformationAttributes, ref aliases); } } // If this is a PSCredential type and they haven't added any argument transformation attributes, // add one for credential transformation if ((this.Type == typeof(PSCredential)) && argTransformationAttributes == null) { ProcessAttribute(runtimeDefinedParameter.Name, new CredentialAttribute(), ref validationAttributes, ref argTransformationAttributes, ref aliases); } // Now process type converters foreach (var attribute in runtimeDefinedParameter.Attributes.OfType <ArgumentTypeConverterAttribute>()) { ProcessAttribute(runtimeDefinedParameter.Name, attribute, ref validationAttributes, ref argTransformationAttributes, ref aliases); } this.ValidationAttributes = validationAttributes == null ? Utils.EmptyArray <ValidateArgumentsAttribute>() : validationAttributes.ToArray(); this.ArgumentTransformationAttributes = argTransformationAttributes == null ? Utils.EmptyArray <ArgumentTransformationAttribute>() : argTransformationAttributes.ToArray(); this.Aliases = aliases == null ? Utils.EmptyArray <string>() : aliases.ToArray(); }
/// <summary> /// Constructs an instance of the CompiledCommandAttribute using the reflection information retrieved /// from the enclosing bindable object type. /// </summary> /// <param name="member"> /// The member information for the parameter /// </param> /// <param name="processingDynamicParameters"> /// True if dynamic parameters are being processed, or false otherwise. /// </param> /// <exception cref="ArgumentNullException"> /// If <paramref name="member"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="member"/> is not a field or a property. /// </exception> /// <exception cref="MetadataException"> /// If the member has more than one <see cref="ParameterAttribute">ParameterAttribute</see> /// that defines the same parameter-set name. /// </exception> internal CompiledCommandParameter(MemberInfo member, bool processingDynamicParameters) { if (member == null) { throw PSTraceSource.NewArgumentNullException("member"); } this.Name = member.Name; this.DeclaringType = member.DeclaringType; this.IsDynamic = processingDynamicParameters; var propertyInfo = member as PropertyInfo; if (propertyInfo != null) { this.Type = propertyInfo.PropertyType; } else { var fieldInfo = member as FieldInfo; if (fieldInfo != null) { this.Type = fieldInfo.FieldType; } else { ArgumentException e = PSTraceSource.NewArgumentException( "member", DiscoveryExceptions.CompiledCommandParameterMemberMustBeFieldOrProperty); throw e; } } this.CollectionTypeInformation = new ParameterCollectionTypeInformation(this.Type); this.CompiledAttributes = new Collection <Attribute>(); this.ParameterSetData = new Dictionary <string, ParameterSetSpecificMetadata>(StringComparer.OrdinalIgnoreCase); // We do not want to get the inherited custom attributes, only the attributes exposed // directly on the member var memberAttributes = member.GetCustomAttributes(false); Collection <ValidateArgumentsAttribute> validationAttributes = null; Collection <ArgumentTransformationAttribute> argTransformationAttributes = null; string[] aliases = null; foreach (Attribute attr in memberAttributes) { switch (attr) { case ExperimentalAttribute _: case ParameterAttribute param when param.ToHide: break; default: ProcessAttribute(member.Name, attr, ref validationAttributes, ref argTransformationAttributes, ref aliases); break; } } this.ValidationAttributes = validationAttributes == null ? Utils.EmptyArray <ValidateArgumentsAttribute>() : validationAttributes.ToArray(); this.ArgumentTransformationAttributes = argTransformationAttributes == null ? Utils.EmptyArray <ArgumentTransformationAttribute>() : argTransformationAttributes.ToArray(); this.Aliases = aliases ?? Utils.EmptyArray <string>(); }
} // SetLocation /// <summary> /// Changes the current working directory to the path specified /// </summary> /// /// <param name="path"> /// The path of the new current working directory /// </param> /// /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// /// <returns> /// The PathInfo object representing the path of the location /// that was set. /// </returns> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// /// <exception cref="ArgumentException"> /// If <paramref name="path"/> does not exist, is not a container, or /// resolved to multiple containers. /// </exception> /// /// <exception cref="ProviderNotFoundException"> /// If <paramref name="path"/> refers to a provider that does not exist. /// </exception> /// /// <exception cref="DriveNotFoundException"> /// If <paramref name="path"/> refers to a drive that does not exist. /// </exception> /// /// <exception cref="ProviderInvocationException"> /// If the provider associated with <paramref name="path"/> threw an /// exception. /// </exception> /// /// <exception cref="ItemNotFoundException"> /// If the <paramref name="path"/> could not be resolved. /// </exception> /// internal PathInfo SetLocation(string path, CmdletProviderContext context) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } string originalPath = path; string driveName = null; ProviderInfo provider = null; string providerId = null; PSDriveInfo previousWorkingDrive = CurrentDrive; // First check to see if the path is a home path if (LocationGlobber.IsHomePath(path)) { path = Globber.GetHomeRelativePath(path); } if (LocationGlobber.IsProviderDirectPath(path)) { // The path is a provider-direct path so use the current // provider and its hidden drive but don't modify the path // at all. provider = CurrentLocation.Provider; CurrentDrive = provider.HiddenDrive; } else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId)) { provider = GetSingleProvider(providerId); CurrentDrive = provider.HiddenDrive; } else { // See if the path is a relative or absolute // path. if (Globber.IsAbsolutePath(path, out driveName)) { // Since the path is an absolute path // we need to change the current working // drive PSDriveInfo newWorkingDrive = GetDrive(driveName); CurrentDrive = newWorkingDrive; // Now that the current working drive is set, // process the rest of the path as a relative path. } } if (context == null) { context = new CmdletProviderContext(this.ExecutionContext); } if (CurrentDrive != null) { context.Drive = CurrentDrive; } CmdletProvider providerInstance = null; Collection <PathInfo> workingPath = null; try { workingPath = Globber.GetGlobbedMonadPathsFromMonadPath( path, false, context, out providerInstance); } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } if (workingPath.Count == 0) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( path, "PathNotFound", SessionStateStrings.PathNotFound); } // We allow globbing the location as long as it only resolves a single container. bool foundContainer = false; bool pathIsContainer = false; bool pathIsProviderQualifiedPath = false; bool currentPathisProviderQualifiedPath = false; for (int index = 0; index < workingPath.Count; ++index) { CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); PathInfo resolvedPath = workingPath[index]; string currentPath = path; try { string providerName = null; currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName); if (currentPathisProviderQualifiedPath) { // The path should be the provider-qualified path without the provider ID // or :: string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path); try { currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, String.Empty, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } else { try { currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) // Catch-all OK, 3rd party callout { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } // Now see if there was errors while normalizing the path if (normalizePathContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; normalizePathContext.ThrowFirstErrorOrDoNothing(); } } finally { normalizePathContext.RemoveStopReferral(); } // Check to see if the path is a container bool isContainer = false; CmdletProviderContext itemContainerContext = new CmdletProviderContext(context); itemContainerContext.SuppressWildcardExpansion = true; try { isContainer = IsItemContainer( resolvedPath.Path, itemContainerContext); if (itemContainerContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; itemContainerContext.ThrowFirstErrorOrDoNothing(); } } catch (NotSupportedException) { if (currentPath.Length == 0) { // Treat this as a container because providers that only // support the ContainerCmdletProvider interface are really // containers at their root. isContainer = true; } } finally { itemContainerContext.RemoveStopReferral(); } if (isContainer) { if (foundContainer) { // The path resolved to more than one container // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw PSTraceSource.NewArgumentException( "path", SessionStateStrings.PathResolvedToMultiple, originalPath); } else { // Set the path to use path = currentPath; // Mark it as a container pathIsContainer = true; // Mark whether or not it was provider-qualified pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath; // Mark that we have already found one container. Finding additional // should be an error foundContainer = true; } } } if (pathIsContainer) { // Remove the root slash since it is implied that the // current working directory is relative to the root. if (!LocationGlobber.IsProviderDirectPath(path) && path.StartsWith(StringLiterals.DefaultPathSeparatorString, StringComparison.CurrentCulture) && !pathIsProviderQualifiedPath) { path = path.Substring(1); } s_tracer.WriteLine( "New working path = {0}", path); CurrentDrive.CurrentLocation = path; } else { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( originalPath, "PathNotFound", SessionStateStrings.PathNotFound); } // Now make sure the current drive is set in the provider's // current working drive hashtable ProvidersCurrentWorkingDrive[CurrentDrive.Provider] = CurrentDrive; // Set the $PWD variable to the new location this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal); return(this.CurrentLocation); } // SetLocation
/// <summary> /// Process the data received from the runspace pool on /// the server. /// </summary> /// <param name="receivedData">Data received.</param> internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { if (receivedData == null) { throw PSTraceSource.NewArgumentNullException("receivedData"); } Dbg.Assert(receivedData.TargetInterface == RemotingTargetInterface.RunspacePool, "RemotingTargetInterface must be Runspace"); switch (receivedData.DataType) { case RemotingDataType.CreatePowerShell: { Dbg.Assert(CreateAndInvokePowerShell != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); CreateAndInvokePowerShell.SafeInvoke(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); } break; case RemotingDataType.GetCommandMetadata: { Dbg.Assert(GetCommandMetadata != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); GetCommandMetadata.SafeInvoke(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); } break; case RemotingDataType.RemoteRunspaceHostResponseData: { Dbg.Assert(HostResponseReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); RemoteHostResponse remoteHostResponse = RemoteHostResponse.Decode(receivedData.Data); // part of host message robustness algo. Now the host response is back, report to transport that // execution status is back to running _transportManager.ReportExecutionStatusAsRunning(); HostResponseReceived.SafeInvoke(this, new RemoteDataEventArgs <RemoteHostResponse>(remoteHostResponse)); } break; case RemotingDataType.SetMaxRunspaces: { Dbg.Assert(SetMaxRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); SetMaxRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.SetMinRunspaces: { Dbg.Assert(SetMinRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); SetMinRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.AvailableRunspaces: { Dbg.Assert(GetAvailableRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); GetAvailableRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.ResetRunspaceState: { Dbg.Assert(ResetRunspaceState != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events."); ResetRunspaceState.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; } }
/// <summary> /// Set a function in the current scope of session state. /// </summary> /// <param name="name"> /// The name of the function to set. /// </param> /// <param name="function"> /// The new value of the function being set. /// </param> /// <param name="originalFunction"> /// The original function (if any) from which the ScriptBlock is derived. /// </param> /// <param name="force"> /// If true, the function will be set even if its ReadOnly. /// </param> /// <param name="origin"> /// The origin of the caller /// </param> /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// or /// If <paramref name="function"/> is not a <see cref="FilterInfo">FilterInfo</see> /// or <see cref="FunctionInfo">FunctionInfo</see> /// </exception> /// <exception cref="ArgumentNullException"> /// If <paramref name="function"/> is null. /// </exception> /// <exception cref="SessionStateUnauthorizedAccessException"> /// If the function is read-only or constant. /// </exception> internal FunctionInfo SetFunction( string name, ScriptBlock function, FunctionInfo originalFunction, bool force, CommandOrigin origin) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } if (function == null) { throw PSTraceSource.NewArgumentNullException("function"); } string originalName = name; FunctionLookupPath path = new FunctionLookupPath(name); name = path.UnqualifiedPath; if (string.IsNullOrEmpty(name)) { SessionStateException exception = new SessionStateException( originalName, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument); throw exception; } ScopedItemOptions options = ScopedItemOptions.None; if (path.IsPrivate) { options |= ScopedItemOptions.Private; } FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher( this, path, origin); FunctionInfo result = null; SessionStateScope scope = searcher.InitialScope; if (searcher.MoveNext()) { scope = searcher.CurrentLookupScope; name = searcher.Name; if (path.IsPrivate) { // Need to add the Private flag FunctionInfo existingFunction = scope.GetFunction(name); options |= existingFunction.Options; result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext); } else { result = scope.SetFunction(name, function, force, origin, ExecutionContext); } } else { if (path.IsPrivate) { result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext); } else { result = scope.SetFunction(name, function, force, origin, ExecutionContext); } } return(result); }
/// <summary> /// Changes the current working directory to the path specified. /// </summary> /// <param name="path"> /// The path of the new current working directory. /// </param> /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// <param name="literalPath"> /// Indicate if the path is a literal path. /// </param> /// <returns> /// The PathInfo object representing the path of the location /// that was set. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="path"/> does not exist, is not a container, or /// resolved to multiple containers. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If <paramref name="path"/> refers to a provider that does not exist. /// </exception> /// <exception cref="DriveNotFoundException"> /// If <paramref name="path"/> refers to a drive that does not exist. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider associated with <paramref name="path"/> threw an /// exception. /// </exception> /// <exception cref="ItemNotFoundException"> /// If the <paramref name="path"/> could not be resolved. /// </exception> internal PathInfo SetLocation(string path, CmdletProviderContext context, bool literalPath) { if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } PathInfo current = CurrentLocation; string originalPath = path; string driveName = null; ProviderInfo provider = null; string providerId = null; switch (originalPath) { case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("-", StringComparison.Ordinal): if (_setLocationHistory.UndoCount <= 0) { throw new InvalidOperationException(SessionStateStrings.LocationUndoStackIsEmpty); } path = _setLocationHistory.Undo(this.CurrentLocation).Path; break; case string originalPathSwitch when !literalPath && originalPathSwitch.Equals("+", StringComparison.Ordinal): if (_setLocationHistory.RedoCount <= 0) { throw new InvalidOperationException(SessionStateStrings.LocationRedoStackIsEmpty); } path = _setLocationHistory.Redo(this.CurrentLocation).Path; break; default: var pushPathInfo = GetNewPushPathInfo(); _setLocationHistory.Push(pushPathInfo); break; } PSDriveInfo previousWorkingDrive = CurrentDrive; // First check to see if the path is a home path if (LocationGlobber.IsHomePath(path)) { path = Globber.GetHomeRelativePath(path); } if (LocationGlobber.IsProviderDirectPath(path)) { // The path is a provider-direct path so use the current // provider and its hidden drive but don't modify the path // at all. provider = CurrentLocation.Provider; CurrentDrive = provider.HiddenDrive; } else if (LocationGlobber.IsProviderQualifiedPath(path, out providerId)) { provider = GetSingleProvider(providerId); CurrentDrive = provider.HiddenDrive; } else { // See if the path is a relative or absolute // path. if (Globber.IsAbsolutePath(path, out driveName)) { // Since the path is an absolute path // we need to change the current working // drive PSDriveInfo newWorkingDrive = GetDrive(driveName); CurrentDrive = newWorkingDrive; // If the path is simply a colon-terminated drive, // not a slash-terminated path to the root of a drive, // set the path to the current working directory of that drive. string colonTerminatedVolume = CurrentDrive.Name + ':'; if (CurrentDrive.VolumeSeparatedByColon && (path.Length == colonTerminatedVolume.Length)) { path = Path.Combine(colonTerminatedVolume + Path.DirectorySeparatorChar, CurrentDrive.CurrentLocation); } // Now that the current working drive is set, // process the rest of the path as a relative path. } } if (context == null) { context = new CmdletProviderContext(this.ExecutionContext); } if (CurrentDrive != null) { context.Drive = CurrentDrive; } CmdletProvider providerInstance = null; Collection <PathInfo> workingPath = null; try { workingPath = Globber.GetGlobbedMonadPathsFromMonadPath( path, false, context, out providerInstance); } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } if (workingPath.Count == 0) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( path, "PathNotFound", SessionStateStrings.PathNotFound); } // We allow globbing the location as long as it only resolves a single container. bool foundContainer = false; bool pathIsContainer = false; bool pathIsProviderQualifiedPath = false; bool currentPathisProviderQualifiedPath = false; for (int index = 0; index < workingPath.Count; ++index) { CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); PathInfo resolvedPath = workingPath[index]; string currentPath = path; try { string providerName = null; currentPathisProviderQualifiedPath = LocationGlobber.IsProviderQualifiedPath(resolvedPath.Path, out providerName); if (currentPathisProviderQualifiedPath) { // The path should be the provider-qualified path without the provider ID // or :: string providerInternalPath = LocationGlobber.RemoveProviderQualifier(resolvedPath.Path); try { currentPath = NormalizeRelativePath(GetSingleProvider(providerName), providerInternalPath, string.Empty, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } else { try { currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } catch (Exception) { // Reset the drive to the previous drive and // then rethrow the error CurrentDrive = previousWorkingDrive; throw; } } // Now see if there was errors while normalizing the path if (normalizePathContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; normalizePathContext.ThrowFirstErrorOrDoNothing(); } } finally { normalizePathContext.RemoveStopReferral(); } bool isContainer = false; CmdletProviderContext itemContainerContext = new CmdletProviderContext(context); itemContainerContext.SuppressWildcardExpansion = true; try { isContainer = IsItemContainer( resolvedPath.Path, itemContainerContext); if (itemContainerContext.HasErrors()) { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; itemContainerContext.ThrowFirstErrorOrDoNothing(); } } catch (NotSupportedException) { if (currentPath.Length == 0) { // Treat this as a container because providers that only // support the ContainerCmdletProvider interface are really // containers at their root. isContainer = true; } } finally { itemContainerContext.RemoveStopReferral(); } if (isContainer) { if (foundContainer) { // The path resolved to more than one container // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw PSTraceSource.NewArgumentException( "path", SessionStateStrings.PathResolvedToMultiple, originalPath); } else { // Set the path to use path = currentPath; // Mark it as a container pathIsContainer = true; // Mark whether or not it was provider-qualified pathIsProviderQualifiedPath = currentPathisProviderQualifiedPath; // Mark that we have already found one container. Finding additional // should be an error foundContainer = true; } } } if (pathIsContainer) { // Remove the root slash since it is implied that the // current working directory is relative to the root. if (!LocationGlobber.IsProviderDirectPath(path) && path.StartsWith(StringLiterals.DefaultPathSeparator) && !pathIsProviderQualifiedPath) { path = path.Substring(1); } s_tracer.WriteLine( "New working path = {0}", path); CurrentDrive.CurrentLocation = path; } else { // Set the current working drive back to the previous // one in case it was changed. CurrentDrive = previousWorkingDrive; throw new ItemNotFoundException( originalPath, "PathNotFound", SessionStateStrings.PathNotFound); } // Now make sure the current drive is set in the provider's // current working drive hashtable ProvidersCurrentWorkingDrive[CurrentDrive.Provider] = CurrentDrive; // Set the $PWD variable to the new location this.SetVariable(SpecialVariables.PWDVarPath, this.CurrentLocation, false, true, CommandOrigin.Internal); // If an action has been defined for location changes, invoke it now. if (PublicSessionState.InvokeCommand.LocationChangedAction != null) { var eventArgs = new LocationChangedEventArgs(PublicSessionState, current, CurrentLocation); PublicSessionState.InvokeCommand.LocationChangedAction.Invoke(ExecutionContext.CurrentRunspace, eventArgs); s_tracer.WriteLine("Invoked LocationChangedAction"); } return(this.CurrentLocation); }
/// <summary> /// Constructor for the ProviderInfo class. /// </summary> /// /// <param name="sessionState"> /// The instance of session state that the provider is being added to. /// </param> /// /// <param name="implementingType"> /// The type that implements the provider /// </param> /// /// <param name="name"> /// The alternate name to use for the provider instead of the one specified /// in the .cmdletprovider file. /// </param> /// /// <param name="description"> /// The description of the provider. /// </param> /// /// <param name="home"> /// The home path for the provider. This must be an MSH path. /// </param> /// /// <param name="helpFile"> /// The help file for the provider. /// </param> /// /// <param name="psSnapIn"> /// The Snap-In for the provider. /// </param> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="implementingType"/> or <paramref name="sessionState"/> is null. /// </exception> /// /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// </exception> /// internal ProviderInfo( SessionState sessionState, Type implementingType, string name, string description, string home, string helpFile, PSSnapInInfo psSnapIn) { // Verify parameters if (sessionState == null) { throw PSTraceSource.NewArgumentNullException("sessionState"); } if (implementingType == null) { throw PSTraceSource.NewArgumentNullException("implementingType"); } if (String.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } if (String.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } _sessionState = sessionState; Name = name; Description = description; Home = home; ImplementingType = implementingType; HelpFile = helpFile; PSSnapIn = psSnapIn; #if SUPPORTS_CMDLETPROVIDER_FILE LoadProviderFromPath(path); #endif // Create the hidden drive. The name doesn't really // matter since we are not adding this drive to a scope. _hiddenDrive = new PSDriveInfo( this.FullName, this, "", "", null); _hiddenDrive.Hidden = true; // TODO:PSL // this is probably not right here if (implementingType == typeof(Microsoft.PowerShell.Commands.FileSystemProvider) && !Platform.IsWindows) { VolumeSeparatedByColon = false; } }
private static T ConvertPropertyValueTo <T>(string propertyName, object propertyValue) { if (propertyName == null) { throw PSTraceSource.NewArgumentNullException("propertyName"); } if (typeof(T).IsEnum) { if (propertyValue is string) { try { string str = (string)propertyValue; return((T)Enum.Parse(typeof(T), str, true)); } catch (ArgumentException) { throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName }); } } try { Type underlyingType = Enum.GetUnderlyingType(typeof(T)); return((T)LanguagePrimitives.ConvertTo(propertyValue, underlyingType, CultureInfo.InvariantCulture)); } catch (InvalidCastException) { throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName }); } } if (typeof(T).Equals(typeof(PSObject))) { if (propertyValue == null) { return(default(T)); } return((T)Convert.ChangeType(PSObject.AsPSObject(propertyValue), typeof(T))); } if (propertyValue == null) { if (typeof(T).IsValueType && (!typeof(T).IsGenericType || !typeof(T).GetGenericTypeDefinition().Equals(typeof(Nullable <>)))) { throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, (propertyValue != null) ? propertyValue.GetType().FullName : "null" }); } return(default(T)); } if (propertyValue is T) { return((T)propertyValue); } if (propertyValue is PSObject) { PSObject obj3 = (PSObject)propertyValue; return(ConvertPropertyValueTo <T>(propertyName, obj3.BaseObject)); } if ((propertyValue is Hashtable) && typeof(T).Equals(typeof(PSPrimitiveDictionary))) { try { return((T)Convert.ChangeType(new PSPrimitiveDictionary((Hashtable)propertyValue), typeof(T))); } catch (ArgumentException) { throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, (propertyValue != null) ? propertyValue.GetType().FullName : "null" }); } } throw new PSRemotingDataStructureException(RemotingErrorIdStrings.CantCastPropertyToExpectedType, new object[] { propertyName, typeof(T).FullName, propertyValue.GetType().FullName }); }
internal virtual bool BindParameter(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags) { bool flag = false; bool flag2 = (flags & ParameterBindingFlags.ShouldCoerceType) != ParameterBindingFlags.None; if (parameter == null) { throw PSTraceSource.NewArgumentNullException("parameter"); } if (parameterMetadata == null) { throw PSTraceSource.NewArgumentNullException("parameterMetadata"); } using (bindingTracer.TraceScope("BIND arg [{0}] to parameter [{1}]", new object[] { parameter.ArgumentValue, parameterMetadata.Name })) { parameter.ParameterName = parameterMetadata.Name; object argumentValue = parameter.ArgumentValue; ScriptParameterBinder binder = this as ScriptParameterBinder; bool bindingScriptCmdlet = false; if (binder != null) { bindingScriptCmdlet = binder.Script.UsesCmdletBinding; } foreach (ArgumentTransformationAttribute attribute in parameterMetadata.ArgumentTransformationAttributes) { using (bindingTracer.TraceScope("Executing DATA GENERATION metadata: [{0}]", new object[] { attribute.GetType() })) { try { ArgumentTypeConverterAttribute attribute2 = attribute as ArgumentTypeConverterAttribute; if (attribute2 != null) { if (flag2) { argumentValue = attribute2.Transform(this.engine, argumentValue, true, bindingScriptCmdlet); } } else { argumentValue = attribute.Transform(this.engine, argumentValue); } bindingTracer.WriteLine("result returned from DATA GENERATION: {0}", new object[] { argumentValue }); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); bindingTracer.WriteLine("ERROR: DATA GENERATION: {0}", new object[] { exception.Message }); ParameterBindingException exception2 = new ParameterBindingArgumentTransformationException(exception, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentTransformationError", new object[] { exception.Message }); throw exception2; } } } if (flag2) { argumentValue = this.CoerceTypeAsNeeded(parameter, parameterMetadata.Name, parameterMetadata.Type, parameterMetadata.CollectionTypeInformation, argumentValue); } else if (!this.ShouldContinueUncoercedBind(parameter, parameterMetadata, flags, ref argumentValue)) { goto Label_040E; } if ((parameterMetadata.PSTypeName != null) && (argumentValue != null)) { IEnumerable enumerable = LanguagePrimitives.GetEnumerable(argumentValue); if (enumerable != null) { foreach (object obj3 in enumerable) { this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, obj3); } } else { this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, argumentValue); } } if ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None) { foreach (ValidateArgumentsAttribute attribute3 in parameterMetadata.ValidationAttributes) { using (bindingTracer.TraceScope("Executing VALIDATION metadata: [{0}]", new object[] { attribute3.GetType() })) { try { attribute3.InternalValidate(argumentValue, this.engine); } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); bindingTracer.WriteLine("ERROR: VALIDATION FAILED: {0}", new object[] { exception3.Message }); ParameterBindingValidationException exception4 = new ParameterBindingValidationException(exception3, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationError", new object[] { exception3.Message }); throw exception4; } tracer.WriteLine("Validation attribute on {0} returned {1}.", new object[] { parameterMetadata.Name, flag }); } } if (IsParameterMandatory(parameterMetadata)) { this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.Type, argumentValue, true); } } Exception innerException = null; try { this.BindParameter(parameter.ParameterName, argumentValue); flag = true; } catch (SetValueException exception6) { innerException = exception6; } if (innerException != null) { Type typeSpecified = (argumentValue == null) ? null : argumentValue.GetType(); ParameterBindingException exception7 = new ParameterBindingException(innerException, ErrorCategory.WriteError, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, typeSpecified, "ParameterBinderStrings", "ParameterBindingFailed", new object[] { innerException.Message }); throw exception7; } Label_040E :; bindingTracer.WriteLine("BIND arg [{0}] to param [{1}] {2}", new object[] { argumentValue, parameter.ParameterName, flag ? "SUCCESSFUL" : "SKIPPED" }); if (flag) { if (this.RecordBoundParameters) { this.CommandLineParameters.Add(parameter.ParameterName, argumentValue); } MshCommandRuntime commandRuntime = this.Command.commandRuntime as MshCommandRuntime; if ((commandRuntime != null) && commandRuntime.LogPipelineExecutionDetail) { IEnumerable source = LanguagePrimitives.GetEnumerable(argumentValue); if (source != null) { string parameterValue = string.Join(", ", source.Cast <object>().ToArray <object>()); commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, parameterValue); } else { commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, (argumentValue == null) ? "" : argumentValue.ToString()); } } } return(flag); } }
private object CoerceTypeAsNeeded(CommandParameterInternal argument, string parameterName, Type toType, ParameterCollectionTypeInformation collectionTypeInfo, object currentValue) { if (argument == null) { throw PSTraceSource.NewArgumentNullException("argument"); } if (toType == null) { throw PSTraceSource.NewArgumentNullException("toType"); } if (collectionTypeInfo == null) { collectionTypeInfo = new ParameterCollectionTypeInformation(toType); } object result = currentValue; using (bindingTracer.TraceScope("COERCE arg to [{0}]", new object[] { toType })) { Type c = null; try { if (IsNullParameterValue(currentValue)) { return(this.HandleNullParameterForSpecialTypes(argument, parameterName, toType, currentValue)); } c = currentValue.GetType(); if (toType.IsAssignableFrom(c)) { bindingTracer.WriteLine("Parameter and arg types the same, no coercion is needed.", new object[0]); return(currentValue); } bindingTracer.WriteLine("Trying to convert argument value from {0} to {1}", new object[] { c, toType }); if (toType == typeof(PSObject)) { if ((this.command != null) && (currentValue == this.command.CurrentPipelineObject.BaseObject)) { currentValue = this.command.CurrentPipelineObject; } bindingTracer.WriteLine("The parameter is of type [{0}] and the argument is an PSObject, so the parameter value is the argument value wrapped into an PSObject.", new object[] { toType }); return(LanguagePrimitives.AsPSObjectOrNull(currentValue)); } if ((toType == typeof(string)) && (c == typeof(PSObject))) { PSObject obj3 = (PSObject)currentValue; if (obj3 == AutomationNull.Value) { bindingTracer.WriteLine("CONVERT a null PSObject to a null string.", new object[0]); return(null); } } if (((toType == typeof(bool)) || (toType == typeof(SwitchParameter))) || (toType == typeof(bool?))) { Type type = null; if (c == typeof(PSObject)) { PSObject obj4 = (PSObject)currentValue; currentValue = obj4.BaseObject; if (currentValue is SwitchParameter) { SwitchParameter parameter = (SwitchParameter)currentValue; currentValue = parameter.IsPresent; } type = currentValue.GetType(); } else { type = c; } if (type == typeof(bool)) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject((bool)currentValue)); } return(new SwitchParameter((bool)currentValue)); } if (type == typeof(int)) { if (((int)LanguagePrimitives.ConvertTo(currentValue, typeof(int), CultureInfo.InvariantCulture)) != 0) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(true)); } return(new SwitchParameter(true)); } if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(false)); } return(new SwitchParameter(false)); } if (LanguagePrimitives.IsNumeric(Type.GetTypeCode(type))) { double num = (double)LanguagePrimitives.ConvertTo(currentValue, typeof(double), CultureInfo.InvariantCulture); if (num == 0.0) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(false)); } return(new SwitchParameter(false)); } if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(true)); } return(new SwitchParameter(true)); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { type, "" }); throw exception; } if ((collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.ICollectionGeneric) || (collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.IList)) { object obj5 = PSObject.Base(currentValue); if (obj5 != null) { ConversionRank conversionRank = LanguagePrimitives.GetConversionRank(obj5.GetType(), toType); if ((((conversionRank == ConversionRank.Constructor) || (conversionRank == ConversionRank.ImplicitCast)) || (conversionRank == ConversionRank.ExplicitCast)) && LanguagePrimitives.TryConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture, out result)) { return(result); } } } if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection) { bindingTracer.WriteLine("ENCODING arg into collection", new object[0]); bool coercionRequired = false; return(this.EncodeCollection(argument, parameterName, collectionTypeInfo, toType, currentValue, collectionTypeInfo.ElementType != null, out coercionRequired)); } if (((((GetIList(currentValue) != null) && (toType != typeof(object))) && ((toType != typeof(PSObject)) && (toType != typeof(PSListModifier)))) && ((!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(PSListModifier <>))) && (!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(FlagsExpression <>))))) && !toType.IsEnum) { throw new NotSupportedException(); } bindingTracer.WriteLine("CONVERT arg type to param type using LanguagePrimitives.ConvertTo", new object[0]); bool flag2 = false; if (this.context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { object obj6 = PSObject.Base(currentValue); bool flag3 = obj6 is PSObject; bool flag4 = (obj6 != null) && typeof(IDictionary).IsAssignableFrom(obj6.GetType()); flag2 = ((((PSLanguageMode)this.Command.CommandInfo.DefiningLanguageMode) == PSLanguageMode.FullLanguage) && !flag3) && !flag4; } try { if (flag2) { this.context.LanguageMode = PSLanguageMode.FullLanguage; } result = LanguagePrimitives.ConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture); } finally { if (flag2) { this.context.LanguageMode = PSLanguageMode.ConstrainedLanguage; } } bindingTracer.WriteLine("CONVERT SUCCESSFUL using LanguagePrimitives.ConvertTo: [{0}]", new object[] { (result == null) ? "null" : result.ToString() }); return(result); } catch (NotSupportedException exception2) { bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", new object[] { (result == null) ? "null" : result, toType }); ParameterBindingException exception3 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { (result == null) ? "null" : result, exception2.Message }); throw exception3; } catch (PSInvalidCastException exception4) { object[] args = new object[] { result ?? "null", toType }; bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", args); ParameterBindingException exception5 = new ParameterBindingException(exception4, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgumentNoMessage", new object[] { exception4.Message }); throw exception5; } } return(result); }
/// <summary> /// Determines if the specified path is the current working directory /// or a parent of the current working directory. /// </summary> /// <param name="path"> /// A monad namespace absolute or relative path. /// </param> /// <param name="context"> /// The context the provider uses when performing the operation. /// </param> /// <returns> /// true, if the path is the current working directory or a parent of the current /// working directory. false, otherwise. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="path"/> is null. /// </exception> /// <exception cref="ProviderNotFoundException"> /// If the path is a provider-qualified path for a provider that is /// not loaded into the system. /// </exception> /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider used to build the path threw an exception. /// </exception> /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> represents is not a NavigationCmdletProvider /// or ContainerCmdletProvider. /// </exception> /// <exception cref="InvalidOperationException"> /// If the <paramref name="path"/> starts with "~" and the home location is not set for /// the provider. /// </exception> /// <exception cref="ProviderInvocationException"> /// If the provider specified by <paramref name="providerId"/> threw an /// exception when its GetParentPath or MakePath was called while /// processing the <paramref name="path"/>. /// </exception> internal bool IsCurrentLocationOrAncestor(string path, CmdletProviderContext context) { bool result = false; if (path == null) { throw PSTraceSource.NewArgumentNullException("path"); } PSDriveInfo drive = null; ProviderInfo provider = null; string providerSpecificPath = Globber.GetProviderPath( path, context, out provider, out drive); if (drive != null) { s_tracer.WriteLine("Tracing drive"); drive.Trace(); } Dbg.Diagnostics.Assert( providerSpecificPath != null, "There should always be a way to generate a provider path for a " + "given path"); if (drive != null) { context.Drive = drive; } // Check to see if the path that was specified is within the current // working drive if (drive == CurrentDrive) { // The path needs to be normalized to get rid of relative path tokens // so they don't interfere with our path comparisons below CmdletProviderContext normalizePathContext = new CmdletProviderContext(context); try { providerSpecificPath = NormalizeRelativePath(path, null, normalizePathContext); } catch (NotSupportedException) { // Since the provider does not support normalizing the path, just // use the path we currently have. } catch (LoopFlowException) { throw; } catch (PipelineStoppedException) { throw; } catch (ActionPreferenceStopException) { throw; } finally { normalizePathContext.RemoveStopReferral(); } if (normalizePathContext.HasErrors()) { normalizePathContext.ThrowFirstErrorOrDoNothing(); } s_tracer.WriteLine("Provider path = {0}", providerSpecificPath); // Get the current working directory provider specific path PSDriveInfo currentWorkingDrive = null; ProviderInfo currentDriveProvider = null; string currentWorkingPath = Globber.GetProviderPath( ".", context, out currentDriveProvider, out currentWorkingDrive); Dbg.Diagnostics.Assert( currentWorkingDrive == CurrentDrive, "The current working drive should be the CurrentDrive."); s_tracer.WriteLine( "Current working path = {0}", currentWorkingPath); // See if the path is the current working directory or a parent // of the current working directory s_tracer.WriteLine( "Comparing {0} to {1}", providerSpecificPath, currentWorkingPath); if (String.Compare(providerSpecificPath, currentWorkingPath, StringComparison.CurrentCultureIgnoreCase) == 0) { // The path is the current working directory so // return true s_tracer.WriteLine("The path is the current working directory"); result = true; } else { // Check to see if the specified path is a parent // of the current working directory string lockedDirectory = currentWorkingPath; while (lockedDirectory.Length > 0) { // We need to allow the provider to go as far up the tree // as it can even if that means it has to traverse higher // than the mount point for this drive. That is // why we are passing the empty string as the root here. lockedDirectory = GetParentPath( drive.Provider, lockedDirectory, String.Empty, context); s_tracer.WriteLine( "Comparing {0} to {1}", lockedDirectory, providerSpecificPath); if (String.Compare(lockedDirectory, providerSpecificPath, StringComparison.CurrentCultureIgnoreCase) == 0) { // The path is a parent of the current working // directory s_tracer.WriteLine( "The path is a parent of the current working directory: {0}", lockedDirectory); result = true; break; } } } } else { s_tracer.WriteLine("Drives are not the same"); } return(result); }
/// <summary> /// Unescapes any escaped characters in the input string. /// </summary> /// <param name="pattern"> /// The input string containing the text to convert. /// </param> /// <returns> /// A string of characters with any escaped characters /// converted to their unescaped form. /// </returns> /// <exception cref="ArgumentNullException"> /// If <paramref name="pattern" /> is null. /// </exception> public static string Unescape(string pattern) { if (pattern == null) { throw PSTraceSource.NewArgumentNullException("pattern"); } char[] temp = new char[pattern.Length]; int tempIndex = 0; bool prevCharWasEscapeChar = false; for (int i = 0; i < pattern.Length; i++) { char ch = pattern[i]; if (ch == escapeChar) { if (prevCharWasEscapeChar) { temp[tempIndex++] = ch; prevCharWasEscapeChar = false; } else { prevCharWasEscapeChar = true; } continue; } if (prevCharWasEscapeChar) { if (!IsWildcardChar(ch)) { temp[tempIndex++] = escapeChar; } } temp[tempIndex++] = ch; prevCharWasEscapeChar = false; } // Need to account for a trailing escape character as a real // character if (prevCharWasEscapeChar) { temp[tempIndex++] = escapeChar; prevCharWasEscapeChar = false; } string s = null; if (tempIndex > 0) { s = new string(temp, 0, tempIndex); } else { s = string.Empty; } return(s); }
/// <summary> /// Get a Hashtable object out of a PowerShell data file (.psd1) /// </summary> /// <param name="parameterName"> /// Name of the parameter that takes the specified .psd1 file as a value /// </param> /// <param name="psDataFilePath"> /// Path to the powershell data file /// </param> /// <param name="context"> /// ExecutionContext to use /// </param> /// <param name="allowedCommands"> /// Set of command names that are allowed to use in the .psd1 file /// </param> /// <param name="allowedVariables"> /// Set of variable names that are allowed to use in the .psd1 file /// </param> /// <param name="allowEnvironmentVariables"> /// If true, allow to use environment variables in the .psd1 file /// </param> /// <param name="skipPathValidation"> /// If true, caller guarantees the path is valid /// </param> /// <returns></returns> internal static Hashtable EvaluatePowerShellDataFile( string parameterName, string psDataFilePath, ExecutionContext context, IEnumerable <string> allowedCommands, IEnumerable <string> allowedVariables, bool allowEnvironmentVariables, bool skipPathValidation) { if (!skipPathValidation && string.IsNullOrEmpty(parameterName)) { throw PSTraceSource.NewArgumentNullException("parameterName"); } if (string.IsNullOrEmpty(psDataFilePath)) { throw PSTraceSource.NewArgumentNullException("psDataFilePath"); } if (context == null) { throw PSTraceSource.NewArgumentNullException("context"); } string resolvedPath; if (skipPathValidation) { resolvedPath = psDataFilePath; } else { #region "ValidatePowerShellDataFilePath" bool isPathValid = true; // File extension needs to be .psd1 string pathExt = Path.GetExtension(psDataFilePath); if (string.IsNullOrEmpty(pathExt) || !StringLiterals.PowerShellDataFileExtension.Equals(pathExt, StringComparison.OrdinalIgnoreCase)) { isPathValid = false; } ProviderInfo provider; var resolvedPaths = context.SessionState.Path.GetResolvedProviderPathFromPSPath(psDataFilePath, out provider); // ConfigPath should be resolved as FileSystem provider if (provider == null || !Microsoft.PowerShell.Commands.FileSystemProvider.ProviderName.Equals(provider.Name, StringComparison.OrdinalIgnoreCase)) { isPathValid = false; } // ConfigPath should be resolved to a single path if (resolvedPaths.Count != 1) { isPathValid = false; } if (!isPathValid) { throw PSTraceSource.NewArgumentException( parameterName, ParserStrings.CannotResolvePowerShellDataFilePath, psDataFilePath); } resolvedPath = resolvedPaths[0]; #endregion "ValidatePowerShellDataFilePath" } #region "LoadAndEvaluatePowerShellDataFile" object evaluationResult; try { // Create the scriptInfo for the .psd1 file string dataFileName = Path.GetFileName(resolvedPath); var dataFileScriptInfo = new ExternalScriptInfo(dataFileName, resolvedPath, context); ScriptBlock scriptBlock = dataFileScriptInfo.ScriptBlock; // Validate the scriptblock scriptBlock.CheckRestrictedLanguage(allowedCommands, allowedVariables, allowEnvironmentVariables); // Evaluate the scriptblock object oldPsScriptRoot = context.GetVariableValue(SpecialVariables.PSScriptRootVarPath); try { // Set the $PSScriptRoot before the evaluation context.SetVariable(SpecialVariables.PSScriptRootVarPath, Path.GetDirectoryName(resolvedPath)); evaluationResult = PSObject.Base(scriptBlock.InvokeReturnAsIs()); } finally { context.SetVariable(SpecialVariables.PSScriptRootVarPath, oldPsScriptRoot); } } catch (RuntimeException ex) { throw PSTraceSource.NewInvalidOperationException( ex, ParserStrings.CannotLoadPowerShellDataFile, psDataFilePath, ex.Message); } var retResult = evaluationResult as Hashtable; if (retResult == null) { throw PSTraceSource.NewInvalidOperationException( ParserStrings.InvalidPowerShellDataFile, psDataFilePath); } #endregion "LoadAndEvaluatePowerShellDataFile" return(retResult); }
/// <summary> /// Gets the ResourceManager from the cache or gets an instance of the ResourceManager /// and returns it if it isn't already present in the cache. /// </summary> /// <param name="assembly"> /// The assembly to be used as the base for resource lookup. /// </param> /// <param name="baseName"> /// The base name of the resources to get the ResourceManager for. /// </param> /// <returns> /// A ResourceManager instance for the assembly and base name that were specified. /// </returns> internal static ResourceManager GetResourceManager( Assembly assembly, string baseName) { if (assembly == null) { throw PSTraceSource.NewArgumentNullException("assembly"); } if (string.IsNullOrEmpty(baseName)) { throw PSTraceSource.NewArgumentException("baseName"); } // Check to see if the manager is already in the cache ResourceManager manager = null; Dictionary <string, ResourceManager> baseNameCache; string assemblyManifestFileLocation = assembly.Location; lock (s_syncRoot) { // First do the lookup based on the assembly location if (s_resourceManagerCache.TryGetValue(assemblyManifestFileLocation, out baseNameCache) && baseNameCache != null) { // Now do the lookup based on the resource base name baseNameCache.TryGetValue(baseName, out manager); } } // If it's not in the cache, create it an add it. if (manager == null) { manager = InitRMWithAssembly(baseName, assembly); // Add the new resource manager to the hash if (baseNameCache != null) { lock (s_syncRoot) { // Since the assembly is already cached, we just have // to cache the base name entry baseNameCache[baseName] = manager; } } else { // Since the assembly wasn't cached, we have to create base name // cache entry and then add it into the cache keyed by the assembly // location var baseNameCacheEntry = new Dictionary <string, ResourceManager>(); baseNameCacheEntry[baseName] = manager; lock (s_syncRoot) { s_resourceManagerCache[assemblyManifestFileLocation] = baseNameCacheEntry; } } } Diagnostics.Assert( manager != null, "If the manager was not already created, it should have been dynamically created or an exception should have been thrown"); return(manager); }
/// <summary> /// Merges the specified metadata with the other metadata already defined /// in this object. /// </summary> /// <param name="parameterMetadata"> /// The compiled metadata for the type to be merged. /// </param> /// <param name="binderAssociation"> /// The type of binder that the CommandProcessor will use to bind /// the parameters for <paramref name="parameterMetadata"/> /// </param> /// <returns> /// A collection of the merged parameter metadata that was added. /// </returns> /// <exception cref="MetadataException"> /// If a parameter name or alias described in the <paramref name="parameterMetadata"/> already /// exists. /// </exception> internal Collection <MergedCompiledCommandParameter> AddMetadataForBinder( InternalParameterMetadata parameterMetadata, ParameterBinderAssociation binderAssociation) { if (parameterMetadata == null) { throw PSTraceSource.NewArgumentNullException("parameterMetadata"); } Collection <MergedCompiledCommandParameter> result = new Collection <MergedCompiledCommandParameter>(); // Merge in the bindable parameters foreach (KeyValuePair <string, CompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters) { if (_bindableParameters.ContainsKey(bindableParameter.Key)) { MetadataException exception = new MetadataException( "ParameterNameAlreadyExistsForCommand", null, Metadata.ParameterNameAlreadyExistsForCommand, bindableParameter.Key); throw exception; } // NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN if (_aliasedParameters.ContainsKey(bindableParameter.Key)) { MetadataException exception = new MetadataException( "ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, bindableParameter.Key, RetrieveParameterNameForAlias(bindableParameter.Key, _aliasedParameters)); throw exception; } MergedCompiledCommandParameter mergedParameter = new MergedCompiledCommandParameter(bindableParameter.Value, binderAssociation); _bindableParameters.Add(bindableParameter.Key, mergedParameter); result.Add(mergedParameter); // Merge in the aliases foreach (string aliasName in bindableParameter.Value.Aliases) { if (_aliasedParameters.ContainsKey(aliasName)) { MetadataException exception = new MetadataException( "AliasParameterNameAlreadyExistsForCommand", null, Metadata.AliasParameterNameAlreadyExistsForCommand, aliasName); throw exception; } // NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN if (_bindableParameters.ContainsKey(aliasName)) { MetadataException exception = new MetadataException( "ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, RetrieveParameterNameForAlias(aliasName, _bindableParameters), bindableParameter.Value.Name); throw exception; } _aliasedParameters.Add(aliasName, mergedParameter); } } return(result); }
private void LoadHelpFile(ProviderInfo providerInfo) { if (providerInfo == null) { throw PSTraceSource.NewArgumentNullException("providerInfo"); } string helpFile = providerInfo.HelpFile; if (!string.IsNullOrEmpty(helpFile) && !this._helpFiles.Contains(helpFile)) { string file = helpFile; PSSnapInInfo pSSnapIn = providerInfo.PSSnapIn; Collection <string> searchPaths = new Collection <string>(); if (pSSnapIn != null) { file = Path.Combine(pSSnapIn.ApplicationBase, helpFile); } else if ((providerInfo.Module != null) && !string.IsNullOrEmpty(providerInfo.Module.Path)) { file = Path.Combine(providerInfo.Module.ModuleBase, helpFile); } else { searchPaths.Add(base.GetDefaultShellSearchPath()); searchPaths.Add(GetProviderAssemblyPath(providerInfo)); } string str3 = MUIFileSearcher.LocateFile(file, searchPaths); if (string.IsNullOrEmpty(str3)) { throw new FileNotFoundException(helpFile); } XmlDocument document = InternalDeserializer.LoadUnsafeXmlDocument(new FileInfo(str3), false, null); this._helpFiles[helpFile] = 0; System.Xml.XmlNode node = null; if (document.HasChildNodes) { for (int i = 0; i < document.ChildNodes.Count; i++) { System.Xml.XmlNode node2 = document.ChildNodes[i]; if ((node2.NodeType == XmlNodeType.Element) && (string.Compare(node2.Name, "helpItems", StringComparison.OrdinalIgnoreCase) == 0)) { node = node2; break; } } } if (node != null) { using (base.HelpSystem.Trace(str3)) { if (node.HasChildNodes) { for (int j = 0; j < node.ChildNodes.Count; j++) { System.Xml.XmlNode xmlNode = node.ChildNodes[j]; if ((xmlNode.NodeType == XmlNodeType.Element) && (string.Compare(xmlNode.Name, "providerHelp", StringComparison.OrdinalIgnoreCase) == 0)) { HelpInfo helpInfo = ProviderHelpInfo.Load(xmlNode); if (helpInfo != null) { base.HelpSystem.TraceErrors(helpInfo.Errors); helpInfo.FullHelp.TypeNames.Insert(0, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}#{1}", new object[] { providerInfo.PSSnapInName, helpInfo.Name })); if (!string.IsNullOrEmpty(providerInfo.PSSnapInName)) { helpInfo.FullHelp.Properties.Add(new PSNoteProperty("PSSnapIn", providerInfo.PSSnapIn)); helpInfo.FullHelp.TypeNames.Insert(1, string.Format(CultureInfo.InvariantCulture, "ProviderHelpInfo#{0}", new object[] { providerInfo.PSSnapInName })); } base.AddCache(providerInfo.PSSnapInName + @"\" + helpInfo.Name, helpInfo); } } } } } } } }