private PSAuthorizationManager.RunPromptDecision RemoteFilePrompt(
string path,
PSHost host)
{
if (host == null || host.UI == null)
{
return(PSAuthorizationManager.RunPromptDecision.DoNotRun);
}
Collection <ChoiceDescription> filePromptChoices = this.GetRemoteFilePromptChoices();
string resourceString = ResourceManagerCache.GetResourceString("Authenticode", "RemoteFilePromptCaption");
string message = ResourceManagerCache.FormatResourceString("Authenticode", "RemoteFilePromptText", (object)path);
switch (host.UI.PromptForChoice(resourceString, message, filePromptChoices, 0))
{
case 0:
return(PSAuthorizationManager.RunPromptDecision.DoNotRun);
case 1:
return(PSAuthorizationManager.RunPromptDecision.RunOnce);
case 2:
return(PSAuthorizationManager.RunPromptDecision.Suspend);
default:
return(PSAuthorizationManager.RunPromptDecision.DoNotRun);
}
}
private static string GetAndCheckFullFileName(
string psSnapinName,
Hashtable fullFileNameHash,
RunspaceConfiguration runspaceConfiguration,
string baseFolder,
string baseFileName,
Collection <string> independentErrors)
{
string path = !Path.IsPathRooted(baseFileName) ? Path.Combine(baseFolder, baseFileName) : baseFileName;
if (!File.Exists(path))
{
string str = ResourceManagerCache.FormatResourceString("TypesXml", "FileNotFound", (object)psSnapinName, (object)path);
independentErrors.Add(str);
return((string)null);
}
string str1 = (string)fullFileNameHash[(object)path];
if (str1 != null)
{
string str2 = ResourceManagerCache.FormatResourceString("TypesXml", "DuplicateFile", (object)psSnapinName, (object)path, (object)str1);
independentErrors.Add(str2);
return((string)null);
}
if (!path.EndsWith(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
string str2 = ResourceManagerCache.FormatResourceString("TypesXml", "EntryShouldBeMshXml", (object)psSnapinName, (object)path);
independentErrors.Add(str2);
return((string)null);
}
fullFileNameHash.Add((object)path, (object)psSnapinName);
return(path);
}
internal static void ThrowIfNotAdministrator()
{
if (!new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator))
{
throw new InvalidOperationException(ResourceManagerCache.FormatResourceString("RemotingErrorIdStrings", "EDcsRequiresElevation"));
}
}
private bool SetPolicyFromAuthenticodePrompt(
string path,
PSHost host,
ref Exception reason,
System.Management.Automation.Signature signature)
{
bool flag = false;
switch (this.AuthenticodePrompt(path, signature, host))
{
case PSAuthorizationManager.RunPromptDecision.NeverRun:
this.UntrustPublisher(signature);
string message1 = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_NeverRun", (object)path);
reason = (Exception) new UnauthorizedAccessException(message1);
flag = false;
break;
case PSAuthorizationManager.RunPromptDecision.DoNotRun:
flag = false;
string message2 = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_DoNotRun", (object)path);
reason = (Exception) new UnauthorizedAccessException(message2);
break;
case PSAuthorizationManager.RunPromptDecision.RunOnce:
flag = true;
break;
case PSAuthorizationManager.RunPromptDecision.AlwaysRun:
this.TrustPublisher(signature);
flag = true;
break;
}
return(flag);
}
private Collection <PSSnapInInfo> Load(
string path,
out PSConsoleLoadException cle)
{
using (MshConsoleInfo.tracer.TraceMethod())
{
cle = (PSConsoleLoadException)null;
MshConsoleInfo._mshsnapinTracer.WriteLine("Load mshsnapins from console file {0}", (object)path);
if (string.IsNullOrEmpty(path))
{
throw MshConsoleInfo.tracer.NewArgumentNullException(nameof(path));
}
if (!Path.IsPathRooted(path))
{
MshConsoleInfo._mshsnapinTracer.TraceError("Console file {0} needs to be a absolute path.", (object)path);
throw MshConsoleInfo.tracer.NewArgumentException(nameof(path), "ConsoleInfoErrorStrings", "PathNotAbsolute", (object)path);
}
if (!path.EndsWith(".psc1", StringComparison.OrdinalIgnoreCase))
{
MshConsoleInfo._mshsnapinTracer.TraceError("Console file {0} needs to have {1} extension.", (object)path, (object)".psc1");
throw MshConsoleInfo.tracer.NewArgumentException(nameof(path), "ConsoleInfoErrorStrings", "BadConsoleExtension", (object)"");
}
PSConsoleFileElement fromFile = PSConsoleFileElement.CreateFromFile(path);
if (!Utils.IsVersionSupported(fromFile.MonadVersion))
{
MshConsoleInfo._mshsnapinTracer.TraceError("Console version {0} is not supported in current monad session.", (object)fromFile.MonadVersion);
throw MshConsoleInfo.tracer.NewArgumentException("PSVersion", "ConsoleInfoErrorStrings", "BadMonadVersion", (object)fromFile.MonadVersion, (object)this.psVersion.ToString());
}
Collection <PSSnapInException> exceptions = new Collection <PSSnapInException>();
foreach (string psSnapIn in fromFile.PSSnapIns)
{
try
{
this.AddPSSnapIn(psSnapIn);
}
catch (PSArgumentException ex)
{
PSSnapInException psSnapInException = new PSSnapInException(psSnapIn, ex.Message, (Exception)ex);
MshConsoleInfo._mshsnapinTracer.TraceException((Exception)psSnapInException);
exceptions.Add(psSnapInException);
}
catch (SecurityException ex)
{
string message = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInReadError");
PSSnapInException psSnapInException = new PSSnapInException(psSnapIn, message, (Exception)ex);
MshConsoleInfo._mshsnapinTracer.TraceException((Exception)psSnapInException);
exceptions.Add(psSnapInException);
}
}
if (exceptions.Count > 0)
{
cle = new PSConsoleLoadException(this, exceptions);
}
this.isDirty = false;
return(this.externalPSSnapIns);
}
}
internal RunspaceOpenModuleLoadException(
string moduleName,
PSDataCollection <ErrorRecord> errors)
: base(ResourceManagerCache.FormatResourceString("runspace", "ErrorLoadingModulesOnRunspaceOpen", (object)moduleName, errors == null || errors.Count <= 0 || errors[0] == null ? (object) string.Empty : (object)errors[0].ToString()), (Exception)null)
{
this._errors = errors;
this.SetErrorId("ErrorLoadingModulesOnRunspaceOpen");
this.SetErrorCategory(ErrorCategory.OpenError);
}
internal void AddError(
string typeName,
int errorLineNumber,
string resourceId,
params object[] formatArguments)
{
string str = ResourceManagerCache.FormatResourceString("TypesXml", resourceId, formatArguments);
this.errors.Add(ResourceManagerCache.FormatResourceString("TypesXml", "FileLineTypeError", (object)this.PSSnapinName, (object)this.fileName, (object)errorLineNumber, (object)typeName, (object)str));
}
private string PromptUserForFile()
{
if (!this.ShouldContinue(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PromptForExportConsole"), (string)null))
{
return(string.Empty);
}
Dictionary <string, PSObject> dictionary = this.PSHostInternal.UI.Prompt(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "FileNameCaptionForExportConsole", (object)"export-console"), ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "FileNamePromptMessage"), new Collection <FieldDescription>()
{
new FieldDescription("Name")
});
return(dictionary != null && dictionary["Name"] != null ? dictionary["Name"].BaseObject as string : string.Empty);
}
private void ClearHistoryByID()
{
using (ClearHistoryCommand._trace.TraceMethod())
{
if (this._countParamterSpecified && this.Count < 0)
{
this.ThrowTerminatingError(new ErrorRecord((Exception) new ArgumentException(ResourceManagerCache.FormatResourceString("History", "InvalidCountValue")), "ClearHistoryInvalidCountValue", ErrorCategory.InvalidArgument, (object)this._count));
}
if (this._id != null)
{
if (!this._countParamterSpecified)
{
foreach (long id in this._id)
{
HistoryInfo entry = this.history.GetEntry(id);
if (entry != null && entry.Id == id)
{
this.history.ClearEntry(entry.Id);
}
else
{
this.WriteError(new ErrorRecord((Exception) new ArgumentException(ResourceManagerCache.FormatResourceString("History", "NoHistoryForId", (object)id)), "GetHistoryNoHistoryForId", ErrorCategory.ObjectNotFound, (object)id));
}
}
}
else if (this._id.Length > 1)
{
this.ThrowTerminatingError(new ErrorRecord((Exception) new ArgumentException(ResourceManagerCache.FormatResourceString("History", "NoCountWithMultipleIds")), "GetHistoryNoCountWithMultipleIds", ErrorCategory.InvalidArgument, (object)this._count));
}
else
{
this.ClearHistoryEntries((long)this._id[0], this._count, (string)null, this._newest);
}
}
else if (!this._countParamterSpecified)
{
if (!this.ShouldProcess(ResourceManagerCache.FormatResourceString("History", "ClearHistoryWarning", (object)"Warning")))
{
return;
}
this.ClearHistoryEntries(0L, -1, (string)null, this._newest);
}
else
{
this.ClearHistoryEntries(0L, this._count, (string)null, this._newest);
}
}
}
public ModuleSpecification(Hashtable moduleSpecification)
{
if (moduleSpecification == null)
{
throw new ArgumentNullException(nameof(moduleSpecification));
}
StringBuilder stringBuilder = new StringBuilder();
foreach (DictionaryEntry dictionaryEntry in moduleSpecification)
{
if (dictionaryEntry.Key.ToString().Equals("ModuleName", StringComparison.OrdinalIgnoreCase))
{
this.name = (string)LanguagePrimitives.ConvertTo(dictionaryEntry.Value, typeof(string), (IFormatProvider)CultureInfo.InvariantCulture);
}
else if (dictionaryEntry.Key.ToString().Equals("ModuleVersion", StringComparison.OrdinalIgnoreCase))
{
this.version = (Version)LanguagePrimitives.ConvertTo(dictionaryEntry.Value, typeof(Version), (IFormatProvider)CultureInfo.InvariantCulture);
}
else if (dictionaryEntry.Key.ToString().Equals("GUID", StringComparison.OrdinalIgnoreCase))
{
this.guid = (System.Guid?)LanguagePrimitives.ConvertTo(dictionaryEntry.Value, typeof(System.Guid?), (IFormatProvider)CultureInfo.InvariantCulture);
}
else
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(", ");
}
stringBuilder.Append("'");
stringBuilder.Append(dictionaryEntry.Key.ToString());
stringBuilder.Append("'");
}
}
if (stringBuilder.Length != 0)
{
throw new ArgumentException(ResourceManagerCache.FormatResourceString("Modules", "InvalidModuleSpecificationMember", (object)"ModuleName, ModuleVersion, GUID", (object)stringBuilder));
}
if (string.IsNullOrEmpty(this.name))
{
throw new MissingMemberException(ResourceManagerCache.FormatResourceString("Modules", "RequiredModuleMissingModuleName"));
}
if (this.version == (Version)null)
{
throw new MissingMemberException(ResourceManagerCache.FormatResourceString("Modules", "RequiredModuleMissingModuleVersion"));
}
}
private PSAuthorizationManager.RunPromptDecision AuthenticodePrompt(
string path,
System.Management.Automation.Signature signature,
PSHost host)
{
if (host == null || host.UI == null)
{
return(PSAuthorizationManager.RunPromptDecision.DoNotRun);
}
PSAuthorizationManager.RunPromptDecision runPromptDecision1 = PSAuthorizationManager.RunPromptDecision.DoNotRun;
if (signature == null)
{
return(runPromptDecision1);
}
PSAuthorizationManager.RunPromptDecision runPromptDecision2;
switch (signature.Status)
{
case SignatureStatus.Valid:
Collection <ChoiceDescription> authenticodePromptChoices = this.GetAuthenticodePromptChoices();
string resourceString = ResourceManagerCache.GetResourceString("Authenticode", "AuthenticodePromptCaption");
string message;
if (signature.SignerCertificate == null)
{
message = ResourceManagerCache.FormatResourceString("Authenticode", "AuthenticodePromptText_UnknownPublisher", (object)path);
}
else
{
message = ResourceManagerCache.FormatResourceString("Authenticode", "AuthenticodePromptText", (object)path, (object)signature.SignerCertificate.SubjectName.Name);
}
runPromptDecision2 = (PSAuthorizationManager.RunPromptDecision)host.UI.PromptForChoice(resourceString, message, authenticodePromptChoices, 1);
break;
case SignatureStatus.UnknownError:
case SignatureStatus.NotSigned:
case SignatureStatus.HashMismatch:
case SignatureStatus.NotSupportedFileFormat:
runPromptDecision2 = PSAuthorizationManager.RunPromptDecision.DoNotRun;
break;
default:
runPromptDecision2 = PSAuthorizationManager.RunPromptDecision.DoNotRun;
break;
}
return(runPromptDecision2);
}
internal static void ThrowExceptionOnError(
string errorId,
Collection <string> independentErrors,
Collection <PSSnapInTypeAndFormatErrors> PSSnapinFilesCollection,
RunspaceConfigurationCategory category)
{
Collection <string> collection = new Collection <string>();
foreach (string independentError in independentErrors)
{
collection.Add(independentError);
}
foreach (PSSnapInTypeAndFormatErrors psSnapinFiles in PSSnapinFilesCollection)
{
foreach (string error in psSnapinFiles.Errors)
{
collection.Add(error);
}
}
if (collection.Count != 0)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append('\n');
foreach (string str in collection)
{
stringBuilder.Append(str);
stringBuilder.Append('\n');
}
string message = "";
switch (category)
{
case RunspaceConfigurationCategory.Types:
message = ResourceManagerCache.FormatResourceString("ExtendedTypeSystem", "TypesXmlError", (object)stringBuilder.ToString());
break;
case RunspaceConfigurationCategory.Formats:
message = XmlLoadingResourceManager.FormatString("FormatLoadingErrors", (object)stringBuilder.ToString());
break;
}
RuntimeException runtimeException = new RuntimeException(message);
runtimeException.SetErrorId(errorId);
throw runtimeException;
}
}
protected XmlDocument LoadXmlDocumentFromFileLoadingInfo(
AuthorizationManager authorizationManager,
PSHost host)
{
ExternalScriptInfo externalScriptInfo = new ExternalScriptInfo(this.FilePath, this.FilePath);
string scriptContents = externalScriptInfo.ScriptContents;
if (authorizationManager != null)
{
try
{
authorizationManager.ShouldRunInternal((CommandInfo)externalScriptInfo, CommandOrigin.Internal, host);
}
catch (PSSecurityException ex)
{
this.ReportError(ResourceManagerCache.FormatResourceString("TypesXml", "ValidationException", (object)string.Empty, (object)this.FilePath, (object)ex.Message));
return((XmlDocument)null);
}
}
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.PreserveWhitespace = true;
try
{
using (StringReader stringReader = new StringReader(scriptContents))
xmlDocument.Load((TextReader)stringReader);
}
catch (XmlException ex)
{
this.ReportError(XmlLoadingResourceManager.FormatString("ErrorInFile", (object)this.FilePath, (object)ex.Message));
this.ReportTrace("XmlDocument discarded");
return((XmlDocument)null);
}
catch (Exception ex)
{
XmlLoaderBase.tracer.TraceException(ex);
CommandProcessorBase.CheckForSevereException(ex);
throw;
}
this.ReportTrace("XmlDocument loaded OK");
return(xmlDocument);
}
internal static void RestartWinRMService(
PSCmdlet cmdlet,
bool isErrorReported,
bool force,
bool noServiceRestart)
{
if (isErrorReported || noServiceRestart)
{
return;
}
string resourceString = ResourceManagerCache.GetResourceString("RemotingErrorIdStrings", "RestartWSManServiceAction");
string target = ResourceManagerCache.FormatResourceString("RemotingErrorIdStrings", "RestartWSManServiceTarget", (object)"WinRM");
if (!force && !cmdlet.ShouldProcess(target, resourceString))
{
return;
}
cmdlet.WriteVerbose(ResourceManagerCache.FormatResourceString("RemotingErrorIdStrings", "RestartWSManServiceMessageV"));
cmdlet.InvokeCommand.NewScriptBlock("restart-service winrm -force -confirm:$false").InvokeUsingCmdlet((Cmdlet)cmdlet, true, true, (object)AutomationNull.Value, (object)new object[0], (object)AutomationNull.Value);
}
private static string GetBaseFolder(
RunspaceConfiguration runspaceConfiguration,
Collection <string> independentErrors)
{
string pathFromRegistry = CommandDiscovery.GetShellPathFromRegistry(runspaceConfiguration.ShellId);
string path;
if (pathFromRegistry == null)
{
path = Path.GetDirectoryName(PsUtils.GetMainModule(Process.GetCurrentProcess()).FileName);
}
else
{
path = Path.GetDirectoryName(pathFromRegistry);
if (!Directory.Exists(path))
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string str = ResourceManagerCache.FormatResourceString("TypesXml", "CannotFindRegistryKeyPath", (object)path, (object)Utils.GetRegistryConfigurationPath(runspaceConfiguration.ShellId), (object)"\\Path", (object)directoryName);
independentErrors.Add(str);
path = directoryName;
}
}
return(path);
}
internal static string FormatString(string resourceId, params object[] args) => ResourceManagerCache.FormatResourceString("FormatAndOut.XmlLoading", resourceId, args);
private void ClearHistoryEntries(long id, int count, string cmdline, SwitchParameter newest)
{
using (ClearHistoryCommand._trace.TraceMethod())
{
if (cmdline == null)
{
if (id > 0L)
{
HistoryInfo entry = this.history.GetEntry(id);
if (entry == null || entry.Id != id)
{
this.WriteError(new ErrorRecord((Exception) new ArgumentException(ResourceManagerCache.FormatResourceString("History", "NoHistoryForId", (object)id)), "GetHistoryNoHistoryForId", ErrorCategory.ObjectNotFound, (object)id));
}
this.entries = this.history.GetEntries(id, (long)count, newest);
}
else
{
this.entries = this.history.GetEntries(0L, (long)count, newest);
}
}
else
{
WildcardPattern wildcardpattern = new WildcardPattern(cmdline, WildcardOptions.IgnoreCase);
if (!this._countParamterSpecified && WildcardPattern.ContainsWildcardCharacters(cmdline))
{
count = 0;
}
this.entries = this.history.GetEntries(wildcardpattern, (long)count, newest);
}
foreach (HistoryInfo entry in this.entries)
{
if (entry != null && !entry.Cleared)
{
this.history.ClearEntry(entry.Id);
}
}
}
}
private void CoreInvoke(IEnumerable input, bool syncCall)
{
using (PipelineBase._trace.TraceMethod())
{
lock (this.SyncRoot)
{
if (this._disposed)
{
throw PipelineBase._trace.NewObjectDisposedException("pipeline");
}
if (this.Commands == null || this.Commands.Count == 0)
{
throw PipelineBase._trace.NewInvalidOperationException("Runspace", "NoCommandInPipeline");
}
if (this.PipelineState != PipelineState.NotStarted)
{
InvalidPipelineStateException pipelineStateException = new InvalidPipelineStateException(ResourceManagerCache.FormatResourceString("Runspace", "PipelineReInvokeNotAllowed"), this.PipelineState, PipelineState.NotStarted);
PipelineBase._trace.TraceException((Exception)pipelineStateException);
throw pipelineStateException;
}
if (syncCall)
{
if (input != null)
{
foreach (object obj in input)
{
this._inputStream.Write(obj);
}
}
this._inputStream.Close();
}
this._syncInvokeCall = syncCall;
this._pipelineFinishedEvent = new ManualResetEvent(false);
this.RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
this.SetPipelineState(PipelineState.Running);
}
try
{
this.StartPipelineExecution();
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
PipelineBase._trace.TraceException(ex);
this.RunspaceBase.RemoveFromRunningPipelineList(this);
this.SetPipelineState(PipelineState.Failed, ex);
throw;
}
}
}
private Collection <int> EmulatePromptForMultipleChoice(
string caption,
string message,
Collection <ChoiceDescription> choices,
IEnumerable <int> defaultChoices)
{
if (choices == null)
{
throw InternalHostUserInterface.tracer.NewArgumentNullException(nameof(choices));
}
if (choices.Count == 0)
{
throw InternalHostUserInterface.tracer.NewArgumentException(nameof(choices), "InternalHostUserInterfaceStrings", "EmptyChoicesError", (object)nameof(choices));
}
Dictionary <int, bool> dictionary = new Dictionary <int, bool>();
if (defaultChoices != null)
{
foreach (int defaultChoice in defaultChoices)
{
if (defaultChoice < 0 || defaultChoice >= choices.Count)
{
throw InternalHostUserInterface.tracer.NewArgumentOutOfRangeException("defaultChoice", (object)defaultChoice, "InternalHostUserInterfaceStrings", "InvalidDefaultChoiceForMultipleSelection", (object)"defaultChoice", (object)nameof(choices), (object)defaultChoice);
}
if (!dictionary.ContainsKey(defaultChoice))
{
dictionary.Add(defaultChoice, true);
}
}
}
StringBuilder stringBuilder1 = new StringBuilder();
char ch = '\n';
if (!string.IsNullOrEmpty(caption))
{
stringBuilder1.Append(caption);
stringBuilder1.Append(ch);
}
if (!string.IsNullOrEmpty(message))
{
stringBuilder1.Append(message);
stringBuilder1.Append(ch);
}
string[,] hotkeysAndPlainLabels = (string[, ])null;
HostUIHelperMethods.BuildHotkeysAndPlainLabels(choices, out hotkeysAndPlainLabels);
string format = "[{0}] {1} ";
for (int index = 0; index < hotkeysAndPlainLabels.GetLength(1); ++index)
{
string str = string.Format((IFormatProvider)CultureInfo.InvariantCulture, format, (object)hotkeysAndPlainLabels[0, index], (object)hotkeysAndPlainLabels[1, index]);
stringBuilder1.Append(str);
stringBuilder1.Append(ch);
}
string str1 = "";
if (dictionary.Count > 0)
{
string str2 = "";
StringBuilder stringBuilder2 = new StringBuilder();
foreach (int key in dictionary.Keys)
{
string str3 = hotkeysAndPlainLabels[0, key];
if (string.IsNullOrEmpty(str3))
{
str3 = hotkeysAndPlainLabels[1, key];
}
stringBuilder2.Append(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "{0}{1}", (object)str2, (object)str3));
str2 = ",";
}
string str4 = stringBuilder2.ToString();
if (dictionary.Count == 1)
{
str1 = ResourceManagerCache.FormatResourceString("InternalHostUserInterfaceStrings", "DefaultChoice", (object)str4);
}
else
{
str1 = ResourceManagerCache.FormatResourceString("InternalHostUserInterfaceStrings", "DefaultChoicesForMultipleChoices", (object)str4);
}
}
string str5 = stringBuilder1.ToString() + str1 + (object)ch;
Collection <int> collection = new Collection <int>();
int num = 0;
while (true)
{
string str2 = ResourceManagerCache.FormatResourceString("InternalHostUserInterfaceStrings", "ChoiceMessage", (object)num);
this.externalUI.WriteLine(str5 + str2);
string str3 = this.externalUI.ReadLine();
if (str3.Length != 0)
{
int choicePicked = HostUIHelperMethods.DetermineChoicePicked(str3.Trim(), choices, hotkeysAndPlainLabels);
if (choicePicked >= 0)
{
collection.Add(choicePicked);
++num;
}
str5 = "";
}
else
{
break;
}
}
if (collection.Count == 0 && dictionary.Keys.Count >= 0)
{
foreach (int key in dictionary.Keys)
{
collection.Add(key);
}
}
return(collection);
}
public PromptingException()
: base(ResourceManagerCache.FormatResourceString("HostInterfaceExceptionsStrings", "DefaultCtorMessageTemplate", (object) typeof(PromptingException).FullName))
=> this.SetDefaultErrorRecord();
internal static PSConsoleFileElement CreateFromFile(string path)
{
using (PSConsoleFileElement.tracer.TraceMethod())
{
PSConsoleFileElement._mshsnapinTracer.WriteLine("Loading console info from file {0}.", (object)path);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(path);
if (xmlDocument["PSConsoleFile"] == null)
{
PSConsoleFileElement._mshsnapinTracer.TraceError("Console file {0} doesn't contain tag {1}.", (object)path, (object)"PSConsoleFile");
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "MonadConsoleNotFound", (object)path));
}
if (xmlDocument["PSConsoleFile"]["PSVersion"] == null || string.IsNullOrEmpty(xmlDocument["PSConsoleFile"]["PSVersion"].InnerText))
{
PSConsoleFileElement._mshsnapinTracer.TraceError("Console file {0} doesn't contain tag {1}.", (object)path, (object)"PSVersion");
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "MonadVersionNotFound", (object)path));
}
XmlElement xmlElement1 = xmlDocument["PSConsoleFile"];
if (xmlElement1.HasAttribute("ConsoleSchemaVersion"))
{
if (!xmlElement1.GetAttribute("ConsoleSchemaVersion").Equals("1.0", StringComparison.OrdinalIgnoreCase))
{
string str = string.Format((IFormatProvider)Thread.CurrentThread.CurrentCulture, ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "BadConsoleVersion", (object)path), (object)"1.0");
PSConsoleFileElement._mshsnapinTracer.TraceError(str);
throw new XmlException(str);
}
PSConsoleFileElement consoleFileElement = new PSConsoleFileElement(xmlDocument["PSConsoleFile"]["PSVersion"].InnerText.Trim());
bool flag1 = false;
bool flag2 = false;
for (XmlNode xmlNode1 = xmlDocument["PSConsoleFile"].FirstChild; xmlNode1 != null; xmlNode1 = xmlNode1.NextSibling)
{
if (xmlNode1.NodeType != XmlNodeType.Comment)
{
if (!(xmlNode1 is XmlElement xmlElement))
{
throw new XmlException(ResourceManagerCache.GetResourceString("ConsoleInfoErrorStrings", "BadXMLFormat"));
}
if (xmlElement.Name == "PSVersion")
{
if (flag2)
{
PSConsoleFileElement._mshsnapinTracer.TraceError("Console file {0} contains more than one msh versions", (object)path);
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "MultipleMshSnapinsElementNotSupported", (object)"PSVersion"));
}
flag2 = true;
}
else
{
if (xmlElement.Name != "PSSnapIns")
{
PSConsoleFileElement._mshsnapinTracer.TraceError("Tag {0} is not supported in console file", (object)xmlElement.Name);
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "BadXMLElementFound", (object)xmlElement.Name, (object)"PSConsoleFile", (object)"PSVersion", (object)"PSSnapIns"));
}
if (flag1)
{
PSConsoleFileElement._mshsnapinTracer.TraceError("Console file {0} contains more than one mshsnapin lists", (object)path);
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "MultipleMshSnapinsElementNotSupported", (object)"PSSnapIns"));
}
flag1 = true;
for (XmlNode xmlNode2 = xmlElement.FirstChild; xmlNode2 != null; xmlNode2 = xmlNode2.NextSibling)
{
if (!(xmlNode2 is XmlElement xmlElement) || xmlElement.Name != "PSSnapIn")
{
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInNotFound", (object)xmlNode2.Name));
}
string attribute = xmlElement.GetAttribute("Name");
if (string.IsNullOrEmpty(attribute))
{
throw new XmlException(ResourceManagerCache.GetResourceString("ConsoleInfoErrorStrings", "IDNotFound"));
}
consoleFileElement.mshsnapins.Add(attribute);
PSConsoleFileElement._mshsnapinTracer.WriteLine("Found in mshsnapin {0} in console file {1}", (object)attribute, (object)path);
}
}
}
}
return(consoleFileElement);
}
PSConsoleFileElement._mshsnapinTracer.TraceError("Console file {0} doesn't contain tag schema version.", (object)path);
throw new XmlException(ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "BadConsoleVersion", (object)path));
}
}
private HistoryInfo GetHistoryInfoObject(PSObject mshObject)
{
using (AddHistoryCommand._trace.TraceMethod())
{
if (mshObject != null && AddHistoryCommand.GetPropertyValue(mshObject, "CommandLine") is string propertyValue)
{
object propertyValue1 = AddHistoryCommand.GetPropertyValue(mshObject, "ExecutionStatus");
switch (propertyValue1)
{
case PipelineState status:
label_7:
object propertyValue2 = AddHistoryCommand.GetPropertyValue(mshObject, "StartExecutionTime");
switch (propertyValue2)
{
case DateTime startTime:
label_10:
object propertyValue3 = AddHistoryCommand.GetPropertyValue(mshObject, "EndExecutionTime");
switch (propertyValue3)
{
case DateTime endTime:
label_13:
return(new HistoryInfo(0L, propertyValue, status, startTime, endTime));
case string _:
try
{
endTime = DateTime.Parse((string)propertyValue3, (IFormatProvider)CultureInfo.CurrentCulture);
goto label_13;
}
catch (FormatException ex)
{
AddHistoryCommand._trace.TraceException((Exception)ex);
break;
}
}
break;
case string _:
try
{
startTime = DateTime.Parse((string)propertyValue2, (IFormatProvider)CultureInfo.CurrentCulture);
goto label_10;
}
catch (FormatException ex)
{
AddHistoryCommand._trace.TraceException((Exception)ex);
break;
}
}
break;
case PSObject _:
object baseObject = (propertyValue1 as PSObject).BaseObject;
if (baseObject is int)
{
status = (PipelineState)baseObject;
switch (status)
{
case PipelineState.NotStarted:
case PipelineState.Running:
case PipelineState.Stopping:
case PipelineState.Stopped:
case PipelineState.Completed:
case PipelineState.Failed:
goto label_7;
}
}
else
{
break;
}
break;
case string _:
try
{
status = (PipelineState)Enum.Parse(typeof(PipelineState), (string)propertyValue1);
goto label_7;
}
catch (ArgumentException ex)
{
AddHistoryCommand._trace.TraceException((Exception)ex);
break;
}
}
}
this.WriteError(new ErrorRecord((Exception) new InvalidDataException(ResourceManagerCache.FormatResourceString("History", "AddHistoryInvalidInput")), "AddHistoryInvalidInput", ErrorCategory.InvalidData, (object)mshObject));
return((HistoryInfo)null);
}
}
internal FormatTableLoadException(Collection <string> loadErrors)
: base(ResourceManagerCache.FormatResourceString("FormatAndOut.XmlLoading", "FormattableLoadErrors"))
{
this.errors = loadErrors;
this.SetDefaultErrorRecord();
}
internal TypeTableLoadException(Collection <string> loadErrors)
: base(ResourceManagerCache.FormatResourceString("TypesXml", "TypeTableLoadErrors"))
{
this.errors = loadErrors;
this.SetDefaultErrorRecord();
}
internal void AddError(string resourceId, params object[] formatArguments) => this.errors.Add(ResourceManagerCache.FormatResourceString("TypesXml", "FileError", (object)this.PSSnapinName, (object)this.fileName, (object)ResourceManagerCache.FormatResourceString("TypesXml", resourceId, formatArguments)));
private bool CheckPolicy(ExternalScriptInfo script, PSHost host, out Exception reason)
{
bool flag1 = false;
reason = (Exception)null;
string path = script.Path;
if (path.IndexOf('\\') < 0)
{
throw PSAuthorizationManager.tracer.NewArgumentException("path");
}
FileInfo fileInfo = path.LastIndexOf('\\') != path.Length - 1 ? new FileInfo(path) : throw PSAuthorizationManager.tracer.NewArgumentException("path");
if (!fileInfo.Exists)
{
return(false);
}
if (!PSAuthorizationManager.IsSupportedExtension(fileInfo.Extension) || this.IsProductBinary(path))
{
return(true);
}
this.executionPolicy = SecuritySupport.GetExecutionPolicy(this.shellId);
if (this.executionPolicy == ExecutionPolicy.Bypass)
{
return(true);
}
if (SecuritySupport.GetSaferPolicy(path) == SaferPolicy.Disallowed)
{
string message = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_DisallowedBySafer", (object)path);
reason = (Exception) new UnauthorizedAccessException(message);
return(false);
}
if (this.executionPolicy == ExecutionPolicy.Unrestricted)
{
if (!this.IsLocalFile(fileInfo.FullName))
{
if (string.IsNullOrEmpty(script.ScriptContents))
{
string message = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_FileContentUnavailable", (object)path);
reason = (Exception) new UnauthorizedAccessException(message);
return(false);
}
System.Management.Automation.Signature withEncodingRetry = this.GetSignatureWithEncodingRetry(path, script);
if (withEncodingRetry.Status == SignatureStatus.Valid && this.IsTrustedPublisher(withEncodingRetry, path))
{
flag1 = true;
}
if (!flag1)
{
PSAuthorizationManager.RunPromptDecision runPromptDecision;
do
{
runPromptDecision = this.RemoteFilePrompt(path, host);
if (runPromptDecision == PSAuthorizationManager.RunPromptDecision.Suspend)
{
host.EnterNestedPrompt();
}
}while (runPromptDecision == PSAuthorizationManager.RunPromptDecision.Suspend);
switch (runPromptDecision - 1)
{
case PSAuthorizationManager.RunPromptDecision.DoNotRun:
flag1 = true;
break;
default:
flag1 = false;
string message = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_DoNotRun", (object)path);
reason = (Exception) new UnauthorizedAccessException(message);
break;
}
}
}
else
{
flag1 = true;
}
}
else if (this.IsLocalFile(fileInfo.FullName) && this.executionPolicy == ExecutionPolicy.RemoteSigned)
{
flag1 = true;
}
else if (this.executionPolicy == ExecutionPolicy.AllSigned || this.executionPolicy == ExecutionPolicy.RemoteSigned)
{
if (string.IsNullOrEmpty(script.ScriptContents))
{
string message = ResourceManagerCache.FormatResourceString("Authenticode", "Reason_FileContentUnavailable", (object)path);
reason = (Exception) new UnauthorizedAccessException(message);
return(false);
}
System.Management.Automation.Signature withEncodingRetry = this.GetSignatureWithEncodingRetry(path, script);
if (withEncodingRetry.Status == SignatureStatus.Valid)
{
flag1 = this.IsTrustedPublisher(withEncodingRetry, path) || this.SetPolicyFromAuthenticodePrompt(path, host, ref reason, withEncodingRetry);
}
else
{
flag1 = false;
if (withEncodingRetry.Status == SignatureStatus.NotTrusted)
{
reason = (Exception) new UnauthorizedAccessException(ResourceManagerCache.FormatResourceString("Authenticode", "Reason_NotTrusted", (object)path, (object)withEncodingRetry.SignerCertificate.SubjectName.Name));
}
else
{
reason = (Exception) new UnauthorizedAccessException(ResourceManagerCache.FormatResourceString("Authenticode", "Reason_Unknown", (object)path, (object)withEncodingRetry.StatusMessage));
}
}
}
else
{
flag1 = false;
bool flag2 = false;
if (string.Equals(fileInfo.Extension, ".ps1xml", StringComparison.OrdinalIgnoreCase))
{
string[] strArray = new string[2]
{
Environment.GetFolderPath(Environment.SpecialFolder.System),
Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)
};
foreach (string str in strArray)
{
if (fileInfo.FullName.StartsWith(str, StringComparison.OrdinalIgnoreCase))
{
flag1 = true;
}
}
if (!flag1)
{
System.Management.Automation.Signature withEncodingRetry = this.GetSignatureWithEncodingRetry(path, script);
if (withEncodingRetry.Status == SignatureStatus.Valid)
{
if (this.IsTrustedPublisher(withEncodingRetry, path))
{
flag1 = true;
}
else
{
flag1 = this.SetPolicyFromAuthenticodePrompt(path, host, ref reason, withEncodingRetry);
flag2 = true;
}
}
}
}
if (!flag1 && !flag2)
{
reason = (Exception) new UnauthorizedAccessException(ResourceManagerCache.FormatResourceString("Authenticode", "Reason_RestrictedMode", (object)path));
}
}
return(flag1);
}
internal static Assembly LoadPSSnapInAssembly(
PSSnapInInfo psSnapInInfo,
out Dictionary <string, SessionStateCmdletEntry> cmdlets,
out Dictionary <string, SessionStateProviderEntry> providers)
{
Assembly assembly1 = (Assembly)null;
cmdlets = (Dictionary <string, SessionStateCmdletEntry>)null;
providers = (Dictionary <string, SessionStateProviderEntry>)null;
PSSnapInHelpers._PSSnapInTracer.WriteLine("Loading assembly from GAC. Assembly Name: {0}", (object)psSnapInInfo.AssemblyName);
try
{
assembly1 = Assembly.Load(psSnapInInfo.AssemblyName);
}
catch (FileLoadException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
}
catch (BadImageFormatException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
}
catch (FileNotFoundException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceWarning("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
}
if (assembly1 != null)
{
return(assembly1);
}
PSSnapInHelpers._PSSnapInTracer.WriteLine("Loading assembly from path: {0}", (object)psSnapInInfo.AssemblyName);
try
{
Assembly assembly2 = Assembly.ReflectionOnlyLoadFrom(psSnapInInfo.AbsoluteModulePath);
if (assembly2 == null)
{
return((Assembly)null);
}
if (!string.Equals(assembly2.FullName, psSnapInInfo.AssemblyName, StringComparison.OrdinalIgnoreCase))
{
string str = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInAssemblyNameMismatch", (object)psSnapInInfo.AbsoluteModulePath, (object)psSnapInInfo.AssemblyName);
PSSnapInHelpers._PSSnapInTracer.TraceError(str);
throw new PSSnapInException(psSnapInInfo.Name, str);
}
return(Assembly.LoadFrom(psSnapInInfo.AbsoluteModulePath));
}
catch (FileLoadException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
throw new PSSnapInException(psSnapInInfo.Name, ex.Message);
}
catch (BadImageFormatException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
throw new PSSnapInException(psSnapInInfo.Name, ex.Message);
}
catch (FileNotFoundException ex)
{
PSSnapInHelpers._PSSnapInTracer.TraceError("Not able to load assembly {0}: {1}", (object)psSnapInInfo.AssemblyName, (object)ex.Message);
throw new PSSnapInException(psSnapInInfo.Name, ex.Message);
}
}
internal static string FormatResourceString(PSRemotingErrorId messageId, params object[] args) => ResourceManagerCache.FormatResourceString("RemotingErrorIdStrings", messageId.ToString(), args);
internal static void AnalyzePSSnapInAssembly(
Assembly assembly,
string name,
PSSnapInInfo psSnapInInfo,
out Dictionary <string, SessionStateCmdletEntry> cmdlets,
out Dictionary <string, SessionStateProviderEntry> providers)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
if (PSSnapInHelpers._cmdletCache != null && PSSnapInHelpers._providerCache != null && (PSSnapInHelpers._cmdletCache.ContainsKey(assembly) && PSSnapInHelpers._providerCache.ContainsKey(assembly)))
{
cmdlets = PSSnapInHelpers._cmdletCache[assembly];
providers = PSSnapInHelpers._providerCache[assembly];
}
else
{
cmdlets = (Dictionary <string, SessionStateCmdletEntry>)null;
providers = (Dictionary <string, SessionStateProviderEntry>)null;
PSSnapInHelpers._PSSnapInTracer.WriteLine("Analyzing assembly {0} for cmdlet and providers", (object)assembly.Location);
string helpFile = PSSnapInHelpers.GetHelpFile(assembly.Location);
Type[] types;
try
{
types = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
string str = ex.Message + "\nLoader Exceptions: \n";
if (ex.LoaderExceptions != null)
{
foreach (Exception loaderException in ex.LoaderExceptions)
{
str = str + "\n" + loaderException.Message;
}
}
PSSnapInHelpers._PSSnapInTracer.TraceError(str);
throw new PSSnapInException(name, str);
}
foreach (Type type in types)
{
if ((type.IsPublic || type.IsNestedPublic) && !type.IsAbstract)
{
object[] customAttributes = type.GetCustomAttributes(false);
string str1 = (string)null;
string str2 = (string)null;
foreach (object obj in customAttributes)
{
if (obj.GetType() == typeof(CmdletAttribute))
{
str1 = PSSnapInHelpers.GetCmdletName(obj as CmdletAttribute);
break;
}
if (obj.GetType() == typeof(CmdletProviderAttribute))
{
str2 = PSSnapInHelpers.GetProviderName(obj as CmdletProviderAttribute);
break;
}
}
if (!string.IsNullOrEmpty(str1))
{
if (PSSnapInHelpers.IsCmdletClass(type) && PSSnapInHelpers.HasDefaultConstructor(type))
{
if (cmdlets != null && cmdlets.ContainsKey(str1))
{
string str3 = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInDuplicateCmdlets", (object)str1, (object)name);
PSSnapInHelpers._PSSnapInTracer.TraceError(str3);
throw new PSSnapInException(name, str3);
}
SessionStateCmdletEntry stateCmdletEntry = new SessionStateCmdletEntry(str1, type, helpFile);
if (psSnapInInfo != null)
{
stateCmdletEntry.SetPSSnapIn(psSnapInInfo);
}
if (cmdlets == null)
{
cmdlets = new Dictionary <string, SessionStateCmdletEntry>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase);
}
cmdlets.Add(str1, stateCmdletEntry);
PSSnapInHelpers._PSSnapInTracer.WriteLine("{0} from type {1} is added as a cmdlet. ", (object)str1, (object)type.FullName);
continue;
}
PSSnapInHelpers._PSSnapInTracer.TraceWarning("{0} is not valid cmdlet because it doesn't derive from the Cmdlet type or it doesn't have a default constructor.", (object)str1);
}
if (!string.IsNullOrEmpty(str2))
{
if (PSSnapInHelpers.IsProviderClass(type) && PSSnapInHelpers.HasDefaultConstructor(type))
{
if (providers != null && providers.ContainsKey(str2))
{
string str3 = ResourceManagerCache.FormatResourceString("ConsoleInfoErrorStrings", "PSSnapInDuplicateProviders", (object)str2, (object)psSnapInInfo.Name);
PSSnapInHelpers._PSSnapInTracer.TraceError(str3);
throw new PSSnapInException(psSnapInInfo.Name, str3);
}
SessionStateProviderEntry stateProviderEntry = new SessionStateProviderEntry(str2, type, helpFile);
stateProviderEntry.SetPSSnapIn(psSnapInInfo);
if (providers == null)
{
providers = new Dictionary <string, SessionStateProviderEntry>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase);
}
providers.Add(str2, stateProviderEntry);
PSSnapInHelpers._PSSnapInTracer.WriteLine("{0} from type {1} is added as a provider. ", (object)str2, (object)type.FullName);
}
else
{
PSSnapInHelpers._PSSnapInTracer.TraceWarning("{0} is not valid provider because it doesn't derive from the provider type or it doesn't have a default constructor.", (object)str2);
}
}
}
}
lock (PSSnapInHelpers._syncObject)
{
if (cmdlets != null)
{
if (PSSnapInHelpers._cmdletCache == null)
{
PSSnapInHelpers._cmdletCache = new Dictionary <Assembly, Dictionary <string, SessionStateCmdletEntry> >();
}
PSSnapInHelpers._cmdletCache[assembly] = cmdlets;
}
if (providers == null)
{
return;
}
if (PSSnapInHelpers._providerCache == null)
{
PSSnapInHelpers._providerCache = new Dictionary <Assembly, Dictionary <string, SessionStateProviderEntry> >();
}
PSSnapInHelpers._providerCache[assembly] = providers;
}
}
}
internal string GetMessage(PSRemotingErrorId errorId, params object[] args) => args == null?ResourceManagerCache.GetResourceString("RemotingErrorIdStrings", errorId.ToString()) : ResourceManagerCache.FormatResourceString("RemotingErrorIdStrings", errorId.ToString(), args);