protected override void ProcessRecord()
{
if (this.Force == 0)
{
PSVariable atScope = null;
if (string.IsNullOrEmpty(base.Scope))
{
atScope = base.SessionState.PSVariable.GetAtScope(this.name, "local");
}
else
{
atScope = base.SessionState.PSVariable.GetAtScope(this.name, base.Scope);
}
if (atScope != null)
{
SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(this.name, SessionStateCategory.Variable, "VariableAlreadyExists", SessionStateStrings.VariableAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
return;
}
}
string newVariableAction = VariableCommandStrings.NewVariableAction;
string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, this.Name, this.Value);
if (base.ShouldProcess(target, newVariableAction))
{
PSVariable variable = new PSVariable(this.name, this._value, this.options);
if (this._visibility.HasValue)
{
variable.Visibility = this._visibility.Value;
}
if (this.description != null)
{
variable.Description = this.description;
}
try
{
if (string.IsNullOrEmpty(base.Scope))
{
base.SessionState.Internal.NewVariable(variable, (bool) this.Force);
}
else
{
base.SessionState.Internal.NewVariableAtScope(variable, base.Scope, (bool) this.Force);
}
}
catch (SessionStateException exception2)
{
base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
return;
}
catch (PSArgumentException exception3)
{
base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3));
return;
}
if (this.passThru)
{
base.WriteObject(variable);
}
}
}
public static void ThrowIfNotVisible(CommandOrigin origin, object valueToCheck)
{
if (!IsVisible(origin, valueToCheck))
{
SessionStateException exception;
System.Management.Automation.PSVariable variable = valueToCheck as System.Management.Automation.PSVariable;
if (variable != null)
{
exception = new SessionStateException(variable.Name, SessionStateCategory.Variable, "VariableIsPrivate", SessionStateStrings.VariableIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
throw exception;
}
CommandInfo info = valueToCheck as CommandInfo;
if (info != null)
{
string itemName = null;
if (info != null)
{
itemName = info.Name;
}
if (itemName != null)
{
exception = new SessionStateException(itemName, SessionStateCategory.Command, "NamedCommandIsPrivate", SessionStateStrings.NamedCommandIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
}
else
{
exception = new SessionStateException("", SessionStateCategory.Command, "CommandIsPrivate", SessionStateStrings.CommandIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
}
throw exception;
}
exception = new SessionStateException(null, SessionStateCategory.Resource, "ResourceIsPrivate", SessionStateStrings.ResourceIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
throw exception;
}
}
/// <summary>
/// Utility to check the visibility of an object based on the current
/// command origin. If the object implements IHasSessionStateEntryVisibility
/// then the check will be made. If the check fails, then an exception will be thrown...
/// </summary>
/// <param name="origin">The command origin value to check against...</param>
/// <param name="valueToCheck">The object to check</param>
public static void ThrowIfNotVisible(CommandOrigin origin, object valueToCheck)
{
SessionStateException exception;
if (!IsVisible(origin, valueToCheck))
{
PSVariable sv = valueToCheck as PSVariable;
if (sv != null)
{
exception =
new SessionStateException(
sv.Name,
SessionStateCategory.Variable,
"VariableIsPrivate",
SessionStateStrings.VariableIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
CommandInfo cinfo = valueToCheck as CommandInfo;
if (cinfo != null)
{
string commandName = cinfo.Name;
if (commandName != null)
{
// If we have a name, use it in the error message
exception =
new SessionStateException(
commandName,
SessionStateCategory.Command,
"NamedCommandIsPrivate",
SessionStateStrings.NamedCommandIsPrivate,
ErrorCategory.PermissionDenied);
}
else
{
exception =
new SessionStateException(
string.Empty,
SessionStateCategory.Command,
"CommandIsPrivate",
SessionStateStrings.CommandIsPrivate,
ErrorCategory.PermissionDenied);
}
throw exception;
}
// Catch all error for other types of resources...
exception =
new SessionStateException(
null,
SessionStateCategory.Resource,
"ResourceIsPrivate",
SessionStateStrings.ResourceIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
}
internal void NewDrive(PSDriveInfo newDrive)
{
if (newDrive == null)
{
throw PSTraceSource.NewArgumentNullException("newDrive");
}
if (this.GetDrives().ContainsKey(newDrive.Name))
{
SessionStateException exception = new SessionStateException(newDrive.Name, SessionStateCategory.Drive, "DriveAlreadyExists", SessionStateStrings.DriveAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
throw exception;
}
if (!newDrive.IsAutoMounted && (this.GetDrives().Count > (this.DriveCapacity.FastValue - 1)))
{
SessionStateOverflowException exception2 = new SessionStateOverflowException(newDrive.Name, SessionStateCategory.Drive, "DriveOverflow", SessionStateStrings.DriveOverflow, new object[] { this.DriveCapacity.FastValue });
throw exception2;
}
if (!newDrive.IsAutoMounted)
{
this.GetDrives().Add(newDrive.Name, newDrive);
}
else if (!this.GetAutomountedDrives().ContainsKey(newDrive.Name))
{
this.GetAutomountedDrives().Add(newDrive.Name, newDrive);
}
}
} // SetFunctionRaw
internal WorkflowInfo SetWorkflowRaw(
WorkflowInfo workflowInfo,
CommandOrigin origin)
{
string originalName = workflowInfo.Name;
string name = originalName;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (String.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
// The script that defines a workflowInfo wrapper is fully trusted
workflowInfo.ScriptBlock.LanguageMode = PSLanguageMode.FullLanguage;
if (workflowInfo.Module == null && this.Module != null)
{
workflowInfo.Module = this.Module;
}
var wfInfo = (WorkflowInfo)
searcher.InitialScope.SetFunction(name, workflowInfo.ScriptBlock, null, options, false, origin, ExecutionContext, null,
(arg1, arg2, arg3, arg4, arg5, arg6) => workflowInfo);
foreach (var aliasName in GetFunctionAliases(workflowInfo.ScriptBlock.Ast as IParameterMetadataProvider))
{
searcher.InitialScope.SetAliasValue(aliasName, name, ExecutionContext, false, origin);
}
return(wfInfo);
} // SetWorkflowRaw
/// <summary>
/// Set a function in the current scope of session state.
/// </summary>
/// <param name="name">
/// The name of the function to set.
/// </param>
/// <param name="function">
/// The new value of the function being set.
/// </param>
/// <param name="origin">
/// Origin of the caller of this API
/// </param>
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
/// <exception cref="ArgumentNullException">
/// If <paramref name="function"/> is null.
/// </exception>
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is read-only or constant.
/// </exception>
internal FunctionInfo SetFunctionRaw(
string name,
ScriptBlock function,
CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string originalName = name;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (string.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
var functionInfo = searcher.InitialScope.SetFunction(name, function, null, options, false, origin, ExecutionContext);
foreach (var aliasName in GetFunctionAliases(function.Ast as IParameterMetadataProvider))
{
searcher.InitialScope.SetAliasValue(aliasName, name, ExecutionContext, false, origin);
}
return(functionInfo);
}
} // SetFunction
/// <summary>
/// Set a function in the current scope of session state.
/// </summary>
///
/// <param name="name">
/// The name of the function to set.
/// </param>
///
/// <param name="function">
/// The new value of the function being set.
/// </param>
///
/// <param name="originalFunction">
/// The original function (if any) from which the ScriptBlock is derived.
/// </param>
///
/// <param name="options">
/// The options to set on the function.
/// </param>
///
/// <param name="force">
/// If true, the function will be set even if its ReadOnly.
/// </param>
///
/// <param name="origin">
/// Origin of the caller of this API
/// </param>
///
/// <param name="context">
/// The execution context for the function.
/// </param>
///
/// <param name="helpFile">
/// The name of the help file associated with the function.
/// </param>
///
/// <param name="isPreValidated">
/// Set to true if it is a regular function (meaning, we do not need to check this is a workflow or if the script contains JobDefinition Attribute and then process it)
/// </param>
///
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="function"/> is null.
/// </exception>
///
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is read-only or constant.
/// </exception>
///
/// <exception cref="SessionStateOverflowException">
/// If the maximum number of functions have been reached for this scope.
/// </exception>
///
internal FunctionInfo SetFunction(
string name,
ScriptBlock function,
FunctionInfo originalFunction,
ScopedItemOptions options,
bool force,
CommandOrigin origin,
ExecutionContext context,
string helpFile,
bool isPreValidated)
{
if (String.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string originalName = name;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (String.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
return(searcher.InitialScope.SetFunction(name, function, originalFunction, options, force, origin, context, helpFile));
} // SetFunction
internal SessionStateException(
string itemName,
SessionStateCategory sessionStateCategory,
string errorIdAndResourceId,
ErrorCategory errorCategory,
params object[] messageArgs)
: base(SessionStateException.BuildMessage(itemName, errorIdAndResourceId, messageArgs))
{
this._itemName = itemName;
this._sessionStateCategory = sessionStateCategory;
this._errorId = errorIdAndResourceId;
this._errorCategory = errorCategory;
}
private static void ThrowIfVariableIsPrivate(PSVariable variable)
{
if (variable.Visibility != SessionStateEntryVisibility.Private)
{
return;
}
var exception = new SessionStateException(
String.Format("Cannot access the variable '${0}' because it is a private variable", variable.Name),
variable.ItemName,
SessionStateCategory.Variable);
string errorId = "VariableIsPrivate";
var parentException = new ParentContainsErrorRecordException(exception);
var error = new ErrorRecord(parentException, errorId, ErrorCategory.PermissionDenied, variable.Name);
exception.ErrorRecord = error;
throw exception;
}
/// <summary>
/// The main processing loop of the command.
/// </summary>
///
protected override void ProcessRecord()
{
Collection<AliasInfo> importedAliases = GetAliasesFromFile(this.ParameterSetName.Equals(LiteralPathParameterSetName,
StringComparison.OrdinalIgnoreCase));
CommandOrigin origin = MyInvocation.CommandOrigin;
foreach (AliasInfo alias in importedAliases)
{
// If not force, then see if the alias already exists
// NTRAID#Windows Out Of Band Releases-906910-2006/03/17-JonN
string action = AliasCommandStrings.ImportAliasAction;
string target = StringUtil.Format(AliasCommandStrings.ImportAliasTarget, alias.Name, alias.Definition);
if (!ShouldProcess(target, action))
continue;
if (!Force)
{
AliasInfo existingAlias = null;
if (String.IsNullOrEmpty(Scope))
{
existingAlias = SessionState.Internal.GetAlias(alias.Name);
}
else
{
existingAlias = SessionState.Internal.GetAliasAtScope(alias.Name, Scope);
}
if (existingAlias != null)
{
// Write an error for aliases that aren't visible...
try
{
SessionState.ThrowIfNotVisible(origin, existingAlias);
}
catch (SessionStateException sessionStateException)
{
WriteError(
new ErrorRecord(
sessionStateException.ErrorRecord,
sessionStateException));
// Only report the error once...
continue;
}
// Since the alias already exists, write an error.
SessionStateException aliasExists =
new SessionStateException(
alias.Name,
SessionStateCategory.Alias,
"AliasAlreadyExists",
SessionStateStrings.AliasAlreadyExists,
ErrorCategory.ResourceExists);
WriteError(
new ErrorRecord(
aliasExists.ErrorRecord,
aliasExists));
continue;
}
if (VerifyShadowingExistingCommandsAndWriteError(alias.Name))
{
continue;
}
} // if (!Force)
// Set the alias in the specified scope or the
// current scope.
AliasInfo result = null;
try
{
if (String.IsNullOrEmpty(Scope))
{
result = SessionState.Internal.SetAliasItem(alias, Force, MyInvocation.CommandOrigin);
}
else
{
result = SessionState.Internal.SetAliasItemAtScope(alias, Scope, Force, MyInvocation.CommandOrigin);
}
}
catch (SessionStateException sessionStateException)
{
WriteError(
new ErrorRecord(
sessionStateException.ErrorRecord,
sessionStateException));
continue;
}
catch (PSArgumentOutOfRangeException argOutOfRange)
{
WriteError(
new ErrorRecord(
argOutOfRange.ErrorRecord,
argOutOfRange));
continue;
}
catch (PSArgumentException argException)
{
WriteError(
new ErrorRecord(
argException.ErrorRecord,
argException));
continue;
}
// Write the alias to the pipeline if PassThru was specified
if (PassThru && result != null)
{
WriteObject(result);
}
}
} // ProcessRecord
/// <summary>
/// Add objects received on the pipeline to an ArrayList of values, to
/// take the place of the Value parameter if none was specified on the
/// command line.
/// </summary>
///
protected override void ProcessRecord()
{
// If Force is not specified, see if the variable already exists
// in the specified scope. If the scope isn't specified, then
// check to see if it exists in the current scope.
if (!Force)
{
PSVariable varFound = null;
if (String.IsNullOrEmpty(Scope))
{
varFound =
SessionState.PSVariable.GetAtScope(Name, "local");
}
else
{
varFound =
SessionState.PSVariable.GetAtScope(Name, Scope);
}
if (varFound != null)
{
SessionStateException sessionStateException =
new SessionStateException(
Name,
SessionStateCategory.Variable,
"VariableAlreadyExists",
SessionStateStrings.VariableAlreadyExists,
ErrorCategory.ResourceExists);
WriteError(
new ErrorRecord(
sessionStateException.ErrorRecord,
sessionStateException));
return;
}
}
// Since the variable doesn't exist or -Force was specified,
// Call should process to validate the set with the user.
string action = VariableCommandStrings.NewVariableAction;
string target = StringUtil.Format(VariableCommandStrings.NewVariableTarget, Name, Value);
if (ShouldProcess(target, action))
{
PSVariable newVariable = new PSVariable(Name, Value, Option);
if (_visibility != null)
{
newVariable.Visibility = (SessionStateEntryVisibility)_visibility;
}
if (Description != null)
{
newVariable.Description = Description;
}
try
{
if (String.IsNullOrEmpty(Scope))
{
SessionState.Internal.NewVariable(newVariable, Force);
}
else
{
SessionState.Internal.NewVariableAtScope(newVariable, Scope, Force);
}
}
catch (SessionStateException sessionStateException)
{
WriteError(
new ErrorRecord(
sessionStateException.ErrorRecord,
sessionStateException));
return;
}
catch (PSArgumentException argException)
{
WriteError(
new ErrorRecord(
argException.ErrorRecord,
argException));
return;
}
if (_passThru)
{
WriteObject(newVariable);
}
}
} // ProcessRecord
/// <summary>
/// Utility to check the visibility of an object based on the current
/// command origin. If the object implements IHasSessionStateEntryVisibility
/// then the check will be made. If the check fails, then an exception will be thrown...
/// </summary>
/// <param name="origin">The command origin value to check against...</param>
/// <param name="valueToCheck">The object to check</param>
public static void ThrowIfNotVisible(CommandOrigin origin, object valueToCheck)
{
SessionStateException exception;
if (!IsVisible(origin, valueToCheck))
{
PSVariable sv = valueToCheck as PSVariable;
if (sv != null)
{
exception =
new SessionStateException(
sv.Name,
SessionStateCategory.Variable,
"VariableIsPrivate",
SessionStateStrings.VariableIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
CommandInfo cinfo = valueToCheck as CommandInfo;
if (cinfo != null)
{
string commandName = null;
if (cinfo != null)
commandName = cinfo.Name;
if (commandName != null)
{
// If we have a name, use it in the error message
exception =
new SessionStateException(
commandName,
SessionStateCategory.Command,
"NamedCommandIsPrivate",
SessionStateStrings.NamedCommandIsPrivate,
ErrorCategory.PermissionDenied);
}
else
{
exception =
new SessionStateException(
"",
SessionStateCategory.Command,
"CommandIsPrivate",
SessionStateStrings.CommandIsPrivate,
ErrorCategory.PermissionDenied);
}
throw exception;
}
// Catch all error for other types of resources...
exception =
new SessionStateException(
null,
SessionStateCategory.Resource,
"ResourceIsPrivate",
SessionStateStrings.ResourceIsPrivate,
ErrorCategory.PermissionDenied);
throw exception;
}
}
/// <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
} // InitializeProvider
/// <summary>
/// Creates and adds a provider to the provider container
/// </summary>
///
/// <param name="provider">
/// The provider to add.
/// </param>
///
/// <returns>
/// The provider that was added or null if the provider failed to be added.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="provider"/> is null.
/// </exception>
///
/// <exception cref="SessionStateException">
/// If the provider already exists.
/// </exception>
///
/// <exception cref="ProviderInvocationException">
/// If there was a failure to load the provider or the provider
/// threw an exception.
/// </exception>
///
internal ProviderInfo NewProvider(ProviderInfo provider)
{
if (provider == null)
{
throw PSTraceSource.NewArgumentNullException("provider");
}
// Check to see if the provider already exists.
// We do the check instead of allowing the hashtable to
// throw the exception so that we give a better error
// message.
ProviderInfo existingProvider = ProviderExists(provider);
if (existingProvider != null)
{
// If it's an already loaded provider, don't return an error...
if (existingProvider.ImplementingType == provider.ImplementingType)
return existingProvider;
SessionStateException sessionStateException =
new SessionStateException(
provider.Name,
SessionStateCategory.CmdletProvider,
"CmdletProviderAlreadyExists",
SessionStateStrings.CmdletProviderAlreadyExists,
ErrorCategory.ResourceExists);
throw sessionStateException;
}
// Make sure we are able to create an instance of the provider.
// Note, this will also set the friendly name if the user didn't
// specify one.
Provider.CmdletProvider providerInstance = provider.CreateInstance();
// Now call start to let the provider initialize itself
CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
ProviderInfo newProviderInfo = null;
try
{
newProviderInfo = providerInstance.Start(provider, context);
// Set the new provider info in the instance in case the provider
// derived a new one
providerInstance.SetProviderInformation(newProviderInfo);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception e) // Catch-call OK, 3rd party callout
{
CommandProcessorBase.CheckForSevereException(e);
throw
NewProviderInvocationException(
"ProviderStartException",
SessionStateStrings.ProviderStartException,
provider,
null,
e);
}
context.ThrowFirstErrorOrDoNothing(true);
if (newProviderInfo == null)
{
throw
PSTraceSource.NewInvalidOperationException(
SessionStateStrings.InvalidProviderInfoNull);
}
if (newProviderInfo != provider)
{
// Since the references are not the same, ensure that the provider
// name is the same.
if (!string.Equals(newProviderInfo.Name, provider.Name, StringComparison.OrdinalIgnoreCase))
{
throw
PSTraceSource.NewInvalidOperationException(
SessionStateStrings.InvalidProviderInfo);
}
// Use the new provider info instead
provider = newProviderInfo;
}
// Add the newly create provider to the providers container
try
{
NewProviderEntry(provider);
}
catch (ArgumentException)
{
SessionStateException sessionStateException =
new SessionStateException(
provider.Name,
SessionStateCategory.CmdletProvider,
"CmdletProviderAlreadyExists",
SessionStateStrings.CmdletProviderAlreadyExists,
ErrorCategory.ResourceExists);
throw sessionStateException;
}
// Add the provider to the provider current working
// drive hashtable so that we can associate a current working
// drive with it.
ProvidersCurrentWorkingDrive.Add(provider, null);
bool initializeProviderError = false;
try
{
// Initialize the provider and give it a chance to
// mount some drives.
InitializeProvider(providerInstance, provider, context);
context.ThrowFirstErrorOrDoNothing(true);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
initializeProviderError = true;
throw;
}
catch (ActionPreferenceStopException)
{
initializeProviderError = true;
throw;
}
catch (NotSupportedException)
{
// We can safely ignore NotSupportedExceptions because
// it just means that the provider doesn't support
// drives.
initializeProviderError = false;
}
catch (SessionStateException)
{
initializeProviderError = true;
throw;
}
finally
{
if (initializeProviderError)
{
// An exception during initialization should remove the provider from
// session state.
Providers.Remove(provider.Name.ToString());
ProvidersCurrentWorkingDrive.Remove(provider);
provider = null;
}
}
#if RELATIONSHIP_SUPPORTED
// 2004/11/24-JeffJon - Relationships have been removed from the Exchange release
// Make sure the delay-load relationships get updated for the new provider
relationships.ProcessDelayLoadRelationships (provider.Name);
#endif
// Now write out the result
return provider;
} // NewProvider
} // SetFunction
/// <summary>
/// Set a function in the current scope of session state.
/// </summary>
///
/// <param name="name">
/// The name of the function to set.
/// </param>
///
/// <param name="function">
/// The new value of the function being set.
/// </param>
///
/// <param name="originalFunction">
/// The original function (if any) from which the ScriptBlock is derived.
/// </param>
///
/// <param name="force">
/// If true, the function will be set even if its ReadOnly.
/// </param>
///
/// <param name="origin">
/// The origin of the caller
/// </param>
///
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// or
/// If <paramref name="function"/> is not a <see cref="FilterInfo">FilterInfo</see>
/// or <see cref="FunctionInfo">FunctionInfo</see>
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="function"/> is null.
/// </exception>
///
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is read-only or constant.
/// </exception>
///
/// <exception cref="SessionStateOverflowException">
/// If the maximum number of functions have been reached for this scope.
/// </exception>
///
internal FunctionInfo SetFunction(
string name,
ScriptBlock function,
FunctionInfo originalFunction,
bool force,
CommandOrigin origin)
{
if (String.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string originalName = name;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (String.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
FunctionInfo result = null;
SessionStateScope scope = searcher.InitialScope;
if (searcher.MoveNext())
{
scope = searcher.CurrentLookupScope;
name = searcher.Name;
if (path.IsPrivate)
{
// Need to add the Private flag
FunctionInfo existingFunction = scope.GetFunction(name);
options |= existingFunction.Options;
result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext);
}
else
{
result = scope.SetFunction(name, function, force, origin, ExecutionContext);
}
}
else
{
if (path.IsPrivate)
{
result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext);
}
else
{
result = scope.SetFunction(name, function, force, origin, ExecutionContext);
}
}
return result;
}
internal void NewDrive(PSDriveInfo newDrive)
{
if (newDrive == null)
{
throw PSTraceSource.NewArgumentNullException("newDrive");
}
if (this.GetDrives().ContainsKey(newDrive.Name))
{
SessionStateException exception = new SessionStateException(newDrive.Name, SessionStateCategory.Drive, "DriveAlreadyExists", SessionStateStrings.DriveAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
throw exception;
}
if (!newDrive.IsAutoMounted && (this.GetDrives().Count > (this.DriveCapacity.FastValue - 1)))
{
SessionStateOverflowException exception2 = new SessionStateOverflowException(newDrive.Name, SessionStateCategory.Drive, "DriveOverflow", SessionStateStrings.DriveOverflow, new object[] { this.DriveCapacity.FastValue });
throw exception2;
}
if (!newDrive.IsAutoMounted)
{
this.GetDrives().Add(newDrive.Name, newDrive);
}
else if (!this.GetAutomountedDrives().ContainsKey(newDrive.Name))
{
this.GetAutomountedDrives().Add(newDrive.Name, newDrive);
}
}
/// <summary>
/// The main processing loop of the command.
/// </summary>
///
protected override void ProcessRecord()
{
// If not force, then see if the alias already exists
if (!Force)
{
AliasInfo existingAlias = null;
if (String.IsNullOrEmpty(Scope))
{
existingAlias = SessionState.Internal.GetAlias(Name);
}
else
{
existingAlias = SessionState.Internal.GetAliasAtScope(Name, Scope);
}
if (existingAlias != null)
{
// Throw if alias exists and is private...
SessionState.ThrowIfNotVisible(this.CommandOrigin, existingAlias);
// Since the alias already exists, write an error.
SessionStateException aliasExists =
new SessionStateException(
Name,
SessionStateCategory.Alias,
"AliasAlreadyExists",
SessionStateStrings.AliasAlreadyExists,
ErrorCategory.ResourceExists);
WriteError(
new ErrorRecord(
aliasExists.ErrorRecord,
aliasExists));
return;
}
}
// Create the alias info
AliasInfo newAlias =
new AliasInfo(
Name,
Value,
Context,
Option);
newAlias.Description = Description;
string action =
AliasCommandStrings.NewAliasAction;
string target =
StringUtil.Format(AliasCommandStrings.NewAliasTarget, Name, Value);
if (ShouldProcess(target, action))
{
// Set the alias in the specified scope or the
// current scope.
AliasInfo result = null;
try
{
if (String.IsNullOrEmpty(Scope))
{
result = SessionState.Internal.SetAliasItem(newAlias, Force, MyInvocation.CommandOrigin);
}
else
{
result = SessionState.Internal.SetAliasItemAtScope(newAlias, Scope, Force, MyInvocation.CommandOrigin);
}
}
catch (SessionStateException sessionStateException)
{
WriteError(
new ErrorRecord(
sessionStateException.ErrorRecord,
sessionStateException));
return;
}
catch (PSArgumentOutOfRangeException argOutOfRange)
{
WriteError(
new ErrorRecord(
argOutOfRange.ErrorRecord,
argOutOfRange));
return;
}
catch (PSArgumentException argException)
{
WriteError(
new ErrorRecord(
argException.ErrorRecord,
argException));
return;
}
// Write the alias to the pipeline if PassThru was specified
if (PassThru && result != null)
{
WriteObject(result);
}
}
} // ProcessRecord
protected override void ProcessRecord()
{
Collection<AliasInfo> aliasesFromFile = this.GetAliasesFromFile(base.ParameterSetName.Equals("ByLiteralPath", StringComparison.OrdinalIgnoreCase));
CommandOrigin commandOrigin = base.MyInvocation.CommandOrigin;
foreach (AliasInfo info in aliasesFromFile)
{
string importAliasAction = AliasCommandStrings.ImportAliasAction;
string target = StringUtil.Format(AliasCommandStrings.ImportAliasTarget, info.Name, info.Definition);
if (base.ShouldProcess(target, importAliasAction))
{
if (this.Force == 0)
{
AliasInfo valueToCheck = null;
if (string.IsNullOrEmpty(this.Scope))
{
valueToCheck = base.SessionState.Internal.GetAlias(info.Name);
}
else
{
valueToCheck = base.SessionState.Internal.GetAliasAtScope(info.Name, this.Scope);
}
if (valueToCheck != null)
{
try
{
SessionState.ThrowIfNotVisible(commandOrigin, valueToCheck);
}
catch (SessionStateException exception)
{
base.WriteError(new ErrorRecord(exception.ErrorRecord, exception));
continue;
}
SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(info.Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
continue;
}
if (this.VerifyShadowingExistingCommandsAndWriteError(info.Name))
{
continue;
}
}
AliasInfo sendToPipeline = null;
try
{
if (string.IsNullOrEmpty(this.Scope))
{
sendToPipeline = base.SessionState.Internal.SetAliasItem(info, (bool) this.Force, base.MyInvocation.CommandOrigin);
}
else
{
sendToPipeline = base.SessionState.Internal.SetAliasItemAtScope(info, this.Scope, (bool) this.Force, base.MyInvocation.CommandOrigin);
}
}
catch (SessionStateException exception3)
{
base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3));
continue;
}
catch (PSArgumentOutOfRangeException exception4)
{
base.WriteError(new ErrorRecord(exception4.ErrorRecord, exception4));
continue;
}
catch (PSArgumentException exception5)
{
base.WriteError(new ErrorRecord(exception5.ErrorRecord, exception5));
continue;
}
if ((this.PassThru != 0) && (sendToPipeline != null))
{
base.WriteObject(sendToPipeline);
}
}
}
}
/// <summary>
/// Set a function in the current scope of session state.
/// </summary>
///
/// <param name="name">
/// The name of the function to set.
/// </param>
///
/// <param name="function">
/// The new value of the function being set.
/// </param>
///
/// <param name="origin">
/// Origin of the caller of this API
/// </param>
///
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="function"/> is null.
/// </exception>
///
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is read-only or constant.
/// </exception>
///
/// <exception cref="SessionStateOverflowException">
/// If the maximum number of functions have been reached for this scope.
/// </exception>
///
internal FunctionInfo SetFunctionRaw(
string name,
ScriptBlock function,
CommandOrigin origin)
{
if (String.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string originalName = name;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (String.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
var functionInfo = searcher.InitialScope.SetFunction(name, function, null, options, false, origin, ExecutionContext);
foreach (var aliasName in GetFunctionAliases(function.Ast as IParameterMetadataProvider))
{
searcher.InitialScope.SetAliasValue(aliasName, name, ExecutionContext, false, origin);
}
return functionInfo;
} // SetFunctionRaw
internal FunctionInfo SetFunction(string name, ScriptBlock function, FunctionInfo originalFunction, ScopedItemOptions options, bool force, CommandOrigin origin, System.Management.Automation.ExecutionContext context, string helpFile, bool isPreValidated)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string itemName = name;
FunctionLookupPath lookupPath = new FunctionLookupPath(name);
name = lookupPath.UnqualifiedPath;
if (string.IsNullOrEmpty(name))
{
SessionStateException exception = new SessionStateException(itemName, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument, new object[0]);
throw exception;
}
if (lookupPath.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher(this, lookupPath, origin);
return searcher.InitialScope.SetFunction(name, function, originalFunction, options, force, origin, context, helpFile);
}
internal FunctionInfo SetFunction(string name, ScriptBlock function, FunctionInfo originalFunction, bool force, CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string itemName = name;
FunctionLookupPath lookupPath = new FunctionLookupPath(name);
name = lookupPath.UnqualifiedPath;
if (string.IsNullOrEmpty(name))
{
SessionStateException exception = new SessionStateException(itemName, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument, new object[0]);
throw exception;
}
ScopedItemOptions none = ScopedItemOptions.None;
if (lookupPath.IsPrivate)
{
none |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher(this, lookupPath, origin);
SessionStateScope initialScope = searcher.InitialScope;
if (searcher.MoveNext())
{
initialScope = searcher.CurrentLookupScope;
name = searcher.Name;
if (!lookupPath.IsPrivate)
{
return initialScope.SetFunction(name, function, force, origin, this.ExecutionContext);
}
FunctionInfo info2 = initialScope.GetFunction(name);
FunctionInfo info3 = info2;
if (info3 != null)
{
none |= info3.Options;
}
else
{
none |= ((FilterInfo) info2).Options;
}
return initialScope.SetFunction(name, function, originalFunction, none, force, origin, this.ExecutionContext);
}
if (lookupPath.IsPrivate)
{
return initialScope.SetFunction(name, function, originalFunction, none, force, origin, this.ExecutionContext);
}
return initialScope.SetFunction(name, function, force, origin, this.ExecutionContext);
}
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);
}
}
}
internal ProviderInfo NewProvider(ProviderInfo provider)
{
if (provider == null)
{
throw PSTraceSource.NewArgumentNullException("provider");
}
ProviderInfo info = this.ProviderExists(provider);
if (info != null)
{
if (info.ImplementingType == provider.ImplementingType)
{
return info;
}
SessionStateException exception = new SessionStateException(provider.Name, SessionStateCategory.CmdletProvider, "CmdletProviderAlreadyExists", SessionStateStrings.CmdletProviderAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
throw exception;
}
CmdletProvider providerInstance = provider.CreateInstance();
CmdletProviderContext cmdletProviderContext = new CmdletProviderContext(this.ExecutionContext);
ProviderInfo providerInfoToSet = null;
try
{
providerInfoToSet = providerInstance.Start(provider, cmdletProviderContext);
providerInstance.SetProviderInformation(providerInfoToSet);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
throw;
}
catch (ActionPreferenceStopException)
{
throw;
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
throw this.NewProviderInvocationException("ProviderStartException", SessionStateStrings.ProviderStartException, provider, null, exception2);
}
cmdletProviderContext.ThrowFirstErrorOrDoNothing(true);
if (providerInfoToSet == null)
{
throw PSTraceSource.NewInvalidOperationException("SessionStateStrings", "InvalidProviderInfoNull", new object[0]);
}
if (providerInfoToSet != provider)
{
if (!string.Equals(providerInfoToSet.Name, provider.Name, StringComparison.OrdinalIgnoreCase))
{
throw PSTraceSource.NewInvalidOperationException("SessionStateStrings", "InvalidProviderInfo", new object[0]);
}
provider = providerInfoToSet;
}
try
{
this.NewProviderEntry(provider);
}
catch (ArgumentException)
{
SessionStateException exception3 = new SessionStateException(provider.Name, SessionStateCategory.CmdletProvider, "CmdletProviderAlreadyExists", SessionStateStrings.CmdletProviderAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
throw exception3;
}
this.ProvidersCurrentWorkingDrive.Add(provider, null);
bool flag = false;
try
{
this.InitializeProvider(providerInstance, provider, cmdletProviderContext);
cmdletProviderContext.ThrowFirstErrorOrDoNothing(true);
}
catch (LoopFlowException)
{
throw;
}
catch (PipelineStoppedException)
{
flag = true;
throw;
}
catch (ActionPreferenceStopException)
{
flag = true;
throw;
}
catch (NotSupportedException)
{
flag = false;
}
catch (SessionStateException)
{
flag = true;
throw;
}
finally
{
if (flag)
{
this.Providers.Remove(provider.Name.ToString());
this.ProvidersCurrentWorkingDrive.Remove(provider);
provider = null;
}
}
return provider;
}
private bool VerifyShadowingExistingCommandsAndWriteError(string aliasName)
{
CommandSearcher searcher = new CommandSearcher(aliasName, SearchResolutionOptions.None, CommandTypes.All ^ CommandTypes.Alias, this.Context);
foreach (string expandedCommandName in searcher.ConstructSearchPatternsFromName(aliasName))
{
CommandTypes commandTypeOfExistingCommand;
if (this.ExistingCommands.TryGetValue(expandedCommandName, out commandTypeOfExistingCommand))
{
// Since the alias already exists, write an error.
SessionStateException aliasExists =
new SessionStateException(
aliasName,
SessionStateCategory.Alias,
"AliasAlreadyExists",
SessionStateStrings.AliasWithCommandNameAlreadyExists,
ErrorCategory.ResourceExists,
commandTypeOfExistingCommand);
WriteError(
new ErrorRecord(
aliasExists.ErrorRecord,
aliasExists));
return true;
}
}
return false;
}
public static void ThrowIfNotVisible(CommandOrigin origin, object valueToCheck)
{
if (!IsVisible(origin, valueToCheck))
{
SessionStateException exception;
System.Management.Automation.PSVariable variable = valueToCheck as System.Management.Automation.PSVariable;
if (variable != null)
{
exception = new SessionStateException(variable.Name, SessionStateCategory.Variable, "VariableIsPrivate", SessionStateStrings.VariableIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
throw exception;
}
CommandInfo info = valueToCheck as CommandInfo;
if (info != null)
{
string itemName = null;
if (info != null)
{
itemName = info.Name;
}
if (itemName != null)
{
exception = new SessionStateException(itemName, SessionStateCategory.Command, "NamedCommandIsPrivate", SessionStateStrings.NamedCommandIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
}
else
{
exception = new SessionStateException("", SessionStateCategory.Command, "CommandIsPrivate", SessionStateStrings.CommandIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
}
throw exception;
}
exception = new SessionStateException(null, SessionStateCategory.Resource, "ResourceIsPrivate", SessionStateStrings.ResourceIsPrivate, ErrorCategory.PermissionDenied, new object[0]);
throw exception;
}
}
protected internal void WriteError(SessionStateException ex)
{
string errorId = String.Format("{0},{1}", ex.ErrorRecord.ErrorId, GetType().FullName);
var error = new ErrorRecord(ex, errorId, ex.ErrorRecord.CategoryInfo.Category, ex.ItemName);
error.CategoryInfo.Activity = GetActivityName();
WriteError(error);
}
internal FunctionInfo SetFunctionRaw(string name, ScriptBlock function, CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string itemName = name;
FunctionLookupPath lookupPath = new FunctionLookupPath(name);
name = lookupPath.UnqualifiedPath;
if (string.IsNullOrEmpty(name))
{
SessionStateException exception = new SessionStateException(itemName, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument, new object[0]);
throw exception;
}
ScopedItemOptions none = ScopedItemOptions.None;
if (lookupPath.IsPrivate)
{
none |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher(this, lookupPath, origin);
return searcher.InitialScope.SetFunction(name, function, null, none, false, origin, this.ExecutionContext);
}
} // SetFunctionRaw
internal WorkflowInfo SetWorkflowRaw(
WorkflowInfo workflowInfo,
CommandOrigin origin)
{
string originalName = workflowInfo.Name;
string name = originalName;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (String.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
// The script that defines a workflowInfo wrapper is fully trusted
workflowInfo.ScriptBlock.LanguageMode = PSLanguageMode.FullLanguage;
if (workflowInfo.Module == null && this.Module != null)
{
workflowInfo.Module = this.Module;
}
var wfInfo = (WorkflowInfo)
searcher.InitialScope.SetFunction(name, workflowInfo.ScriptBlock, null, options, false, origin, ExecutionContext, null,
(arg1, arg2, arg3, arg4, arg5, arg6) => workflowInfo);
foreach (var aliasName in GetFunctionAliases(workflowInfo.ScriptBlock.Ast as IParameterMetadataProvider))
{
searcher.InitialScope.SetAliasValue(aliasName, name, ExecutionContext, false, origin);
}
return wfInfo;
} // SetWorkflowRaw
internal WorkflowInfo SetWorkflowRaw(WorkflowInfo workflowInfo, CommandOrigin origin)
{
string name = workflowInfo.Name;
string unqualifiedPath = name;
FunctionLookupPath lookupPath = new FunctionLookupPath(unqualifiedPath);
unqualifiedPath = lookupPath.UnqualifiedPath;
if (string.IsNullOrEmpty(unqualifiedPath))
{
SessionStateException exception = new SessionStateException(name, SessionStateCategory.Function, "ScopedFunctionMustHaveName", SessionStateStrings.ScopedFunctionMustHaveName, ErrorCategory.InvalidArgument, new object[0]);
throw exception;
}
ScopedItemOptions none = ScopedItemOptions.None;
if (lookupPath.IsPrivate)
{
none |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher = new FunctionScopeItemSearcher(this, lookupPath, origin);
workflowInfo.ScriptBlock.LanguageMode = 0;
return (WorkflowInfo) searcher.InitialScope.SetFunction(unqualifiedPath, workflowInfo.ScriptBlock, null, none, false, origin, this.ExecutionContext, null, (arg1, arg2, arg3, arg4, arg5, arg6) => workflowInfo);
}
protected override void ProcessRecord()
{
if (base.Force == 0)
{
AliasInfo valueToCheck = null;
if (string.IsNullOrEmpty(base.Scope))
{
valueToCheck = base.SessionState.Internal.GetAlias(base.Name);
}
else
{
valueToCheck = base.SessionState.Internal.GetAliasAtScope(base.Name, base.Scope);
}
if (valueToCheck != null)
{
SessionState.ThrowIfNotVisible(base.CommandOrigin, valueToCheck);
SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(base.Name, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasAlreadyExists, ErrorCategory.ResourceExists, new object[0]);
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
return;
}
}
AliasInfo alias = new AliasInfo(base.Name, base.Value, base.Context, base.Option) {
Description = base.Description
};
string newAliasAction = AliasCommandStrings.NewAliasAction;
string target = StringUtil.Format(AliasCommandStrings.NewAliasTarget, base.Name, base.Value);
if (base.ShouldProcess(target, newAliasAction))
{
AliasInfo sendToPipeline = null;
try
{
if (string.IsNullOrEmpty(base.Scope))
{
sendToPipeline = base.SessionState.Internal.SetAliasItem(alias, (bool) base.Force, base.MyInvocation.CommandOrigin);
}
else
{
sendToPipeline = base.SessionState.Internal.SetAliasItemAtScope(alias, base.Scope, (bool) base.Force, base.MyInvocation.CommandOrigin);
}
}
catch (SessionStateException exception2)
{
base.WriteError(new ErrorRecord(exception2.ErrorRecord, exception2));
return;
}
catch (PSArgumentOutOfRangeException exception3)
{
base.WriteError(new ErrorRecord(exception3.ErrorRecord, exception3));
return;
}
catch (PSArgumentException exception4)
{
base.WriteError(new ErrorRecord(exception4.ErrorRecord, exception4));
return;
}
if ((base.PassThru != 0) && (sendToPipeline != null))
{
base.WriteObject(sendToPipeline);
}
}
}
private bool VerifyShadowingExistingCommandsAndWriteError(string aliasName)
{
CommandSearcher searcher = new CommandSearcher(aliasName, SearchResolutionOptions.None, CommandTypes.Workflow | CommandTypes.Script | CommandTypes.Application | CommandTypes.ExternalScript | CommandTypes.Cmdlet | CommandTypes.Filter | CommandTypes.Function, base.Context);
foreach (string str in searcher.ConstructSearchPatternsFromName(aliasName))
{
CommandTypes types;
if (this.ExistingCommands.TryGetValue(str, out types))
{
SessionStateException replaceParentContainsErrorRecordException = new SessionStateException(aliasName, SessionStateCategory.Alias, "AliasAlreadyExists", SessionStateStrings.AliasWithCommandNameAlreadyExists, ErrorCategory.ResourceExists, new object[] { types });
base.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException));
return true;
}
}
return false;
}
private void WriteVariableAlreadyExistsError(PSVariable variable)
{
var ex = new SessionStateException(
String.Format("A variable with name '{0}' already exists.", variable.Name),
variable.Name,
SessionStateCategory.Variable);
string errorId = String.Format("VariableAlreadyExists,{0}", typeof(NewVariableCommand).FullName);
var error = new ErrorRecord(ex, errorId, ErrorCategory.ResourceExists, variable.Name);
error.CategoryInfo.Activity = "New-Variable";
WriteError(error);
}
/// <summary>
/// Set a function in the current scope of session state.
/// </summary>
/// <param name="name">
/// The name of the function to set.
/// </param>
/// <param name="function">
/// The new value of the function being set.
/// </param>
/// <param name="originalFunction">
/// The original function (if any) from which the ScriptBlock is derived.
/// </param>
/// <param name="force">
/// If true, the function will be set even if its ReadOnly.
/// </param>
/// <param name="origin">
/// The origin of the caller
/// </param>
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// or
/// If <paramref name="function"/> is not a <see cref="FilterInfo">FilterInfo</see>
/// or <see cref="FunctionInfo">FunctionInfo</see>
/// </exception>
/// <exception cref="ArgumentNullException">
/// If <paramref name="function"/> is null.
/// </exception>
/// <exception cref="SessionStateUnauthorizedAccessException">
/// If the function is read-only or constant.
/// </exception>
internal FunctionInfo SetFunction(
string name,
ScriptBlock function,
FunctionInfo originalFunction,
bool force,
CommandOrigin origin)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (function == null)
{
throw PSTraceSource.NewArgumentNullException("function");
}
string originalName = name;
FunctionLookupPath path = new FunctionLookupPath(name);
name = path.UnqualifiedPath;
if (string.IsNullOrEmpty(name))
{
SessionStateException exception =
new SessionStateException(
originalName,
SessionStateCategory.Function,
"ScopedFunctionMustHaveName",
SessionStateStrings.ScopedFunctionMustHaveName,
ErrorCategory.InvalidArgument);
throw exception;
}
ScopedItemOptions options = ScopedItemOptions.None;
if (path.IsPrivate)
{
options |= ScopedItemOptions.Private;
}
FunctionScopeItemSearcher searcher =
new FunctionScopeItemSearcher(
this,
path,
origin);
FunctionInfo result = null;
SessionStateScope scope = searcher.InitialScope;
if (searcher.MoveNext())
{
scope = searcher.CurrentLookupScope;
name = searcher.Name;
if (path.IsPrivate)
{
// Need to add the Private flag
FunctionInfo existingFunction = scope.GetFunction(name);
options |= existingFunction.Options;
result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext);
}
else
{
result = scope.SetFunction(name, function, force, origin, ExecutionContext);
}
}
else
{
if (path.IsPrivate)
{
result = scope.SetFunction(name, function, originalFunction, options, force, origin, ExecutionContext);
}
else
{
result = scope.SetFunction(name, function, force, origin, ExecutionContext);
}
}
return(result);
}
/// <summary>
/// Adds a new drive to the scope's drive collection.
/// </summary>
///
/// <param name="newDrive">
/// The new drive to be added.
/// </param>
///
/// <remarks>
/// This method assumes the drive has already been verified and
/// the provider has already been notified.
/// </remarks>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="newDrive" /> is null.
/// </exception>
///
/// <exception cref="SessionStateException">
/// If a drive of the same name already exists in this scope.
/// </exception>
///
/// <exception cref="SessionStateOverflowException">
/// If the maximum drive count has been reached for this scope.
/// </exception>
///
internal void NewDrive(PSDriveInfo newDrive)
{
if (newDrive == null)
{
throw PSTraceSource.NewArgumentNullException("newDrive");
}
// Ensure that multiple threads do not try to modify the
// drive data at the same time.
var driveInfos = GetDrives();
if (driveInfos.ContainsKey(newDrive.Name))
{
SessionStateException e =
new SessionStateException(
newDrive.Name,
SessionStateCategory.Drive,
"DriveAlreadyExists",
SessionStateStrings.DriveAlreadyExists,
ErrorCategory.ResourceExists);
throw e;
}
if (!newDrive.IsAutoMounted &&
driveInfos.Count > DriveCapacity.FastValue - 1)
{
SessionStateOverflowException e =
new SessionStateOverflowException(
newDrive.Name,
SessionStateCategory.Drive,
"DriveOverflow",
SessionStateStrings.DriveOverflow,
DriveCapacity.FastValue);
throw e;
}
if (!newDrive.IsAutoMounted)
{
driveInfos.Add(newDrive.Name, newDrive);
}
else
{
var automountedDrives = GetAutomountedDrives();
if (!automountedDrives.ContainsKey(newDrive.Name))
{
automountedDrives.Add(newDrive.Name, newDrive);
}
}
} // New Drive
