public override void Setup(ICollection <ApplicationUninstallerEntry> allUninstallers)
{
base.Setup(allUninstallers);
_comEntries = new List <ComEntry>();
_extensionKeyNames = new Dictionary <string, string[]>();
foreach (var classesKeyPath in _classesKeys)
{
using (var classesKey = RegistryTools.OpenRegistryKey(classesKeyPath, false, true))
{
if (classesKey == null)
{
continue;
}
_extensionKeyNames.Add(classesKeyPath, classesKey.GetSubKeyNames().Where(x => x[0] == '.').ToArray());
try
{
GetClsidEntries(_comEntries, classesKey);
GetTypeLibEntries(_comEntries, classesKey);
}
catch (SystemException ex)
{
Console.WriteLine(@"Unexpected error while scanning COM entries, the registry might be corrupted. COM junk detection will not work.");
Console.WriteLine(ex);
}
}
}
// Gather com interface info
// https://docs.microsoft.com/en-us/windows/desktop/com/interface-key
foreach (var classesKeyPath in _classesKeys)
{
using (var interfacesKey = RegistryTools.OpenRegistryKey(Path.Combine(classesKeyPath, "Interface"), false, true))
{
if (interfacesKey == null)
{
continue;
}
foreach (var singleInterfaceKey in interfacesKey.GetSubKeyNames())
{
using (var proxyKey = interfacesKey.OpenSubKey(Path.Combine(singleInterfaceKey, "ProxyStubClsid32")))
{
var proxyGuid = proxyKey?.GetValue(null, null) as string;
if (proxyGuid == null)
{
continue;
}
var matchClass = _comEntries.FirstOrDefault(x => string.Equals(x.Guid, proxyGuid, StringComparison.OrdinalIgnoreCase));
matchClass?.InterfaceNames.Add(Path.Combine(interfacesKey.Name, singleInterfaceKey));
}
}
}
}
}
public override void Delete()
{
using (var key = RegistryTools.OpenRegistryKey(ParentPath, true))
{
key?.DeleteSubKeyTree(Name);
}
}
public IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
var returnList = new List <IJunkResult>();
if (string.IsNullOrEmpty(target.InstallLocation))
{
return(returnList);
}
string pathRoot;
try
{
pathRoot = Path.GetPathRoot(target.InstallLocation);
}
catch (SystemException ex)
{
Console.WriteLine(ex);
return(returnList);
}
var unrootedLocation = pathRoot.Length >= 1
? target.InstallLocation.Replace(pathRoot, string.Empty)
: target.InstallLocation;
if (string.IsNullOrEmpty(unrootedLocation.Trim()))
{
return(returnList);
}
using (var key = RegistryTools.OpenRegistryKey(Path.Combine(SoftwareRegKeyScanner.KeyCu, AudioPolicyConfigSubkey)))
{
if (key == null)
{
return(returnList);
}
foreach (var subKeyName in key.GetSubKeyNames())
{
using (var subKey = key.OpenSubKey(subKeyName))
{
if (subKey == null)
{
continue;
}
var defVal = subKey.GetValue(null) as string;
if (defVal != null &&
defVal.Contains(unrootedLocation, StringComparison.InvariantCultureIgnoreCase))
{
var junk = new RegistryKeyJunk(subKey.Name, target, this);
junk.Confidence.Add(ConfidenceRecords.ExplicitConnection);
returnList.Add(junk);
}
}
}
}
return(returnList);
}
public SettingsWindow()
{
Opacity = 0;
InitializeComponent();
Icon = Resources.editoricon;
var settings = Settings.Default.Binder;
settings.BindControl(checkBoxRestoreSessionSettings, s => s.RestoreSessionSettingsOnExit, this);
settings.SendUpdates(this);
try
{
using (var key = RegistryTools.OpenRegistryKey(RunKeyPath))
{
checkBoxBoot.Checked = key?.GetValue(RunKeyValueName) != null;
}
}
catch (Exception ex)
{
ShowBootException(ex);
checkBoxBoot.Enabled = false;
}
checkBoxBoot.CheckedChanged += checkBoxBoot_CheckedChanged;
}
public bool StillExists(StartupEntry startupEntry)
{
if (startupEntry.IsRegKey)
{
using (var key = RegistryTools.OpenRegistryKey(startupEntry.ParentLongName))
return(!string.IsNullOrEmpty(key.GetStringSafe(startupEntry.EntryLongName)));
}
return(File.Exists(startupEntry.FullLongName));
}
private static Microsoft.Win32.RegistryKey GetFirewallRulesKey()
{
try
{
return(RegistryTools.OpenRegistryKey(FirewallRulesKey));
}
catch (SystemException ex)
{
Console.WriteLine(ex);
return(null);
}
}
/// <summary>
/// Create a registry value for the specified entry. Works for drive links as well.
/// </summary>
/// <param name="startupEntry"></param>
internal static void CreateRegValue(StartupEntry startupEntry)
{
if (string.IsNullOrEmpty(startupEntry.Command))
{
return;
}
using (var runKey = RegistryTools.OpenRegistryKey(startupEntry.ParentLongName, true))
{
runKey.SetValue(startupEntry.EntryLongName, startupEntry.Command, RegistryValueKind.String);
}
}
private IEnumerable <JunkNode> ScanRelatedKeys(IEnumerable <JunkNode> itemsToCompare)
{
var input = itemsToCompare.ToList();
var output = new List <JunkNode>();
foreach (var registryJunkNode in input)
{
var nodeName = registryJunkNode.FullName;
// Check Wow first because non-wow path will match wow path
var softwareKey = new[] { KeyLmWow, KeyCuWow, KeyLm, KeyCu }.First(
key => nodeName.StartsWith(key, StringComparison.InvariantCultureIgnoreCase));
nodeName = nodeName.Substring(softwareKey.Length + 1);
foreach (var keyToTest in SoftwareRegKeys.Except(new[] { softwareKey }))
{
var nodePath = Path.Combine(keyToTest, nodeName);
// Check if the same node exists in other root keys
var node = input.FirstOrDefault(x => PathTools.PathsEqual(x.FullName, nodePath));
if (node != null)
{
// Add any non-duplicate confidence to the existing node
node.Confidence.AddRange(registryJunkNode.Confidence.ConfidenceParts
.Where(x => !node.Confidence.ConfidenceParts.Any(x.Equals)));
}
else
{
try
{
// Check if the key acually exists
using (var nodeKey = RegistryTools.OpenRegistryKey(nodePath, false))
{
if (nodeKey != null)
{
var newNode = new RegistryKeyJunkNode(Path.GetDirectoryName(nodePath),
Path.GetFileName(nodePath), Uninstaller.DisplayName);
newNode.Confidence.AddRange(registryJunkNode.Confidence.ConfidenceParts);
output.Add(newNode);
}
}
}
catch
{
// Ignore keys that don't exist
}
}
}
}
return(output);
}
private static void GetTypeLibEntries(ICollection <ComEntry> results, RegistryKey classes)
{
using (var typeLibKey = RegistryTools.OpenRegistryKey(Path.Combine(classes.Name, "TypeLib"), false, true))
{
if (typeLibKey == null)
{
return;
}
foreach (var typeLibKeyGuid in typeLibKey.GetSubKeyNames())
{
if (IsSystemGuid(typeLibKeyGuid))
{
continue;
}
using (var guidKey = typeLibKey.OpenSubKey(typeLibKeyGuid))
{
var versionKeyName = guidKey?.GetSubKeyNames().FirstOrDefault();
if (versionKeyName == null)
{
continue;
}
var result = results.FirstOrDefault(x => string.Equals(x.Guid, typeLibKeyGuid, StringComparison.OrdinalIgnoreCase)) ?? new ComEntry(typeLibKeyGuid);
foreach (var fileKeyPath in new[] { Path.Combine(versionKeyName, "0\\win32"), Path.Combine(versionKeyName, "0\\win64") })
{
using (var fileKey = guidKey.OpenSubKey(fileKeyPath))
{
var path = fileKey?.GetValue(null, null) as string;
if (string.IsNullOrEmpty(path))
{
continue;
}
path = PathTools.NormalizePath(path);
if (UninstallToolsGlobalConfig.IsSystemDirectory(path))
{
continue;
}
result.FullFilename = PathTools.NormalizePath(Environment.ExpandEnvironmentVariables(path));
results.Add(result);
break;
}
}
}
}
}
}
private IEnumerable <JunkNode> ScanAudioPolicyConfig()
{
var returnList = new List <JunkNode>();
if (string.IsNullOrEmpty(Uninstaller.InstallLocation))
{
return(returnList);
}
var pathRoot = Path.GetPathRoot(Uninstaller.InstallLocation);
var unrootedLocation = pathRoot.Length >= 1
? Uninstaller.InstallLocation.Replace(pathRoot, string.Empty)
: Uninstaller.InstallLocation;
if (string.IsNullOrEmpty(unrootedLocation.Trim()))
{
return(returnList);
}
using (var key = RegistryTools.OpenRegistryKey(Path.Combine(KeyCu,
@"Microsoft\Internet Explorer\LowRegistry\Audio\PolicyConfig\PropertyStore")))
{
if (key == null)
{
return(returnList);
}
foreach (var subKeyName in key.GetSubKeyNames())
{
using (var subKey = key.OpenSubKey(subKeyName))
{
if (subKey == null)
{
continue;
}
var defVal = subKey.GetValue(null) as string;
if (defVal != null &&
defVal.Contains(unrootedLocation, StringComparison.InvariantCultureIgnoreCase))
{
var junk = new RegistryKeyJunkNode(key.Name, subKeyName, Uninstaller.DisplayName);
junk.Confidence.Add(ConfidencePart.ExplicitConnection);
returnList.Add(junk);
}
}
}
}
return(returnList);
}
public override void Delete()
{
try
{
using (var key = RegistryTools.OpenRegistryKey(ParentPath, true))
{
key.DeleteSubKeyTree(Name);
}
}
catch (Exception ex)
{
// Failed to remove the key
Debug.WriteLine("RegistryJunkNode\\Delete -> " + ex.Message);
}
}
public override void CreateBackup(string backupPath)
{
var path = @"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\" + ProgramName;
using (var key = RegistryTools.OpenRegistryKey(path))
{
if (key == null)
{
throw new IOException();
}
}
var filename = PathTools.SanitizeFileName(FullLongName) + ".reg";
RegistryTools.ExportRegistry(Path.Combine(backupPath, filename), new[] { path });
}
private IEnumerable <JunkNode> ScanForJunk()
{
var output = new List <JunkNode>();
foreach (var softwareKeyName in SoftwareRegKeys)
{
using (var softwareKey = RegistryTools.OpenRegistryKey(softwareKeyName))
{
if (softwareKey != null)
{
output.AddRange(FindJunkRecursively(softwareKey));
}
}
}
return(output.Concat(ScanRelatedKeys(output)));
}
public void Setup(ICollection <ApplicationUninstallerEntry> allUninstallers)
{
try
{
using (var key = RegistryTools.OpenRegistryKey(RegKey))
{
if (key != null)
{
// Reg key names are case insensitive so using tolower key is fine
_lookup = key.GetSubKeyNames().ToDictionary(x => x.ToLower(), x => x);
}
}
}
catch (SystemException ex)
{
Console.WriteLine(ex);
}
}
public override IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
_uninstaller = target;
var output = new List <RegistryKeyJunk>();
foreach (var softwareKeyName in SoftwareRegKeys)
{
using (var softwareKey = RegistryTools.OpenRegistryKey(softwareKeyName))
{
if (softwareKey != null)
{
output.AddRange(FindJunkRecursively(softwareKey));
}
}
}
return(output.Concat(ScanRelatedKeys(output)).Cast <IJunkResult>());
}
/// <summary>
/// Remove registry key of a disabled startup entry. Link file is not touched if it exists.
/// </summary>
private static void RemoveDisabledRegEntry(StartupEntry startupEntry)
{
using (var disabledStartupEntryStore = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path, true))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
var disabledSubkeyKey =
disabledStartupEntryStore.GetSubKeyNames()
.FirstOrDefault(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase));
if (!string.IsNullOrEmpty(disabledSubkeyKey))
{
disabledStartupEntryStore.DeleteSubKey(disabledSubkeyKey);
}
}
}
public bool StillExists(StartupEntry startupEntry)
{
try
{
using (var key = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
return(key.GetSubKeyNames()
.Any(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase)));
}
}
catch
{
return(false);
}
}
private void FindJunkRecursively(ICollection <RegistryJunkNode> returnList, string softwareKey, int level)
{
try
{
string[] names;
using (var key = RegistryTools.OpenRegistryKey(softwareKey))
{
names = key.GetSubKeyNames();
}
foreach (var name in names)
{
if (KeyBlacklist.Any(y => y.Equals(name)))
{
continue;
}
var generatedConfidence = GenerateConfidence(name, softwareKey, level, false);
var confidenceParts = generatedConfidence as IList <ConfidencePart> ?? generatedConfidence.ToList();
if (confidenceParts.Any())
{
var newNode = new RegistryJunkNode(softwareKey, name, Uninstaller.DisplayName);
newNode.Confidence.AddRange(confidenceParts);
returnList.Add(newNode);
}
else if (level <= 1)
{
FindJunkRecursively(returnList, Path.Combine(softwareKey, name), level + 1);
}
}
}
// Reg key invalid
catch (ArgumentException)
{
}
catch (SecurityException)
{
}
catch (ObjectDisposedException)
{
}
}
public static IEnumerable <BrowserHelperEntry> GetBrowserHelpers()
{
using (var clsidKey = RegistryTools.OpenRegistryKey(ClsidPath))
{
foreach (var registryStartupPoint in RegistryStartupPoints)
{
RegistryKey mainKey;
try
{
mainKey = RegistryTools.CreateSubKeyRecursively(registryStartupPoint);
}
catch (UnauthorizedAccessException e)
{
Console.WriteLine(e);
continue;
}
using (mainKey)
{
foreach (var browserHelperEntry in
GatherBrowserHelpersFromKey(mainKey, clsidKey, registryStartupPoint, false))
{
yield return(browserHelperEntry);
}
using (var disabledKey = mainKey.OpenSubKey(AutorunsDisabledKeyName))
{
if (disabledKey == null)
{
continue;
}
foreach (var browserHelperEntry in
GatherBrowserHelpersFromKey(disabledKey, clsidKey, registryStartupPoint, true))
{
yield return(browserHelperEntry);
}
}
}
}
}
}
/// <summary>
/// Look for registry values in the run keys
/// </summary>
private static IEnumerable <StartupEntry> GetRegStartupItems(StartupPointData point)
{
var results = new List <StartupEntry>();
try
{
using (var rKey = RegistryTools.OpenRegistryKey(point.Path))
{
if (rKey != null)
{
foreach (var name in rKey.GetValueNames())
{
var result = rKey.GetStringSafe(name);
if (string.IsNullOrEmpty(result))
{
continue;
}
try
{
results.Add(new StartupEntry(point, name, result));
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
}
}
}
}
catch (ArgumentException)
{
// Key doesn't exist, create it
RegistryTools.CreateSubKeyRecursively(point.Path)?.Close();
}
catch (SecurityException ex)
{
Console.WriteLine(@"Failed to process startup entries: " + ex);
}
return(results);
}
public override void Backup(string backupDirectory)
{
using (var key = RegistryTools.OpenRegistryKey(ParentPath))
{
var target = key.GetValue(Name);
var targetValue = target as string;
if (targetValue != null)
{
var dir = CreateBackupDirectory(backupDirectory);
var fileName = PathTools.SanitizeFileName(FullName.TrimStart('\\').Replace('.', '_')) + ".reg";
RegistryTools.ExportRegistryStringValues(Path.Combine(dir, fileName), ParentPath,
new KeyValuePair <string, string>(Name, targetValue));
}
else
{
Debug.Fail("Unsupported type " + target.GetType().FullName);
}
}
}
public IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
if (string.IsNullOrEmpty(target.InstallLocation))
{
yield break;
}
foreach (var userAssistGuid in UserAssistGuids)
{
using (var key = RegistryTools.OpenRegistryKey(
$@"{SoftwareRegKeyScanner.KeyCu}\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{userAssistGuid}\Count"))
{
if (key == null)
{
continue;
}
foreach (var valueName in key.GetValueNames())
{
// Convert the value name to a usable form
var convertedName = Rot13(valueName);
var guidEnd = convertedName.IndexOf('}') + 1;
Guid g;
if (guidEnd > 0 && GuidTools.GuidTryParse(convertedName.Substring(0, guidEnd), out g))
{
convertedName = NativeMethods.GetKnownFolderPath(g) + convertedName.Substring(guidEnd);
}
// Check for matches
if (convertedName.StartsWith(target.InstallLocation,
StringComparison.InvariantCultureIgnoreCase))
{
var junk = new RegistryValueJunk(key.Name, valueName, target, this);
junk.DisplayValueName = convertedName;
junk.Confidence.Add(ConfidenceRecords.ExplicitConnection);
yield return(junk);
}
}
}
}
}
/// <summary>
/// Check if the startup entry still exists in registry or on disk.
/// If the entry is disabled, but it exists in the backup store, this method will return true.
/// </summary>
public override bool StillExists()
{
try
{
if (Disabled)
{
return(StartupEntryManager.DisableFunctions.StillExists(this));
}
if (!IsRegKey)
{
return(File.Exists(FullLongName));
}
using (var key = RegistryTools.OpenRegistryKey(ParentLongName))
return(!string.IsNullOrEmpty(key.GetValue(EntryLongName) as string));
}
catch
{
return(false);
}
}
public override string CategoryName => Localisation.Junk_Clsid_GroupName; // "COM Objects";
public override IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
if (!_classesKeys.Any())
{
yield break;
}
if (string.IsNullOrEmpty(target.InstallLocation) ||
UninstallToolsGlobalConfig.IsSystemDirectory(target.InstallLocation))
{
yield break;
}
foreach (var comEntry in _comEntries.Where(x => SubPathIsInsideBasePath(target.InstallLocation, x.FullFilename)))
{
foreach (var interfacePath in comEntry.InterfaceNames)
{
using (var interfaceKey = RegistryTools.OpenRegistryKey(interfacePath, false, true))
{
if (interfaceKey != null)
{
yield return(JunkFromKey(target, interfaceKey));
}
}
}
foreach (var classesKeyPath in _classesKeys)
{
using (var classesKey = RegistryTools.OpenRegistryKey(classesKeyPath, false, true))
{
if (classesKey == null)
{
continue;
}
foreach (var targetSubKeyPath in new[]
{
Path.Combine("CLSID", comEntry.Guid),
Path.Combine("TypeLib", comEntry.Guid),
comEntry.ProgId,
comEntry.VersionIndependentProgId
})
{
if (targetSubKeyPath != null)
{
var result = TryGetFromPath(target, classesKey, targetSubKeyPath);
if (result != null)
{
yield return(result);
}
}
}
foreach (var extensionKeyName in GetExtensionNames(classesKeyPath))
{
using (var extensionKey = classesKey.OpenSubKey(extensionKeyName))
{
if (extensionKey == null)
{
continue;
}
// Contains subkeys with default values containing class guids of the extensions
using (var shellExKey = extensionKey.OpenSubKey("ShellEx"))
{
if (shellExKey != null)
{
foreach (var shellSubKeyName in shellExKey.GetSubKeyNames())
{
using (var shellSubKey = shellExKey.OpenSubKey(shellSubKeyName))
{
if (string.Equals(shellSubKey?.GetValue(null, null) as string, comEntry.Guid, StringComparison.OrdinalIgnoreCase))
{
yield return(JunkFromKey(target, shellSubKey));
}
}
}
}
}
// Contains default value pointing to a class guid
using (var persistentHandlerKey = extensionKey.OpenSubKey("PersistentHandler"))
{
if (string.Equals(persistentHandlerKey?.GetValue(null, null) as string, comEntry.Guid, StringComparison.OrdinalIgnoreCase))
{
yield return(JunkFromKey(target, persistentHandlerKey));
}
}
if (comEntry.ProgId != null || comEntry.VersionIndependentProgId != null)
{
// Contains values with names corresponding to ProgIDs
using (var openWithProgidsKey = extensionKey.OpenSubKey("OpenWithProgIDs"))
{
if (openWithProgidsKey != null)
{
foreach (var progIdName in openWithProgidsKey.GetValueNames())
{
if (string.Equals(progIdName, comEntry.ProgId, StringComparison.OrdinalIgnoreCase) ||
string.Equals(progIdName, comEntry.VersionIndependentProgId, StringComparison.OrdinalIgnoreCase))
{
yield return(JunkFromValue(target, openWithProgidsKey.Name, progIdName));
}
}
}
}
}
}
}
}
}
}
}
private static ApplicationUninstallerEntry GetOneDrive()
{
var result = new ApplicationUninstallerEntry();
// Check if installed
try
{
using (var key = RegistryTools.OpenRegistryKey(@"HKEY_CURRENT_USER\SOFTWARE\Microsoft\OneDrive", false))
{
result.RegistryPath = key.Name;
result.RegistryKeyName = key.GetKeyName();
result.InstallLocation = key.GetValue("CurrentVersionPath") as string;
if (result.InstallLocation == null || !Directory.Exists(result.InstallLocation))
{
return(null);
}
result.DisplayIcon = key.GetValue("OneDriveTrigger") as string;
result.DisplayVersion = ApplicationEntryTools.CleanupDisplayVersion(key.GetValue("Version") as string);
}
}
catch
{
return(null);
}
// Check if the uninstaller is available
var systemRoot = WindowsTools.GetEnvironmentPath(CSIDL.CSIDL_WINDOWS);
var uninstallPath = Path.Combine(systemRoot, @"System32\OneDriveSetup.exe");
if (!File.Exists(uninstallPath))
{
uninstallPath = Path.Combine(systemRoot, @"SysWOW64\OneDriveSetup.exe");
if (!File.Exists(uninstallPath))
{
uninstallPath = null;
}
}
if (uninstallPath != null)
{
result.IsValid = true;
result.UninstallString = $"\"{uninstallPath}\" /uninstall";
result.QuietUninstallString = result.UninstallString;
if (!File.Exists(result.DisplayIcon))
{
result.DisplayIcon = uninstallPath;
}
}
result.AboutUrl = @"https://onedrive.live.com/";
result.RawDisplayName = "OneDrive";
result.Publisher = "Microsoft Corporation";
result.EstimatedSize = FileSize.FromKilobytes(1024 * 90);
result.Is64Bit = MachineType.X86;
result.IsRegistered = true;
result.UninstallerKind = UninstallerType.Unknown;
result.InstallDate = Directory.GetCreationTime(result.InstallLocation);
if (!string.IsNullOrEmpty(result.DisplayIcon))
{
result.IconBitmap = UninstallToolsGlobalConfig.TryExtractAssociatedIcon(result.DisplayIcon);
}
return(result);
}
/// <summary>
/// Create a new record in the appropriate disabled entry store. If the entry already exists it is overwritten.
/// </summary>
/// <param name="startupEntry">Startup entry to create the record for</param>
/// <param name="newEntryPath">Full path to the new backup file</param>
private static void CreateDisabledEntry(StartupEntry startupEntry, string newEntryPath)
{
using (var disabledStartupEntryStore = RegistryTools.OpenRegistryKey(
startupEntry.IsRegKey ? RegistryDisabledKey.Path : DriveDisabledKey.Path, true))
{
var disabledSubKeyName = startupEntry.IsRegKey
? startupEntry.EntryLongName
: startupEntry.FullLongName.Replace('\\', '^');
var disabledSubkeyKey =
disabledStartupEntryStore.GetSubKeyNames()
.FirstOrDefault(x => disabledSubKeyName.Equals(x, StringComparison.InvariantCultureIgnoreCase));
// Clean up old disabled entry if any
if (!string.IsNullOrEmpty(disabledSubkeyKey))
{
disabledStartupEntryStore.DeleteSubKey(disabledSubkeyKey);
}
using (
var storeSubkey = disabledStartupEntryStore.CreateSubKey(disabledSubKeyName,
RegistryKeyPermissionCheck.ReadWriteSubTree))
{
if (storeSubkey == null)
{
return;
}
if (startupEntry.IsRegKey)
{
storeSubkey.SetValue("key", RegistryTools.StripKeyRoot(startupEntry.ParentLongName),
RegistryValueKind.String);
storeSubkey.SetValue("item", startupEntry.EntryLongName, RegistryValueKind.String);
storeSubkey.SetValue("hkey", RegistryTools.GetKeyRoot(startupEntry.ParentLongName, true),
RegistryValueKind.String);
storeSubkey.SetValue("inimapping", 0, RegistryValueKind.String);
}
else
{
storeSubkey.SetValue("item",
Path.GetFileNameWithoutExtension(startupEntry.EntryLongName) ?? string.Empty,
RegistryValueKind.String);
storeSubkey.SetValue("path", startupEntry.FullLongName, RegistryValueKind.String);
storeSubkey.SetValue("location", startupEntry.ParentLongName, RegistryValueKind.String);
storeSubkey.SetValue("backup", newEntryPath, RegistryValueKind.String);
storeSubkey.SetValue("backupExtension", BackupExtension, RegistryValueKind.String);
}
// Command stays the same for both
storeSubkey.SetValue("command", startupEntry.Command, RegistryValueKind.String);
// Set the disable date
var now = DateTime.Now;
storeSubkey.SetValue("YEAR", now.Year, RegistryValueKind.DWord);
storeSubkey.SetValue("MONTH", now.Month, RegistryValueKind.DWord);
storeSubkey.SetValue("DAY", now.Day, RegistryValueKind.DWord);
storeSubkey.SetValue("HOUR", now.Hour, RegistryValueKind.DWord);
storeSubkey.SetValue("MINUTE", now.Minute, RegistryValueKind.DWord);
storeSubkey.SetValue("SECOND", now.Second, RegistryValueKind.DWord);
}
}
}
/// <summary>
/// Opens a new instance of registry key used by this uninstaller. Remember to close it!
/// </summary>
/// <exception cref="System.Security.SecurityException">
/// The user does not have the permissions required to access the registry key in the
/// specified mode.
/// </exception>
public RegistryKey OpenRegKey(bool writable)
{
return(RegistryTools.OpenRegistryKey(RegistryPath, writable));
}
/// <summary>
/// Opens a new read-only instance of registry key used by this uninstaller. Remember to close it!
/// </summary>
public RegistryKey OpenRegKey()
{
return(RegistryPath != null?RegistryTools.OpenRegistryKey(RegistryPath) : null);
}
public override bool StillExists()
{
using (var key = RegistryTools.OpenRegistryKey(GetRealParentPath()))
return(key != null && key.GetSubKeyNames().Contains(EntryLongName));
}
public override void Delete()
{
using (var key = RegistryTools.OpenRegistryKey(GetRealParentPath(), true))
key?.DeleteSubKey(EntryLongName);
}