protected override void BeginProcessing() { string str; if (!ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this)) { ManagementScope managementScope = new ManagementScope("\\root\\default"); managementScope.Connect(); this.WMIClass = new ManagementClass("SystemRestore"); this.WMIClass.Scope = managementScope; string str1 = Environment.ExpandEnvironmentVariables("%SystemDrive%"); string[] strArrays = new string[2]; strArrays[0] = str1; strArrays[1] = "\\"; str1 = string.Concat(strArrays); if (!ComputerWMIHelper.ContainsSystemDrive(this._drive, str1)) { ArgumentException argumentException = new ArgumentException(StringUtil.Format(ComputerResources.NoSystemDrive, new object[0])); base.WriteError(new ErrorRecord(argumentException, "EnableComputerNoSystemDrive", ErrorCategory.InvalidArgument, null)); } else { object[] objArray = new object[1]; objArray[0] = str1; object[] objArray1 = objArray; try { int num = Convert.ToInt32(this.WMIClass.InvokeMethod("Enable", objArray1), CultureInfo.CurrentCulture); if (num.Equals(0) || num.Equals(0x420)) { string[] strArrays1 = this._drive; for (int i = 0; i < (int)strArrays1.Length; i++) { string str2 = strArrays1[i]; if (base.ShouldProcess(str2)) { if (str2.EndsWith("\\", StringComparison.CurrentCultureIgnoreCase)) { str = str2; } else { str = string.Concat(str2, "\\"); } if (ComputerWMIHelper.IsValidDrive(str)) { if (!str.Equals(str1, StringComparison.OrdinalIgnoreCase)) { object[] objArray2 = new object[1]; objArray2[0] = str; object[] objArray3 = objArray2; num = Convert.ToInt32(this.WMIClass.InvokeMethod("Enable", objArray3), CultureInfo.CurrentCulture); if (num.Equals(0x6b5)) { num = Convert.ToInt32(this.WMIClass.InvokeMethod("Enable", objArray3), CultureInfo.CurrentCulture); } } if (!num.Equals(0) && !num.Equals(0x420) && !num.Equals(0x6b5)) { Exception exception = new ArgumentException(StringUtil.Format(ComputerResources.NotEnabled, str2)); base.WriteError(new ErrorRecord(exception, "EnableComputerRestoreNotEnabled", ErrorCategory.InvalidOperation, null)); } } else { Exception argumentException1 = new ArgumentException(StringUtil.Format(ComputerResources.InvalidDrive, str2)); base.WriteError(new ErrorRecord(argumentException1, "EnableComputerRestoreInvalidDrive", ErrorCategory.InvalidData, null)); } } } } else { ArgumentException argumentException2 = new ArgumentException(StringUtil.Format(ComputerResources.NotEnabled, str1)); base.WriteError(new ErrorRecord(argumentException2, "EnableComputerRestoreNotEnabled", ErrorCategory.InvalidOperation, null)); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; if (managementException.ErrorCode.Equals(ManagementStatus.NotFound) || managementException.ErrorCode.Equals(ManagementStatus.InvalidClass)) { ErrorRecord errorRecord = new ErrorRecord(new ArgumentException(StringUtil.Format(ComputerResources.NotSupported, new object[0])), null, ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord); } else { ErrorRecord errorRecord1 = new ErrorRecord(managementException, "GetWMIManagementException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); } } catch (COMException cOMException1) { COMException cOMException = cOMException1; if (!string.IsNullOrEmpty(cOMException.Message)) { ErrorRecord errorRecord2 = new ErrorRecord(cOMException, "COMException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord2); } else { Exception exception1 = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled, new object[0])); base.WriteError(new ErrorRecord(exception1, "ServiceDisabled", ErrorCategory.InvalidOperation, null)); } } } return; } else { return; } }
/// <summary> /// Get the List of HotFixes installed on the Local Machine. /// </summary> protected override void ProcessRecord() { foreach (string computer in ComputerName) { bool foundRecord = false; StringBuilder queryString = new StringBuilder(); ManagementScope scope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, ComputerWMIHelper.WMI_Path_CIM), _connectionOptions); scope.Connect(); if (Id != null) { queryString.Append("Select * from Win32_QuickFixEngineering where ("); for (int i = 0; i <= Id.Length - 1; i++) { queryString.Append("HotFixID= '"); queryString.Append(Id[i].Replace("'", "\\'")); queryString.Append("'"); if (i < Id.Length - 1) { queryString.Append(" Or "); } } queryString.Append(")"); } else { queryString.Append("Select * from Win32_QuickFixEngineering"); foundRecord = true; } _searchProcess = new ManagementObjectSearcher(scope, new ObjectQuery(queryString.ToString())); foreach (ManagementObject obj in _searchProcess.Get()) { if (Description != null) { if (!FilterMatch(obj)) { continue; } } else { _inputContainsWildcard = true; } // try to translate the SID to a more friendly username // just stick with the SID if anything goes wrong string installed = (string)obj["InstalledBy"]; if (!string.IsNullOrEmpty(installed)) { try { SecurityIdentifier secObj = new SecurityIdentifier(installed); obj["InstalledBy"] = secObj.Translate(typeof(NTAccount)); } catch (IdentityNotMappedException) { // thrown by SecurityIdentifier.Translate } catch (SystemException) { // thrown by SecurityIdentifier.constr } } WriteObject(obj); foundRecord = true; } if (!foundRecord && !_inputContainsWildcard) { Exception ex = new ArgumentException(StringUtil.Format(HotFixResources.NoEntriesFound, computer)); WriteError(new ErrorRecord(ex, "GetHotFixNoEntriesFound", ErrorCategory.ObjectNotFound, null)); } if (_searchProcess != null) { this.Dispose(); } } }
/// <summary> /// Get the List of HotFixes installed on the Local Machine. /// </summary> protected override void BeginProcessing() { foreach (string computer in ComputerName) { bool foundRecord = false; StringBuilder QueryString = new StringBuilder(); ConnectionOptions conOptions = ComputerWMIHelper.GetConnectionOptions(AuthenticationLevel.Packet, ImpersonationLevel.Impersonate, this.Credential); ManagementScope scope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, ComputerWMIHelper.WMI_Path_CIM), conOptions); scope.Connect(); if (Id != null) { QueryString.Append("Select * from Win32_QuickFixEngineering where ("); for (int i = 0; i <= Id.Length - 1; i++) { QueryString.Append("HotFixID= '"); QueryString.Append(Id[i].ToString().Replace("'", "\\'")); QueryString.Append("'"); if (i < Id.Length - 1) { QueryString.Append(" Or "); } } QueryString.Append(")"); } else { QueryString.Append("Select * from Win32_QuickFixEngineering"); foundRecord = true; } _searchProcess = new ManagementObjectSearcher(scope, new ObjectQuery(QueryString.ToString())); foreach (ManagementObject obj in _searchProcess.Get()) { if (Description != null) { if (!FilterMatch(obj)) { continue; } } else { _inputContainsWildcard = true; } // try to translate the SID to a more friendly username // just stick with the SID if anything goes wrong string installed = (string)obj["InstalledBy"]; if (!String.IsNullOrEmpty(installed)) { try { SecurityIdentifier secObj = new SecurityIdentifier(installed); obj["InstalledBy"] = secObj.Translate(typeof(NTAccount));; } catch (IdentityNotMappedException) // thrown by SecurityIdentifier.Translate { } catch (SystemException) // thrown by SecurityIdentifier.constr { } //catch (ArgumentException) // thrown (indirectly) by SecurityIdentifier.constr (on XP only?) //{ catch not needed - this is already caught as SystemException //} //catch (PlatformNotSupportedException) // thrown (indirectly) by SecurityIdentifier.Translate (on Win95 only?) //{ catch not needed - this is already caught as SystemException //} //catch (UnauthorizedAccessException) // thrown (indirectly) by SecurityIdentifier.Translate //{ catch not needed - this is already caught as SystemException //} } WriteObject(obj); foundRecord = true; } if (!foundRecord && !_inputContainsWildcard) { Exception Ex = new ArgumentException(StringUtil.Format(HotFixResources.NoEntriesFound, computer)); WriteError(new ErrorRecord(Ex, "GetHotFixNoEntriesFound", ErrorCategory.ObjectNotFound, null)); } if (_searchProcess != null) { this.Dispose(); } } }//end of BeginProcessing method
protected override void BeginProcessing() { if (!ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this)) { try { ManagementScope managementScope = new ManagementScope("\\root\\default"); managementScope.Connect(); this.WMIClass = new ManagementClass("SystemRestore"); this.WMIClass.Scope = managementScope; if (base.ParameterSetName.Equals("LastStatus")) { int num = Convert.ToInt32(this.WMIClass.InvokeMethod("GetLastRestoreStatus", null), CultureInfo.CurrentCulture); if (!num.Equals(0)) { if (!num.Equals(1)) { if (num.Equals(2)) { base.WriteObject(ComputerResources.RestoreInterrupted); } } else { base.WriteObject(ComputerResources.RestoreSuceess); } } else { base.WriteObject(ComputerResources.RestoreFailed); } } Dictionary <int, string> nums = new Dictionary <int, string>(); if (base.ParameterSetName.Equals("ID")) { ObjectQuery objectQuery = new ObjectQuery(); if (this._restorepoint != null) { StringBuilder stringBuilder = new StringBuilder("select * from "); stringBuilder.Append("SystemRestore"); stringBuilder.Append(" where SequenceNumber = "); for (int i = 0; i <= (int)this._restorepoint.Length - 1; i++) { stringBuilder.Append(this._restorepoint[i]); if (i < (int)this._restorepoint.Length - 1) { stringBuilder.Append(" OR SequenceNumber = "); } if (!nums.ContainsKey(this._restorepoint[i])) { nums.Add(this._restorepoint[i], "true"); } } objectQuery.QueryString = stringBuilder.ToString(); } else { objectQuery.QueryString = "select * from SystemRestore"; } ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(managementScope, objectQuery); foreach (ManagementObject managementObject in managementObjectSearcher.Get()) { base.WriteObject(managementObject); if (this._restorepoint == null) { continue; } int num1 = Convert.ToInt32(managementObject.Properties["SequenceNumber"].Value, CultureInfo.CurrentCulture); if (!nums.ContainsKey(num1)) { continue; } nums.Remove(num1); } if (nums != null && nums.Count > 0) { foreach (int key in nums.Keys) { string str = StringUtil.Format(ComputerResources.NoResorePoint, key); ArgumentException argumentException = new ArgumentException(str); ErrorRecord errorRecord = new ErrorRecord(argumentException, "NoResorePoint", ErrorCategory.InvalidArgument, null); base.WriteError(errorRecord); } } } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; if (managementException.ErrorCode.Equals(ManagementStatus.NotFound) || managementException.ErrorCode.Equals(ManagementStatus.InvalidClass)) { Exception exception = new ArgumentException(StringUtil.Format(ComputerResources.NotSupported, new object[0])); base.WriteError(new ErrorRecord(exception, "GetComputerRestorePointNotSupported", ErrorCategory.InvalidOperation, null)); } else { ErrorRecord errorRecord1 = new ErrorRecord(managementException, "GetWMIManagementException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); } } catch (COMException cOMException1) { COMException cOMException = cOMException1; if (!string.IsNullOrEmpty(cOMException.Message)) { ErrorRecord errorRecord2 = new ErrorRecord(cOMException, "COMException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord2); } else { Exception argumentException1 = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled, new object[0])); base.WriteError(new ErrorRecord(argumentException1, "ServiceDisabled", ErrorCategory.InvalidOperation, null)); } } return; } else { return; } }
protected override void ProcessRecord() { string hostName; ConnectionOptions connection = ComputerWMIHelper.GetConnection(this.Authentication, this.Impersonation, this.Credential); object[] objArray = new object[2]; objArray[0] = 1; objArray[1] = 0; object[] objArray1 = objArray; if (this._force.IsPresent) { objArray1[0] = 5; } if (!this._asjob.IsPresent) { string empty = string.Empty; string[] strArrays = this._computername; for (int i = 0; i < (int)strArrays.Length; i++) { string str = strArrays[i]; if (str.Equals("localhost", StringComparison.CurrentCultureIgnoreCase) || str.Equals(".", StringComparison.OrdinalIgnoreCase)) { hostName = Dns.GetHostName(); empty = "localhost"; } else { hostName = str; } if (base.ShouldProcess(StringUtil.Format(ComputerResources.DoubleComputerName, empty, hostName))) { try { ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection); EnumerationOptions enumerationOption = new EnumerationOptions(); enumerationOption.UseAmendedQualifiers = true; enumerationOption.DirectRead = true; ObjectQuery objectQuery = new ObjectQuery("select * from Win32_OperatingSystem"); this.searcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption); foreach (ManagementObject managementObject in this.searcher.Get()) { object obj = managementObject.InvokeMethod("Win32shutdown", objArray1); int num = Convert.ToInt32(obj.ToString(), CultureInfo.CurrentCulture); if (num == 0) { continue; } ComputerWMIHelper.WriteNonTerminatingError(num, this, hostName); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; ErrorRecord errorRecord = new ErrorRecord(managementException, "StopComputerException", ErrorCategory.InvalidOperation, hostName); base.WriteError(errorRecord); } catch (COMException cOMException1) { COMException cOMException = cOMException1; ErrorRecord errorRecord1 = new ErrorRecord(cOMException, "StopComputerException", ErrorCategory.InvalidOperation, hostName); base.WriteError(errorRecord1); } } } return; } else { string machineNames = ComputerWMIHelper.GetMachineNames(this.ComputerName); if (base.ShouldProcess(machineNames)) { InvokeWmiMethod invokeWmiMethod = new InvokeWmiMethod(); invokeWmiMethod.Path = "Win32_OperatingSystem=@"; invokeWmiMethod.ComputerName = this._computername; invokeWmiMethod.Authentication = this._authentication; invokeWmiMethod.Impersonation = this._impersonation; invokeWmiMethod.Credential = this._credential; invokeWmiMethod.ThrottleLimit = this._throttlelimit; invokeWmiMethod.Name = "Win32Shutdown"; invokeWmiMethod.EnableAllPrivileges = SwitchParameter.Present; invokeWmiMethod.ArgumentList = objArray1; PSWmiJob pSWmiJob = new PSWmiJob(invokeWmiMethod, this._computername, this._throttlelimit, Job.GetCommandTextFromInvocationInfo(base.MyInvocation)); base.JobRepository.Add(pSWmiJob); base.WriteObject(pSWmiJob); return; } else { return; } } }
protected override void BeginProcessing() { if (!ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this)) { CheckpointComputerCommand.exceptionfromnewthread = null; if (Environment.OSVersion.Version.Major >= 6 && this.intRestorePoint == 13) { ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(StringUtil.Format(ComputerResources.NotSupported, new object[0])), null, ErrorCategory.InvalidOperation, null); base.ThrowTerminatingError(errorRecord); } if (this.CanCreateNewRestorePoint(DateTime.Now)) { this.startUtcTime = DateTime.UtcNow; this.startLocalTime = DateTime.Now; ThreadStart threadStart = new ThreadStart(this.CreateRestorePoint); Thread thread = new Thread(threadStart); thread.Start(); this.WriteProgress(); if (CheckpointComputerCommand.exceptionfromnewthread != null) { if (CheckpointComputerCommand.exceptionfromnewthread as COMException == null) { if (CheckpointComputerCommand.exceptionfromnewthread as ManagementException == null) { throw CheckpointComputerCommand.exceptionfromnewthread; } else { if (((ManagementException)CheckpointComputerCommand.exceptionfromnewthread).ErrorCode.Equals(ManagementStatus.NotFound) || ((ManagementException)CheckpointComputerCommand.exceptionfromnewthread).ErrorCode.Equals(ManagementStatus.InvalidClass)) { Exception argumentException = new ArgumentException(StringUtil.Format(ComputerResources.NotSupported, new object[0])); base.WriteError(new ErrorRecord(argumentException, "CheckpointComputerNotSupported", ErrorCategory.InvalidOperation, null)); return; } else { ErrorRecord errorRecord1 = new ErrorRecord(CheckpointComputerCommand.exceptionfromnewthread, "GetWMIManagementException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); return; } } } else { if (!string.IsNullOrEmpty(CheckpointComputerCommand.exceptionfromnewthread.Message)) { ErrorRecord errorRecord2 = new ErrorRecord(CheckpointComputerCommand.exceptionfromnewthread, "COMException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord2); return; } else { Exception exception = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled, new object[0])); base.WriteError(new ErrorRecord(exception, "ServiceDisabled", ErrorCategory.InvalidOperation, null)); return; } } } else { if (!this.ret.Equals(0x422)) { if (this.ret.Equals(0) || this.ret.Equals(0x422)) { return; } else { Exception argumentException1 = new ArgumentException(StringUtil.Format(ComputerResources.RestorePointNotCreated, new object[0])); base.WriteError(new ErrorRecord(argumentException1, "CheckpointComputerPointNotCreated", ErrorCategory.InvalidOperation, null)); return; } } else { Exception exception1 = new ArgumentException(StringUtil.Format(ComputerResources.ServiceDisabled, new object[0])); base.WriteError(new ErrorRecord(exception1, "CheckpointComputerServiceDisabled", ErrorCategory.InvalidOperation, null)); return; } } } else { base.WriteWarning(ComputerResources.CannotCreateRestorePointWarning); return; } } else { return; } }
internal static void ResetMachineAccountPassword(string domain, string localMachineName, string server, PSCredential credential, PSCmdlet cmdlet) { SAMAPI.LSA_UNICODE_STRING structure; string userName; string stringFromSecureString; string cannotFindMachineAccountFromServer; DirectoryEntry directoryEntry = null; DirectoryEntry directoryEntry1 = null; DirectorySearcher directorySearcher = null; string randomPassword = null; string str = server; string str1 = str; if (str == null) { str1 = domain; } string str2 = str1; try { try { if (credential != null) { userName = credential.UserName; } else { userName = null; } string str3 = userName; if (credential != null) { stringFromSecureString = Utils.GetStringFromSecureString(credential.Password); } else { stringFromSecureString = null; } string str4 = stringFromSecureString; directoryEntry = new DirectoryEntry(string.Concat("LDAP://", str2), str3, str4, AuthenticationTypes.Secure); directorySearcher = new DirectorySearcher(directoryEntry); string[] strArrays = new string[5]; strArrays[0] = "(&(objectClass=computer)(|(cn="; strArrays[1] = localMachineName; strArrays[2] = ")(dn="; strArrays[3] = localMachineName; strArrays[4] = ")))"; directorySearcher.Filter = string.Concat(strArrays); SearchResult searchResult = directorySearcher.FindOne(); if (searchResult != null) { directoryEntry1 = searchResult.GetDirectoryEntry(); randomPassword = ComputerWMIHelper.GetRandomPassword(120); object[] objArray = new object[1]; objArray[0] = randomPassword; directoryEntry1.Invoke("SetPassword", objArray); directoryEntry1.Properties["LockOutTime"].Value = 0; } else { if (server != null) { cannotFindMachineAccountFromServer = ComputerResources.CannotFindMachineAccountFromServer; } else { cannotFindMachineAccountFromServer = ComputerResources.CannotFindMachineAccountFromDomain; } string str5 = cannotFindMachineAccountFromServer; string str6 = StringUtil.Format(str5, str2); ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str6), "CannotFindMachineAccount", ErrorCategory.OperationStopped, localMachineName); cmdlet.ThrowTerminatingError(errorRecord); } } #if !MONO catch (DirectoryServicesCOMException directoryServicesCOMException1) { DirectoryServicesCOMException directoryServicesCOMException = directoryServicesCOMException1; string str7 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, directoryServicesCOMException.Message); ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str7), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName); cmdlet.ThrowTerminatingError(errorRecord1); } #endif catch (TargetInvocationException targetInvocationException1) { TargetInvocationException targetInvocationException = targetInvocationException1; string str8 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, targetInvocationException.InnerException.Message); ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str8), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName); cmdlet.ThrowTerminatingError(errorRecord2); } catch (COMException cOMException1) { COMException cOMException = cOMException1; string str9 = StringUtil.Format(ComputerResources.FailToResetPasswordOnDomain, cOMException.Message); ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str9), "FailToResetPasswordOnDomain", ErrorCategory.OperationStopped, localMachineName); cmdlet.ThrowTerminatingError(errorRecord3); } } finally { if (directoryEntry != null) { directoryEntry.Close(); directoryEntry.Dispose(); } if (directorySearcher != null) { directorySearcher.Dispose(); } if (directoryEntry1 != null) { directoryEntry1.Close(); directoryEntry1.Dispose(); } } SAMAPI.LSA_OBJECT_ATTRIBUTES zero = new SAMAPI.LSA_OBJECT_ATTRIBUTES(); zero.RootDirectory = IntPtr.Zero; zero.ObjectName = IntPtr.Zero; zero.Attributes = 0; zero.SecurityDescriptor = IntPtr.Zero; zero.SecurityQualityOfService = IntPtr.Zero; zero.Length = Marshal.SizeOf(typeof(SAMAPI.LSA_OBJECT_ATTRIBUTES)); IntPtr intPtr = IntPtr.Zero; IntPtr zero1 = IntPtr.Zero; IntPtr intPtr1 = IntPtr.Zero; SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING = new SAMAPI.LSA_UNICODE_STRING(); lSAUNICODESTRING.Buffer = IntPtr.Zero; SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING1 = lSAUNICODESTRING; SAMAPI.LSA_UNICODE_STRING zero2 = new SAMAPI.LSA_UNICODE_STRING(); zero2.Buffer = IntPtr.Zero; SAMAPI.LSA_UNICODE_STRING lSAUNICODESTRING2 = zero2; SAMAPI.LSA_UNICODE_STRING zero3 = new SAMAPI.LSA_UNICODE_STRING(); zero3.Buffer = IntPtr.Zero; zero3.Length = 0; zero3.MaximumLength = 0; try { uint num = SAMAPI.LsaOpenPolicy(ref zero3, ref zero, 0xf0fff, out intPtr); if (num == -1073741790) { string needAdminPrivilegeToResetPassword = ComputerResources.NeedAdminPrivilegeToResetPassword; ErrorRecord errorRecord4 = new ErrorRecord(new InvalidOperationException(needAdminPrivilegeToResetPassword), "UnauthorizedAccessException", ErrorCategory.InvalidOperation, localMachineName); cmdlet.ThrowTerminatingError(errorRecord4); } if (num != 0) { ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet); } SAMAPI.InitLsaString("$MACHINE.ACC", ref lSAUNICODESTRING1); SAMAPI.InitLsaString(randomPassword, ref lSAUNICODESTRING2); bool flag = false; num = SAMAPI.LsaOpenSecret(intPtr, ref lSAUNICODESTRING1, 3, out zero1); if (num == -1073741772) { num = SAMAPI.LsaCreateSecret(intPtr, ref lSAUNICODESTRING1, 1, out zero1); flag = true; } if (num != 0) { ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet); } if (!flag) { num = SAMAPI.LsaQuerySecret(zero1, out intPtr1, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); if (num != 0) { ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet); } structure = (SAMAPI.LSA_UNICODE_STRING)Marshal.PtrToStructure(intPtr1, typeof(SAMAPI.LSA_UNICODE_STRING)); } else { structure = lSAUNICODESTRING2; } num = SAMAPI.LsaSetSecret(zero1, ref lSAUNICODESTRING2, ref structure); if (num != 0) { ResetComputerMachinePasswordCommand.ThrowOutLsaError(num, cmdlet); } } finally { if (intPtr1 != IntPtr.Zero) { SAMAPI.LsaFreeMemory(intPtr1); } if (intPtr != IntPtr.Zero) { SAMAPI.LsaClose(intPtr); } if (zero1 != IntPtr.Zero) { SAMAPI.LsaClose(zero1); } SAMAPI.FreeLsaString(ref lSAUNICODESTRING1); SAMAPI.FreeLsaString(ref lSAUNICODESTRING2); } }
private string ValidateComputerName(string computer, bool validateNewName) { IPAddress pAddress = null; string str; object obj; string str1 = null; if (computer.Equals(".", StringComparison.OrdinalIgnoreCase) || computer.Equals("localhost", StringComparison.OrdinalIgnoreCase) || computer.Equals(this._shortLocalMachineName, StringComparison.OrdinalIgnoreCase) || computer.Equals(this._fullLocalMachineName, StringComparison.OrdinalIgnoreCase)) { str1 = "localhost"; } else { bool flag = false; try { flag = IPAddress.TryParse(computer, out pAddress); } catch (Exception exception1) { Exception exception = exception1; CommandProcessorBase.CheckForSevereException(exception); } try { string hostName = Dns.GetHostEntry(computer).HostName; if (hostName.Equals(this._shortLocalMachineName, StringComparison.OrdinalIgnoreCase) || hostName.Equals(this._fullLocalMachineName, StringComparison.OrdinalIgnoreCase)) { str1 = "localhost"; } else { str1 = computer; } goto Label0; } catch (Exception exception3) { Exception exception2 = exception3; CommandProcessorBase.CheckForSevereException(exception2); if (flag) { str1 = computer; goto Label0; } else { object[] message = new object[2]; message[0] = computer; message[1] = exception2.Message; this.WriteErrorHelper(ComputerResources.CannotResolveComputerName, "AddressResolutionException", computer, ErrorCategory.InvalidArgument, false, message); str = null; } } return(str); } Label0: bool flag1 = str1.Equals("localhost", StringComparison.OrdinalIgnoreCase); if (!validateNewName || this._newName == null || ComputerWMIHelper.IsComputerNameValid(this._newName)) { return(str1); } else { AddComputerCommand addComputerCommand = this; string invalidNewName = ComputerResources.InvalidNewName; string str2 = "InvalidNewName"; string str3 = this._newName; int num = 5; int num1 = 0; object[] objArray = new object[2]; object[] objArray1 = objArray; int num2 = 0; if (flag1) { obj = this._shortLocalMachineName; } else { obj = str1; } objArray1[num2] = obj; objArray[1] = this._newName; addComputerCommand.WriteErrorHelper(invalidNewName, str2, str3, (ErrorCategory)num, num1 == 1 ? true : false, objArray); return(null); } }
protected override void BeginProcessing() { if (!ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this)) { try { ConnectionOptions connection = ComputerWMIHelper.GetConnection(AuthenticationLevel.Packet, ImpersonationLevel.Impersonate, null); ManagementPath managementPath = new ManagementPath(); managementPath.Path = "\\root\\default"; ManagementScope managementScope = new ManagementScope(managementPath, connection); managementScope.Connect(); this.WMIClass = new ManagementClass("SystemRestore"); this.WMIClass.Scope = managementScope; ObjectQuery objectQuery = new ObjectQuery(string.Concat("select * from SystemRestore where SequenceNumber = ", this._restorepoint)); ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(managementScope, objectQuery); if (managementObjectSearcher.Get().Count != 0) { string machineName = Environment.MachineName; if (base.ShouldProcess(machineName)) { object[] objArray = new object[1]; objArray[0] = this._restorepoint; object[] objArray1 = objArray; this.WMIClass.InvokeMethod("Restore", objArray1); managementPath.Path = "\\root\\cimv2"; managementScope.Path = managementPath; ManagementClass managementClass = new ManagementClass("Win32_OperatingSystem"); managementClass.Scope = managementScope; ObjectQuery objectQuery1 = new ObjectQuery("Select * from Win32_OperatingSystem"); ManagementObjectSearcher managementObjectSearcher1 = new ManagementObjectSearcher(managementScope, objectQuery1); foreach (ManagementObject managementObject in managementObjectSearcher1.Get()) { string[] strArrays = new string[1]; strArrays[0] = ""; string[] strArrays1 = strArrays; managementObject.InvokeMethod("Reboot", strArrays1); } } } else { string str = StringUtil.Format(ComputerResources.InvalidRestorePoint, this._restorepoint); ArgumentException argumentException = new ArgumentException(str); ErrorRecord errorRecord = new ErrorRecord(argumentException, "InvalidRestorePoint", ErrorCategory.InvalidArgument, null); base.WriteError(errorRecord); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; if (managementException.ErrorCode.ToString().Equals("NotFound") || managementException.ErrorCode.ToString().Equals("InvalidClass")) { Exception exception = new ArgumentException(StringUtil.Format(ComputerResources.NotSupported, new object[0])); base.WriteError(new ErrorRecord(exception, "RestoreComputerNotSupported", ErrorCategory.InvalidOperation, null)); } else { ErrorRecord errorRecord1 = new ErrorRecord(managementException, "GetWMIManagementException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); } } catch (COMException cOMException1) { COMException cOMException = cOMException1; if (!string.IsNullOrEmpty(cOMException.Message)) { ErrorRecord errorRecord2 = new ErrorRecord(cOMException, "COMException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord2); } else { Exception argumentException1 = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled, new object[0])); base.WriteError(new ErrorRecord(argumentException1, "ServiceDisabled", ErrorCategory.InvalidOperation, null)); } } return; } else { return; } }
protected override void ProcessRecord() { ConnectionOptions connection = ComputerWMIHelper.GetConnection(this.Authentication, this.Impersonation, this.Credential); if (!this.asjob) { int num = 0; string[] strArrays = this.source; for (int i = 0; i < (int)strArrays.Length; i++) { string str = strArrays[i]; try { num++; string str1 = this.QueryString(this.destination, true, true); ObjectQuery objectQuery = new ObjectQuery(str1); ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection); managementScope.Options.EnablePrivileges = true; managementScope.Connect(); EnumerationOptions enumerationOption = new EnumerationOptions(); enumerationOption.UseAmendedQualifiers = true; enumerationOption.DirectRead = true; this.searcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption); for (int j = 0; j <= this.count - 1; j++) { ManagementObjectCollection managementObjectCollections = this.searcher.Get(); int num1 = 0; foreach (ManagementBaseObject managementBaseObject in managementObjectCollections) { num1++; this.ProcessPingStatus(managementBaseObject); if (num1 >= managementObjectCollections.Count && j >= this.count - 1 && num >= (int)this.Source.Length) { continue; } Thread.Sleep(this.delay * 0x3e8); } } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; ErrorRecord errorRecord = new ErrorRecord(managementException, "TestConnectionException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord); } catch (COMException cOMException1) { COMException cOMException = cOMException1; ErrorRecord errorRecord1 = new ErrorRecord(cOMException, "TestConnectionException", ErrorCategory.InvalidOperation, null); base.WriteError(errorRecord1); } } } else { string str2 = this.QueryString(this.destination, true, false); GetWmiObjectCommand getWmiObjectCommand = new GetWmiObjectCommand(); getWmiObjectCommand.Filter = str2.ToString(); getWmiObjectCommand.Class = "Win32_PingStatus"; getWmiObjectCommand.ComputerName = this.source; getWmiObjectCommand.Authentication = this.Authentication; getWmiObjectCommand.Impersonation = this.Impersonation; getWmiObjectCommand.ThrottleLimit = this.throttlelimit; PSWmiJob pSWmiJob = new PSWmiJob(getWmiObjectCommand, this.source, this.throttlelimit, base.MyInvocation.MyCommand.Name, this.count); base.JobRepository.Add(pSWmiJob); base.WriteObject(pSWmiJob); } if (this.quiet) { string[] strArrays1 = this.destination; for (int k = 0; k < (int)strArrays1.Length; k++) { string str3 = strArrays1[k]; bool flag = false; this.quietResults.TryGetValue(str3, out flag); base.WriteObject(flag); } } }
private void DoAddComputerAction(string computer, string newName, bool isLocalhost, ConnectionOptions options, EnumerationOptions enumOptions, ObjectQuery computerSystemQuery) { string str; string userName; string stringFromSecureString; string userName1; string stringFromSecureString1; int num = 0; bool flag = false; if (isLocalhost) { str = this._shortLocalMachineName; } else { str = computer; } string str1 = str; if (base.ParameterSetName != "Domain") { string str2 = StringUtil.Format(ComputerResources.AddComputerActionWorkgroup, this._workgroupName); if (!base.ShouldProcess(str1, str2)) { return; } } else { string str3 = StringUtil.Format(ComputerResources.AddComputerActionDomain, this._domainName); if (!base.ShouldProcess(str1, str3)) { return; } } if (newName != null && newName.Length > 15) { string str4 = newName.Substring(0, 15); string str5 = StringUtil.Format(ComputerResources.TruncateNetBIOSName, str4); string truncateNetBIOSNameCaption = ComputerResources.TruncateNetBIOSNameCaption; if (!this.Force && !base.ShouldContinue(str5, truncateNetBIOSNameCaption)) { return; } } if (this.LocalCredential != null) { //options.SecurePassword = this.LocalCredential.Password; options.Username = ComputerWMIHelper.GetLocalAdminUserName(str1, this.LocalCredential); } if (isLocalhost) { options.Username = null; //options.SecurePassword = null; } ManagementObjectSearcher managementObjectSearcher = null; ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, "\\root\\cimv2"), options); using (managementObjectSearcher) { try { managementObjectSearcher = new ManagementObjectSearcher(managementScope, computerSystemQuery, enumOptions); foreach (ManagementObject managementObject in managementObjectSearcher.Get()) { string item = (string)managementObject["DNSHostName"]; if (newName == null && item.Length > 15) { string str6 = item.Substring(0, 15); string str7 = StringUtil.Format(ComputerResources.TruncateNetBIOSName, str6); string truncateNetBIOSNameCaption1 = ComputerResources.TruncateNetBIOSNameCaption; if (!this.Force && !base.ShouldContinue(str7, truncateNetBIOSNameCaption1)) { continue; } } if (newName == null || !item.Equals(newName, StringComparison.OrdinalIgnoreCase)) { if (base.ParameterSetName != "Domain") { if (!(bool)managementObject["PartOfDomain"]) { string str8 = (string)LanguagePrimitives.ConvertTo(managementObject["Domain"], typeof(string), CultureInfo.InvariantCulture); if (!str8.Equals(this._workgroupName, StringComparison.OrdinalIgnoreCase)) { num = this.JoinWorkgroup(managementObject, str1, null); if (num == 0 && newName != null) { num = this.RenameComputer(managementObject, str1, newName); } flag = num == 0; } else { object[] objArray = new object[2]; objArray[0] = str1; objArray[1] = this._workgroupName; this.WriteErrorHelper(ComputerResources.AddComputerToSameWorkgroup, "AddComputerToSameWorkgroup", str1, ErrorCategory.InvalidOperation, false, objArray); continue; } } else { string removeComputerConfirm = ComputerResources.RemoveComputerConfirm; if (!this.Force && !base.ShouldContinue(removeComputerConfirm, null)) { continue; } string str9 = (string)LanguagePrimitives.ConvertTo(managementObject["Domain"], typeof(string), CultureInfo.InvariantCulture); if (this.Credential != null) { userName = this.Credential.UserName; } else { userName = null; } string str10 = userName; if (this.Credential != null) { stringFromSecureString = Utils.GetStringFromSecureString(this.Credential.Password); } else { stringFromSecureString = null; } string str11 = stringFromSecureString; num = this.UnjoinDomain(managementObject, str1, str9, str10, str11); if (num == 0) { num = this.JoinWorkgroup(managementObject, str1, str9); if (num == 0 && newName != null) { num = this.RenameComputer(managementObject, str1, newName); } } flag = num == 0; } } else { if (!(bool)managementObject["PartOfDomain"]) { string str12 = (string)LanguagePrimitives.ConvertTo(managementObject["Domain"], typeof(string), CultureInfo.InvariantCulture); num = this.JoinDomain(managementObject, str1, null, str12); if (num == 0 && newName != null) { num = this.RenameComputer(managementObject, str1, newName); } flag = num == 0; } else { string str13 = (string)LanguagePrimitives.ConvertTo(managementObject["Domain"], typeof(string), CultureInfo.InvariantCulture); string str14 = ""; if (str13.Contains(".")) { int num1 = str13.IndexOf(".", StringComparison.OrdinalIgnoreCase); str14 = str13.Substring(0, num1); } if (str13.Equals(this._domainName, StringComparison.OrdinalIgnoreCase) || str14.Equals(this._domainName, StringComparison.OrdinalIgnoreCase)) { object[] objArray1 = new object[2]; objArray1[0] = str1; objArray1[1] = this._domainName; this.WriteErrorHelper(ComputerResources.AddComputerToSameDomain, "AddComputerToSameDomain", str1, ErrorCategory.InvalidOperation, false, objArray1); continue; } else { PSCredential unjoinDomainCredential = this.UnjoinDomainCredential; PSCredential credential = unjoinDomainCredential; if (unjoinDomainCredential == null) { credential = this.Credential; } PSCredential pSCredential = credential; if (pSCredential != null) { userName1 = pSCredential.UserName; } else { userName1 = null; } string str15 = userName1; if (pSCredential != null) { stringFromSecureString1 = Utils.GetStringFromSecureString(pSCredential.Password); } else { stringFromSecureString1 = null; } string str16 = stringFromSecureString1; num = this.UnjoinDomain(managementObject, str1, str13, str15, str16); if (num == 0) { num = this.JoinDomain(managementObject, str1, str13, null); if (num == 0 && newName != null) { num = this.RenameComputer(managementObject, str1, newName); } } flag = num == 0; } } } if (!this._passThru) { continue; } base.WriteObject(ComputerWMIHelper.GetComputerStatusObject(num, str1)); } else { object[] objArray2 = new object[2]; objArray2[0] = str1; objArray2[1] = newName; this.WriteErrorHelper(ComputerResources.NewNameIsOldName, "NewNameIsOldName", newName, ErrorCategory.InvalidArgument, false, objArray2); } } if (flag && this._restart) { object[] objArray3 = new object[2]; objArray3[0] = 6; objArray3[1] = 0; object[] objArray4 = objArray3; RestartComputerCommand.RestartOneComputerUsingDcom(this, isLocalhost, str1, objArray4, options); } if (flag && !this._restart) { base.WriteWarning(StringUtil.Format(ComputerResources.RestartNeeded, null, str1)); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; object[] message = new object[2]; message[0] = str1; message[1] = managementException.Message; this.WriteErrorHelper(ComputerResources.FailToConnectToComputer, "AddComputerException", str1, ErrorCategory.OperationStopped, false, message); } catch (COMException cOMException1) { COMException cOMException = cOMException1; object[] message1 = new object[2]; message1[0] = str1; message1[1] = cOMException.Message; this.WriteErrorHelper(ComputerResources.FailToConnectToComputer, "AddComputerException", str1, ErrorCategory.OperationStopped, false, message1); } catch (UnauthorizedAccessException unauthorizedAccessException1) { UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1; object[] message2 = new object[2]; message2[0] = str1; message2[1] = unauthorizedAccessException.Message; this.WriteErrorHelper(ComputerResources.FailToConnectToComputer, "AddComputerException", str1, ErrorCategory.OperationStopped, false, message2); } } }
protected override void BeginProcessing() { bool flag = false; string[] strArrays = this._computername; for (int i = 0; i < (int)strArrays.Length; i++) { string str = strArrays[i]; StringBuilder stringBuilder = new StringBuilder(); ConnectionOptions connection = ComputerWMIHelper.GetConnection(AuthenticationLevel.Packet, ImpersonationLevel.Impersonate, this.Credential); ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection); managementScope.Connect(); if (this._id == null) { stringBuilder.Append("Select * from Win32_QuickFixEngineering"); flag = true; } else { stringBuilder.Append("Select * from Win32_QuickFixEngineering where ("); for (int j = 0; j <= (int)this._id.Length - 1; j++) { stringBuilder.Append("HotFixID= '"); stringBuilder.Append(this._id[j].ToString().Replace("'", "\\'")); stringBuilder.Append("'"); if (j < (int)this._id.Length - 1) { stringBuilder.Append(" Or "); } } stringBuilder.Append(")"); } this.searchProcess = new ManagementObjectSearcher(managementScope, new ObjectQuery(stringBuilder.ToString())); foreach (ManagementObject managementObject in this.searchProcess.Get()) { if (this._description == null) { this.inputContainsWildcard = true; } else { if (!this.FilterMatch(managementObject)) { continue; } } string item = (string)managementObject["InstalledBy"]; if (!string.IsNullOrEmpty(item)) { try { SecurityIdentifier securityIdentifier = new SecurityIdentifier(item); managementObject["InstalledBy"] = securityIdentifier.Translate(typeof(NTAccount)); } catch (IdentityNotMappedException identityNotMappedException) { } catch (SystemException systemException1) { SystemException systemException = systemException1; CommandsCommon.CheckForSevereException(this, systemException); } } base.WriteObject(managementObject); flag = true; } if (!flag && !this.inputContainsWildcard) { Exception argumentException = new ArgumentException(StringUtil.Format(HotFixResources.NoEntriesFound, str)); base.WriteError(new ErrorRecord(argumentException, "GetHotFixNoEntriesFound", ErrorCategory.ObjectNotFound, null)); } if (this.searchProcess != null) { this.Dispose(); } } }
private void ConnectInvokeWmi() { ManagementObject managementObject; object obj; string str; InvokeWmiMethod invokeWmiMethod = (InvokeWmiMethod)this.wmiObject; this.state = WmiState.Running; this.RaiseWmiOperationState(null, WmiState.Running); if (invokeWmiMethod.InputObject == null) { ConnectionOptions connectionOption = invokeWmiMethod.GetConnectionOption(); ManagementPath managementPath = null; if (invokeWmiMethod.Path != null) { managementPath = new ManagementPath(invokeWmiMethod.Path); if (!string.IsNullOrEmpty(managementPath.NamespacePath)) { if (invokeWmiMethod.namespaceSpecified) { InvalidOperationException invalidOperationException = new InvalidOperationException("NamespaceSpecifiedWithPath"); this.internalException = invalidOperationException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } else { managementPath.NamespacePath = invokeWmiMethod.Namespace; } if (!(managementPath.Server != ".") || !invokeWmiMethod.serverNameSpecified) { if (!(managementPath.Server == ".") || !invokeWmiMethod.serverNameSpecified) { this.computerName = managementPath.Server; } } else { InvalidOperationException invalidOperationException1 = new InvalidOperationException("ComputerNameSpecifiedWithPath"); this.internalException = invalidOperationException1; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } bool flag = false; bool enablePrivilege = false; Win32Native.TOKEN_PRIVILEGE tOKENPRIVILEGE = new Win32Native.TOKEN_PRIVILEGE(); try { try { enablePrivilege = this.NeedToEnablePrivilege(this.computerName, invokeWmiMethod.Name, ref flag); if (!enablePrivilege || flag && ComputerWMIHelper.EnableTokenPrivilege("SeShutdownPrivilege", ref tOKENPRIVILEGE) || !flag && ComputerWMIHelper.EnableTokenPrivilege("SeRemoteShutdownPrivilege", ref tOKENPRIVILEGE)) { if (invokeWmiMethod.Path == null) { ManagementScope managementScope = new ManagementScope(WMIHelper.GetScopeString(this.computerName, invokeWmiMethod.Namespace), connectionOption); ManagementClass managementClass = new ManagementClass(invokeWmiMethod.Class); managementObject = managementClass; managementObject.Scope = managementScope; } else { managementPath.Server = this.computerName; if (!managementPath.IsClass) { ManagementObject managementObject1 = new ManagementObject(managementPath); managementObject = managementObject1; } else { ManagementClass managementClass1 = new ManagementClass(managementPath); managementObject = managementClass1; } ManagementScope managementScope1 = new ManagementScope(managementPath, connectionOption); managementObject.Scope = managementScope1; } ManagementBaseObject methodParameters = managementObject.GetMethodParameters(invokeWmiMethod.Name); if (invokeWmiMethod.ArgumentList != null) { int length = (int)invokeWmiMethod.ArgumentList.Length; foreach (PropertyData property in methodParameters.Properties) { if (length == 0) { break; } property.Value = invokeWmiMethod.ArgumentList[(int)invokeWmiMethod.ArgumentList.Length - length]; length--; } } if (!enablePrivilege) { managementObject.InvokeMethod(this.results, invokeWmiMethod.Name, methodParameters, null); } else { ManagementBaseObject managementBaseObject = managementObject.InvokeMethod(invokeWmiMethod.Name, methodParameters, null); int num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); if (num == 0) { this.ShutdownComplete.SafeInvoke <EventArgs>(this, null); } else { Win32Exception win32Exception = new Win32Exception(num); this.internalException = win32Exception; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } } } else { string privilegeNotEnabled = ComputerResources.PrivilegeNotEnabled; string str1 = this.computerName; if (flag) { obj = "SeShutdownPrivilege"; } else { obj = "SeRemoteShutdownPrivilege"; } string str2 = StringUtil.Format(privilegeNotEnabled, str1, obj); InvalidOperationException invalidOperationException2 = new InvalidOperationException(str2); this.internalException = invalidOperationException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); return; } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; this.internalException = managementException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (COMException cOMException1) { COMException cOMException = cOMException1; this.internalException = cOMException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (UnauthorizedAccessException unauthorizedAccessException1) { UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1; this.internalException = unauthorizedAccessException; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } } finally { if (enablePrivilege) { if (flag) { str = "SeShutdownPrivilege"; } else { str = "SeRemoteShutdownPrivilege"; } ComputerWMIHelper.RestoreTokenPrivilege(str, ref tOKENPRIVILEGE); } } return; } else { try { ManagementBaseObject methodParameters1 = invokeWmiMethod.InputObject.GetMethodParameters(invokeWmiMethod.Name); if (invokeWmiMethod.ArgumentList != null) { int length1 = (int)invokeWmiMethod.ArgumentList.Length; foreach (PropertyData argumentList in methodParameters1.Properties) { if (length1 == 0) { break; } argumentList.Value = invokeWmiMethod.ArgumentList[(int)invokeWmiMethod.ArgumentList.Length - length1]; length1--; } } invokeWmiMethod.InputObject.InvokeMethod(this.results, invokeWmiMethod.Name, methodParameters1, null); } catch (ManagementException managementException3) { ManagementException managementException2 = managementException3; this.internalException = managementException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (COMException cOMException3) { COMException cOMException2 = cOMException3; this.internalException = cOMException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } catch (UnauthorizedAccessException unauthorizedAccessException3) { UnauthorizedAccessException unauthorizedAccessException2 = unauthorizedAccessException3; this.internalException = unauthorizedAccessException2; this.state = WmiState.Failed; this.RaiseOperationCompleteEvent(null, OperationState.StopComplete); } return; } }
private void DoRemoveComputerAction(string computer, bool isLocalhost, ConnectionOptions options, EnumerationOptions enumOptions, ObjectQuery computerSystemQuery) { string str; string userName; string stringFromSecureString; bool flag = false; if (isLocalhost) { str = this._shortLocalMachineName; } else { str = computer; } string str1 = str; if (base.ShouldProcess(str1)) { if (this.LocalCredential != null) { //options.SecurePassword = this.LocalCredential.Password; options.Username = ComputerWMIHelper.GetLocalAdminUserName(str1, this.LocalCredential); } if (isLocalhost) { options.Username = null; //options.SecurePassword = null; } ManagementObjectSearcher managementObjectSearcher = null; ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, "\\root\\cimv2"), options); using (managementObjectSearcher) { try { managementObjectSearcher = new ManagementObjectSearcher(managementScope, computerSystemQuery, enumOptions); foreach (ManagementObject managementObject in managementObjectSearcher.Get()) { if ((bool)managementObject["PartOfDomain"]) { string removeComputerConfirm = ComputerResources.RemoveComputerConfirm; if (!this.Force && !base.ShouldContinue(removeComputerConfirm, null)) { continue; } string str2 = (string)LanguagePrimitives.ConvertTo(managementObject["Domain"], typeof(string), CultureInfo.InvariantCulture); if (this.UnjoinDomainCredential != null) { userName = this.UnjoinDomainCredential.UserName; } else { userName = null; } string str3 = userName; if (this.UnjoinDomainCredential != null) { stringFromSecureString = Utils.GetStringFromSecureString(this.UnjoinDomainCredential.Password); } else { stringFromSecureString = null; } string str4 = stringFromSecureString; ManagementBaseObject methodParameters = managementObject.GetMethodParameters("UnjoinDomainOrWorkgroup"); methodParameters.SetPropertyValue("UserName", str3); methodParameters.SetPropertyValue("Password", str4); methodParameters.SetPropertyValue("FUnjoinOptions", 4); ManagementBaseObject managementBaseObject = managementObject.InvokeMethod("UnjoinDomainOrWorkgroup", methodParameters, null); int num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); if ((num == 0x54b || num == 53) && this.Force) { methodParameters.SetPropertyValue("FUnjoinOptions", 0); managementBaseObject = managementObject.InvokeMethod("UnjoinDomainOrWorkgroup", methodParameters, null); num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); } if (num == 0) { flag = true; if (this._workGroup != null) { ManagementBaseObject methodParameters1 = managementObject.GetMethodParameters("JoinDomainOrWorkgroup"); methodParameters1.SetPropertyValue("Name", this._workGroup); methodParameters1.SetPropertyValue("Password", null); methodParameters1.SetPropertyValue("UserName", null); methodParameters1.SetPropertyValue("FJoinOptions", 0); managementBaseObject = managementObject.InvokeMethod("JoinDomainOrWorkgroup", methodParameters1, null); num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); if (num != 0) { Win32Exception win32Exception = new Win32Exception(num); object[] message = new object[4]; message[0] = str1; message[1] = str2; message[2] = this._workGroup; message[3] = win32Exception.Message; string str5 = StringUtil.Format(ComputerResources.FailToSwitchFromDomainToWorkgroup, message); ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str5), "FailToJoinWorkGroup", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord); } } } else { Win32Exception win32Exception1 = new Win32Exception(num); object[] objArray = new object[3]; objArray[0] = str1; objArray[1] = str2; objArray[2] = win32Exception1.Message; string str6 = StringUtil.Format(ComputerResources.FailToUnjoinDomain, objArray); ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str6), "FailToUnjoinDomain", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord1); } if (!this._passThru) { continue; } base.WriteObject(ComputerWMIHelper.GetComputerStatusObject(num, str1)); } else { string str7 = StringUtil.Format(ComputerResources.ComputerNotInDomain, str1); ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str7), "ComputerNotInDomain", ErrorCategory.InvalidOperation, str1); base.WriteError(errorRecord2); } } if (flag && this._restart) { object[] objArray1 = new object[2]; objArray1[0] = 6; objArray1[1] = 0; object[] objArray2 = objArray1; RestartComputerCommand.RestartOneComputerUsingDcom(this, isLocalhost, str1, objArray2, options); } if (flag && !this._restart) { base.WriteWarning(StringUtil.Format(ComputerResources.RestartNeeded, null, str1)); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; string str8 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, managementException.Message); ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str8), "RemoveComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord3); } catch (COMException cOMException1) { COMException cOMException = cOMException1; string str9 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, cOMException.Message); ErrorRecord errorRecord4 = new ErrorRecord(new InvalidOperationException(str9), "RemoveComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord4); } catch (UnauthorizedAccessException unauthorizedAccessException1) { UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1; string str10 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, unauthorizedAccessException.Message); ErrorRecord errorRecord5 = new ErrorRecord(new InvalidOperationException(str10), "RemoveComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord5); } } return; } else { return; } }
private string ValidateComputerName() { IPAddress pAddress = null; string str; object obj; string str1 = null; if (this._computerName.Equals(".", StringComparison.OrdinalIgnoreCase) || this._computerName.Equals("localhost", StringComparison.OrdinalIgnoreCase) || this._computerName.Equals(this._shortLocalMachineName, StringComparison.OrdinalIgnoreCase) || this._computerName.Equals(this._fullLocalMachineName, StringComparison.OrdinalIgnoreCase)) { str1 = "localhost"; } else { bool flag = false; try { flag = IPAddress.TryParse(this._computerName, out pAddress); } catch (Exception exception1) { Exception exception = exception1; CommandProcessorBase.CheckForSevereException(exception); } try { string hostName = Dns.GetHostEntry(this._computerName).HostName; if (hostName.Equals(this._shortLocalMachineName, StringComparison.OrdinalIgnoreCase) || hostName.Equals(this._fullLocalMachineName, StringComparison.OrdinalIgnoreCase)) { str1 = "localhost"; } else { str1 = this._computerName; } goto Label0; } catch (Exception exception3) { Exception exception2 = exception3; CommandProcessorBase.CheckForSevereException(exception2); if (flag) { str1 = this._computerName; goto Label0; } else { string str2 = StringUtil.Format(ComputerResources.CannotResolveComputerName, this._computerName, exception2.Message); ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str2), "AddressResolutionException", ErrorCategory.InvalidArgument, this._computerName); base.WriteError(errorRecord); str = null; } } return(str); } Label0: bool flag1 = str1.Equals("localhost", StringComparison.OrdinalIgnoreCase); if (ComputerWMIHelper.IsComputerNameValid(this._newComputerName)) { return(str1); } else { string invalidNewName = ComputerResources.InvalidNewName; if (flag1) { obj = this._shortLocalMachineName; } else { obj = str1; } string str3 = StringUtil.Format(invalidNewName, obj, this._newComputerName); ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str3), "InvalidNewName", ErrorCategory.InvalidArgument, this._newComputerName); base.WriteError(errorRecord1); return(null); } }
private void DoRenameComputerAction(string computer, string newName, bool isLocalhost) { string str; string userName; string stringFromSecureString; EnumerationOptions enumerationOption = new EnumerationOptions(); enumerationOption.UseAmendedQualifiers = true; enumerationOption.DirectRead = true; EnumerationOptions enumerationOption1 = enumerationOption; ObjectQuery objectQuery = new ObjectQuery("select * from Win32_ComputerSystem"); bool flag = false; if (isLocalhost) { str = this._shortLocalMachineName; } else { str = computer; } string str1 = str; if (base.ShouldProcess(str1)) { if (newName != null && newName.Length > 15) { string str2 = newName.Substring(0, 15); string str3 = StringUtil.Format(ComputerResources.TruncateNetBIOSName, str2); string truncateNetBIOSNameCaption = ComputerResources.TruncateNetBIOSNameCaption; if (!this.Force && !base.ShouldContinue(str3, truncateNetBIOSNameCaption)) { return; } } ConnectionOptions connectionOption = new ConnectionOptions(); connectionOption.Authentication = AuthenticationLevel.PacketPrivacy; connectionOption.Impersonation = ImpersonationLevel.Impersonate; connectionOption.EnablePrivileges = true; ConnectionOptions password = connectionOption; if (!isLocalhost) { if (this.LocalCredential == null) { if (this.DomainCredential != null) { //password.SecurePassword = this.DomainCredential.Password; password.Username = this.DomainCredential.UserName; } } else { //password.SecurePassword = this.LocalCredential.Password; password.Username = ComputerWMIHelper.GetLocalAdminUserName(str1, this.LocalCredential); } } else { password.Username = null; //password.SecurePassword = null; } ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(computer, "\\root\\cimv2"), password); try { try { this._searcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption1); foreach (ManagementObject managementObject in this._searcher.Get()) { string item = (string)managementObject["DNSHostName"]; if (!item.Equals(newName, StringComparison.OrdinalIgnoreCase)) { string str4 = null; string str5 = null; if ((bool)managementObject["PartOfDomain"]) { if (this.DomainCredential != null) { userName = this.DomainCredential.UserName; } else { userName = null; } str4 = userName; if (this.DomainCredential != null) { stringFromSecureString = Utils.GetStringFromSecureString(this.DomainCredential.Password); } else { stringFromSecureString = null; } str5 = stringFromSecureString; } ManagementBaseObject methodParameters = managementObject.GetMethodParameters("Rename"); methodParameters.SetPropertyValue("Name", newName); methodParameters.SetPropertyValue("UserName", str4); methodParameters.SetPropertyValue("Password", str5); ManagementBaseObject managementBaseObject = managementObject.InvokeMethod("Rename", methodParameters, null); int num = Convert.ToInt32(managementBaseObject["ReturnValue"], CultureInfo.CurrentCulture); if (num == 0) { flag = true; } else { Win32Exception win32Exception = new Win32Exception(num); object[] message = new object[3]; message[0] = str1; message[1] = newName; message[2] = win32Exception.Message; string str6 = StringUtil.Format(ComputerResources.FailToRename, message); ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(str6), "FailToRenameComputer", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord); } if (!this._passThru) { continue; } base.WriteObject(ComputerWMIHelper.GetRenameComputerStatusObject(num, newName, str1)); } else { string str7 = StringUtil.Format(ComputerResources.NewNameIsOldName, str1, newName); ErrorRecord errorRecord1 = new ErrorRecord(new InvalidOperationException(str7), "NewNameIsOldName", ErrorCategory.InvalidArgument, newName); base.WriteError(errorRecord1); } } if (flag && this._restart) { object[] objArray = new object[2]; objArray[0] = 6; objArray[1] = 0; object[] objArray1 = objArray; RestartComputerCommand.RestartOneComputerUsingDcom(this, isLocalhost, str1, objArray1, password); } if (flag && !this._restart) { base.WriteWarning(StringUtil.Format(ComputerResources.RestartNeeded, null, str1)); } } catch (ManagementException managementException1) { ManagementException managementException = managementException1; string str8 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, managementException.Message); ErrorRecord errorRecord2 = new ErrorRecord(new InvalidOperationException(str8), "RenameComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord2); } catch (COMException cOMException1) { COMException cOMException = cOMException1; string str9 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, cOMException.Message); ErrorRecord errorRecord3 = new ErrorRecord(new InvalidOperationException(str9), "RenameComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord3); } catch (UnauthorizedAccessException unauthorizedAccessException1) { UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1; string str10 = StringUtil.Format(ComputerResources.FailToConnectToComputer, str1, unauthorizedAccessException.Message); ErrorRecord errorRecord4 = new ErrorRecord(new InvalidOperationException(str10), "RenameComputerException", ErrorCategory.OperationStopped, str1); base.WriteError(errorRecord4); } } finally { this._searcher.Dispose(); } return; } else { return; } }