public IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
var results = new List <RegistryKeyJunk>();
using (var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(TracingKey))
{
if (key != null)
{
foreach (var subKeyName in key.GetSubKeyNames())
{
var i = subKeyName.LastIndexOf('_');
if (i <= 0)
{
continue;
}
var str = subKeyName.Substring(0, i);
var conf = ConfidenceGenerators.GenerateConfidence(str, Path.Combine(FullTracingKey, subKeyName), 0, target).ToList();
if (conf.Any())
{
var node = new RegistryKeyJunk(Path.Combine(FullTracingKey, subKeyName), target, this);
node.Confidence.AddRange(conf);
results.Add(node);
}
}
}
}
ConfidenceGenerators.TestForSimilarNames(target, _allEntries, results.Select(x => new KeyValuePair <JunkResultBase, string>(x, x.RegKeyName)).ToList());
return(results.Cast <IJunkResult>());
}
protected IEnumerable <ConfidenceRecord> GenerateConfidence(string itemName, string itemParentPath, int level)
{
var baseOutput = ConfidenceGenerators.GenerateConfidence(itemName, itemParentPath, level, _uninstaller).ToList();
if (!baseOutput.Any(x => x.Change > 0))
{
return(Enumerable.Empty <ConfidenceRecord>());
}
if (UninstallToolsGlobalConfig.QuestionableDirectoryNames.Contains(itemName, StringComparison.OrdinalIgnoreCase))
{
baseOutput.Add(ConfidenceRecords.QuestionableDirectoryName);
}
return(baseOutput);
}
public override IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
var results = new List <FileSystemJunk>();
if (!string.IsNullOrEmpty(target.InstallLocation))
{
results.AddRange(GetLinksPointingToLocation(entry => entry.InstallLocation, target)
.DoForEach(x => x.Confidence.Add(ConfidenceRecords.ExplicitConnection)));
}
if (target.UninstallerKind == UninstallerType.Steam)
{
results.AddRange(GetLinksPointingToSteamApp(target));
}
else
{
if (!string.IsNullOrEmpty(target.UninstallerFullFilename))
{
results.AddRange(GetLinksPointingToLocation(entry => entry.UninstallerFullFilename, target)
.DoForEach(x => x.Confidence.Add(ConfidenceRecords.ExplicitConnection)));
}
if (!string.IsNullOrEmpty(target.UninstallerLocation))
{
var exceptUninstallerShortcut = GetLinksPointingToLocation(entry => entry.UninstallerLocation, target)
.Where(possibleResult => results.All(result => !PathTools.PathsEqual(result.Path, possibleResult.Path)))
.ToList();
results.AddRange(exceptUninstallerShortcut);
}
}
// Remove shortcuts that we aren't sure about
foreach (var junkNode in results.ToList())
{
var name = Path.GetFileNameWithoutExtension(junkNode.Path.Name);
junkNode.Confidence.AddRange(ConfidenceGenerators.GenerateConfidence(name, target));
if (junkNode.Confidence.IsEmpty)
{
results.Remove(junkNode);
}
}
return(results.Cast <IJunkResult>());
}
private IEnumerable <RegistryKeyJunk> FindJunkRecursively(RegistryKey softwareKey, int level = -1)
{
var returnList = new List <RegistryKeyJunk>();
try
{
// Don't try to scan root keys
if (level > -1)
{
var keyName = Path.GetFileName(softwareKey.Name);
var keyDir = Path.GetDirectoryName(softwareKey.Name);
var confidence =
ConfidenceGenerators.GenerateConfidence(keyName, keyDir, level, _uninstaller).ToList();
// Check if application's location is explicitly mentioned in any of the values
if (softwareKey.TryGetValueNames().Any(valueName => TestValueForMatches(softwareKey, valueName)))
{
confidence.Add(ConfidenceRecord.ExplicitConnection);
}
if (confidence.Any())
{
// TODO Add extra confidence if the key is, or will be empty after junk removal
var newNode = new RegistryKeyJunk(softwareKey.Name, _uninstaller, this);
newNode.Confidence.AddRange(confidence);
returnList.Add(newNode);
}
}
// Limit recursion depth
if (level <= 1)
{
foreach (var subKeyName in softwareKey.GetSubKeyNames())
{
if (KeyBlacklist.Contains(subKeyName, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
using (var subKey = softwareKey.OpenSubKey(subKeyName, false))
{
if (subKey != null)
{
returnList.AddRange(FindJunkRecursively(subKey, level + 1));
}
}
}
}
}
// Reg key invalid
catch (ArgumentException)
{
}
catch (SecurityException)
{
}
catch (ObjectDisposedException)
{
}
return(returnList);
}
public override IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
var isStoreApp = target.UninstallerKind == UninstallerType.StoreApp;
if (isStoreApp && string.IsNullOrEmpty(target.RatingId))
{
throw new ArgumentException("StoreApp entry has no ID");
}
if (isStoreApp)
{
foreach (var regAppEntry in _regAppsValueCache)
{
if (regAppEntry.AppName == null)
{
continue;
}
if (string.Equals(regAppEntry.AppName, target.RatingId, StringComparison.OrdinalIgnoreCase))
{
// Handle the value under RegisteredApps itself
var regAppResult = new RegistryValueJunk(regAppEntry.RegAppFullPath, regAppEntry.ValueName, target, this);
regAppResult.Confidence.Add(ConfidenceRecords.ExplicitConnection);
yield return(regAppResult);
// Handle the key pointed at by the value
var appEntryKey = new RegistryKeyJunk(regAppEntry.AppKey, target, this);
appEntryKey.Confidence.Add(ConfidenceRecords.ExplicitConnection);
appEntryKey.Confidence.Add(ConfidenceRecords.IsStoreApp);
yield return(appEntryKey);
}
}
}
else
{
foreach (var regAppEntry in _regAppsValueCache)
{
if (regAppEntry.AppName != null)
{
continue;
}
var generatedConfidence = ConfidenceGenerators.GenerateConfidence(regAppEntry.ValueName, target).ToList();
if (generatedConfidence.Count > 0)
{
// Handle the value under RegisteredApps itself
var regAppResult = new RegistryValueJunk(regAppEntry.RegAppFullPath, regAppEntry.ValueName, target, this);
regAppResult.Confidence.AddRange(generatedConfidence);
yield return(regAppResult);
// Handle the key pointed at by the value
const string capabilitiesSubkeyName = "\\Capabilities";
if (regAppEntry.TargetSubKeyPath.EndsWith(capabilitiesSubkeyName, StringComparison.Ordinal))
{
var capabilitiesKeyResult = new RegistryKeyJunk(regAppEntry.TargetFullPath, target, this);
capabilitiesKeyResult.Confidence.AddRange(generatedConfidence);
yield return(capabilitiesKeyResult);
var ownerKey = regAppEntry.TargetFullPath.Substring(0,
regAppEntry.TargetFullPath.Length - capabilitiesSubkeyName.Length);
var subConfidence = ConfidenceGenerators.GenerateConfidence(Path.GetFileName(ownerKey),
target).ToList();
if (subConfidence.Count > 0)
{
var subResult = new RegistryKeyJunk(ownerKey, target, this);
subResult.Confidence.AddRange(subConfidence);
yield return(subResult);
}
}
}
}
}
}