/// <summary>
/// Add a parameter to the command invocation.
/// It needs to be called before any execution takes place.
/// </summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="parameterValue">Value of the parameter.</param>
internal void AddNamedParameter(string parameterName, object parameterValue)
{
_commandParameterList.Add(
CommandParameterInternal.CreateParameterWithArgument(
/*parameterAst*/ null, parameterName, null,
/*argumentAst*/ null, parameterValue,
false));
}
/// <summary>
/// add a parameter to the command invocation.
/// It needs to be called before any execution takes place
/// </summary>
/// <param name="parameterName">name of the parameter</param>
/// <param name="parameterValue">value of the parameter</param>
internal void AddNamedParameter(string parameterName, object parameterValue)
{
_commandParameterList.Add(
CommandParameterInternal.CreateParameterWithArgument(
PositionUtilities.EmptyExtent, parameterName, null,
PositionUtilities.EmptyExtent, parameterValue,
false));
}
/// <summary>
/// Passes the binding directly through to the parameter binder.
/// It does no verification against metadata.
/// </summary>
/// <param name="argument">
/// The name and value of the variable to bind.
/// </param>
/// <param name="flags">
/// Ignored.
/// </param>
/// <returns>
/// True if the parameter was successfully bound. Any error condition
/// produces an exception.
/// </returns>
internal override bool BindParameter(
CommandParameterInternal argument,
ParameterBindingFlags flags)
{
Diagnostics.Assert(false, "Unreachable code");
throw new InvalidOperationException();
}
internal static CommandParameter FromCommandParameterInternal(
CommandParameterInternal internalParameter)
{
if (internalParameter == null)
{
throw CommandParameter._trace.NewArgumentNullException(nameof(internalParameter));
}
string name = (string)null;
if (internalParameter.Name != null)
{
name = internalParameter.Token == null ? internalParameter.Name : (!internalParameter.Token.FollowedBySpace ? internalParameter.Token.ToString() : internalParameter.Token.ToString() + " ");
}
if (internalParameter.IsValidPair)
{
object obj = internalParameter.Value2;
return(new CommandParameter(name, obj));
}
return(name != null ? new CommandParameter(name) : new CommandParameter((string)null, internalParameter.Value1));
}
internal static CommandParameterInternal ToCommandParameterInternal(CommandParameter publicParameter, bool forNativeCommand)
{
string str2;
if (publicParameter == null)
{
throw PSTraceSource.NewArgumentNullException("publicParameter");
}
string name = publicParameter.Name;
object obj2 = publicParameter.Value;
if (name == null)
{
return(CommandParameterInternal.CreateArgument(PositionUtilities.EmptyExtent, obj2, false));
}
if (!name[0].IsDash())
{
str2 = forNativeCommand ? name : ("-" + name);
return(CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, name, str2, PositionUtilities.EmptyExtent, obj2, true));
}
bool spaceAfterParameter = false;
int length = name.Length;
while ((length > 0) && char.IsWhiteSpace(name[length - 1]))
{
spaceAfterParameter = true;
length--;
}
str2 = name.Substring(0, length);
bool flag2 = name[length - 1] == ':';
string parameterName = str2.Substring(1, str2.Length - (flag2 ? 2 : 1));
if (!flag2 && (obj2 == null))
{
return(CommandParameterInternal.CreateParameter(PositionUtilities.EmptyExtent, parameterName, str2));
}
return(CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, parameterName, str2, PositionUtilities.EmptyExtent, obj2, spaceAfterParameter));
}
CreateCommandProcessor
(
ExecutionContext executionContext,
CommandFactory commandFactory,
bool addToHistory,
CommandOrigin origin
)
{
Dbg.Assert(executionContext != null, "Caller should verify the parameters");
Dbg.Assert(commandFactory != null, "Caller should verify the parameters");
CommandProcessorBase commandProcessorBase;
if (IsScript)
{
if ((executionContext.LanguageMode == PSLanguageMode.NoLanguage) &&
(origin == Automation.CommandOrigin.Runspace))
{
throw InterpreterError.NewInterpreterException(CommandText, typeof(ParseException),
null, "ScriptsNotAllowed", ParserStrings.ScriptsNotAllowed);
}
ScriptBlock scriptBlock = executionContext.Engine.ParseScriptBlock(CommandText, addToHistory);
if (origin == Automation.CommandOrigin.Internal)
{
scriptBlock.LanguageMode = PSLanguageMode.FullLanguage;
}
// If running in restricted language mode, verify that the parse tree represents on legitimate
// constructions...
switch (scriptBlock.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
scriptBlock.CheckRestrictedLanguage(null, null, false);
break;
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode.
break;
case PSLanguageMode.ConstrainedLanguage:
// Constrained Language is checked at runtime.
break;
default:
// This should never happen...
Diagnostics.Assert(false, "Invalid langage mode was set when building a ScriptCommandProcessor");
throw new InvalidOperationException("Invalid langage mode was set when building a ScriptCommandProcessor");
}
if (scriptBlock.UsesCmdletBinding)
{
FunctionInfo functionInfo = new FunctionInfo("", scriptBlock, executionContext);
commandProcessorBase = new CommandProcessor(functionInfo, executionContext,
_useLocalScope ?? false, fromScriptFile: false, sessionState: executionContext.EngineSessionState);
}
else
{
commandProcessorBase = new DlrScriptCommandProcessor(scriptBlock,
executionContext, _useLocalScope ?? false,
origin,
executionContext.EngineSessionState);
}
}
else
{
// RestrictedLanguage / NoLanguage do not support dot-sourcing when CommandOrigin is Runspace
if ((_useLocalScope.HasValue) && (!_useLocalScope.Value))
{
switch (executionContext.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
case PSLanguageMode.NoLanguage:
string message = StringUtil.Format(RunspaceStrings.UseLocalScopeNotAllowed,
"UseLocalScope",
PSLanguageMode.RestrictedLanguage.ToString(),
PSLanguageMode.NoLanguage.ToString());
throw new RuntimeException(message);
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode...
break;
}
}
commandProcessorBase =
commandFactory.CreateCommand(CommandText, origin, _useLocalScope);
}
CommandParameterCollection parameters = Parameters;
if (parameters != null)
{
bool isNativeCommand = commandProcessorBase is NativeCommandProcessor;
foreach (CommandParameter publicParameter in parameters)
{
CommandParameterInternal internalParameter = CommandParameter.ToCommandParameterInternal(publicParameter, isNativeCommand);
commandProcessorBase.AddParameter(internalParameter);
}
}
string helpTarget;
HelpCategory helpCategory;
if (commandProcessorBase.IsHelpRequested(out helpTarget, out helpCategory))
{
commandProcessorBase = CommandProcessorBase.CreateGetHelpCommandProcessor(
executionContext,
helpTarget,
helpCategory);
}
//Set the merge settings
SetMergeSettingsOnCommandProcessor(commandProcessorBase);
return(commandProcessorBase);
}
/// <summary>
/// Binds the specified parameters to the native command.
/// </summary>
/// <param name="parameters">
/// The parameters to bind.
/// </param>
/// <param name="outputRedirected">
/// true if minishell output is redirected.
/// </param>
/// <param name="hostName">
/// name of the calling host.
/// </param>
/// <remarks>
/// For any parameters that do not have a name, they are added to the command
/// line arguments for the command
/// </remarks>
internal Collection<CommandParameterInternal> BindParameters(Collection<CommandParameterInternal> parameters, bool outputRedirected, string hostName)
{
MinishellParameters seen = 0;
string inputFormat = null;
string outputFormat = null;
for (int i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
if (parameter.ParameterNameSpecified)
{
var parameterName = parameter.ParameterName;
if (CommandParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
{
HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter);
// Value must be specified for -Command parameter.
if (i + 1 >= parameters.Count)
{
throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter,
typeof(ScriptBlock), null,
NativeCP.NoValueForCommandParameter,
"NoValueForCommandParameter");
}
i += 1;
// Value of -Command parameter must be scriptblock
var scriptBlockArgument = parameters[i];
var argumentValue = PSObject.Base(scriptBlockArgument.ArgumentValue);
if (!scriptBlockArgument.ArgumentSpecified || argumentValue is not ScriptBlock)
{
throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter,
typeof(ScriptBlock), argumentValue.GetType(),
NativeCP.IncorrectValueForCommandParameter,
"IncorrectValueForCommandParameter");
}
// Replace the parameters with -EncodedCommand <base64 encoded scriptblock>
parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedCommandParameter, "-" + EncodedCommandParameter, parameter.ParameterAst);
string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString());
parameters[i] = CommandParameterInternal.CreateArgument(encodedScript, scriptBlockArgument.ArgumentAst);
}
else if (InputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
{
HandleSeenParameter(ref seen, MinishellParameters.InputFormat, InputFormatParameter);
// Value for -Inputformat must be specified
if (i + 1 >= parameters.Count)
{
throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, InputFormatParameter,
typeof(string), null,
NativeCP.NoValueForInputFormatParameter,
"NoValueForInputFormatParameter");
}
// Update the argument (partial arguments are allowed)
i += 1;
var inputFormatArg = parameters[i];
inputFormat = ProcessFormatParameterValue(InputFormatParameter, inputFormatArg.ArgumentValue);
parameters[i - 1] = CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter, parameter.ParameterAst);
parameters[i] = CommandParameterInternal.CreateArgument(inputFormat, inputFormatArg.ArgumentAst);
}
else if (OutputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
{
HandleSeenParameter(ref seen, MinishellParameters.OutputFormat, OutputFormatParameter);
// Value for -Inputformat must be specified
if (i + 1 >= parameters.Count)
{
throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, OutputFormatParameter,
typeof(string), null,
NativeCP.NoValueForOutputFormatParameter,
"NoValueForInputFormatParameter");
}
// Update the argument (partial arguments are allowed)
i += 1;
var outputFormatArg = parameters[i];
outputFormat = ProcessFormatParameterValue(OutputFormatParameter, outputFormatArg.ArgumentValue);
parameters[i - 1] = CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter, parameter.ParameterAst);
parameters[i] = CommandParameterInternal.CreateArgument(outputFormat, outputFormatArg.ArgumentAst);
}
else if (ArgsParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
{
HandleSeenParameter(ref seen, MinishellParameters.Arguments, ArgsParameter);
// Value for -Args parameter must be specified
if (i + 1 >= parameters.Count)
{
throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, ArgsParameter,
typeof(string), null, NativeCP.NoValuesSpecifiedForArgs,
"NoValuesSpecifiedForArgs");
}
// Get the encoded value for -args parameter
i += 1;
var argsArg = parameters[i];
var encodedArgs = ConvertArgsValueToEncodedString(argsArg.ArgumentValue);
parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedArgsParameter, "-" + EncodedArgsParameter, parameter.ParameterAst);
// NOTE: do not pass the ArgumentAst; it will fail validation in BindParameters if there
// are multiple arguments (array) but encodedArgs is an encoded string.
parameters[i] = CommandParameterInternal.CreateArgument(encodedArgs);
}
}
else
{
// -Command is positional parameter. Bind first scriptblock to it, others are errors.
var scriptBlockArgument = parameters[i];
var argumentValue = PSObject.Base(scriptBlockArgument.ArgumentValue);
if (argumentValue is ScriptBlock)
{
HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter);
// Replace the argument with -EncodedCommand <base64 encoded scriptblock>
string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString());
parameters[i] = CommandParameterInternal.CreateParameterWithArgument(
parameter.ArgumentAst, EncodedCommandParameter, "-" + EncodedCommandParameter,
parameter.ArgumentAst, encodedScript,
spaceAfterParameter: true);
}
}
}
// Add InputFormat and OutputFormat parameter if not specified
if (inputFormat == null)
{
// For minishell default input format is xml
parameters.Add(CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter));
parameters.Add(CommandParameterInternal.CreateArgument(XmlFormatValue));
inputFormat = XmlFormatValue;
}
if (outputFormat == null)
{
// If output is redirected, output format should be xml
outputFormat = outputRedirected ? XmlFormatValue : TextFormatValue;
parameters.Add(CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter));
parameters.Add(CommandParameterInternal.CreateArgument(outputFormat));
}
// Set the output and input format class variable
InputFormat = XmlFormatValue.StartsWith(inputFormat, StringComparison.OrdinalIgnoreCase)
? NativeCommandIOFormat.Xml
: NativeCommandIOFormat.Text;
OutputFormat = XmlFormatValue.StartsWith(outputFormat, StringComparison.OrdinalIgnoreCase)
? NativeCommandIOFormat.Xml
: NativeCommandIOFormat.Text;
// Note if a minishell is invoked from a non-console host, we need to
// pass -nonInteractive flag. Our console host's name is "ConsoleHost".
// Correct check would be see if current host has access to console and
// pass noninteractive flag if doesn't.
if (string.IsNullOrEmpty(hostName) || !hostName.Equals("ConsoleHost", StringComparison.OrdinalIgnoreCase))
{
NonInteractive = true;
parameters.Insert(0, CommandParameterInternal.CreateParameter(NonInteractiveParameter, "-" + NonInteractiveParameter));
}
((NativeCommandParameterBinder)DefaultParameterBinder).BindParameters(parameters);
Diagnostics.Assert(s_emptyReturnCollection.Count == 0, "This list shouldn't be used for anything as it's shared.");
return s_emptyReturnCollection;
}
internal static CommandParameterInternal ToCommandParameterInternal(CommandParameter publicParameter, bool forNativeCommand)
{
if (publicParameter == null)
{
throw PSTraceSource.NewArgumentNullException(nameof(publicParameter));
}
string name = publicParameter.Name;
object value = publicParameter.Value;
Debug.Assert((name == null) || (name.Trim().Length != 0), "Parameter name has to null or have some non-whitespace characters in it");
if (name == null)
{
return(CommandParameterInternal.CreateArgument(value));
}
string parameterText;
if (!name[0].IsDash())
{
parameterText = forNativeCommand ? name : "-" + name;
return(CommandParameterInternal.CreateParameterWithArgument(
/*parameterAst*/ null, name, parameterText,
/*argumentAst*/ null, value,
true));
}
// if first character of name is '-', then we try to fake the original token
// reconstructing dashes, colons and followed-by-space information
// find the last non-whitespace character
bool spaceAfterParameter = false;
int endPosition = name.Length;
while ((endPosition > 0) && char.IsWhiteSpace(name[endPosition - 1]))
{
spaceAfterParameter = true;
endPosition--;
}
Debug.Assert(endPosition > 0, "parameter name should have some non-whitespace characters in it");
// now make sure that parameterText doesn't have whitespace at the end,
parameterText = name.Substring(0, endPosition);
// parameterName should contain only the actual name of the parameter (no whitespace, colons, dashes)
bool hasColon = (name[endPosition - 1] == ':');
var parameterName = parameterText.Substring(1, parameterText.Length - (hasColon ? 2 : 1));
// At this point we have rebuilt the token. There are 3 strings that might be different:
// name = nameToken.Script = "-foo: " <- needed to fake FollowedBySpace=true (i.e. for "testecho.exe -a:b -c: d")
// tokenString = nameToken.TokenText = "-foo:" <- needed to preserve full token text (i.e. for write-output)
// nameToken.Data = "foo" <- needed to preserve name of parameter so parameter binding works
// Now we just need to use the token to build appropriate CommandParameterInternal object
// is this a name+value pair, or is it just a name (of a parameter)?
if (!hasColon && value == null)
{
// just a name
return(CommandParameterInternal.CreateParameter(parameterName, parameterText));
}
// name+value pair
return(CommandParameterInternal.CreateParameterWithArgument(
/*parameterAst*/ null, parameterName, parameterText,
/*argumentAst*/ null, value,
spaceAfterParameter));
}
internal CommandProcessorBase CreateCommandProcessor(ExecutionContext executionContext, CommandFactory commandFactory, bool addToHistory, CommandOrigin origin)
{
CommandProcessorBase base2;
string str2;
HelpCategory category;
if (!this.IsScript)
{
if (this._useLocalScope.HasValue && !this._useLocalScope.Value)
{
switch (executionContext.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
case PSLanguageMode.NoLanguage:
throw new RuntimeException(StringUtil.Format(RunspaceStrings.UseLocalScopeNotAllowed, new object[] { "UseLocalScope", PSLanguageMode.RestrictedLanguage.ToString(), PSLanguageMode.NoLanguage.ToString() }));
}
}
base2 = commandFactory.CreateCommand(this.CommandText, origin, this._useLocalScope);
}
else
{
if (executionContext.LanguageMode == PSLanguageMode.NoLanguage)
{
throw InterpreterError.NewInterpreterException(this.CommandText, typeof(ParseException), null, "ScriptsNotAllowed", ParserStrings.ScriptsNotAllowed, new object[0]);
}
ScriptBlock function = executionContext.Engine.ParseScriptBlock(this.CommandText, addToHistory);
switch (executionContext.LanguageMode)
{
case PSLanguageMode.FullLanguage:
case PSLanguageMode.ConstrainedLanguage:
break;
case PSLanguageMode.RestrictedLanguage:
function.CheckRestrictedLanguage(null, null, false);
break;
default:
throw new InvalidOperationException("Invalid langage mode was set when building a ScriptCommandProcessor");
}
if (function.UsesCmdletBinding)
{
FunctionInfo scriptCommandInfo = new FunctionInfo("", function, executionContext);
bool? nullable = this._useLocalScope;
base2 = new CommandProcessor(scriptCommandInfo, executionContext, nullable.HasValue ? nullable.GetValueOrDefault() : false, false, executionContext.EngineSessionState);
}
else
{
bool?nullable2 = this._useLocalScope;
base2 = new DlrScriptCommandProcessor(function, executionContext, nullable2.HasValue ? nullable2.GetValueOrDefault() : false, CommandOrigin.Runspace, executionContext.EngineSessionState);
}
}
CommandParameterCollection parameters = this.Parameters;
if (parameters != null)
{
bool forNativeCommand = base2 is NativeCommandProcessor;
foreach (CommandParameter parameter in parameters)
{
CommandParameterInternal internal2 = CommandParameter.ToCommandParameterInternal(parameter, forNativeCommand);
base2.AddParameter(internal2);
}
}
if (base2.IsHelpRequested(out str2, out category))
{
base2 = CommandProcessorBase.CreateGetHelpCommandProcessor(executionContext, str2, category);
}
this.SetMergeSettingsOnCommandProcessor(base2);
return(base2);
}
private PipelineProcessor CreatePipelineProcessor()
{
PipelineProcessor processor2;
CommandCollection commands = base.Commands;
if ((commands == null) || (commands.Count == 0))
{
throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoCommandInPipeline", new object[0]);
}
PipelineProcessor processor = new PipelineProcessor {
TopLevel = true
};
bool flag = false;
try
{
foreach (Command command in commands)
{
CommandProcessorBase base2;
if (command.CommandInfo == null)
{
base2 = command.CreateCommandProcessor(this.LocalRunspace.ExecutionContext, this.LocalRunspace.CommandFactory, base.AddToHistory, this.IsNested ? CommandOrigin.Internal : CommandOrigin.Runspace);
}
else
{
CmdletInfo commandInfo = (CmdletInfo)command.CommandInfo;
base2 = new CommandProcessor(commandInfo, this.LocalRunspace.ExecutionContext);
PSSQMAPI.IncrementData(commandInfo.CommandType);
base2.Command.CommandOriginInternal = CommandOrigin.Internal;
base2.Command.MyInvocation.InvocationName = commandInfo.Name;
if (command.Parameters != null)
{
foreach (CommandParameter parameter in command.Parameters)
{
CommandParameterInternal internal2 = CommandParameter.ToCommandParameterInternal(parameter, false);
base2.AddParameter(internal2);
}
}
}
base2.RedirectShellErrorOutputPipe = base.RedirectShellErrorOutputPipe;
processor.Add(base2);
}
processor2 = processor;
}
catch (RuntimeException)
{
flag = true;
throw;
}
catch (Exception exception)
{
flag = true;
CommandProcessorBase.CheckForSevereException(exception);
throw new RuntimeException(PipelineStrings.CannotCreatePipeline, exception);
}
finally
{
if (flag)
{
base.SetHadErrors(true);
processor.Dispose();
}
}
return(processor2);
}
