/// <summary>
/// Retrieve the encoding parameter from the command line
/// it throws if the encoding does not match the known ones.
/// </summary>
/// <returns>A System.Text.Encoding object (null if no encoding specified).</returns>
internal static Encoding Convert(Cmdlet cmdlet, string encoding)
{
if (string.IsNullOrEmpty(encoding))
{
// no parameter passed, default to UTF8
return(ClrFacade.GetDefaultEncoding());
}
Encoding foundEncoding;
if (encodingMap.TryGetValue(encoding, out foundEncoding))
{
return(foundEncoding);
}
// error condition: unknown encoding value
string validEncodingValues = string.Join(", ", TabCompletionResults);
string msg = StringUtil.Format(PathUtilsStrings.OutFile_WriteToFileEncodingUnknown, encoding, validEncodingValues);
ErrorRecord errorRecord = new ErrorRecord(
PSTraceSource.NewArgumentException("Encoding"),
"WriteToFileEncodingUnknown",
ErrorCategory.InvalidArgument,
null);
errorRecord.ErrorDetails = new ErrorDetails(msg);
cmdlet.ThrowTerminatingError(errorRecord);
return(null);
}
internal static Encoding Convert(Cmdlet cmdlet, string encoding)
{
switch (encoding)
{
case "":
case null:
return(Encoding.Unicode);
default:
if (string.Equals(encoding, "unicode", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Unicode);
}
if (string.Equals(encoding, "bigendianunicode", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.BigEndianUnicode);
}
if (string.Equals(encoding, "ascii", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.ASCII);
}
if (string.Equals(encoding, "utf8", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF8);
}
if (string.Equals(encoding, "utf7", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF7);
}
if (string.Equals(encoding, "utf32", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF32);
}
if (string.Equals(encoding, "default", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Default);
}
if (string.Equals(encoding, "oem", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.GetEncoding((int)EncodingConversion.NativeMethods.GetOEMCP()));
}
string str = string.Join(", ", new string[8]
{
"unicode",
"bigendianunicode",
"ascii",
"utf8",
"utf7",
"utf32",
"default",
"oem"
});
string message = ResourceManagerCache.FormatResourceString("PathUtils", "OutFile_WriteToFileEncodingUnknown", (object)encoding, (object)str);
cmdlet.ThrowTerminatingError(new ErrorRecord((Exception)EncodingConversion.tracer.NewArgumentException("Encoding"), "WriteToFileEncodingUnknown", ErrorCategory.InvalidArgument, (object)null)
{
ErrorDetails = new ErrorDetails(message)
});
return((Encoding)null);
}
}
private static void HandleErrorFromPipeline(Cmdlet cmdlet, ErrorRecord errorRecord, PowerShell powerShell)
{
if (!cmdlet.MyInvocation.ExpectingInput && (((powerShell.Runspace != null) && (powerShell.Runspace.RunspaceStateInfo.State != RunspaceState.Opened)) || ((powerShell.RunspacePool != null) && (powerShell.RunspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opened))))
{
cmdlet.ThrowTerminatingError(errorRecord);
}
cmdlet.WriteError(errorRecord);
}
internal static void ReportWildcardingFailure(Cmdlet cmdlet, string filePath)
{
string message = ResourceManagerCache.FormatResourceString(nameof(PathUtils), "OutFile_DidNotResolveFile", (object)filePath);
cmdlet.ThrowTerminatingError(new ErrorRecord((Exception) new FileNotFoundException(), "FileOpenFailure", ErrorCategory.OpenError, (object)filePath)
{
ErrorDetails = new ErrorDetails(message)
});
}
internal static void ReportMultipleFilesNotSupported(Cmdlet cmdlet)
{
string message = ResourceManagerCache.FormatResourceString(nameof(PathUtils), "OutFile_MultipleFilesNotSupported");
cmdlet.ThrowTerminatingError(new ErrorRecord((Exception)PathUtils.tracer.NewInvalidOperationException(), "ReadWriteMultipleFilesNotSupported", ErrorCategory.InvalidArgument, (object)null)
{
ErrorDetails = new ErrorDetails(message)
});
}
internal static void ReportWrongProviderType(Cmdlet cmdlet, string providerId)
{
string message = ResourceManagerCache.FormatResourceString(nameof(PathUtils), "OutFile_ReadWriteFileNotFileSystemProvider", (object)providerId);
cmdlet.ThrowTerminatingError(new ErrorRecord((Exception)PathUtils.tracer.NewInvalidOperationException(), "ReadWriteFileNotFileSystemProvider", ErrorCategory.InvalidArgument, (object)null)
{
ErrorDetails = new ErrorDetails(message)
});
}
internal static Encoding Convert(Cmdlet cmdlet, string encoding)
{
if ((encoding == null) || (encoding.Length == 0))
{
return(Encoding.Unicode);
}
if (string.Equals(encoding, "unknown", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Unicode);
}
if (string.Equals(encoding, "string", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Unicode);
}
if (string.Equals(encoding, "unicode", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Unicode);
}
if (string.Equals(encoding, "bigendianunicode", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.BigEndianUnicode);
}
if (string.Equals(encoding, "ascii", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.ASCII);
}
if (string.Equals(encoding, "utf8", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF8);
}
if (string.Equals(encoding, "utf7", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF7);
}
if (string.Equals(encoding, "utf32", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.UTF32);
}
if (string.Equals(encoding, "default", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.Default);
}
if (string.Equals(encoding, "oem", StringComparison.OrdinalIgnoreCase))
{
return(Encoding.GetEncoding((int)NativeMethods.GetOEMCP()));
}
string str = string.Join(", ", new string[] { "unknown", "string", "unicode", "bigendianunicode", "ascii", "utf8", "utf7", "utf32", "default", "oem" });
string message = StringUtil.Format(PathUtilsStrings.OutFile_WriteToFileEncodingUnknown, encoding, str);
ErrorRecord errorRecord = new ErrorRecord(PSTraceSource.NewArgumentException("Encoding"), "WriteToFileEncodingUnknown", ErrorCategory.InvalidArgument, null)
{
ErrorDetails = new ErrorDetails(message)
};
cmdlet.ThrowTerminatingError(errorRecord);
return(null);
}
internal static void ReportFileOpenFailure(Cmdlet cmdlet, string filePath, Exception e)
{
ErrorRecord errorRecord = new ErrorRecord(
e,
"FileOpenFailure",
ErrorCategory.OpenError,
null);
cmdlet.ThrowTerminatingError(errorRecord);
}
internal static void ReportWrongProviderType(Cmdlet cmdlet, string providerId)
{
string message = StringUtil.Format(PathUtilsStrings.OutFile_ReadWriteFileNotFileSystemProvider, providerId);
ErrorRecord errorRecord = new ErrorRecord(PSTraceSource.NewInvalidOperationException(), "ReadWriteFileNotFileSystemProvider", ErrorCategory.InvalidArgument, null)
{
ErrorDetails = new ErrorDetails(message)
};
cmdlet.ThrowTerminatingError(errorRecord);
}
internal static void ReportWildcardingFailure(Cmdlet cmdlet, string filePath)
{
string message = StringUtil.Format(PathUtilsStrings.OutFile_DidNotResolveFile, filePath);
ErrorRecord errorRecord = new ErrorRecord(new FileNotFoundException(), "FileOpenFailure", ErrorCategory.OpenError, filePath)
{
ErrorDetails = new ErrorDetails(message)
};
cmdlet.ThrowTerminatingError(errorRecord);
}
internal static void ReportMultipleFilesNotSupported(Cmdlet cmdlet)
{
string message = StringUtil.Format(PathUtilsStrings.OutFile_MultipleFilesNotSupported, new object[0]);
ErrorRecord errorRecord = new ErrorRecord(PSTraceSource.NewInvalidOperationException(), "ReadWriteMultipleFilesNotSupported", ErrorCategory.InvalidArgument, null)
{
ErrorDetails = new ErrorDetails(message)
};
cmdlet.ThrowTerminatingError(errorRecord);
}
private static IEnumerable <CimModule> GetCimModules(CimSession cimSession, Uri resourceUri, string cimNamespace, string moduleNamePattern, bool onlyManifests, Cmdlet cmdlet, CancellationToken cancellationToken)
{
Func <CimModule, CimModule> selector = null;
WildcardPattern wildcardPattern = new WildcardPattern(moduleNamePattern, WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase);
string optionValue = WildcardPatternToDosWildcardParser.Parse(wildcardPattern);
CimOperationOptions options = new CimOperationOptions {
CancellationToken = new CancellationToken?(cancellationToken)
};
options.SetCustomOption("PS_ModuleNamePattern", optionValue, false);
if (resourceUri != null)
{
options.ResourceUri = resourceUri;
}
if (string.IsNullOrEmpty(cimNamespace) && (resourceUri == null))
{
cimNamespace = "root/Microsoft/Windows/Powershellv3";
}
IEnumerable <CimModule> source = from cimInstance in cimSession.EnumerateInstances(cimNamespace, "PS_Module", options)
select new CimModule(cimInstance) into cimModule
where wildcardPattern.IsMatch(cimModule.ModuleName)
select cimModule;
if (!onlyManifests)
{
if (selector == null)
{
selector = delegate(CimModule cimModule) {
cimModule.FetchAllModuleFiles(cimSession, cimNamespace, options);
return(cimModule);
};
}
source = source.Select <CimModule, CimModule>(selector);
}
return(EnumerateWithCatch <CimModule>(source, delegate(Exception exception) {
ErrorRecord errorRecord = GetErrorRecordForRemoteDiscoveryProvider(exception);
if (!cmdlet.MyInvocation.ExpectingInput && (((-1 != errorRecord.FullyQualifiedErrorId.IndexOf("DiscoveryProviderNotFound", StringComparison.OrdinalIgnoreCase)) || cancellationToken.IsCancellationRequested) || ((exception is OperationCanceledException) || !cimSession.TestConnection())))
{
cmdlet.ThrowTerminatingError(errorRecord);
}
cmdlet.WriteError(errorRecord);
}));
}
private static IEnumerable <CimModule> GetCimModules(
CimSession cimSession,
Uri resourceUri,
string cimNamespace,
string moduleNamePattern,
bool onlyManifests,
Cmdlet cmdlet,
CancellationToken cancellationToken)
{
Dbg.Assert(cimSession != null, "Caller should verify cimSession != null");
Dbg.Assert(moduleNamePattern != null, "Caller should verify that moduleNamePattern != null");
const WildcardOptions wildcardOptions = WildcardOptions.IgnoreCase | WildcardOptions.CultureInvariant;
var wildcardPattern = WildcardPattern.Get(moduleNamePattern, wildcardOptions);
string dosWildcard = WildcardPatternToDosWildcardParser.Parse(wildcardPattern);
var options = new CimOperationOptions {
CancellationToken = cancellationToken
};
options.SetCustomOption("PS_ModuleNamePattern", dosWildcard, mustComply: false);
if (resourceUri != null)
{
options.ResourceUri = resourceUri;
}
if (string.IsNullOrEmpty(cimNamespace) && (resourceUri == null))
{
cimNamespace = DiscoveryProviderNamespace;
}
// TODO/FIXME: ETW for method invocation
IEnumerable <CimInstance> syncResults = cimSession.EnumerateInstances(
cimNamespace,
DiscoveryProviderModuleClass,
options);
// TODO/FIXME: ETW for method results
IEnumerable <CimModule> cimModules = syncResults
.Select(cimInstance => new CimModule(cimInstance))
.Where(cimModule => wildcardPattern.IsMatch(cimModule.ModuleName));
if (!onlyManifests)
{
cimModules = cimModules.Select(
delegate(CimModule cimModule)
{
cimModule.FetchAllModuleFiles(cimSession, cimNamespace, options);
return(cimModule);
});
}
return(EnumerateWithCatch(
cimModules,
delegate(Exception exception)
{
ErrorRecord errorRecord = GetErrorRecordForRemoteDiscoveryProvider(exception);
if (!cmdlet.MyInvocation.ExpectingInput)
{
if (((-1) != errorRecord.FullyQualifiedErrorId.IndexOf(DiscoveryProviderNotFoundErrorId, StringComparison.OrdinalIgnoreCase)) ||
(cancellationToken.IsCancellationRequested || (exception is OperationCanceledException)) ||
(!cimSession.TestConnection()))
{
cmdlet.ThrowTerminatingError(errorRecord);
}
}
cmdlet.WriteError(errorRecord);
}));
}
/// <summary>
/// retrieve the encoding paramater from the command line
/// it throws if the encoding does not match the known ones
/// </summary>
/// <returns>a System.Text.Encoding object (null if no encoding specified)</returns>
internal static Encoding Convert(Cmdlet cmdlet, string encoding)
{
if (string.IsNullOrEmpty(encoding))
{
// no parameter passed, default to Unicode (OS preferred)
return(System.Text.Encoding.Unicode);
}
// Default to unicode (this matches Get-Content)
if (string.Equals(encoding, Unknown, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.Unicode);
}
if (string.Equals(encoding, String, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.Unicode);
}
// these are the encodings the CLR supports
if (string.Equals(encoding, Unicode, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.Unicode);
}
if (string.Equals(encoding, BigEndianUnicode, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.BigEndianUnicode);
}
if (string.Equals(encoding, Utf8, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.UTF8);
}
if (string.Equals(encoding, Ascii, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.ASCII);
}
if (string.Equals(encoding, Utf7, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.UTF7);
}
if (string.Equals(encoding, Utf32, StringComparison.OrdinalIgnoreCase))
{
return(System.Text.Encoding.UTF32);
}
if (string.Equals(encoding, Default, StringComparison.OrdinalIgnoreCase))
{
return(ClrFacade.GetDefaultEncoding());
}
if (string.Equals(encoding, OEM, StringComparison.OrdinalIgnoreCase))
{
return(ClrFacade.GetOEMEncoding());
}
// error condition: unknown encoding value
string validEncodingValues = string.Join(
", ",
new string[] { Unknown, String, Unicode, BigEndianUnicode, Ascii, Utf8, Utf7, Utf32, Default, OEM });
string msg = StringUtil.Format(PathUtilsStrings.OutFile_WriteToFileEncodingUnknown,
encoding, validEncodingValues);
ErrorRecord errorRecord = new ErrorRecord(
PSTraceSource.NewArgumentException("Encoding"),
"WriteToFileEncodingUnknown",
ErrorCategory.InvalidArgument,
null);
errorRecord.ErrorDetails = new ErrorDetails(msg);
cmdlet.ThrowTerminatingError(errorRecord);
return(null);
}
