} // RemoveDrive
/// <summary>
/// Removes the drive with the specified name.
/// </summary>
///
/// <param name="driveName">
/// The name of the drive to remove.
/// </param>
///
/// <param name="force">
/// Determines whether drive should be forcefully removed even if there was errors.
/// </param>
///
/// <param name="scopeID">
/// The ID of the scope from which to remove the drive.
/// If the scope ID is null or empty, the scope hierarchy will be searched
/// starting at the current scope through all the parent scopes to the
/// global scope until a drive of the given name is found to remove.
/// </param>
///
/// <param name="context">
/// The context of the command.
/// </param>
///
internal void RemoveDrive(
string driveName,
bool force,
string scopeID,
CmdletProviderContext context)
{
if (driveName == null)
{
throw PSTraceSource.NewArgumentNullException("driveName");
}
Dbg.Diagnostics.Assert(
context != null,
"The caller should verify the context");
PSDriveInfo drive = GetDrive(driveName, scopeID);
if (drive == null)
{
DriveNotFoundException e = new DriveNotFoundException(
driveName,
"DriveNotFound",
SessionStateStrings.DriveNotFound);
context.WriteError(new ErrorRecord(e.ErrorRecord, e));
}
else
{
RemoveDrive(drive, force, scopeID, context);
}
} // RemoveDrive
internal void WriteErrorsToContext(CmdletProviderContext errorContext)
{
if (errorContext == null)
{
throw PSTraceSource.NewArgumentNullException("errorContext");
}
if (this.HasErrors())
{
foreach (ErrorRecord record in this.GetAccumulatedErrorObjects())
{
errorContext.WriteError(record);
}
}
}
/// <summary>
/// Writes all the accumulated errors to the specified context using WriteError.
/// </summary>
/// <param name="errorContext">
/// The context to write the errors to.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="errorContext"/> is null.
/// </exception>
internal void WriteErrorsToContext(CmdletProviderContext errorContext)
{
if (errorContext is null)
{
throw PSTraceSource.NewArgumentNullException(nameof(errorContext));
}
if (HasErrors())
{
foreach (ErrorRecord errorRecord in GetAccumulatedErrorObjects())
{
errorContext.WriteError(errorRecord);
}
}
}
private PSDriveInfo ValidateDriveWithProvider(
DriveCmdletProvider driveProvider,
PSDriveInfo drive,
CmdletProviderContext context,
bool resolvePathIfPossible)
{
Dbg.Diagnostics.Assert(
drive != null,
"drive should have been validated by the caller");
Dbg.Diagnostics.Assert(
driveProvider != null,
"driveProvider should have been validated by the caller");
// Mark the drive as being created so that the provider can modify the
// root if necessary
drive.DriveBeingCreated = true;
// Only try to resolve the root as an MSH path if there is a current drive.
if (CurrentDrive != null && resolvePathIfPossible)
{
string newRoot = GetProviderRootFromSpecifiedRoot(drive.Root, drive.Provider);
if (newRoot != null)
{
drive.SetRoot(newRoot);
}
}
PSDriveInfo result = null;
try
{
result = driveProvider.NewDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception e) // Catch-all OK, 3rd party callout
{
CommandProcessorBase.CheckForSevereException(e);
ProviderInvocationException pie =
NewProviderInvocationException(
"NewDriveProviderException",
SessionStateStrings.NewDriveProviderException,
driveProvider.ProviderInfo,
drive.Root,
e);
context.WriteError(
new ErrorRecord(
pie.ErrorRecord,
pie));
}
finally
{
drive.DriveBeingCreated = false;
}
return result;
} // ValidateDriveWithProvider
} // GenerateNewPathsWithGlobLeaf
/// <summary>
/// Gets the child names in the specified path by using the provider
/// </summary>
///
/// <param name="dir">
/// The path of the directory to get the child names from. If this is an Msh Path,
/// dirIsProviderPath must be false, If this is a provider-internal path,
/// dirIsProviderPath must be true.
/// </param>
///
/// <param name="leafElement">
/// The element that we are ultimately looking for. Used to set filters on the context
/// if desired.
/// </param>
///
/// <param name="getAllContainers">
/// Determines if the GetChildNames call should get all containers even if they don't
/// match the filter.
/// </param>
///
/// <param name="context">
/// The context to be used for the command. The context is copied to a new context, the
/// results are accumulated and then returned.
/// </param>
///
/// <param name="dirIsProviderPath">
/// Specifies whether the dir parameter is a provider-internal path (true) or Msh Path (false).
/// </param>
///
/// <param name="drive">
/// The drive to use to qualify the Msh path if dirIsProviderPath is false.
/// </param>
///
/// <param name="provider">
/// The provider to use to get the child names.
/// </param>
///
/// <param name="modifiedDirPath">
/// Returns the modified dir path. If dirIsProviderPath is true, this is the unescaped dir path.
/// If dirIsProviderPath is false, this is the unescaped resolved provider path.
/// </param>
///
/// <returns>
/// A collection of PSObjects whose BaseObject is a string that contains the name of the child.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="dir"/> or <paramref name="drive"/> 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 associated with the <paramref name="path"/> threw an
/// exception when its GetParentPath or MakePath was called while
/// processing the <paramref name="path"/>.
/// </exception>
///
/// <exception cref="PipelineStoppedException">
/// If <paramref name="context"/> has been signaled for
/// StopProcessing.
/// </exception>
///
/// <exception>
/// Any exception can be thrown by the provider that is called to build
/// the provider path.
/// </exception>
///
private Collection<PSObject> GetChildNamesInDir(
string dir,
string leafElement,
bool getAllContainers,
CmdletProviderContext context,
bool dirIsProviderPath,
PSDriveInfo drive,
ContainerCmdletProvider provider,
out string modifiedDirPath)
{
// See if the provider wants to convert the path and filter
string convertedPath = null;
string convertedFilter = null;
string originalFilter = context.Filter;
bool changedPathOrFilter = provider.ConvertPath(leafElement, context.Filter, ref convertedPath, ref convertedFilter, context);
if (changedPathOrFilter)
{
if (s_tracer.IsEnabled)
{
s_tracer.WriteLine("Provider converted path and filter.");
s_tracer.WriteLine("Original path: {0}", leafElement);
s_tracer.WriteLine("Converted path: {0}", convertedPath);
s_tracer.WriteLine("Original filter: {0}", context.Filter);
s_tracer.WriteLine("Converted filter: {0}", convertedFilter);
}
leafElement = convertedPath;
context.Filter = convertedFilter;
}
ReturnContainers returnContainers = ReturnContainers.ReturnAllContainers;
if (!getAllContainers)
{
returnContainers = ReturnContainers.ReturnMatchingContainers;
}
CmdletProviderContext getChildNamesContext =
new CmdletProviderContext(context);
// Remove the include/exclude filters from the new context
getChildNamesContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
context.Filter);
try
{
// Use the provider to get the children
string unescapedDir = null;
modifiedDirPath = null;
if (dirIsProviderPath)
{
modifiedDirPath = unescapedDir = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
}
else
{
Dbg.Diagnostics.Assert(
drive != null,
"Caller should verify that drive is not null when dirIsProviderPath is false");
// If the directory is an MSH path we must resolve it before calling GetChildNames()
// -- If the path is passed in by LiteralPath (context.SuppressWildcardExpansion == false), we surely should use 'dir' unchanged.
// -- If the path is passed in by Path (context.SuppressWildcardExpansion == true), we still should use 'dir' unchanged, in case that the special character
// in 'dir' is escaped
modifiedDirPath = GetMshQualifiedPath(dir, drive);
ProviderInfo providerIgnored = null;
CmdletProvider providerInstanceIgnored = null;
Collection<string> resolvedPaths =
GetGlobbedProviderPathsFromMonadPath(
modifiedDirPath,
false,
getChildNamesContext,
out providerIgnored,
out providerInstanceIgnored);
// After resolving the path, we unescape the modifiedDirPath if necessary.
modifiedDirPath = context.SuppressWildcardExpansion
? modifiedDirPath
: RemoveGlobEscaping(modifiedDirPath);
if (resolvedPaths.Count > 0)
{
unescapedDir = resolvedPaths[0];
}
else
{
// If there were no results from globbing but no
// exception was thrown, that means there was filtering.
// So return an empty collection and let the caller deal
// with it.
if (changedPathOrFilter)
{
context.Filter = originalFilter;
}
return new Collection<PSObject>();
}
}
if (provider.HasChildItems(unescapedDir, getChildNamesContext))
{
provider.GetChildNames(
unescapedDir,
returnContainers,
getChildNamesContext);
}
// First check to see if there were any errors, and write them
// to the real context if there are.
if (getChildNamesContext.HasErrors())
{
Collection<ErrorRecord> errors = getChildNamesContext.GetAccumulatedErrorObjects();
if (errors != null &&
errors.Count > 0)
{
foreach (ErrorRecord errorRecord in errors)
{
context.WriteError(errorRecord);
}
}
}
Collection<PSObject> childNamesObjectArray = getChildNamesContext.GetAccumulatedObjects();
if (changedPathOrFilter)
{
context.Filter = originalFilter;
}
return childNamesObjectArray;
}
finally
{
getChildNamesContext.RemoveStopReferral();
}
} // GetChildNamesInDir
private PSDriveInfo ValidateDriveWithProvider(DriveCmdletProvider driveProvider, PSDriveInfo drive, CmdletProviderContext context, bool resolvePathIfPossible)
{
drive.DriveBeingCreated = true;
if ((this.CurrentDrive != null) && resolvePathIfPossible)
{
string providerRootFromSpecifiedRoot = this.GetProviderRootFromSpecifiedRoot(drive.Root, drive.Provider);
if (providerRootFromSpecifiedRoot != null)
{
drive.SetRoot(providerRootFromSpecifiedRoot);
}
}
PSDriveInfo info = null;
try
{
info = driveProvider.NewDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
ProviderInvocationException replaceParentContainsErrorRecordException = this.NewProviderInvocationException("NewDriveProviderException", SessionStateStrings.NewDriveProviderException, driveProvider.ProviderInfo, drive.Root, exception);
context.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
}
finally
{
drive.DriveBeingCreated = false;
}
return info;
}
internal void RenameItem(string path, string newName, CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
Collection<string> targetObject = this.Globber.GetGlobbedProviderPathsFromMonadPath(path, false, context, out info, out providerInstance);
if (targetObject.Count == 1)
{
this.RenameItem(providerInstance, targetObject[0], newName, context);
}
else
{
ArgumentException exception = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "RenameMultipleItemError", new object[0]);
context.WriteError(new ErrorRecord(exception, "RenameMultipleItemError", ErrorCategory.InvalidArgument, targetObject));
}
}
internal void RemoveDrive(string driveName, bool force, string scopeID, CmdletProviderContext context)
{
if (driveName == null)
{
throw PSTraceSource.NewArgumentNullException("driveName");
}
PSDriveInfo drive = this.GetDrive(driveName, scopeID);
if (drive == null)
{
System.Management.Automation.DriveNotFoundException replaceParentContainsErrorRecordException = new System.Management.Automation.DriveNotFoundException(driveName, "DriveNotFound", SessionStateStrings.DriveNotFound);
context.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
}
else
{
this.RemoveDrive(drive, force, scopeID, context);
}
}
internal string NormalizeRelativePath(string path, string basePath, CmdletProviderContext context)
{
string str2;
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
CmdletProviderContext context2 = new CmdletProviderContext(context);
try
{
PSDriveInfo drive = null;
ProviderInfo provider = null;
string str = this.Globber.GetProviderPath(path, context2, out provider, out drive);
if (context2.HasErrors())
{
context2.WriteErrorsToContext(context);
return null;
}
if ((str == null) || (provider == null))
{
Exception exception = PSTraceSource.NewArgumentException("path");
context.WriteError(new ErrorRecord(exception, "NormalizePathNullResult", ErrorCategory.InvalidArgument, path));
return null;
}
if (drive != null)
{
context.Drive = drive;
if (((this.GetProviderInstance(provider) is NavigationCmdletProvider) && !string.IsNullOrEmpty(drive.Root)) && path.StartsWith(drive.Root, StringComparison.OrdinalIgnoreCase))
{
str = path;
}
}
str2 = this.NormalizeRelativePath(provider, str, basePath, context);
}
finally
{
context2.RemoveStopReferral();
}
return str2;
}
} // MoveItem
/// <summary>
/// Moves the item specified by path to the specified destination.
/// </summary>
///
/// <param name="paths">
/// The path(s) to the item(s) to be moved.
/// </param>
///
/// <param name="destination">
/// The path of the destination container.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// Nothing. All items that are moved are written into the context object.
/// </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>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void MoveItem(
string[] paths,
string destination,
CmdletProviderContext context)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
if (destination == null)
{
throw PSTraceSource.NewArgumentNullException("destination");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
Collection<PathInfo> providerDestinationPaths =
Globber.GetGlobbedMonadPathsFromMonadPath(
destination,
true,
context,
out providerInstance);
if (providerDestinationPaths.Count > 1)
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"destination",
SessionStateStrings.MoveItemOneDestination);
context.WriteError(new ErrorRecord(argException, argException.GetType().FullName, ErrorCategory.InvalidArgument, destination));
}
else
{
foreach (string path in paths)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
false,
context,
out provider,
out providerInstance);
// Check to be sure we resolved at least one item to move and that the
// destination is a container.
if (providerPaths.Count > 1 &&
providerDestinationPaths.Count > 0 &&
!IsItemContainer(providerDestinationPaths[0].Path))
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.MoveItemPathMultipleDestinationNotContainer);
context.WriteError(new ErrorRecord(argException, argException.GetType().FullName, ErrorCategory.InvalidArgument, providerDestinationPaths[0]));
}
else
{
PSDriveInfo unusedPSDriveInfo = null;
ProviderInfo destinationProvider = null;
CmdletProviderContext destinationContext = new CmdletProviderContext(this.ExecutionContext);
string destinationProviderInternalPath = null;
if (providerDestinationPaths.Count > 0)
{
destinationProviderInternalPath =
Globber.GetProviderPath(
providerDestinationPaths[0].Path,
destinationContext,
out destinationProvider,
out unusedPSDriveInfo);
}
else
{
// Since the path doesn't exist, just convert it to a
// provider path and continue.
destinationProviderInternalPath =
Globber.GetProviderPath(
destination,
destinationContext,
out destinationProvider,
out unusedPSDriveInfo);
}
// Now verify the providers are the same.
if (!String.Equals(
provider.FullName,
destinationProvider.FullName,
StringComparison.OrdinalIgnoreCase))
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"destination",
SessionStateStrings.MoveItemSourceAndDestinationNotSameProvider);
context.WriteError(new ErrorRecord(argException, argException.GetType().FullName, ErrorCategory.InvalidArgument, providerPaths));
}
else
{
foreach (string providerPath in providerPaths)
{
MoveItemPrivate(providerInstance, providerPath, destinationProviderInternalPath, context);
}
}
}
}
}
} // MoveItem
private bool isValidSession(PSSession session, CmdletProviderContext context, out PSLanguageMode? languageMode)
{
// session == null is validated by the parameter binding
if (session.Availability != RunspaceAvailability.Available)
{
context.WriteError(new ErrorRecord(
new InvalidOperationException(
String.Format(System.Globalization.CultureInfo.InvariantCulture,
SessionStateStrings.CopyItemSessionProperties,
"Availability", session.Availability)),
"SessionIsNotAvailable",
ErrorCategory.InvalidOperation,
session.Availability));
languageMode = null;
return false;
}
languageMode = session.Runspace.SessionStateProxy.LanguageMode;
return true;
}
} // CopyItemDynamicParameters
// This function validates a remote path, and if it exists, it returns the root path.
//
private string ValidateRemotePathAndGetRoot(string path, Runspaces.PSSession session, CmdletProviderContext context, PSLanguageMode? languageMode, bool sourceIsRemote)
{
Hashtable op = null;
using (PowerShell ps = PowerShell.Create())
{
ps.Runspace = session.Runspace;
// Check to see if the remote PSSession is running in constrained or no language mode and if so
// then also if the path validation function already exists in the session (for the User drive
// custom endpoint case). Otherwise error out.
if (languageMode.HasValue &&
(languageMode.Value == PSLanguageMode.ConstrainedLanguage || languageMode.Value == PSLanguageMode.NoLanguage))
{
var psRemoteUtilsName = CopyFileRemoteUtils.PSCopyRemoteUtilsName;
ps.Runspace = session.Runspace;
ps.AddCommand("Get-Command").AddArgument(psRemoteUtilsName);
var result = ps.Invoke<bool>();
if (result.Count == 0)
{
context.WriteError(new ErrorRecord(
new InvalidOperationException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
SessionStateStrings.CopyItemSessionProperties,
"LanguageMode",
session.Runspace.SessionStateProxy.LanguageMode)
),
"SessionIsNotInFullLanguageMode",
ErrorCategory.InvalidOperation,
session.Availability
)
);
return null;
}
ps.Commands.Clear();
ps.Streams.ClearStreams();
ps.AddCommand(psRemoteUtilsName);
}
else
{
string remoteScript = CopyFileRemoteUtils.PSValidatePathDefinition;
ps.AddScript(remoteScript);
}
ps.AddParameter("pathToValidate", path);
if (sourceIsRemote)
{
ps.AddParameter("sourceIsRemote", true);
}
op = Microsoft.PowerShell.Commands.SafeInvokeCommand.Invoke(ps, null, context);
}
if (op == null)
{
context.WriteError(new ErrorRecord(
new InvalidOperationException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture, SessionStateStrings.CopyItemValidateRemotePath, path)),
"FailedToValidateRemotePath",
ErrorCategory.InvalidOperation,
path));
return null;
}
// If the remote path is not absolute, display an error to the user.
if (op["IsAbsolute"] != null)
{
bool isAbsolute = (bool)op["IsAbsolute"];
if (!isAbsolute)
{
context.WriteError(new ErrorRecord(
new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture, SessionStateStrings.CopyItemRemotelyPathIsNotAbsolute, path)),
"RemotePathIsNotAbsolute",
ErrorCategory.InvalidArgument,
path));
return null;
}
}
bool pathExist = false;
string root = null;
if (op["Exists"] != null)
pathExist = (bool)op["Exists"];
if (op["Root"] != null)
root = (string)op["Root"];
// Here there are two scenarios:
// 1) If the source is remote and the path does not exist, error out.
bool invalidRemoteSource = (sourceIsRemote && (!pathExist));
// 2) For a remote destination, if the root does not exist, error out.
bool invalidRemoteDestination = (root == null);
if (invalidRemoteSource || invalidRemoteDestination)
{
context.WriteError(new ErrorRecord(
new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture, SessionStateStrings.PathNotFound, path)),
"RemotePathNotFound",
ErrorCategory.InvalidArgument,
path));
return null;
}
return root;
}
} // CopyItem
/// <summary>
/// Copies an item at the specified path to an item at the <paramref name="copyPath" />.
/// </summary>
///
/// <param name="paths">
/// The path(s) of the item(s) to copy.
/// </param>
///
/// <param name="copyPath">
/// The path of the item to copy to.
/// </param>
///
/// <param name="recurse">
/// Tells the provider to recurse sub-containers when copying.
/// </param>
///
/// <param name="copyContainers">
/// Determines how the source container is used in the copy operation.
/// </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 CopyItem(
string[] paths,
string copyPath,
bool recurse,
CopyContainers copyContainers,
CmdletProviderContext context)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
if (copyPath == null)
{
copyPath = String.Empty;
}
// Get the provider specific path for the destination
PSDriveInfo unusedDrive = null;
ProviderInfo destinationProvider = null;
Microsoft.PowerShell.Commands.CopyItemDynamicParameters dynamicParams = context.DynamicParameters as Microsoft.PowerShell.Commands.CopyItemDynamicParameters;
bool destinationIsRemote = false;
bool sourceIsRemote = false;
string providerDestinationPath;
Runspaces.PSSession session = null;
if (dynamicParams != null)
{
if (dynamicParams.FromSession != null)
{
sourceIsRemote = true;
session = dynamicParams.FromSession;
}
if (dynamicParams.ToSession != null)
{
destinationIsRemote = true;
session = dynamicParams.ToSession;
}
}
if (sourceIsRemote && destinationIsRemote)
{
context.WriteError(new ErrorRecord(
new ArgumentException(
String.Format(System.Globalization.CultureInfo.InvariantCulture, SessionStateStrings.CopyItemFromSessionToSession, "FromSession", "ToSession")),
"InvalidInput",
ErrorCategory.InvalidArgument,
dynamicParams));
return;
}
// Validate that the session is available and the language mode is not set to ConstrainedLanguage or NoLanguage.
PSLanguageMode? remoteLanguageMode = null;
if (sourceIsRemote || destinationIsRemote)
{
if (!isValidSession(session, context, out remoteLanguageMode))
{
return;
}
}
if (!destinationIsRemote)
{
providerDestinationPath =
Globber.GetProviderPath(
copyPath,
context,
out destinationProvider,
out unusedDrive);
}
else
{
// Validate remote destination path
providerDestinationPath = copyPath;
if (String.IsNullOrEmpty(providerDestinationPath))
{
context.WriteError(new ErrorRecord(
new ArgumentNullException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
SessionStateStrings.CopyItemRemotelyPathIsNullOrEmpty,
"Destination")),
"CopyItemRemoteDestinationIsNullOrEmpty",
ErrorCategory.InvalidArgument,
providerDestinationPath));
return;
}
string root = ValidateRemotePathAndGetRoot(providerDestinationPath, session, context, remoteLanguageMode, false);
if (root == null)
{
return;
}
}
s_tracer.WriteLine("providerDestinationPath = {0}", providerDestinationPath);
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
foreach (string path in paths)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
Collection<string> providerPaths;
if (sourceIsRemote)
{
// Get the root for the remote path
string root = ValidateRemotePathAndGetRoot(path, session, context, remoteLanguageMode, true);
if (root == null)
{
return;
}
providerInstance = ExecutionContext.SessionState.Internal.GetProviderInstance("FileSystem");
providerPaths = new Collection<string>();
providerPaths.Add(path);
}
else
{
providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
false,
context,
out provider,
out providerInstance);
}
// Ensure that the source and destination are the same provider. Copying between
// providers is not supported
if (!sourceIsRemote && !destinationIsRemote && provider != destinationProvider)
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.CopyItemSourceAndDestinationNotSameProvider);
context.WriteError(
new ErrorRecord(
argException,
"CopyItemSourceAndDestinationNotSameProvider",
ErrorCategory.InvalidArgument,
providerPaths));
return;
}
bool destinationIsContainer = false;
if (!destinationIsRemote)
{
destinationIsContainer = IsItemContainer(
providerInstance,
providerDestinationPath,
context);
s_tracer.WriteLine("destinationIsContainer = {0}", destinationIsContainer);
}
foreach (string providerPath in providerPaths)
{
// Making sure to obey the StopProcessing.
if (context.Stopping)
{
return;
}
if (sourceIsRemote || destinationIsRemote)
{
CopyItem(
providerInstance,
providerPath,
providerDestinationPath,
recurse,
context);
continue;
}
bool sourceIsContainer =
IsItemContainer(
providerInstance,
providerPath,
context);
s_tracer.WriteLine("sourcIsContainer = {0}", sourceIsContainer);
if (sourceIsContainer)
{
if (destinationIsContainer)
{
if (!recurse && copyContainers == CopyContainers.CopyChildrenOfTargetContainer)
{
// Copying a container to a container without the -container or -recurse
// switch is an error.
Exception e =
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.CopyContainerToContainerWithoutRecurseOrContainer);
context.WriteError(new ErrorRecord(
e,
"CopyContainerToContainerWithoutRecurseOrContainer",
ErrorCategory.InvalidArgument,
providerPath));
}
else if (recurse && copyContainers == CopyContainers.CopyChildrenOfTargetContainer)
{
// Copy all the leaf items to a single container
CopyRecurseToSingleContainer(
providerInstance,
providerPath,
providerDestinationPath,
context);
}
else
{
// Call the provider to do a recurse copy of all the items
CopyItem(
providerInstance,
providerPath,
providerDestinationPath,
recurse,
context);
}
}
else
{
// Since we know the destination isn't a container, check to
// see if it exists.
if (ItemExists(providerInstance, providerDestinationPath, context))
{
// Since the item exists and is not a container it must
// be a leaf. Copying a container to a leaf is an error
Exception e =
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.CopyContainerItemToLeafError);
context.WriteError(new ErrorRecord(
e,
"CopyContainerItemToLeafError",
ErrorCategory.InvalidArgument,
providerPath));
}
else
{
// Copy the container to a non-existing path
CopyItem(
providerInstance,
providerPath,
providerDestinationPath,
recurse,
context);
}
}
}
else
{
// Copy a leaf to the destination
CopyItem(
providerInstance,
providerPath,
providerDestinationPath,
recurse,
context);
}
}
}
} // CopyItem
} // RenameItem
/// <summary>
/// Renames the item at the specified path to the new name provided.
/// </summary>
///
/// <param name="path">
/// The path to the item to rename.
/// </param>
///
/// <param name="newName">
/// The name to which the item should be renamed. This name should always be
/// relative to the parent container.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <returns>
/// Nothing. All items that are renamed are written into the context object.
/// </returns>
///
/// <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>
///
/// <exception cref="ItemNotFoundException">
/// If <paramref name="path"/> does not contain glob characters and
/// could not be found.
/// </exception>
///
internal void RenameItem(
string path,
string newName,
CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
path,
false,
context,
out provider,
out providerInstance);
// Can only rename one item at a time, so if we glob more than
// one item write out an error.
if (providerPaths.Count == 1)
{
RenameItem(providerInstance, providerPaths[0], newName, context);
}
else
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"path",
SessionStateStrings.RenameMultipleItemError);
context.WriteError(
new ErrorRecord(
argException,
"RenameMultipleItemError",
ErrorCategory.InvalidArgument,
providerPaths));
}
} // RenameItem
internal void WriteErrorsToContext(CmdletProviderContext errorContext)
{
if (errorContext == null)
{
throw PSTraceSource.NewArgumentNullException("errorContext");
}
if (this.HasErrors())
{
foreach (ErrorRecord record in this.GetAccumulatedErrorObjects())
{
errorContext.WriteError(record);
}
}
}
internal void NewDrive(PSDriveInfo drive, string scopeID, CmdletProviderContext context)
{
if (drive == null)
{
throw PSTraceSource.NewArgumentNullException("drive");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
if (!IsValidDriveName(drive.Name))
{
throw PSTraceSource.NewArgumentException("drive.Name", "SessionStateStrings", "DriveNameIllegalCharacters", new object[0]);
}
PSDriveInfo newDrive = this.ValidateDriveWithProvider(drive, context, true);
if (newDrive != null)
{
if (string.Compare(newDrive.Name, drive.Name, true, Thread.CurrentThread.CurrentCulture) != 0)
{
throw this.NewProviderInvocationException("NewDriveProviderFailed", SessionStateStrings.NewDriveProviderFailed, drive.Provider, drive.Root, PSTraceSource.NewArgumentException("root"));
}
try
{
SessionStateScope currentScope = this.currentScope;
if (!string.IsNullOrEmpty(scopeID))
{
currentScope = this.GetScopeByID(scopeID);
}
currentScope.NewDrive(newDrive);
}
catch (ArgumentException exception2)
{
context.WriteError(new ErrorRecord(exception2, "NewDriveError", ErrorCategory.InvalidArgument, newDrive));
return;
}
catch (SessionStateException)
{
throw;
}
if (this.ProvidersCurrentWorkingDrive[drive.Provider] == null)
{
this.ProvidersCurrentWorkingDrive[drive.Provider] = drive;
}
context.WriteObject(newDrive);
}
}
} //NormalizeRelativePath
/// <summary>
/// Normalizes the path that was passed in and returns the normalized path
/// as a relative path to the basePath that was passed.
/// </summary>
///
/// <param name="path">
/// An MSH path to an item. The item should exist
/// or the provider should write out an error.
/// </param>
///
/// <param name="basePath">
/// The path that the return value should be relative to.
/// </param>
///
/// <param name="context">
/// The context under which the command is running.
/// </param>
///
/// <returns>
/// A normalized path that is relative to the basePath that was passed.
/// </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 NormalizeRelativePath(
string path,
string basePath,
CmdletProviderContext context)
{
if (path == null)
{
throw PSTraceSource.NewArgumentNullException("path");
}
CmdletProviderContext getProviderPathContext =
new CmdletProviderContext(context);
try
{
PSDriveInfo drive = null;
ProviderInfo provider = null;
string workingPath = Globber.GetProviderPath(
path,
getProviderPathContext,
out provider,
out drive);
if (getProviderPathContext.HasErrors())
{
getProviderPathContext.WriteErrorsToContext(context);
return null;
}
if (workingPath == null ||
provider == null)
{
// Since the provider didn't write an error, and we didn't get any
// results ourselves, we need to write out our own error.
Exception e = PSTraceSource.NewArgumentException("path");
context.WriteError(new ErrorRecord(e, "NormalizePathNullResult", ErrorCategory.InvalidArgument, path));
return null;
}
if (basePath != null)
{
PSDriveInfo baseDrive = null;
ProviderInfo baseProvider = null;
Globber.GetProviderPath(
basePath,
getProviderPathContext,
out baseProvider,
out baseDrive);
if (drive != null && baseDrive != null)
{
if (!drive.Name.Equals(baseDrive.Name, StringComparison.OrdinalIgnoreCase))
{
// Make sure they are from physically different drives
// Doing StartsWith from both directions covers the following cases
// C:\ and C:\Temp
// C:\Temp and C:\
if (!(drive.Root.StartsWith(baseDrive.Root, StringComparison.OrdinalIgnoreCase) ||
(baseDrive.Root.StartsWith(drive.Root, StringComparison.OrdinalIgnoreCase))))
{
// In this case, no normalization is necessary
return path;
}
}
}
}
if (drive != null)
{
context.Drive = drive;
// Detect if the original path was already a
// provider path. This happens when a drive doesn't
// have a rooted root -- such as HKEY_LOCAL_MACHINE instead of
// \\HKEY_LOCAL_MACHINE
if (
(GetProviderInstance(provider) is NavigationCmdletProvider) &&
(!String.IsNullOrEmpty(drive.Root)) &&
(path.StartsWith(drive.Root, StringComparison.OrdinalIgnoreCase)))
{
//
// If the drive root doesn't end with a path separator then there is a chance the
// path starts with the drive root name but doesn't actually refer to it. For example,
// (see Win8 bug 922001) consider drive with root HKEY_LOCAL_MACHINE named
// HKEY_LOCAL_MACHINE_foo. The path would start with the drive root but is not a provider
// path.
//
// We will remediate this by only considering this a provider path if
// 1. The drive root ends with a path separator.
// OR
// 2. The path starts with the drive root followed by a path separator
// OR
// 3. The path exactly matches the drive root.
//
// 1. Test for the drive root ending with a path separator.
bool driveRootEndsWithPathSeparator = IsPathSeparator(drive.Root[drive.Root.Length - 1]);
// 2. Test for the path starting with the drive root followed by a path separator
int indexAfterDriveRoot = drive.Root.Length;
bool pathStartsWithDriveRootAndPathSeparator = indexAfterDriveRoot < path.Length && IsPathSeparator(path[indexAfterDriveRoot]);
// 3. Test for the drive root exactly matching the path.
// Since we know the path starts with the drive root then they are equal if the lengths are equal.
bool pathEqualsDriveRoot = drive.Root.Length == path.Length;
if (driveRootEndsWithPathSeparator || pathStartsWithDriveRootAndPathSeparator || pathEqualsDriveRoot)
{
workingPath = path;
}
}
}
return NormalizeRelativePath(provider, workingPath, basePath, context);
}
finally
{
getProviderPathContext.RemoveStopReferral();
}
} // NormalizeRelativePath
internal void RemoveDrive(PSDriveInfo drive, bool force, string scopeID, CmdletProviderContext context)
{
bool flag = false;
try
{
flag = this.CanRemoveDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (ProviderInvocationException)
{
if (!force)
{
throw;
}
}
if (flag || force)
{
if (!string.IsNullOrEmpty(scopeID))
{
this.GetScopeByID(scopeID).RemoveDrive(drive);
if (this.ProvidersCurrentWorkingDrive[drive.Provider] == drive)
{
this.ProvidersCurrentWorkingDrive[drive.Provider] = null;
}
}
else
{
SessionStateScopeEnumerator enumerator = new SessionStateScopeEnumerator(this.CurrentScope);
foreach (SessionStateScope scope in (IEnumerable<SessionStateScope>) enumerator)
{
try
{
PSDriveInfo info = scope.GetDrive(drive.Name);
if (info != null)
{
scope.RemoveDrive(drive);
if (this.ProvidersCurrentWorkingDrive[drive.Provider] == info)
{
this.ProvidersCurrentWorkingDrive[drive.Provider] = null;
}
break;
}
}
catch (ArgumentException)
{
}
}
}
}
else
{
PSInvalidOperationException replaceParentContainsErrorRecordException = PSTraceSource.NewInvalidOperationException("SessionStateStrings", "DriveRemovalPreventedByProvider", new object[] { drive.Name, drive.Provider });
context.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
}
}
} // RemoveDrive
/// <summary>
/// Removes the specified drive.
/// </summary>
///
/// <param name="drive">
/// The drive to be removed.
/// </param>
///
/// <param name="force">
/// Determines whether drive should be forcefully removed even if there was errors.
/// </param>
///
/// <param name="scopeID">
/// The ID of the scope from which to remove the drive.
/// If the scope ID is null or empty, the scope hierarchy will be searched
/// starting at the current scope through all the parent scopes to the
/// global scope until a drive of the given name is found to remove.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="scopeID"/> is less than zero or greater than the number of currently
/// active scopes.
/// </exception>
///
internal void RemoveDrive(
PSDriveInfo drive,
bool force,
string scopeID,
CmdletProviderContext context)
{
// Make sure that the CanRemoveDrive is called even if we are forcing
// the removal because we want the provider to have a chance to
// cleanup.
bool canRemove = false;
try
{
canRemove = CanRemoveDrive(drive, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (ProviderInvocationException)
{
if (!force)
{
throw;
}
}
// Now remove the drive if there was no error or we are forcing the removal
if (canRemove || force)
{
// The scope ID wasn't defined or wasn't recognizable
// so do a search through the scopes looking for the
// drive.
if (String.IsNullOrEmpty(scopeID))
{
SessionStateScopeEnumerator scopeEnumerator =
new SessionStateScopeEnumerator(CurrentScope);
foreach (SessionStateScope scope in scopeEnumerator)
{
try
{
PSDriveInfo result = scope.GetDrive(drive.Name);
if (result != null)
{
scope.RemoveDrive(drive);
// If the drive is the current drive for the provider, remove
// it from the current drive list.
if (ProvidersCurrentWorkingDrive[drive.Provider] == result)
{
ProvidersCurrentWorkingDrive[drive.Provider] = null;
}
break;
}
}
catch (ArgumentException)
{
}
}
}
else
{
SessionStateScope scope = GetScopeByID(scopeID);
scope.RemoveDrive(drive);
// If the drive is the current drive for the provider, remove
// it from the current drive list.
if (ProvidersCurrentWorkingDrive[drive.Provider] == drive)
{
ProvidersCurrentWorkingDrive[drive.Provider] = null;
}
}
}
else
{
PSInvalidOperationException e =
(PSInvalidOperationException)
PSTraceSource.NewInvalidOperationException(
SessionStateStrings.DriveRemovalPreventedByProvider,
drive.Name,
drive.Provider);
context.WriteError(
new ErrorRecord(
e.ErrorRecord,
e));
}
} // RemoveDrive
internal void RemoveProvider(string providerName, bool force, CmdletProviderContext context)
{
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
if (string.IsNullOrEmpty(providerName))
{
throw PSTraceSource.NewArgumentException("providerName");
}
bool flag = false;
ProviderInfo singleProvider = null;
try
{
singleProvider = this.GetSingleProvider(providerName);
}
catch (ProviderNotFoundException)
{
return;
}
try
{
CmdletProvider providerInstance = this.GetProviderInstance(singleProvider);
if (providerInstance == null)
{
ProviderNotFoundException replaceParentContainsErrorRecordException = new ProviderNotFoundException(providerName, SessionStateCategory.CmdletProvider, "ProviderNotFound", SessionStateStrings.ProviderNotFound, new object[0]);
context.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
flag = true;
}
else
{
int num = 0;
foreach (PSDriveInfo info2 in this.GetDrivesForProvider(providerName))
{
if (info2 != null)
{
num++;
break;
}
}
if (num > 0)
{
if (force)
{
foreach (PSDriveInfo info3 in this.GetDrivesForProvider(providerName))
{
if (info3 != null)
{
this.RemoveDrive(info3, true, null);
}
}
}
else
{
flag = true;
SessionStateException exception2 = new SessionStateException(providerName, SessionStateCategory.CmdletProvider, "RemoveDrivesBeforeRemovingProvider", SessionStateStrings.RemoveDrivesBeforeRemovingProvider, ErrorCategory.InvalidOperation, new object[0]);
context.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
return;
}
}
try
{
providerInstance.Stop(context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
}
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
flag = true;
context.WriteError(new ErrorRecord(exception3, "RemoveProviderUnexpectedException", ErrorCategory.InvalidArgument, providerName));
}
finally
{
if (force || !flag)
{
MshLog.LogProviderLifecycleEvent(this.ExecutionContext, providerName, ProviderState.Stopped);
this.RemoveProviderFromCollection(singleProvider);
this.ProvidersCurrentWorkingDrive.Remove(singleProvider);
}
}
}
} // NewDrive
/// <summary>
/// Adds a drive to the PowerShell namespace.
/// </summary>
///
/// <param name="drive">
/// The new drive to be added.
/// </param>
///
/// <param name="scopeID">
/// The ID for the scope to add the drive to. The scope ID can be any of the
/// "special" scope identifiers like "global", "local", or "private" or it
/// can be a numeric identifier that is a count of the number of parent
/// scopes up from the current scope to put the drive in.
/// If this parameter is null or empty the drive will be placed in the
/// current scope.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="drive"/> or <paramref name="context"/> is null.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If the drive already exists
/// or
/// If <paramref name="drive"/>.Name contains one or more invalid characters; ~ / \\ . :
/// </exception>
///
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="scopeID"/> is less than zero or greater than the number of currently
/// active scopes.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider is not a DriveCmdletProvider.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// The provider for the <paramref name="drive"/> could not be found.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If the provider threw an exception or returned null.
/// </exception>
///
/// <exception cref="SessionStateOverflowException">
/// If creating the drive will overflow the MaximumDriveCount limit.
/// </exception>
///
internal void NewDrive(PSDriveInfo drive, string scopeID, CmdletProviderContext context)
{
if (drive == null)
{
throw PSTraceSource.NewArgumentNullException("drive");
}
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
if (!IsValidDriveName(drive.Name))
{
ArgumentException e =
PSTraceSource.NewArgumentException(
"drive.Name",
SessionStateStrings.DriveNameIllegalCharacters);
throw e;
}
// Allow the provider a chance to approve the drive and set
// provider specific data
PSDriveInfo result = ValidateDriveWithProvider(drive, context, true);
// We assume that the provider wrote the error message as they
// are suppose to.
if (result == null)
{
return;
}
if (String.Compare(result.Name, drive.Name, StringComparison.CurrentCultureIgnoreCase) == 0)
{
// Set the drive in the current scope.
try
{
SessionStateScope scope = _currentScope;
if (!String.IsNullOrEmpty(scopeID))
{
scope = GetScopeByID(scopeID);
}
scope.NewDrive(result);
}
catch (ArgumentException argumentException)
{
// Wrap up the exception and write it to the error stream
context.WriteError(
new ErrorRecord(
argumentException,
"NewDriveError",
ErrorCategory.InvalidArgument,
result));
return;
}
catch (SessionStateException)
{
// This should be a pipeline terminating condition
throw;
}
if (ProvidersCurrentWorkingDrive[drive.Provider] == null)
{
// Set the new drive as the current
// drive for the provider since there isn't one set.
ProvidersCurrentWorkingDrive[drive.Provider] = drive;
}
// Upon success, write the drive to the pipeline
context.WriteObject(result);
}
else
{
ProviderInvocationException e =
NewProviderInvocationException(
"NewDriveProviderFailed",
SessionStateStrings.NewDriveProviderFailed,
drive.Provider,
drive.Root,
PSTraceSource.NewArgumentException("root"));
throw e;
}
} // NewDrive
private void SetSecurityDescriptor(CmdletProvider providerInstance, string path, ObjectSecurity securityDescriptor, CmdletProviderContext context)
{
GetPermissionProviderInstance(providerInstance);
try
{
providerInstance.SetSecurityDescriptor(path, securityDescriptor, context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (PrivilegeNotHeldException exception)
{
context.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.PermissionDenied, path));
}
catch (UnauthorizedAccessException exception2)
{
context.WriteError(new ErrorRecord(exception2, exception2.GetType().FullName, ErrorCategory.PermissionDenied, path));
}
catch (NotSupportedException exception3)
{
context.WriteError(new ErrorRecord(exception3, exception3.GetType().FullName, ErrorCategory.InvalidOperation, path));
}
catch (SystemException exception4)
{
CommandProcessorBase.CheckForSevereException(exception4);
context.WriteError(new ErrorRecord(exception4, exception4.GetType().FullName, ErrorCategory.InvalidOperation, path));
}
catch (Exception exception5)
{
CommandProcessorBase.CheckForSevereException(exception5);
throw this.NewProviderInvocationException("SetSecurityDescriptorProviderException", SessionStateStrings.SetSecurityDescriptorProviderException, providerInstance.ProviderInfo, path, exception5);
}
}
public static Hashtable Invoke(System.Management.Automation.PowerShell ps, FileSystemProvider fileSystemContext, CmdletProviderContext cmdletContext, bool shouldHaveOutput)
{
bool useFileSystemProviderContext = (cmdletContext == null);
if (useFileSystemProviderContext)
{
Dbg.Diagnostics.Assert(fileSystemContext != null, "The caller should verify FileSystemProvider context.");
}
Collection<Hashtable> output;
try
{
output = ps.Invoke<Hashtable>();
}
catch (Exception e)
{
if (useFileSystemProviderContext)
{
fileSystemContext.WriteError(new ErrorRecord(e, "CopyFileRemoteExecutionError", ErrorCategory.InvalidOperation, ps));
ps.Commands.Clear();
}
else
{
cmdletContext.WriteError(new ErrorRecord(e, "CopyFileRemoteExecutionError", ErrorCategory.InvalidOperation, ps));
ps.Commands.Clear();
}
return null;
}
if (ps.HadErrors)
{
foreach (var error in ps.Streams.Error)
{
if (useFileSystemProviderContext)
{
fileSystemContext.WriteError(error);
}
else
{
cmdletContext.WriteError(error);
}
}
}
ps.Commands.Clear();
if (shouldHaveOutput)
{
if (output.Count != 1 || output[0].GetType() != typeof(Hashtable))
{
// unexpected output
Dbg.Diagnostics.Assert(output[0] != null, "Expected an output from the remote call.");
return null;
}
return (Hashtable)output[0];
}
return null;
}
internal void CopyItem(string[] paths, string copyPath, bool recurse, CopyContainers copyContainers, CmdletProviderContext context)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
if (copyPath == null)
{
copyPath = string.Empty;
}
PSDriveInfo drive = null;
ProviderInfo info2 = null;
string path = this.Globber.GetProviderPath(copyPath, context, out info2, out drive);
tracer.WriteLine("providerDestinationPath = {0}", new object[] { path });
ProviderInfo info3 = null;
CmdletProvider providerInstance = null;
foreach (string str2 in paths)
{
if (str2 == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
Collection<string> targetObject = this.Globber.GetGlobbedProviderPathsFromMonadPath(str2, false, context, out info3, out providerInstance);
if (info3 != info2)
{
ArgumentException exception = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "CopyItemSourceAndDestinationNotSameProvider", new object[0]);
context.WriteError(new ErrorRecord(exception, "CopyItemSourceAndDestinationNotSameProvider", ErrorCategory.InvalidArgument, targetObject));
break;
}
bool flag = this.IsItemContainer(providerInstance, path, context);
tracer.WriteLine("destinationIsContainer = {0}", new object[] { flag });
foreach (string str3 in targetObject)
{
if (context.Stopping)
{
break;
}
bool flag2 = this.IsItemContainer(providerInstance, str3, context);
tracer.WriteLine("sourcIsContainer = {0}", new object[] { flag2 });
if (flag2)
{
if (flag)
{
if (!recurse && (copyContainers == CopyContainers.CopyChildrenOfTargetContainer))
{
Exception exception2 = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "CopyContainerToContainerWithoutRecurseOrContainer", new object[0]);
context.WriteError(new ErrorRecord(exception2, "CopyContainerToContainerWithoutRecurseOrContainer", ErrorCategory.InvalidArgument, str3));
}
else if (recurse && (copyContainers == CopyContainers.CopyChildrenOfTargetContainer))
{
this.CopyRecurseToSingleContainer(providerInstance, str3, path, context);
}
else
{
this.CopyItem(providerInstance, str3, path, recurse, context);
}
}
else if (this.ItemExists(providerInstance, path, context))
{
Exception exception3 = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "CopyContainerItemToLeafError", new object[0]);
context.WriteError(new ErrorRecord(exception3, "CopyContainerItemToLeafError", ErrorCategory.InvalidArgument, str3));
}
else
{
this.CopyItem(providerInstance, str3, path, recurse, context);
}
}
else
{
this.CopyItem(providerInstance, str3, path, recurse, context);
}
}
}
}
} // MoveProperty
/// <summary>
/// Moves the specified property on the specified item to the specified property
/// on the destination item. The source and destination items can be the same item.
/// </summary>
///
/// <param name="sourcePaths">
/// The path(s) to the item(s) to move the property from.
/// </param>
///
/// <param name="sourceProperty">
/// The name of the property to be moved.
/// </param>
///
/// <param name="destinationPath">
/// The path to the item to move the property to.
/// </param>
///
/// <param name="destinationProperty">
/// The name of the property to move the property to.
/// </param>
///
/// <param name="context">
/// The context which the core command is running.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="sourcePath"/>, <paramref name="sourceProperty"/>,
/// <paramref name="destinationPath"/>, or <paramref name="destinationProperty"/>
/// is null.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If <paramref name="destinationPath"/> resolves to more than one item.
/// </exception>
///
/// <exception cref="ProviderNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a provider that could not be found.
/// </exception>
///
/// <exception cref="DriveNotFoundException">
/// If the <paramref name="sourcePath"/> refers to a drive that could not be found.
/// </exception>
///
/// <exception cref="NotSupportedException">
/// If the provider that the <paramref name="sourcePath"/> 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 MoveProperty(
string[] sourcePaths,
string sourceProperty,
string destinationPath,
string destinationProperty,
CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
ProviderInfo provider = null;
CmdletProvider providerInstance = null;
// We shouldn't be filtering the destination path
CmdletProviderContext destinationContext = new CmdletProviderContext(context);
destinationContext.SetFilters(
new Collection<string>(),
new Collection<string>(),
null);
Collection<string> destinationProviderPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
destinationPath,
false,
destinationContext,
out provider,
out providerInstance);
if (destinationProviderPaths.Count > 1)
{
ArgumentException argException =
PSTraceSource.NewArgumentException(
"destinationPath",
SessionStateStrings.MovePropertyDestinationResolveToSingle);
context.WriteError(new ErrorRecord(argException, argException.GetType().FullName, ErrorCategory.InvalidArgument, destinationProviderPaths));
}
else
{
foreach (string sourcePath in sourcePaths)
{
if (sourcePath == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
Collection<string> providerPaths =
Globber.GetGlobbedProviderPathsFromMonadPath(
sourcePath,
false,
context,
out provider,
out providerInstance);
foreach (string providerPath in providerPaths)
{
MoveProperty(providerInstance, providerPath, sourceProperty, destinationProviderPaths[0], destinationProperty, context);
}
}
}
} // MoveProperty
/// <summary>
/// Removes the provider of the given name.
/// </summary>
///
/// <param name="providerName">
/// The name of the provider to remove.
/// </param>
///
/// <param name="force">
/// Determines if the provider should be removed forcefully even if there were
/// drives present or errors.
/// </param>
///
/// <param name="context">
/// The context under which the command is being run.
/// </param>
///
/// <error cref="ArgumentNullException">
/// If <paramref name="providerName"/> is null.
/// </error>
///
/// <error cref="SessionStateException">
/// There are still drives associated with this provider,
/// and the "force" option was not specified.
/// </error>
///
/// <error cref="ProviderNotFoundException">
/// A provider with name <paramref name="providerName"/> could not be found.
/// </error>
///
/// <error>
/// If a provider throws an exception it gets written to the <paramref name="context"/>.
/// </error>
///
/// <exception cref="ArgumentException">
/// If <paramref name="providerName"/> is null or empty.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="context"/> is null.
/// </exception>
///
/// <remarks>
/// All drives associated with the provider must be removed before the provider
/// can be removed. Call SessionState.GetDrivesForProvider() to determine if there
/// are any drives associated with the provider. A SessionStateException
/// will be written to the context if any such drives do exist.
/// </remarks>
///
internal void RemoveProvider(
string providerName,
bool force,
CmdletProviderContext context)
{
if (context == null)
{
throw PSTraceSource.NewArgumentNullException("context");
}
if (String.IsNullOrEmpty(providerName))
{
throw PSTraceSource.NewArgumentException("providerName");
}
bool errors = false;
ProviderInfo provider = null;
try
{
provider = GetSingleProvider(providerName);
}
catch (ProviderNotFoundException)
{
return;
}
try
{
// First get an instance of the provider to make sure it exists
Provider.CmdletProvider providerBase = GetProviderInstance(provider);
if (providerBase == null)
{
ProviderNotFoundException e = new ProviderNotFoundException(
providerName,
SessionStateCategory.CmdletProvider,
"ProviderNotFound",
SessionStateStrings.ProviderNotFound);
context.WriteError(new ErrorRecord(e.ErrorRecord, e));
errors = true;
}
else
{
// See if there are any drives present for the provider
int driveCount = 0;
foreach (PSDriveInfo drive in GetDrivesForProvider(providerName))
{
if (drive != null)
{
++driveCount;
break;
}
}
if (driveCount > 0)
{
if (force)
{
// Forcefully remove all the drives
foreach (PSDriveInfo drive in GetDrivesForProvider(providerName))
{
if (drive != null)
{
RemoveDrive(drive, true, null);
}
}
}
else
{
errors = true;
// Since there are still drives associated with the provider
// the provider cannot be removed
SessionStateException e = new SessionStateException(
providerName,
SessionStateCategory.CmdletProvider,
"RemoveDrivesBeforeRemovingProvider",
SessionStateStrings.RemoveDrivesBeforeRemovingProvider,
ErrorCategory.InvalidOperation);
context.WriteError(new ErrorRecord(e.ErrorRecord, e));
return;
}
}
// Now tell the provider that they are going to be removed by
// calling the Stop method
try
{
providerBase.Stop(context);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
}
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
errors = true;
context.WriteError(
new ErrorRecord(
e,
"RemoveProviderUnexpectedException",
ErrorCategory.InvalidArgument,
providerName));
}
finally
{
if (force || !errors)
{
// Log the provider stopped event
MshLog.LogProviderLifecycleEvent(
this.ExecutionContext,
providerName,
ProviderState.Stopped);
RemoveProviderFromCollection(provider);
ProvidersCurrentWorkingDrive.Remove(provider);
#if RELATIONSHIP_SUPPORTED
// 2004/11/24-JeffJon - Relationships have been removed from the Exchange release
// Now make sure no relationship reference this provider
relationships.ProcessRelationshipsOnCmdletProviderRemoval (providerName);
#endif
}
}
} // RemoveProvider
internal void MoveItem(string[] paths, string destination, CmdletProviderContext context)
{
if (paths == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
if (destination == null)
{
throw PSTraceSource.NewArgumentNullException("destination");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
Collection<PathInfo> collection = this.Globber.GetGlobbedMonadPathsFromMonadPath(destination, true, context, out providerInstance);
if (collection.Count > 1)
{
ArgumentException exception = PSTraceSource.NewArgumentException("destination", "SessionStateStrings", "MoveItemOneDestination", new object[0]);
context.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, destination));
}
else
{
foreach (string str in paths)
{
if (str == null)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
Collection<string> targetObject = this.Globber.GetGlobbedProviderPathsFromMonadPath(str, false, context, out info, out providerInstance);
if (((targetObject.Count > 1) && (collection.Count > 0)) && !this.IsItemContainer(collection[0].Path))
{
ArgumentException exception2 = PSTraceSource.NewArgumentException("path", "SessionStateStrings", "MoveItemPathMultipleDestinationNotContainer", new object[0]);
context.WriteError(new ErrorRecord(exception2, exception2.GetType().FullName, ErrorCategory.InvalidArgument, collection[0]));
}
else
{
PSDriveInfo drive = null;
ProviderInfo provider = null;
CmdletProviderContext context2 = new CmdletProviderContext(this.ExecutionContext);
string str2 = null;
if (collection.Count > 0)
{
str2 = this.Globber.GetProviderPath(collection[0].Path, context2, out provider, out drive);
}
else
{
str2 = this.Globber.GetProviderPath(destination, context2, out provider, out drive);
}
if (!string.Equals(info.FullName, provider.FullName, StringComparison.OrdinalIgnoreCase))
{
ArgumentException exception3 = PSTraceSource.NewArgumentException("destination", "SessionStateStrings", "MoveItemSourceAndDestinationNotSameProvider", new object[0]);
context.WriteError(new ErrorRecord(exception3, exception3.GetType().FullName, ErrorCategory.InvalidArgument, targetObject));
}
else
{
foreach (string str3 in targetObject)
{
this.MoveItemPrivate(providerInstance, str3, str2, context);
}
}
}
}
}
}
private Collection<PSObject> GetChildNamesInDir(string dir, string leafElement, bool getAllContainers, CmdletProviderContext context, bool dirIsProviderPath, PSDriveInfo drive, ContainerCmdletProvider provider, out string modifiedDirPath)
{
string updatedPath = null;
string updatedFilter = null;
Collection<PSObject> collection4;
string filter = context.Filter;
bool flag = provider.ConvertPath(leafElement, context.Filter, ref updatedPath, ref updatedFilter, context);
if (flag)
{
tracer.WriteLine("Provider converted path and filter.", new object[0]);
tracer.WriteLine("Original path: " + leafElement, new object[0]);
tracer.WriteLine("Converted path: " + updatedPath, new object[0]);
tracer.WriteLine("Original filter: " + context.Filter, new object[0]);
tracer.WriteLine("Converted filter: " + updatedFilter, new object[0]);
leafElement = updatedPath;
context.Filter = updatedFilter;
}
ReturnContainers returnAllContainers = ReturnContainers.ReturnAllContainers;
if (!getAllContainers)
{
returnAllContainers = ReturnContainers.ReturnMatchingContainers;
}
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), context.Filter);
try
{
string path = null;
modifiedDirPath = null;
if (dirIsProviderPath)
{
modifiedDirPath = path = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
}
else
{
modifiedDirPath = GetMshQualifiedPath(dir, drive);
ProviderInfo info = null;
CmdletProvider providerInstance = null;
Collection<string> collection = this.GetGlobbedProviderPathsFromMonadPath(modifiedDirPath, false, context2, out info, out providerInstance);
modifiedDirPath = context.SuppressWildcardExpansion ? modifiedDirPath : RemoveGlobEscaping(modifiedDirPath);
if (collection.Count > 0)
{
path = collection[0];
}
else
{
if (flag)
{
context.Filter = filter;
}
return new Collection<PSObject>();
}
}
if (provider.HasChildItems(path, context2))
{
provider.GetChildNames(path, returnAllContainers, context2);
}
if (context2.HasErrors())
{
Collection<ErrorRecord> accumulatedErrorObjects = context2.GetAccumulatedErrorObjects();
if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0))
{
foreach (ErrorRecord record in accumulatedErrorObjects)
{
context.WriteError(record);
}
}
}
Collection<PSObject> accumulatedObjects = context2.GetAccumulatedObjects();
if (flag)
{
context.Filter = filter;
}
collection4 = accumulatedObjects;
}
finally
{
context2.RemoveStopReferral();
}
return collection4;
}
internal void MoveProperty(string[] sourcePaths, string sourceProperty, string destinationPath, string destinationProperty, CmdletProviderContext context)
{
if (sourcePaths == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
if (sourceProperty == null)
{
throw PSTraceSource.NewArgumentNullException("sourceProperty");
}
if (destinationPath == null)
{
throw PSTraceSource.NewArgumentNullException("destinationPath");
}
if (destinationProperty == null)
{
throw PSTraceSource.NewArgumentNullException("destinationProperty");
}
ProviderInfo info = null;
CmdletProvider providerInstance = null;
CmdletProviderContext context2 = new CmdletProviderContext(context);
context2.SetFilters(new Collection<string>(), new Collection<string>(), null);
Collection<string> targetObject = this.Globber.GetGlobbedProviderPathsFromMonadPath(destinationPath, false, context2, out info, out providerInstance);
if (targetObject.Count > 1)
{
ArgumentException exception = PSTraceSource.NewArgumentException("destinationPath", "SessionStateStrings", "MovePropertyDestinationResolveToSingle", new object[0]);
context.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, targetObject));
}
else
{
foreach (string str in sourcePaths)
{
if (str == null)
{
throw PSTraceSource.NewArgumentNullException("sourcePaths");
}
foreach (string str2 in this.Globber.GetGlobbedProviderPathsFromMonadPath(str, false, context, out info, out providerInstance))
{
this.MoveProperty(providerInstance, str2, sourceProperty, targetObject[0], destinationProperty, 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);
}
}
} // SetSecurityDescriptor
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)
{
CommandProcessorBase.CheckForSevereException(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.
{
CommandProcessorBase.CheckForSevereException(e);
throw NewProviderInvocationException(
"SetSecurityDescriptorProviderException",
SessionStateStrings.SetSecurityDescriptorProviderException,
providerInstance.ProviderInfo,
path,
e);
}
} // SetSecurityDescriptor