internal CmdletProviderContext(CmdletProviderContext contextToCopyFrom)
{
this.credentials = PSCredential.Empty;
this._origin = CommandOrigin.Internal;
this.accumulatedObjects = new Collection<PSObject>();
this.accumulatedErrorObjects = new Collection<ErrorRecord>();
this.stopReferrals = new Collection<CmdletProviderContext>();
if (contextToCopyFrom == null)
{
throw PSTraceSource.NewArgumentNullException("contextToCopyFrom");
}
this.executionContext = contextToCopyFrom.ExecutionContext;
this.command = contextToCopyFrom.command;
if (contextToCopyFrom.Credential != null)
{
this.credentials = contextToCopyFrom.Credential;
}
this.drive = contextToCopyFrom.Drive;
this.force = (bool) contextToCopyFrom.Force;
this.CopyFilters(contextToCopyFrom);
this.suppressWildcardExpansion = contextToCopyFrom.SuppressWildcardExpansion;
this.dynamicParameters = contextToCopyFrom.DynamicParameters;
this._origin = contextToCopyFrom._origin;
this.stopping = contextToCopyFrom.Stopping;
contextToCopyFrom.StopReferrals.Add(this);
this.copiedContext = contextToCopyFrom;
}
internal MamlCommandHelpInfo GetProviderSpecificHelpInfo(string helpItemName)
{
ProviderInfo info = null;
PSDriveInfo drive = null;
string str = null;
CmdletProviderContext context = new CmdletProviderContext(this._executionContext);
try
{
string str2 = this._requestedPath;
if (string.IsNullOrEmpty(this._requestedPath))
{
str2 = this._pathIntrinsics.CurrentLocation.Path;
}
str = this._executionContext.LocationGlobber.GetProviderPath(str2, context, out info, out drive);
}
catch (ArgumentNullException)
{
}
catch (ProviderNotFoundException)
{
}
catch (DriveNotFoundException)
{
}
catch (ProviderInvocationException)
{
}
catch (NotSupportedException)
{
}
catch (InvalidOperationException)
{
}
catch (ItemNotFoundException)
{
}
if (info == null)
{
return null;
}
CmdletProvider provider = info.CreateInstance();
ICmdletProviderSupportsHelp help = provider as ICmdletProviderSupportsHelp;
if (help == null)
{
return null;
}
if (str == null)
{
throw new ItemNotFoundException(this._requestedPath, "PathNotFound", SessionStateStrings.PathNotFound);
}
provider.Start(info, context);
string path = str;
string helpMaml = help.GetHelpMaml(helpItemName, path);
if (string.IsNullOrEmpty(helpMaml))
{
return null;
}
return MamlCommandHelpInfo.Load(InternalDeserializer.LoadUnsafeXmlDocument(helpMaml, false, null).DocumentElement, HelpCategory.Provider);
}
internal PSDriveInfo NewDrive(PSDriveInfo drive, CmdletProviderContext context)
{
base.Context = context;
if (((drive.Credential != null) && (drive.Credential != PSCredential.Empty)) && !CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.Credentials, base.ProviderInfo))
{
throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "NewDriveCredentials_NotSupported", new object[0]);
}
return this.NewDrive(drive);
}
internal void CopyProperty(string sourcePath, string sourceProperty, string destinationPath, string destinationProperty, CmdletProviderContext cmdletProviderContext)
{
this.Context = cmdletProviderContext;
IDynamicPropertyCmdletProvider provider = this as IDynamicPropertyCmdletProvider;
if (provider == null)
{
throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IDynamicPropertyCmdletProvider_NotSupported", new object[0]);
}
provider.CopyProperty(sourcePath, sourceProperty, destinationPath, destinationProperty);
}
internal object ClearPropertyDynamicParameters(string path, Collection<string> providerSpecificPickList, CmdletProviderContext cmdletProviderContext)
{
this.Context = cmdletProviderContext;
IPropertyCmdletProvider provider = this as IPropertyCmdletProvider;
if (provider == null)
{
return null;
}
return provider.ClearPropertyDynamicParameters(path, providerSpecificPickList);
}
internal void ClearProperty(string path, Collection<string> propertyName, CmdletProviderContext cmdletProviderContext)
{
this.Context = cmdletProviderContext;
IPropertyCmdletProvider provider = this as IPropertyCmdletProvider;
if (provider == null)
{
throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IPropertyCmdletProvider_NotSupported", new object[0]);
}
provider.ClearProperty(path, propertyName);
}
internal void ClearContent(string path, CmdletProviderContext cmdletProviderContext)
{
this.Context = cmdletProviderContext;
IContentCmdletProvider provider = this as IContentCmdletProvider;
if (provider == null)
{
throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IContentCmdletProvider_NotSupported", new object[0]);
}
provider.ClearContent(path);
}
internal object ClearContentDynamicParameters(string path, CmdletProviderContext cmdletProviderContext)
{
this.Context = cmdletProviderContext;
IContentCmdletProvider provider = this as IContentCmdletProvider;
if (provider == null)
{
return null;
}
return provider.ClearContentDynamicParameters(path);
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
if (!(this.Path != null & (int)this.Path.Length > 0))
{
return base.InvokeProvider.Property.CopyPropertyDynamicParameters(".", this.property, this.Destination, this.property, context);
}
else
{
return base.InvokeProvider.Property.CopyPropertyDynamicParameters(this.Path[0], this.property, this.Destination, this.property, context);
}
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
if (this.Path == null)
{
return base.InvokeProvider.Property.RenamePropertyDynamicParameters(".", this.Name, this.NewName, context);
}
else
{
return base.InvokeProvider.Property.RenamePropertyDynamicParameters(this.Path, this.Name, this.NewName, context);
}
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
if (base.Path == null || (int)base.Path.Length <= 0)
{
return base.InvokeProvider.Content.GetContentReaderDynamicParameters(".", context);
}
else
{
return base.InvokeProvider.Content.GetContentReaderDynamicParameters(base.Path[0], context);
}
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
if (this.Path == null || (int)this.Path.Length <= 0)
{
return base.InvokeProvider.Property.GetPropertyDynamicParameters(".", SessionStateUtilities.ConvertArrayToCollection<string>(this.property), context);
}
else
{
return base.InvokeProvider.Property.GetPropertyDynamicParameters(this.Path[0], SessionStateUtilities.ConvertArrayToCollection<string>(this.property), context);
}
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
Collection<string> strs = new Collection<string>();
strs.Add(this.property);
if (this.Path == null || (int)this.Path.Length <= 0)
{
return base.InvokeProvider.Property.ClearPropertyDynamicParameters(".", strs, context);
}
else
{
return base.InvokeProvider.Property.ClearPropertyDynamicParameters(this.Path[0], strs, context);
}
}
private string[] GetAcceptedPaths(string[] unfilteredPaths, CmdletProviderContext currentContext)
{
Collection<PathInfo> pathInfos = base.ResolvePaths(unfilteredPaths, true, false, currentContext);
ArrayList arrayLists = new ArrayList();
foreach (PathInfo pathInfo in pathInfos)
{
if (!this.CallShouldProcess(pathInfo.Path))
{
continue;
}
arrayLists.Add(pathInfo.Path);
}
return (string[])arrayLists.ToArray(typeof(string));
}
/// <summary>
/// Gets the path to the parent object for the given object
/// </summary>
///
/// <param name="path">
/// The path to the object to get the parent path from
/// </param>
///
/// <param name="root">
/// The root of the drive.
/// </param>
///
/// <returns>
/// The path to the parent object
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="path"/> is null.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the <paramref name="providerInstance"/> does not support this operation.
/// </exception>
///
/// <exception cref="PipelineStoppedException">
/// If the pipeline is being stopped while executing the command.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception.
/// </exception>
///
internal string GetParentPath(string path, string root)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
string result = GetParentPath(path, root, context);
context.ThrowFirstErrorOrDoNothing();
return result;
} //GetParentPath
private PathInfo ResolvePath(string pathToResolve, bool isLiteralPath, bool allowNonexistingPaths, PSCmdlet cmdlet)
{
CmdletProviderContext context = new CmdletProviderContext(cmdlet) {
SuppressWildcardExpansion = isLiteralPath
};
Collection<PathInfo> targetObject = new Collection<PathInfo>();
try
{
foreach (PathInfo info in cmdlet.SessionState.Path.GetResolvedPSPathFromPSPath(pathToResolve, context))
{
targetObject.Add(info);
}
}
catch (PSNotSupportedException exception)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception.ErrorRecord, exception));
}
catch (DriveNotFoundException exception2)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception2.ErrorRecord, exception2));
}
catch (ProviderNotFoundException exception3)
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception3.ErrorRecord, exception3));
}
catch (ItemNotFoundException exception4)
{
if (allowNonexistingPaths)
{
ProviderInfo provider = null;
PSDriveInfo drive = null;
string path = cmdlet.SessionState.Path.GetUnresolvedProviderPathFromPSPath(pathToResolve, context, out provider, out drive);
PathInfo item = new PathInfo(drive, provider, path, cmdlet.SessionState);
targetObject.Add(item);
}
else
{
cmdlet.ThrowTerminatingError(new ErrorRecord(exception4.ErrorRecord, exception4));
}
}
if (targetObject.Count == 1)
{
return targetObject[0];
}
Exception exception5 = PSTraceSource.NewNotSupportedException();
cmdlet.ThrowTerminatingError(new ErrorRecord(exception5, "NotSupported", ErrorCategory.NotImplemented, targetObject));
return null;
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
string name = null;
if (this.Name != null && (int)this.Name.Length > 0)
{
name = this.Name[0];
}
if (this.Path == null || (int)this.Path.Length <= 0)
{
return base.InvokeProvider.Property.RemovePropertyDynamicParameters(".", name, context);
}
else
{
return base.InvokeProvider.Property.RemovePropertyDynamicParameters(this.Path[0], name, context);
}
}
internal override object GetDynamicParameters(CmdletProviderContext context)
{
string empty = string.Empty;
if (this.Name != null && (int)this.Name.Length > 0)
{
empty = this.Name[0];
}
if (this.Path == null || (int)this.Path.Length <= 0)
{
return base.InvokeProvider.Property.MovePropertyDynamicParameters(".", empty, this.Destination, empty, context);
}
else
{
return base.InvokeProvider.Property.MovePropertyDynamicParameters(this.Path[0], empty, this.Destination, empty, context);
}
}
/// <summary>
/// Determines if the monad virtual namespace path exists.
/// </summary>
///
/// <param name="path">
/// The path to the object to determine if it exists.
/// </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>
/// true if the object specified by path exists, false otherwise.
/// </returns>
///
/// <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>
///
internal bool ItemExists(string path, bool force, bool literalPath)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
context.Force = force;
context.SuppressWildcardExpansion = literalPath;
bool result = ItemExists(path, context);
context.ThrowFirstErrorOrDoNothing();
return result;
} // ItemExists
/// <summary>
/// Internal wrapper for the NewDrive protected method. It is called instead
/// of the protected method that is overridden by derived classes so that the
/// context of the command can be set.
/// </summary>
///
/// <param name="drive">
/// The PSDriveInfo object the represents the drive to be mounted.
/// </param>
///
/// <param name="context">
/// The context under which this method is being called.
/// </param>
///
/// <returns>
/// The drive that was returned from the protected NewDrive method.
/// </returns>
///
internal PSDriveInfo NewDrive(PSDriveInfo drive, CmdletProviderContext context)
{
Context = context;
// Make sure the provider supports credentials if they were passed
// in the drive.
if (drive.Credential != null &&
drive.Credential != PSCredential.Empty &&
!CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.Credentials, ProviderInfo))
{
throw PSTraceSource.NewNotSupportedException(
SessionStateStrings.NewDriveCredentials_NotSupported);
}
return NewDrive(drive);
} // NewDrive
/// <summary>
/// Gets the content reader for the specified item.
/// </summary>
///
/// <param name="paths">
/// The path(s) to the item(s) to get the content reader for.
/// </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>
/// The content readers for all items that the path resolves to.
/// </returns>
///
/// <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>
///
internal Collection<IContentReader> GetContentReader(string[] paths, bool force, bool literalPath)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
context.Force = force;
context.SuppressWildcardExpansion = literalPath;
Collection<IContentReader> results = GetContentReader(paths, context);
context.ThrowFirstErrorOrDoNothing();
return results;
} // GetContentReader
/// <summary>
/// Called by the base class before the streams are open for the path.
/// This override clears the content from the item.
/// </summary>
///
/// <param name="paths">
/// The path to the items that will be opened for writing content.
/// </param>
///
internal override void BeforeOpenStreams(string[] paths)
{
if (paths == null ||
(paths != null && paths.Length == 0))
{
throw PSTraceSource.NewArgumentNullException("paths");
}
CmdletProviderContext context = new CmdletProviderContext(GetCurrentContext());
foreach (string path in paths)
{
try
{
InvokeProvider.Content.Clear(path, context);
context.ThrowFirstErrorOrDoNothing(true);
}
catch (PSNotSupportedException)
{
// If the provider doesn't support clear, that is fine. Continue
// on with the setting of the content.
continue;
}
catch (DriveNotFoundException driveNotFound)
{
WriteError(
new ErrorRecord(
driveNotFound.ErrorRecord,
driveNotFound));
continue;
}
catch (ProviderNotFoundException providerNotFound)
{
WriteError(
new ErrorRecord(
providerNotFound.ErrorRecord,
providerNotFound));
continue;
}
catch (ItemNotFoundException)
{
//If the item is not found then there is nothing to clear so ignore this exception.
continue;
}
}
} // BeforeOpenStreams
/// <summary>
/// A virtual method for retrieving the dynamic parameters for a cmdlet. Derived cmdlets
/// that require dynamic parameters should override this method and return the
/// dynamic parameter object.
/// </summary>
///
/// <param name="context">
/// The context under which the command is running.
/// </param>
///
/// <returns>
/// An object representing the dynamic parameters for the cmdlet or null if there
/// are none.
/// </returns>
///
internal override object GetDynamicParameters(CmdletProviderContext context)
{
if (Path != null && Path.Length > 0)
{
return InvokeProvider.Property.CopyPropertyDynamicParameters(
Path[0],
Name,
Destination,
Name,
context);
}
return InvokeProvider.Property.CopyPropertyDynamicParameters(
".",
Name,
Destination,
Name,
context);
} // GetDynamicParameters
internal List<ContentCommandBase.ContentHolder> GetContentWriters(string[] writerPaths, CmdletProviderContext currentCommandContext)
{
Collection<PathInfo> pathInfos = base.ResolvePaths(writerPaths, true, false, currentCommandContext);
List<ContentCommandBase.ContentHolder> contentHolders = new List<ContentCommandBase.ContentHolder>();
foreach (PathInfo pathInfo in pathInfos)
{
Collection<IContentWriter> writer = null;
try
{
writer = base.InvokeProvider.Content.GetWriter(pathInfo.Path, currentCommandContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
continue;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
continue;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
continue;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
continue;
}
if (writer == null || writer.Count <= 0 || writer.Count != 1 || writer[0] == null)
{
continue;
}
ContentCommandBase.ContentHolder contentHolder = new ContentCommandBase.ContentHolder(pathInfo, null, writer[0]);
contentHolders.Add(contentHolder);
}
return contentHolders;
}
/// <summary>
/// Gets the specified properties from the specified item.
/// </summary>
///
/// <param name="paths">
/// The path(s) to the item(s) to get the properties from.
/// </param>
///
/// <param name="providerSpecificPickList">
/// A list of the properties that the provider should return.
/// </param>
///
/// <param name="literalPath">
/// If true, globbing is not done on paths.
/// </param>
///
/// <returns>
/// A property table container the properties and their values.
/// </returns>
///
/// <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>
///
internal Collection<PSObject> GetProperty(
string[] paths,
Collection<string> providerSpecificPickList,
bool literalPath)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
context.SuppressWildcardExpansion = literalPath;
GetProperty(paths, providerSpecificPickList, context);
context.ThrowFirstErrorOrDoNothing();
Collection<PSObject> results = context.GetAccumulatedObjects();
return results;
} // GetProperties
/// <summary>
/// Gets the specified object
/// </summary>
///
/// <param name="paths">
/// The path(s) to the object(s). They can be either a relative (most common)
/// or absolute path.
/// </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>
/// The item at the specified path.
/// </returns>
///
/// <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>
///
internal Collection<PSObject> GetItem(string[] paths, bool force, bool literalPath)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
context.Force = force;
context.SuppressWildcardExpansion = literalPath;
GetItem(paths, context);
context.ThrowFirstErrorOrDoNothing();
// Since there was not errors return the accumulated objects
Collection<PSObject> results = context.GetAccumulatedObjects();
return results;
} // GetItem
internal override void BeforeOpenStreams(string[] paths)
{
if (paths == null || paths != null && (int)paths.Length == 0)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
else
{
CmdletProviderContext cmdletProviderContext = new CmdletProviderContext(base.GetCurrentContext());
string[] strArrays = paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
base.InvokeProvider.Content.Clear(str, cmdletProviderContext);
cmdletProviderContext.ThrowFirstErrorOrDoNothing(true);
}
catch (PSNotSupportedException pSNotSupportedException)
{
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException)
{
}
}
return;
}
}
internal object GetChildItemsDynamicParameters(string path, bool recurse, CmdletProviderContext context)
{
return(this.sessionState.GetChildItemsDynamicParameters(path, recurse, context));
}
/// <summary>
/// Gets the IContentReaders for the current path(s)
/// </summary>
///
/// <returns>
/// An array of IContentReaders for the current path(s)
/// </returns>
///
internal List<ContentHolder> GetContentReaders(
string[] readerPaths,
CmdletProviderContext currentCommandContext)
{
// Resolve all the paths into PathInfo objects
Collection<PathInfo> pathInfos = ResolvePaths(readerPaths, false, true, currentCommandContext);
// Create the results array
List<ContentHolder> results = new List<ContentHolder>();
foreach (PathInfo pathInfo in pathInfos)
{
// For each path, get the content writer
Collection<IContentReader> readers = null;
try
{
string pathToProcess = WildcardPattern.Escape(pathInfo.Path);
if (currentCommandContext.SuppressWildcardExpansion)
{
pathToProcess = pathInfo.Path;
}
readers =
InvokeProvider.Content.GetReader(pathToProcess, currentCommandContext);
}
catch (PSNotSupportedException notSupported)
{
WriteError(
new ErrorRecord(
notSupported.ErrorRecord,
notSupported));
continue;
}
catch (DriveNotFoundException driveNotFound)
{
WriteError(
new ErrorRecord(
driveNotFound.ErrorRecord,
driveNotFound));
continue;
}
catch (ProviderNotFoundException providerNotFound)
{
WriteError(
new ErrorRecord(
providerNotFound.ErrorRecord,
providerNotFound));
continue;
}
catch (ItemNotFoundException pathNotFound)
{
WriteError(
new ErrorRecord(
pathNotFound.ErrorRecord,
pathNotFound));
continue;
}
if (readers != null && readers.Count > 0)
{
if (readers.Count == 1 && readers[0] != null)
{
ContentHolder holder =
new ContentHolder(pathInfo, readers[0], null);
results.Add(holder);
}
}
} // foreach pathInfo in pathInfos
return results;
} // GetContentReaders
/// <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)
{
return(SetLocation(path, context, literalPath: false));
}
internal void GetNames(string path, ReturnContainers returnContainers, bool recurse, CmdletProviderContext context)
{
this.sessionState.GetChildNames(path, returnContainers, recurse, context);
}
internal object RemovePropertyDynamicParameters(string path, string propertyName, CmdletProviderContext context)
{
return(this.sessionState.RemovePropertyDynamicParameters(path, propertyName, context));
}
internal object RenamePropertyDynamicParameters(string path, string sourceProperty, string destinationProperty, CmdletProviderContext context)
{
return(this.sessionState.RenamePropertyDynamicParameters(path, sourceProperty, destinationProperty, context));
}
internal string ParseChildName(string path, CmdletProviderContext context, bool useDefaultProvider)
{
return(this.sessionState.GetChildName(path, context, useDefaultProvider));
}
internal object NewPropertyDynamicParameters(string path, string propertyName, string type, object value, CmdletProviderContext context)
{
return(this.sessionState.NewPropertyDynamicParameters(path, propertyName, type, value, context));
}
internal string NormalizeRelativePath(string path, string basePath, CmdletProviderContext context)
{
return(this.sessionState.NormalizeRelativePath(path, basePath, context));
}
internal string ParseChildName(string path, CmdletProviderContext context)
{
return(this.sessionState.GetChildName(path, context, false));
}
internal bool IsValid(string path, CmdletProviderContext context)
{
return(this.sessionState.IsValidPath(path, context));
}
/// <summary>
/// Removes the current scope from the scope tree and
/// changes the current scope to the parent scope.
/// </summary>
/// <param name="scope">
/// The scope to cleanup and remove.
/// </param>
/// <exception cref="SessionStateUnauthorizedAccessException">
/// The global scope cannot be removed.
/// </exception>
internal void RemoveScope(SessionStateScope scope)
{
Diagnostics.Assert(
_currentScope != null,
"The currentScope should always be set.");
if (scope == GlobalScope)
{
SessionStateUnauthorizedAccessException e =
new SessionStateUnauthorizedAccessException(
StringLiterals.Global,
SessionStateCategory.Scope,
"GlobalScopeCannotRemove",
SessionStateStrings.GlobalScopeCannotRemove);
throw e;
}
// Give the provider a chance to cleanup the drive data associated
// with drives in this scope
foreach (PSDriveInfo drive in scope.Drives)
{
if (drive == null)
{
continue;
}
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
// Call CanRemoveDrive to give the provider a chance to cleanup
// but ignore the return value and exceptions
try
{
CanRemoveDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception) // Catch-all OK, 3rd party callout.
{
// Ignore all exceptions from the provider as we are
// going to force the removal anyway
}
}
scope.RemoveAllDrives();
// If the scope being removed is the current scope,
// then it must be removed from the tree.
if (scope == _currentScope && _currentScope.Parent != null)
{
_currentScope = _currentScope.Parent;
}
scope.Parent = null;
}
internal string GetUnresolvedProviderPathFromPSPath(string path, CmdletProviderContext context, out ProviderInfo provider, out PSDriveInfo drive)
{
return(this.PathResolver.GetProviderPath(path, context, out provider, out drive));
}
/// <summary>
/// A virtual method for retrieving the dynamic parameters for a cmdlet. Derived cmdlets
/// that require dynamic parameters should override this method and return the
/// dynamic parameter object.
/// </summary>
///
/// <param name="context">
/// The context under which the command is running.
/// </param>
///
/// <returns>
/// An object representing the dynamic parameters for the cmdlet or null if there
/// are none.
/// </returns>
///
internal override object GetDynamicParameters(CmdletProviderContext context)
{
string propertyName = String.Empty;
if (Name != null && Name.Length > 0)
{
propertyName = Name[0];
}
if (Path != null && Path.Length > 0)
{
return InvokeProvider.Property.MovePropertyDynamicParameters(Path[0], propertyName, Destination, propertyName, context);
}
return InvokeProvider.Property.MovePropertyDynamicParameters(
".",
propertyName,
Destination,
propertyName,
context);
} // GetDynamicParameters
internal string ParseParent(string path, string root, CmdletProviderContext context)
{
return(this.sessionState.GetParentPath(path, root, context, false));
}
} // SetLocation
/// <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);
} // IsCurrentLocationOrAncestor
internal string ParseParent(string path, string root, CmdletProviderContext context, bool useDefaultProvider)
{
return(this.sessionState.GetParentPath(path, root, context, useDefaultProvider));
}
internal void Remove(string path, string propertyName, CmdletProviderContext context)
{
this.sessionState.RemoveProperty(new string[] { path }, propertyName, context);
}
internal PathInfo SetLocation(string path, CmdletProviderContext context)
{
return(this.sessionState.SetLocation(path, context));
}
internal void Rename(string path, string sourceProperty, string destinationProperty, CmdletProviderContext context)
{
this.sessionState.RenameProperty(new string[] { path }, sourceProperty, destinationProperty, context);
}
internal string Combine(string parent, string child, CmdletProviderContext context)
{
return(this.sessionState.MakePath(parent, child, context));
}
/// <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(nameof(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(
nameof(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);
}
internal Collection <string> GetResolvedProviderPathFromProviderPath(string path, string providerId, CmdletProviderContext context)
{
CmdletProvider providerInstance = null;
return(this.PathResolver.GetGlobbedProviderPathsFromProviderPath(path, false, providerId, context, out providerInstance));
}
internal bool HasChild(string path, CmdletProviderContext context)
{
return(this.sessionState.HasChildItems(path, context));
}
internal Collection <PathInfo> GetResolvedPSPathFromPSPath(string path, CmdletProviderContext context)
{
CmdletProvider providerInstance = null;
return(this.PathResolver.GetGlobbedMonadPathsFromMonadPath(path, false, context, out providerInstance));
}
internal object GetChildNamesDynamicParameters(string path, CmdletProviderContext context)
{
return(this.sessionState.GetChildNamesDynamicParameters(path, context));
}
/// <summary>
/// Get provider specific help info.
/// </summary>
internal MamlCommandHelpInfo GetProviderSpecificHelpInfo(string helpItemName)
{
if (InternalTestHooks.BypassOnlineHelpRetrieval)
{
// By returning null, we force get-help to return generic help
// which includes a helpUri that points to the fwlink defined in the cmdlet code.
return(null);
}
// Get the provider.
ProviderInfo providerInfo = null;
PSDriveInfo driveInfo = null;
string resolvedProviderPath = null;
CmdletProviderContext cmdletProviderContext = new CmdletProviderContext(_executionContext);
try
{
string psPath = _requestedPath;
if (string.IsNullOrEmpty(_requestedPath))
{
psPath = _pathIntrinsics.CurrentLocation.Path;
}
resolvedProviderPath = _executionContext.LocationGlobber.GetProviderPath(
psPath,
cmdletProviderContext,
out providerInfo,
out driveInfo);
}
// ignore exceptions caused by provider resolution
catch (ArgumentNullException)
{
}
catch (ProviderNotFoundException)
{
}
catch (DriveNotFoundException)
{
}
catch (ProviderInvocationException)
{
}
catch (NotSupportedException)
{
}
catch (InvalidOperationException)
{
}
catch (ItemNotFoundException)
{
}
if (providerInfo is null)
{
return(null);
}
// Does the provider know how to generate MAML.
CmdletProvider cmdletProvider = providerInfo.CreateInstance();
ICmdletProviderSupportsHelp provider = cmdletProvider as ICmdletProviderSupportsHelp;
// Under JEA sessions the resolvedProviderPath will be null, we should allow get-help to continue.
if (provider is null)
{
return(null);
}
bool isJEASession = false;
if (this._executionContext.InitialSessionState != null && this._executionContext.InitialSessionState.Providers != null && providerInfo != null)
{
foreach (
Runspaces.SessionStateProviderEntry sessionStateProvider in
this._executionContext.InitialSessionState.Providers[providerInfo.Name])
{
if (sessionStateProvider.Visibility == SessionStateEntryVisibility.Private)
{
isJEASession = true;
break;
}
}
}
if (resolvedProviderPath is null)
{
if (isJEASession)
{
return(null);
}
else
{
throw new ItemNotFoundException(_requestedPath, "PathNotFound", SessionStateStrings.PathNotFound);
}
}
// ok we have path and valid provider that supplys content..initialize the provider
// and get the help content for the path.
cmdletProvider.Start(providerInfo, cmdletProviderContext);
// There should be exactly one resolved path.
string providerPath = resolvedProviderPath;
// Get the MAML help info. Don't catch exceptions thrown by provider.
string mamlXmlString = provider.GetHelpMaml(helpItemName, providerPath);
if (string.IsNullOrEmpty(mamlXmlString))
{
return(null);
}
// process the MAML content only if it is non-empty.
XmlDocument mamlDoc = InternalDeserializer.LoadUnsafeXmlDocument(
mamlXmlString,
false, /* ignore whitespace, comments, etc. */
null); /* default maxCharactersInDocument */
MamlCommandHelpInfo providerSpecificHelpInfo = MamlCommandHelpInfo.Load(mamlDoc.DocumentElement, HelpCategory.Provider);
return(providerSpecificHelpInfo);
}
internal void Get(string path, bool recurse, CmdletProviderContext context)
{
this.sessionState.GetChildItems(path, recurse, context);
}
private void SetSecurityDescriptor(
CmdletProvider providerInstance,
string path,
ObjectSecurity securityDescriptor,
CmdletProviderContext context)
{
// All parameters should have been validated by caller
Diagnostics.Assert(
providerInstance != null,
"Caller should validate providerInstance before calling this method");
Diagnostics.Assert(
path != null,
"Caller should validate path before calling this method");
Diagnostics.Assert(
securityDescriptor != null,
"Caller should validate securityDescriptor before calling this method");
Diagnostics.Assert(
context != null,
"Caller should validate context before calling this method");
// This just verifies that the provider supports the interface.
GetPermissionProviderInstance(providerInstance);
try
{
providerInstance.SetSecurityDescriptor(path, securityDescriptor, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (PrivilegeNotHeldException e)
{
//
// thrown if one tries to set SACL and does not have
// SeSecurityPrivilege
//
context.WriteError(new ErrorRecord(e, e.GetType().FullName, ErrorCategory.PermissionDenied, path));
}
catch (UnauthorizedAccessException e)
{
//
// thrown if
// -- owner or pri. group are invalid OR
// -- marta returns ERROR_ACCESS_DENIED
//
context.WriteError(new ErrorRecord(e, e.GetType().FullName, ErrorCategory.PermissionDenied, path));
}
catch (NotSupportedException e)
{
//
// thrown if path points to an item that does not
// support access control.
//
// for example, FAT or FAT32 file in case of file system provider
//
context.WriteError(new ErrorRecord(e, e.GetType().FullName, ErrorCategory.InvalidOperation, path));
}
catch (SystemException e)
{
//
// thrown if the CLR gets back unexpected error
// from OS security or marta
//
context.WriteError(new ErrorRecord(e, e.GetType().FullName, ErrorCategory.InvalidOperation, path));
}
catch (Exception e) // Catch-all OK, 3rd party callout.
{
throw NewProviderInvocationException(
"SetSecurityDescriptorProviderException",
SessionStateStrings.SetSecurityDescriptorProviderException,
providerInstance.ProviderInfo,
path,
e);
}
}
} // GetContentReaders
/// <summary>
/// Resolves the specified paths to PathInfo objects
/// </summary>
///
/// <param name="pathsToResolve">
/// The paths to be resolved. Each path may contain glob characters.
/// </param>
///
/// <param name="allowNonexistingPaths">
/// If true, resolves the path even if it doesn't exist.
/// </param>
///
/// <param name="allowEmptyResult">
/// If true, allows a wildcard that returns no results.
/// </param>
///
/// <param name="currentCommandContext">
/// The context under which the command is running.
/// </param>
///
/// <returns>
/// An array of PathInfo objects that are the resolved paths for the
/// <paramref name="pathsToResolve"/> parameter.
/// </returns>
///
internal Collection<PathInfo> ResolvePaths(
string[] pathsToResolve,
bool allowNonexistingPaths,
bool allowEmptyResult,
CmdletProviderContext currentCommandContext)
{
Collection<PathInfo> results = new Collection<PathInfo>();
foreach (string path in pathsToResolve)
{
bool pathNotFound = false;
bool filtersHidPath = false;
ErrorRecord pathNotFoundErrorRecord = null;
try
{
// First resolve each of the paths
Collection<PathInfo> pathInfos =
SessionState.Path.GetResolvedPSPathFromPSPath(
path,
currentCommandContext);
if (pathInfos.Count == 0)
{
pathNotFound = true;
// If the item simply did not exist,
// we would have got an ItemNotFoundException.
// If we get here, it's because the filters
// excluded the file.
if (!currentCommandContext.SuppressWildcardExpansion)
{
filtersHidPath = true;
}
}
foreach (PathInfo pathInfo in pathInfos)
{
results.Add(pathInfo);
}
}
catch (PSNotSupportedException notSupported)
{
WriteError(
new ErrorRecord(
notSupported.ErrorRecord,
notSupported));
}
catch (DriveNotFoundException driveNotFound)
{
WriteError(
new ErrorRecord(
driveNotFound.ErrorRecord,
driveNotFound));
}
catch (ProviderNotFoundException providerNotFound)
{
WriteError(
new ErrorRecord(
providerNotFound.ErrorRecord,
providerNotFound));
}
catch (ItemNotFoundException pathNotFoundException)
{
pathNotFound = true;
pathNotFoundErrorRecord = new ErrorRecord(pathNotFoundException.ErrorRecord, pathNotFoundException);
}
if (pathNotFound)
{
if (allowNonexistingPaths &&
(!filtersHidPath) &&
(currentCommandContext.SuppressWildcardExpansion ||
(!WildcardPattern.ContainsWildcardCharacters(path))))
{
ProviderInfo provider = null;
PSDriveInfo drive = null;
string unresolvedPath =
SessionState.Path.GetUnresolvedProviderPathFromPSPath(
path,
currentCommandContext,
out provider,
out drive);
PathInfo pathInfo =
new PathInfo(
drive,
provider,
unresolvedPath,
SessionState);
results.Add(pathInfo);
}
else
{
if (pathNotFoundErrorRecord == null)
{
// Detect if the path resolution failed to resolve to a file.
String error = StringUtil.Format(NavigationResources.ItemNotFound, Path);
Exception e = new Exception(error);
pathNotFoundErrorRecord = new ErrorRecord(
e,
"ItemNotFound",
ErrorCategory.ObjectNotFound,
Path);
}
WriteError(pathNotFoundErrorRecord);
}
}
}
return results;
} // ResolvePaths
internal void New(string path, string propertyName, string type, object value, CmdletProviderContext context)
{
this.sessionState.NewProperty(new string[] { path }, propertyName, type, value, context);
}
internal bool IsCurrentLocationOrAncestor(string path, CmdletProviderContext context)
{
return(this.sessionState.IsCurrentLocationOrAncestor(path, context));
}
} // 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
