/// <summary>
///
/// </summary>
/// <param name="files"></param>
/// <param name="errorId"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
internal static Collection<string> Glob(string[] files, string errorId, PSCmdlet cmdlet)
{
Collection<string> retValue = new Collection<string>();
foreach (string file in files)
{
Collection<string> providerPaths;
ProviderInfo provider = null;
try
{
providerPaths = cmdlet.SessionState.Path.GetResolvedProviderPathFromPSPath(file, out provider);
}
catch (SessionStateException e)
{
cmdlet.WriteError(new ErrorRecord(e, errorId, ErrorCategory.InvalidOperation, file));
continue;
}
if (!provider.NameEquals(cmdlet.Context.ProviderNames.FileSystem))
{
ReportWrongProviderType(provider.FullName, errorId, cmdlet);
continue;
}
foreach (string providerPath in providerPaths)
{
if (!providerPath.EndsWith(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
ReportWrongExtension(providerPath, "WrongExtension", cmdlet);
continue;
}
retValue.Add(providerPath);
}
}
return retValue;
}
private static void ReportWrongProviderType(string providerId, string errorId, PSCmdlet cmdlet)
{
ErrorRecord errorRecord = new ErrorRecord(
PSTraceSource.NewInvalidOperationException(UpdateDataStrings.UpdateData_WrongProviderError, providerId),
errorId,
ErrorCategory.InvalidArgument,
null);
cmdlet.WriteError(errorRecord);
}
private static void ReportWrongExtension(string file, string errorId, PSCmdlet cmdlet)
{
ErrorRecord errorRecord = new ErrorRecord(
PSTraceSource.NewInvalidOperationException(UpdateDataStrings.UpdateData_WrongExtension, file, "ps1xml"),
errorId,
ErrorCategory.InvalidArgument,
null);
cmdlet.WriteError(errorRecord);
}
internal static List<OrderByPropertyEntry> CreateOrderMatrix(PSCmdlet cmdlet, List<PSObject> inputObjects, List<MshParameter> mshParameterList)
{
List<OrderByPropertyEntry> list = new List<OrderByPropertyEntry>();
foreach (PSObject obj2 in inputObjects)
{
if ((obj2 != null) && (obj2 != AutomationNull.Value))
{
List<ErrorRecord> errors = new List<ErrorRecord>();
List<string> propertyNotFoundMsgs = new List<string>();
OrderByPropertyEntry item = OrderByPropertyEntryEvaluationHelper.ProcessObject(obj2, mshParameterList, errors, propertyNotFoundMsgs);
foreach (ErrorRecord record in errors)
{
cmdlet.WriteError(record);
}
foreach (string str in propertyNotFoundMsgs)
{
cmdlet.WriteDebug(str);
}
list.Add(item);
}
}
return list;
}
internal static Collection<string> Glob(string[] files, string errorId, PSCmdlet cmdlet)
{
Collection<string> collection = new Collection<string>();
foreach (string str in files)
{
Collection<string> resolvedProviderPathFromPSPath;
ProviderInfo provider = null;
try
{
resolvedProviderPathFromPSPath = cmdlet.SessionState.Path.GetResolvedProviderPathFromPSPath(str, out provider);
}
catch (SessionStateException exception)
{
cmdlet.WriteError(new ErrorRecord(exception, errorId, ErrorCategory.InvalidOperation, str));
continue;
}
if (!provider.NameEquals(cmdlet.Context.ProviderNames.FileSystem))
{
ReportWrongProviderType(provider.FullName, errorId, cmdlet);
}
else
{
foreach (string str2 in resolvedProviderPathFromPSPath)
{
if (!str2.EndsWith(".ps1xml", StringComparison.OrdinalIgnoreCase))
{
ReportWrongExtension(str2, "WrongExtension", cmdlet);
}
else
{
collection.Add(str2);
}
}
}
}
return collection;
}
/// <summary>
/// Invokes the Win32Shutdown command on provided target computer using WSMan
/// over a CIMSession. The flags parameter determines the type of shutdown operation
/// such as shutdown, reboot, force etc.
/// </summary>
/// <param name="cmdlet">Cmdlet host for reporting errors</param>
/// <param name="isLocalhost">True if local host computer</param>
/// <param name="computerName">Target computer</param>
/// <param name="flags">Win32Shutdown flags</param>
/// <param name="credential">Optional credential</param>
/// <param name="authentication">Optional authentication</param>
/// <param name="formatErrorMessage">Error message format string that takes two parameters</param>
/// <param name="ErrorFQEID">Fully qualified error Id</param>
/// <param name="cancelToken">Cancel token</param>
/// <returns>True on success</returns>
internal static bool InvokeWin32ShutdownUsingWsman(
PSCmdlet cmdlet,
bool isLocalhost,
string computerName,
object[] flags,
PSCredential credential,
string authentication,
string formatErrorMessage,
string ErrorFQEID,
CancellationToken cancelToken)
{
Dbg.Diagnostics.Assert(flags.Length == 2, "Caller need to verify the flags passed in");
bool isSuccess = false;
string targetMachine = isLocalhost ? "localhost" : computerName;
string authInUse = isLocalhost ? null : authentication;
PSCredential credInUse = isLocalhost ? null : credential;
var currentPrivilegeState = new PlatformInvokes.TOKEN_PRIVILEGE();
var operationOptions = new CimOperationOptions
{
Timeout = TimeSpan.FromMilliseconds(10000),
CancellationToken = cancelToken,
//This prefix works against all versions of the WinRM server stack, both win8 and win7
ResourceUriPrefix = new Uri(ComputerWMIHelper.CimUriPrefix)
};
try
{
if (!(isLocalhost && PlatformInvokes.EnableTokenPrivilege(ComputerWMIHelper.SE_SHUTDOWN_NAME, ref currentPrivilegeState)) &&
!(!isLocalhost && PlatformInvokes.EnableTokenPrivilege(ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME, ref currentPrivilegeState)))
{
string message =
StringUtil.Format(ComputerResources.PrivilegeNotEnabled, computerName,
isLocalhost ? ComputerWMIHelper.SE_SHUTDOWN_NAME : ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(message), "PrivilegeNotEnabled", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(errorRecord);
return false;
}
using (CimSession cimSession = RemoteDiscoveryHelper.CreateCimSession(targetMachine, credInUse, authInUse, cancelToken, cmdlet))
{
var methodParameters = new CimMethodParametersCollection();
methodParameters.Add(CimMethodParameter.Create(
"Flags",
flags[0],
Microsoft.Management.Infrastructure.CimType.SInt32,
CimFlags.None));
methodParameters.Add(CimMethodParameter.Create(
"Reserved",
flags[1],
Microsoft.Management.Infrastructure.CimType.SInt32,
CimFlags.None));
CimMethodResult result = cimSession.InvokeMethod(
ComputerWMIHelper.CimOperatingSystemNamespace,
ComputerWMIHelper.WMI_Class_OperatingSystem,
ComputerWMIHelper.CimOperatingSystemShutdownMethod,
methodParameters,
operationOptions);
int retVal = Convert.ToInt32(result.ReturnValue.Value, CultureInfo.CurrentCulture);
if (retVal != 0)
{
var ex = new Win32Exception(retVal);
string errMsg = StringUtil.Format(formatErrorMessage, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(
new InvalidOperationException(errMsg), ErrorFQEID, ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
else
{
isSuccess = true;
}
}
}
catch (CimException ex)
{
string errMsg = StringUtil.Format(formatErrorMessage, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), ErrorFQEID,
ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
string errMsg = StringUtil.Format(formatErrorMessage, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), ErrorFQEID,
ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
finally
{
// Restore the previous privilege state if something unexpected happened
PlatformInvokes.RestoreTokenPrivilege(
isLocalhost ? ComputerWMIHelper.SE_SHUTDOWN_NAME : ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME, ref currentPrivilegeState);
}
return isSuccess;
}
/// <summary>
/// System Restore APIs are not supported on the ARM platform. Skip the system restore operation is necessary.
/// </summary>
/// <param name="cmdlet"></param>
/// <returns></returns>
internal static bool SkipSystemRestoreOperationForARMPlatform(PSCmdlet cmdlet)
{
bool retValue = false;
if (PsUtils.IsRunningOnProcessorArchitectureARM())
{
var ex = new InvalidOperationException(ComputerResources.SystemRestoreNotSupported);
var er = new ErrorRecord(ex, "SystemRestoreNotSupported", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(er);
retValue = true;
}
return retValue;
}
internal static void WriteNonTerminatingError(int errorcode, PSCmdlet cmdlet, string computername)
{
Win32Exception ex = new Win32Exception(errorcode);
string additionalmessage = String.Empty;
if (ex.NativeErrorCode.Equals(0x00000035))
{
additionalmessage = StringUtil.Format(ComputerResources.NetworkPathNotFound, computername);
}
string message = StringUtil.Format(ComputerResources.OperationFailed, ex.Message, computername, additionalmessage);
ErrorRecord er = new ErrorRecord(new InvalidOperationException(message), "InvalidOperationException", ErrorCategory.InvalidOperation, computername);
cmdlet.WriteError(er);
}
/// <summary>
/// Restart one computer
/// </summary>
/// <param name="cmdlet"></param>
/// <param name="isLocalhost"></param>
/// <param name="computerName"></param>
/// <param name="flags"></param>
/// <param name="options"></param>
/// <returns>
/// True if the restart was successful
/// False otherwise
/// </returns>
internal static bool RestartOneComputerUsingDcom(PSCmdlet cmdlet, bool isLocalhost, string computerName, object[] flags, ConnectionOptions options)
{
bool isSuccess = false;
PlatformInvokes.TOKEN_PRIVILEGE currentPrivilegeState = new PlatformInvokes.TOKEN_PRIVILEGE();
try
{
if (!(isLocalhost && PlatformInvokes.EnableTokenPrivilege(ComputerWMIHelper.SE_SHUTDOWN_NAME, ref currentPrivilegeState)) &&
!(!isLocalhost && PlatformInvokes.EnableTokenPrivilege(ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME, ref currentPrivilegeState)))
{
string message =
StringUtil.Format(ComputerResources.PrivilegeNotEnabled, computerName,
isLocalhost ? ComputerWMIHelper.SE_SHUTDOWN_NAME : ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(message), "PrivilegeNotEnabled", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(errorRecord);
return false;
}
ManagementScope scope = new ManagementScope(ComputerWMIHelper.GetScopeString(isLocalhost ? "localhost" : computerName, ComputerWMIHelper.WMI_Path_CIM), options);
EnumerationOptions enumOptions = new EnumerationOptions { UseAmendedQualifiers = true, DirectRead = true };
ObjectQuery query = new ObjectQuery("select * from " + ComputerWMIHelper.WMI_Class_OperatingSystem);
using (var searcher = new ManagementObjectSearcher(scope, query, enumOptions))
{
foreach (ManagementObject operatingSystem in searcher.Get())
{
using (operatingSystem)
{
object result = operatingSystem.InvokeMethod("Win32shutdown", flags);
int retVal = Convert.ToInt32(result.ToString(), CultureInfo.CurrentCulture);
if (retVal != 0)
{
var ex = new Win32Exception(retVal);
string errMsg = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(
new InvalidOperationException(errMsg), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
else
{
isSuccess = true;
}
}
}
}
}
catch (ManagementException ex)
{
string errMsg = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "RestartcomputerFailed",
ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
catch (COMException ex)
{
string errMsg = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "RestartcomputerFailed",
ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
catch (UnauthorizedAccessException ex)
{
string errMsg = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, ex.Message);
ErrorRecord error = new ErrorRecord(new InvalidOperationException(errMsg), "RestartcomputerFailed",
ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(error);
}
finally
{
// Restore the previous privilege state if something unexpected happened
PlatformInvokes.RestoreTokenPrivilege(
isLocalhost ? ComputerWMIHelper.SE_SHUTDOWN_NAME : ComputerWMIHelper.SE_REMOTE_SHUTDOWN_NAME, ref currentPrivilegeState);
}
return isSuccess;
}
internal static void WriteNonTerminatingError(int errorcode, PSCmdlet cmdlet, string computername)
{
Win32Exception win32Exception = new Win32Exception(errorcode);
string empty = string.Empty;
int nativeErrorCode = win32Exception.NativeErrorCode;
if (nativeErrorCode.Equals(53))
{
empty = StringUtil.Format(ComputerResources.NetworkPathNotFound, computername);
}
object[] message = new object[3];
message[0] = win32Exception.Message;
message[1] = computername;
message[2] = empty;
string str = StringUtil.Format(ComputerResources.OperationFailed, message);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str), "InvalidOperationException", ErrorCategory.InvalidOperation, computername);
cmdlet.WriteError(errorRecord);
}
internal static bool SkipSystemRestoreOperationForARMPlatform(PSCmdlet cmdlet)
{
bool flag = false;
if (PsUtils.IsRunningOnProcessorArchitectureARM())
{
InvalidOperationException invalidOperationException = new InvalidOperationException(ComputerResources.SystemRestoreNotSupported);
ErrorRecord errorRecord = new ErrorRecord(invalidOperationException, "SystemRestoreNotSupported", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(errorRecord);
flag = true;
}
return flag;
}
internal static bool RestartOneComputerUsingWsman(PSCmdlet cmdlet, bool isLocalhost, string computerName, object[] flags, PSCredential credential, string authentication, CancellationToken token)
{
bool flag;
string str;
string str1;
PSCredential pSCredential;
object obj;
string str2;
bool flag1 = false;
if (isLocalhost)
{
str = "localhost";
}
else
{
str = computerName;
}
string str3 = str;
if (isLocalhost)
{
str1 = null;
}
else
{
str1 = authentication;
}
string str4 = str1;
if (isLocalhost)
{
pSCredential = null;
}
else
{
pSCredential = credential;
}
PSCredential pSCredential1 = pSCredential;
Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE();
CimOperationOptions cimOperationOption = new CimOperationOptions();
cimOperationOption.Timeout = TimeSpan.FromMilliseconds(10000);
cimOperationOption.CancellationToken = new CancellationToken?(token);
CimOperationOptions cimOperationOption1 = cimOperationOption;
try
{
try
{
if ((!isLocalhost || !ComputerWMIHelper.EnableTokenPrivilege("SeShutdownPrivilege", ref tOKENPRIVILEGE)) && (isLocalhost || !ComputerWMIHelper.EnableTokenPrivilege("SeRemoteShutdownPrivilege", ref tOKENPRIVILEGE)))
{
string privilegeNotEnabled = ComputerResources.PrivilegeNotEnabled;
string str5 = computerName;
if (isLocalhost)
{
obj = "SeShutdownPrivilege";
}
else
{
obj = "SeRemoteShutdownPrivilege";
}
string str6 = StringUtil.Format(privilegeNotEnabled, str5, obj);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str6), "PrivilegeNotEnabled", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(errorRecord);
flag = false;
return flag;
}
else
{
CimSession cimSession = RemoteDiscoveryHelper.CreateCimSession(str3, pSCredential1, str4, token, cmdlet);
using (cimSession)
{
CimMethodParametersCollection cimMethodParametersCollection = new CimMethodParametersCollection();
cimMethodParametersCollection.Add(CimMethodParameter.Create("Flags", flags[0], Microsoft.Management.Infrastructure.CimType.SInt32, (CimFlags)((long)0)));
cimMethodParametersCollection.Add(CimMethodParameter.Create("Reserved", flags[1], Microsoft.Management.Infrastructure.CimType.SInt32, (CimFlags)((long)0)));
CimMethodResult cimMethodResult = cimSession.InvokeMethod("root/cimv2", "Win32_OperatingSystem", "Win32shutdown", cimMethodParametersCollection, cimOperationOption1);
int num = Convert.ToInt32(cimMethodResult.ReturnValue.Value, CultureInfo.CurrentCulture);
if (num == 0)
{
flag1 = true;
}
else
{
Win32Exception win32Exception = new Win32Exception(num);
string str7 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, win32Exception.Message);
ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str7), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord1);
}
}
}
}
catch (CimException cimException1)
{
CimException cimException = cimException1;
string str8 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, cimException.Message);
ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str8), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord2);
}
catch (Exception exception1)
{
Exception exception = exception1;
CommandProcessorBase.CheckForSevereException(exception);
string str9 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, exception.Message);
ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str9), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord3);
}
return flag1;
}
finally
{
if (isLocalhost)
{
str2 = "SeShutdownPrivilege";
}
else
{
str2 = "SeRemoteShutdownPrivilege";
}
ComputerWMIHelper.RestoreTokenPrivilege(str2, ref tOKENPRIVILEGE);
}
return flag;
}
internal static bool RestartOneComputerUsingDcom(PSCmdlet cmdlet, bool isLocalhost, string computerName, object[] flags, ConnectionOptions options)
{
bool flag;
object obj;
string str;
string str1;
bool flag1 = false;
ManagementObjectSearcher managementObjectSearcher = null;
Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE();
try
{
try
{
if ((!isLocalhost || !ComputerWMIHelper.EnableTokenPrivilege("SeShutdownPrivilege", ref tOKENPRIVILEGE)) && (isLocalhost || !ComputerWMIHelper.EnableTokenPrivilege("SeRemoteShutdownPrivilege", ref tOKENPRIVILEGE)))
{
string privilegeNotEnabled = ComputerResources.PrivilegeNotEnabled;
string str2 = computerName;
if (isLocalhost)
{
obj = "SeShutdownPrivilege";
}
else
{
obj = "SeRemoteShutdownPrivilege";
}
string str3 = StringUtil.Format(privilegeNotEnabled, str2, obj);
ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str3), "PrivilegeNotEnabled", ErrorCategory.InvalidOperation, null);
cmdlet.WriteError(errorRecord);
flag = false;
return flag;
}
else
{
if (isLocalhost)
{
str = "localhost";
}
else
{
str = computerName;
}
ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), options);
EnumerationOptions enumerationOption = new EnumerationOptions();
enumerationOption.UseAmendedQualifiers = true;
enumerationOption.DirectRead = true;
EnumerationOptions enumerationOption1 = enumerationOption;
ObjectQuery objectQuery = new ObjectQuery("select * from Win32_OperatingSystem");
managementObjectSearcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption1);
foreach (ManagementObject managementObject in managementObjectSearcher.Get())
{
object obj1 = managementObject.InvokeMethod("Win32shutdown", flags);
int num = Convert.ToInt32(obj1.ToString(), CultureInfo.CurrentCulture);
if (num == 0)
{
flag1 = true;
}
else
{
Win32Exception win32Exception = new Win32Exception(num);
string str4 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, win32Exception.Message);
ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str4), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord1);
}
}
}
}
catch (ManagementException managementException1)
{
ManagementException managementException = managementException1;
string str5 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, managementException.Message);
ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str5), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord2);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
string str6 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, cOMException.Message);
ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str6), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord3);
}
catch (UnauthorizedAccessException unauthorizedAccessException1)
{
UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1;
string str7 = StringUtil.Format(ComputerResources.RestartcomputerFailed, computerName, unauthorizedAccessException.Message);
ErrorRecord errorRecord4 = new ErrorRecord(new InvalidOperationException(str7), "RestartcomputerFailed", ErrorCategory.OperationStopped, computerName);
cmdlet.WriteError(errorRecord4);
}
return flag1;
}
finally
{
if (isLocalhost)
{
str1 = "SeShutdownPrivilege";
}
else
{
str1 = "SeRemoteShutdownPrivilege";
}
ComputerWMIHelper.RestoreTokenPrivilege(str1, ref tOKENPRIVILEGE);
if (managementObjectSearcher != null)
{
managementObjectSearcher.Dispose();
}
}
return flag;
}