public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
foreach (var device in devlist)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
_psExecServices.RunOnDeviceWithoutAuthentication(device, "cmd.exe /C echo n | gpupdate.exe /force");
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
protected virtual void RunScheduleTrigger(string scheduleId, string deviceList)
{
var devlist = ParseDeviceList(deviceList);
var failedlist = new List <string>();
Connection = new ConnectionOptions {
EnablePrivileges = true
};
try
{
Parallel.ForEach(devlist, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
ManagementScope remote = null;
var remoteConnectExceptionMsg = "";
try
{
remote = WmiService.ConnectToRemoteWmi(device, Scope, Connection);
}
catch (Exception ex)
{
remoteConnectExceptionMsg = ex.Message;
}
if (remote != null)
{
SccmClientService.TriggerClientAction(scheduleId, remote);
}
else
{
ResultConsole.AddConsoleLine($"Error connecting to WMI scope {device}. Process aborted for this device.");
Logger.LogWarning($"Error connecting to WMI scope {device}. Process aborted for this device. Exception message: {remoteConnectExceptionMsg}", null);
failedlist.Add(device);
}
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
catch (Exception) { }
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
foreach (var device in devlist)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
var remote = _wmiServices.ConnectToRemoteWmi(device, _wmiServices.RootNamespace, new ConnectionOptions());
if (remote != null)
{
var query = new ObjectQuery("SELECT username FROM Win32_ComputerSystem");
var searcher = new ManagementObjectSearcher(remote, query);
var queryCollection = searcher.Get();
foreach (var resultobject in queryCollection)
{
var result = $"{resultobject["username"]} logged in to {device}";
if (result == $" logged in to {device}" || result == $" logged in to {device}")
{
result = $"There are no users logged in to {device}!";
}
ResultConsole.AddConsoleLine(result);
}
}
else
{
Logger.LogWarning("There was an error connecting to WMI namespace on " + device, null);
ResultConsole.AddConsoleLine("There was an error connecting to WMI namespace on " + device);
}
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
foreach (var device in devlist)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
if (FileAndFolderServices.ValidateDirectoryExists(device, GpoCacheDir, ActionName, Logger))
{
var dirtyContents = Directory.EnumerateDirectories($"\\\\{device}\\C${GpoCacheDir}").ToList();
var contents = new List <string>();
foreach (var directory in dirtyContents)
{
var cleanedPath = $"{GpoCacheDir}\\{directory.Substring(directory.LastIndexOf("\\") + 1)}";
contents.Add(cleanedPath);
}
foreach (var dir in contents)
{
FileAndFolderServices.CleanDirectory(device, dir, Logger);
}
_psExecServices.RunOnDeviceWithoutAuthentication(device, "cmd.exe /C gpupdate.exe /force");
}
else
{
ResultConsole.AddConsoleLine(
"Unable to validate the directory for the GPO cache. Please delete manually.");
}
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
private void CallbackMethod()
{
var failedlist = new List <string>();
try
{
foreach (var device in _parsedListCache)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
try
{
var result = _wmiServices.RepairRemoteWmi(device, _credToken);
if (!result)
{
failedlist.Add(device);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
catch (Exception ex)
{
Logger.LogError($"There was an error repairing WMI on device {device}. {ex.Message}", ex);
ResultConsole.Instance.AddConsoleLine($"There was an error repairing WMI on device {device}.");
failedlist.Add(device);
}
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
_credToken.Dispose();
}
public override void RunCommand(string rawDeviceList)
{
var connOps = new ConnectionOptions
{
EnablePrivileges = true
};
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
Parallel.ForEach(devlist, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
var remote = _wmiServices.ConnectToRemoteWmi(device, _wmiServices.RootNamespace, connOps);
if (remote != null)
{
_wmiServices.ForceRebootRemoteDevice(device, remote);
}
else
{
Logger.LogWarning($"There was an error connecting to WMI namespace on {device}", null);
ResultConsole.AddConsoleLine($"There was an error connecting to WMI namespace on {device}");
}
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
Parallel.ForEach(devlist, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine(
$"Device {device} failed connection verification. Added to failed list.");
return;
}
var sc = new ServiceController("CMRCService", device);
sc.Start();
ResultConsole.AddConsoleLine($"CMRCService started on {device}");
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
catch (Exception ex)
{
ResultConsole.AddConsoleLine($"Ended with error: {ex.Message}");
Logger.LogError(ex.Message, ex);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var connOps = new ConnectionOptions
{
EnablePrivileges = true
};
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
foreach (var device in devlist)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
var remote = _wmiServices.ConnectToRemoteWmi(device, _wmiServices.RootNamespace, connOps);
if (remote != null)
{
ObjectQuery query = new SelectQuery("Win32_ComputerSystem");
var searcher = new ManagementObjectSearcher(remote, query);
ManagementObjectCollection queryCollection = null;
try
{
queryCollection = searcher.Get();
}
catch (Exception e)
{
Logger.LogWarning($"QueryCollection returned with exception.", e);
ResultConsole.AddConsoleLine($"QueryCollection returned with exception {e.Message}");
continue;
}
if (queryCollection.Count == 0)
{
Logger.LogWarning($"Query returned null or empty result list for device {device}", null);
ResultConsole.AddConsoleLine($"Query returned null or empty result list for device {device}");
continue;
}
foreach (ManagementObject resultobject in queryCollection)
{
ResultConsole.AddConsoleLine($"{device} returned model ID {resultobject["Model"]}");
}
}
else
{
var msg = ($"There was an error connecting to WMI namespace on {device}");
Logger.LogMessage(msg);
ResultConsole.AddConsoleLine(msg);
}
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
private void CallbackMethod()
{
var failedlist = new List <string>();
try
{
Parallel.ForEach(_parsedListCache, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
RemoteAccessEnabledKeyName,
BoolToIntString(_remoteAccessEnabled).ToString(),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
RequiresUserApprovalKeyName,
BoolToIntString(_requiresUserApproval),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
ShowConnectionBannerKeyName,
BoolToIntString(_showConnectionBanner),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
ShowTaskbarIconKeyName,
BoolToIntString(_showTaskBarIcon),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
AllowAccessOnUnattendedComputersKeyName,
BoolToIntString(_allowAccessOnUnattended),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
AllowLocalAdministratorsToRemoteControlKeyName,
BoolToIntString(_allowLocalAdministratorsToRemoteControl),
RegistryValueKind.DWord);
_registry.WriteToSubkey(
device,
RegistryHive.LocalMachine,
SccmRemoteControlRegistryPath,
AudibleSignalKeyName,
BoolToIntString(_audibleSignal),
RegistryValueKind.DWord);
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
Parallel.ForEach(devlist, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
if (FileAndFolderServices.ValidateDirectoryExists(device, CcmCachePath, ActionName, Logger))
{
FileAndFolderServices.CleanDirectory(device, CcmCachePath, Logger);
}
if (FileAndFolderServices.ValidateDirectoryExists(device, WindowsTemp, ActionName, Logger))
{
FileAndFolderServices.CleanDirectory(device, WindowsTemp, Logger);
}
var userDirPaths = Directory.EnumerateDirectories($"\\\\{device}\\C${UsersDirectory}").ToList();
var userFolders = new List <string>();
// Create useable paths
foreach (var userDir in userDirPaths)
{
var cleanedPath = $"{UsersDirectory}\\{userDir.Substring(userDir.LastIndexOf("\\") + 1)}";
userFolders.Add(cleanedPath);
}
foreach (var userFolder in userFolders)
{
if (FileAndFolderServices.ValidateDirectoryExists(device, userFolder, ActionName, Logger))
{
// Validate and Clean User Temp Folder at "C:\users\[user]\appdata\local\temp"
if (FileAndFolderServices.ValidateDirectoryExists(device, userFolder + UserTemp, ActionName, Logger))
{
FileAndFolderServices.CleanDirectory(device, userFolder + UserTemp, Logger);
}
// Validate and Clean User Temporary Internet Files at "C:\Users\[user]\AppData\Local\Microsoft\Windows\Temporary Internet Files"
if (FileAndFolderServices.ValidateDirectoryExists(device, userFolder + UserTempInternetFiles, ActionName, Logger))
{
FileAndFolderServices.CleanDirectory(device, userFolder + UserTempInternetFiles, Logger);
}
// Validate and Clean User Java Cache Files at "C:\Users\[user]\AppData\Local\Microsoft\Windows\Temporary Internet Files"
if (FileAndFolderServices.ValidateDirectoryExists(device, userFolder + JavaCache, ActionName, Logger))
{
FileAndFolderServices.CleanDirectory(device, userFolder + JavaCache, Logger);
}
}
}
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
private void CallbackMethod()
{
var failedlist = new List <string>();
try
{
Parallel.ForEach(_parsedListCache, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
var fileName = fileCopyContextCache.FilePath.Split(new char[] { '\\' }).Last();
string destPath;
if (string.IsNullOrWhiteSpace(fileCopyContextCache.DestinationPath))
{
destPath = $"\\\\{device}\\C$\\";
}
else
{
if (fileCopyContextCache.DestinationPath.StartsWith("\\"))
{
fileCopyContextCache.DestinationPath = fileCopyContextCache.DestinationPath.Remove(0, 1);
}
if (fileCopyContextCache.DestinationPath.EndsWith("\\"))
{
fileCopyContextCache.DestinationPath = fileCopyContextCache.DestinationPath.Remove(fileCopyContextCache.DestinationPath.Length - 1, 1);
}
destPath = $"\\\\{device}\\C$\\{fileCopyContextCache.DestinationPath}\\";
}
ResultConsole.AddConsoleLine($"Copying file {fileName} to device {device}");
try
{
if (FileAndFolderServices.ValidateDirectoryExists(device, fileCopyContextCache.DestinationPath, ActionName, Logger))
{
File.Copy(fileCopyContextCache.FilePath, destPath + fileName, fileCopyContextCache.Overwrite);
Logger.LogMessage($"Copied file {fileName} to {destPath}");
}
else if (fileCopyContextCache.CreateDestination)
{
Logger.LogMessage($"Creating directory {fileCopyContextCache.DestinationPath}");
Directory.CreateDirectory(destPath);
Thread.Sleep(100);
File.Copy(fileCopyContextCache.FilePath, destPath + fileName, fileCopyContextCache.Overwrite);
}
else
{
ResultConsole.AddConsoleLine("Unable to copy, destination doesn't exist.");
Logger.LogMessage("Unable to copy, destination doesn't exist.");
}
}
catch (Exception e)
{
ResultConsole.AddConsoleLine($"Unable to copy file {fileName}. Error: {e.Message}");
Logger.LogWarning($"Unable to copy file {fileName}.", e);
}
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
try
{
Parallel.ForEach(devlist, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
var sc = new ServiceController(UpdateService, device);
ResultConsole.Instance.AddConsoleLine($"Stopping update service on device {device}");
if (sc.Status == ServiceControllerStatus.Running)
{
sc.Stop();
sc.WaitForStatus(ServiceControllerStatus.Stopped, _timeouTimeSpan);
ResultConsole.Instance.AddConsoleLine($"Update service stopped on device {device}");
}
else
{
ResultConsole.Instance.AddConsoleLine($"Update service not running on device {device}. Continuing...");
}
var remotepath = $"\\\\{device}\\C$\\{SoftwareDistributionPath}";
if (FileAndFolderServices.ValidateDirectoryExists(device, SoftwareDistributionPath, ActionName, Logger))
{
var contentsList = Directory.GetFileSystemEntries(remotepath).ToList();
if (contentsList?.Count > 0)
{
foreach (var str in contentsList)
{
var isdir = File.Exists(str);
if (isdir)
{
File.Delete(str);
continue;
}
Directory.Delete(str, true);
}
}
}
ResultConsole.Instance.AddConsoleLine($"Starting update service on device {device}");
sc.Start();
sc.WaitForStatus(ServiceControllerStatus.Running, _timeouTimeSpan);
ResultConsole.Instance.AddConsoleLine($"Update service started on device {device}");
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
private void CallbackMethod()
{
var failedlist = new List <string>();
try
{
Parallel.ForEach(_parsedListCache, (device) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
return;
}
var remote = _wmi.ConnectToRemoteWmi(device, _wmi.RootNamespace, new ConnectionOptions());
if (remote != null)
{
var searcher = new ManagementObjectSearcher(remote, new ObjectQuery(ProfileQuery));
var collection = searcher.Get();
var profiles = new List <ManagementObject>();
foreach (ManagementObject profileObject in collection)
{
CancellationToken.Token.ThrowIfCancellationRequested();
var queryObjDate = profileObject?["LastUseTime"];
if (queryObjDate == null)
{
continue;
}
var date = ManagementDateTimeConverter.ToDateTime(queryObjDate.ToString());
if (DateTime.Now.DayOfYear - date.DayOfYear >= _dayCountCache)
{
profiles.Add(profileObject);
}
}
var countText = $"{profiles.Count} profile{(profiles.Count == 1 ? String.Empty : "s")} slated for deletion.\n" +
$"Deleting profiles older than {_dayCountCache} days on device {device}.";
ResultConsole.AddConsoleLine(countText);
try
{
Parallel.ForEach(profiles, (queryObj) =>
{
CancellationToken.Token.ThrowIfCancellationRequested();
var path = queryObj["LocalPath"];
queryObj.Delete();
queryObj.Dispose();
ResultConsole.AddConsoleLine($"Delete {path} from device {device} done.");
});
}
catch (Exception e)
{
Logger.LogError($"Deleting profiles on device {device} returned an error. {e.Message}", e);
}
}
});
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
public override void RunCommand(string rawDeviceList)
{
var devlist = ParseDeviceList(rawDeviceList);
var failedlist = new List <string>();
var connOps = new ConnectionOptions
{
EnablePrivileges = true
};
try
{
foreach (var device in devlist)
{
CancellationToken.Token.ThrowIfCancellationRequested();
if (!NetworkServices.VerifyDeviceConnectivity(device))
{
failedlist.Add(device);
ResultConsole.Instance.AddConsoleLine($"Device {device} failed connection verification. Added to failed list.");
continue;
}
var remote = _wmiServices.ConnectToRemoteWmi(device, _wmiServices.RootNamespace, connOps);
if (remote != null)
{
ObjectQuery query = new SelectQuery("Win32_OperatingSystem");
var searcher = new ManagementObjectSearcher(remote, query);
var queryCollection = searcher.Get();
foreach (var resultobject in queryCollection)
{
var ro = resultobject as ManagementObject;
// Obtain in-parameters for the method
var inParams = ro.GetMethodParameters("Win32Shutdown");
// Add the input parameters.
inParams["Flags"] = 4;
try
{
// Execute the method and obtain the return values.
var outParams = ro.InvokeMethod("Win32Shutdown", inParams, null);
ResultConsole.AddConsoleLine($"Returned with value {_wmiServices.GetProcessReturnValueText(Convert.ToInt32(outParams["ReturnValue"]))}");
}
catch (Exception e)
{
ResultConsole.AddConsoleLine($"Error running {ActionName} due to a .Net ManagementExcept error. There are likely no users logged on!");
Logger.LogWarning($"Error running {ActionName} due to a .Net ManagementExcept error.", e);
}
}
}
else
{
Logger.LogWarning($"There was an error connecting to WMI namespace on {device}", null);
ResultConsole.AddConsoleLine($"There was an error connecting to WMI namespace on {device}");
}
}
}
catch (OperationCanceledException e)
{
ResetCancelToken(ActionName, e);
}
if (failedlist.Count > 0)
{
WriteToFailedLog(ActionName, failedlist);
}
}
