public IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
// Do nothing when called by the manager
yield break;
}
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);
}
try
{
using (var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Tracing", true))
{
if (key != null && target.SortedExecutables != null)
{
var exeNames = target.SortedExecutables.Select(Path.GetFileNameWithoutExtension).ToList();
foreach (var keyGroup in key.GetSubKeyNames()
.Where(x => x.EndsWith("_RASAPI32") || x.EndsWith("_RASMANCS"))
.Select(name => new { name, trimmed = name.Substring(0, name.LastIndexOf('_')) })
.GroupBy(x => x.trimmed))
{
if (exeNames.Contains(keyGroup.Key, StringComparison.InvariantCultureIgnoreCase))
{
foreach (var keyName in keyGroup)
{
var junk = new RegistryKeyJunk(Path.Combine(key.Name, keyName.name), target, this);
junk.Confidence.Add(ConfidenceRecords.ExplicitConnection);
returnList.Add(junk);
}
}
}
}
}
}
catch (Exception ex)
{
if (ex is UnauthorizedAccessException || ex is SecurityException || ex is IOException)
{
Console.WriteLine(ex);
}
else
{
throw;
}
}
return(returnList);
}
private FileSystemJunk CreateJunkNode(Shortcut source, ApplicationUninstallerEntry entry)
{
return(new FileSystemJunk(new FileInfo(source.LinkFilename), entry, this));
}
private static string GetTrimmedName(ApplicationUninstallerEntry entry)
{
var displayNameTrimmed = entry.DisplayNameTrimmed;
return(displayNameTrimmed.Length > 3 ? displayNameTrimmed : entry.DisplayName);
}
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);
}
}
}
}
}
}
// TODO read the app manifests for more info, requires json parsing - var manifest = Path.Combine(installDir, "current\\manifest.json");
public IList <ApplicationUninstallerEntry> GetUninstallerEntries(ListGenerationProgress.ListGenerationCallback progressCallback)
{
var results = new List <ApplicationUninstallerEntry>();
if (!ScoopIsAvailable)
{
return(results);
}
// Make uninstaller for scoop itself
var scoopEntry = new ApplicationUninstallerEntry
{
RawDisplayName = "Scoop",
Comment = "Automated program installer",
AboutUrl = "https://github.com/lukesampson/scoop",
InstallLocation = _scoopUserPath
};
// Make sure the global directory gets removed as well
var junk = new FileSystemJunk(new DirectoryInfo(_scoopGlobalPath), scoopEntry, null);
junk.Confidence.Add(ConfidenceRecords.ExplicitConnection);
junk.Confidence.Add(4);
scoopEntry.AdditionalJunk.Add(junk);
scoopEntry.UninstallString = MakeScoopCommand("uninstall scoop").ToString();
scoopEntry.UninstallerKind = UninstallerType.PowerShell;
results.Add(scoopEntry);
// Make uninstallers for apps installed by scoop
var result = RunScoopCommand("export");
if (string.IsNullOrEmpty(result))
{
return(results);
}
var appEntries = result.Split(StringTools.NewLineChars.ToArray(), StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
var exeSearcher = new AppExecutablesSearcher();
foreach (var str in appEntries)
{
// Format should be "$app (v:$ver) $global_display $bucket $arch"
// app has no spaces, $global_display is *global*, bucket is inside [] brackets like [main]
// version should always be there but the check errored out for some users, everything after version is optional
string name;
string version = null;
bool isGlobal = false;
var spaceIndex = str.IndexOf(" ", StringComparison.Ordinal);
if (spaceIndex > 0)
{
name = str.Substring(0, spaceIndex);
var startIndex = str.IndexOf("(v:", StringComparison.Ordinal);
if (startIndex > 0)
{
var verEndIndex = str.IndexOf(')', startIndex);
version = str.Substring(Math.Min(startIndex + 3, str.Length - 1), Math.Max(verEndIndex - startIndex - 3, 0));
if (version.Length == 0)
{
version = null;
}
}
isGlobal = str.Substring(spaceIndex).Contains("*global*");
}
else
{
name = str;
}
var entry = new ApplicationUninstallerEntry
{
RawDisplayName = name,
DisplayVersion = ApplicationEntryTools.CleanupDisplayVersion(version),
RatingId = "Scoop " + name
};
var installDir = Path.Combine(isGlobal ? _scoopGlobalPath : _scoopUserPath, "apps\\" + name);
if (Directory.Exists(installDir))
{
// Avoid looking for executables in old versions
entry.InstallLocation = Path.Combine(installDir, "current");
exeSearcher.AddMissingInformation(entry);
entry.InstallLocation = installDir;
}
entry.UninstallerKind = UninstallerType.PowerShell;
entry.UninstallString = MakeScoopCommand("uninstall " + name + (isGlobal ? " --global" : "")).ToString();
results.Add(entry);
}
return(results);
}
public DriveJunk(ApplicationUninstallerEntry entry, IEnumerable <ApplicationUninstallerEntry> otherUninstallers)
: base(entry, otherUninstallers)
{
}
private static IEnumerable <ApplicationUninstallerEntry> GetRelatedUninstallers(
ApplicationUninstallerEntry thisUninstaller, IEnumerable <ApplicationUninstallerEntry> other)
{
return(other.Where(y => ApplicationEntryTools.AreEntriesRelated(thisUninstaller, y, -3)));
}
public IEnumerable <ApplicationUninstallerEntry> GetUninstallerEntries(ListGenerationProgress.ListGenerationCallback progressCallback)
{
if (!HelperAvailable)
{
yield break;
}
var output = FactoryTools.StartHelperAndReadOutput(HelperPath, "/query");
if (string.IsNullOrEmpty(output))
{
yield break;
}
foreach (var data in FactoryTools.ExtractAppDataSetsFromHelperOutput(output))
{
if (!data.ContainsKey("CanonicalName"))
{
continue;
}
var name = data["CanonicalName"];
if (string.IsNullOrEmpty(name))
{
continue;
}
var uninstallStr = $"\"{HelperPath}\" /uninstall {name}";
var entry = new ApplicationUninstallerEntry
{
RatingId = name,
//RegistryKeyName = name,
UninstallString = uninstallStr,
QuietUninstallString = uninstallStr,
IsValid = true,
UninstallerKind = UninstallerType.Oculus,
InstallLocation = data["InstallLocation"],
DisplayVersion = data["Version"],
IsProtected = "true".Equals(data["IsCore"], StringComparison.OrdinalIgnoreCase),
};
var executable = data["LaunchFile"];
if (File.Exists(executable))
{
ExecutableAttributeExtractor.FillInformationFromFileAttribs(entry, executable, true);
entry.DisplayIcon = executable;
}
if (Directory.Exists(entry.InstallLocation))
{
entry.InstallDate = Directory.GetCreationTime(entry.InstallLocation);
}
if (string.IsNullOrEmpty(entry.RawDisplayName))
{
entry.RawDisplayName = name.Replace('-', ' ').ToTitleCase();
}
yield return(entry);
}
}
/// <summary>
/// Test if the input matches this condition. Returns null if it is impossible to determine.
/// </summary>
public bool?TestEntry(ApplicationUninstallerEntry input)
{
if (!Enabled)
{
return(null);
}
var targets = ReferenceEquals(TargetProperty, ComparisonTargetInfo.AllTargetComparison)
? ComparisonTargetInfo.ComparisonTargets.Where(x => x.PossibleStrings == null)
.Select(x => x.Getter(input))
: new[] { TargetProperty.Getter(input) };
bool?result = null;
foreach (var target in targets.Where(target => !string.IsNullOrEmpty(target)))
{
try
{
switch (ComparisonMethod)
{
case ComparisonMethod.Equals:
result = target.Equals(FilterText, StringComparison.InvariantCultureIgnoreCase);
break;
case ComparisonMethod.Any:
result = target.ContainsAny(
FilterText.Split((char[])null, StringSplitOptions.RemoveEmptyEntries),
StringComparison.InvariantCultureIgnoreCase);
break;
case ComparisonMethod.StartsWith:
result = target.StartsWith(FilterText, StringComparison.InvariantCultureIgnoreCase);
break;
case ComparisonMethod.EndsWith:
result = target.EndsWith(FilterText, StringComparison.InvariantCultureIgnoreCase);
break;
case ComparisonMethod.Contains:
result = target.Contains(FilterText, StringComparison.InvariantCultureIgnoreCase);
break;
case ComparisonMethod.Regex:
result = Regex.IsMatch(target, FilterText, RegexOptions.CultureInvariant);
break;
default:
throw new InvalidOperationException("Unknown FilterComparisonMethod");
}
}
catch (InvalidOperationException)
{
throw;
}
catch
{
//result = null;
}
if (result == true)
{
return(!InvertResults);
}
}
if (!result.HasValue)
{
return(null);
}
return(InvertResults ? !result.Value : result.Value);
}
public CacheEntry(ApplicationUninstallerEntry entry, byte[] icon)
{
Entry = entry;
Icon = icon;
}
public StartupJunk(ApplicationUninstallerEntry entry)
: base(entry, Enumerable.Empty <ApplicationUninstallerEntry>())
{
}
protected JunkResultBase(ApplicationUninstallerEntry application, IJunkCreator source, ConfidenceCollection confidence)
{
Application = application;
Source = source;
Confidence = confidence;
}
protected JunkResultBase(ApplicationUninstallerEntry application, IJunkCreator source) : this(application, source, new ConfidenceCollection())
{
}
private static IEnumerable <ApplicationUninstallerEntry> GetUpdates()
{
if (!HelperIsAvailable)
{
yield break;
}
var output = FactoryTools.StartProcessAndReadOutput(HelperPath, "list");
if (string.IsNullOrEmpty(output) || output.Contains("error", StringComparison.OrdinalIgnoreCase))
{
yield break;
}
foreach (var group in ProcessInput(output))
{
var entry = new ApplicationUninstallerEntry
{
UninstallerKind = UninstallerType.WindowsUpdate,
IsUpdate = true,
Publisher = "Microsoft Corporation"
};
foreach (var valuePair in group)
{
switch (valuePair.Key)
{
case "UpdateID":
entry.RatingId = valuePair.Value;
Guid result;
if (GuidTools.TryExtractGuid(valuePair.Value, out result))
{
entry.BundleProviderKey = result;
}
break;
case "RevisionNumber":
entry.DisplayVersion = ApplicationEntryTools.CleanupDisplayVersion(valuePair.Value);
break;
case "Title":
entry.RawDisplayName = valuePair.Value;
break;
case "IsUninstallable":
bool isUnins;
if (bool.TryParse(valuePair.Value, out isUnins))
{
entry.IsValid = isUnins;
}
break;
case "SupportUrl":
entry.AboutUrl = valuePair.Value;
break;
case "MinDownloadSize":
long size;
if (long.TryParse(valuePair.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out size))
{
entry.EstimatedSize = FileSize.FromBytes(size);
}
break;
case "LastDeploymentChangeTime":
DateTime date;
if (DateTime.TryParse(valuePair.Value, CultureInfo.InvariantCulture, DateTimeStyles.None, out date) &&
!DateTime.MinValue.Equals(date))
{
entry.InstallDate = date;
}
break;
}
}
if (entry.IsValid)
{
entry.UninstallString = $"\"{HelperPath}\" uninstall {entry.RatingId}";
entry.QuietUninstallString = entry.UninstallString;
}
yield return(entry);
}
}
/// <summary>
/// Check how related are the two entries.
/// Values above 0 mean there is good confidence
/// </summary>
public static int AreEntriesRelated(ApplicationUninstallerEntry baseEntry, ApplicationUninstallerEntry otherEntry)
{
//Debug.Assert(!(otherEntry.DisplayName.Contains("Steam", StringComparison.OrdinalIgnoreCase) &&
// baseEntry.DisplayName.Contains("Steam", StringComparison.OrdinalIgnoreCase)));
if (PathTools.PathsEqual(baseEntry.InstallLocation, otherEntry.InstallLocation))
{
return(100);
}
if (!string.IsNullOrEmpty(baseEntry.UninstallString))
{
if (PathTools.PathsEqual(baseEntry.UninstallString, otherEntry.UninstallString))
{
return(100);
}
if (!string.IsNullOrEmpty(otherEntry.InstallLocation) &&
baseEntry.UninstallString.Contains(otherEntry.InstallLocation, StringComparison.InvariantCultureIgnoreCase))
{
return(100);
}
}
if (!string.IsNullOrEmpty(baseEntry.UninstallerLocation) && !string.IsNullOrEmpty(otherEntry.InstallLocation) &&
baseEntry.UninstallerLocation.StartsWith(otherEntry.InstallLocation, StringComparison.InvariantCultureIgnoreCase))
{
return(100);
}
var score = 0;
if (!string.IsNullOrEmpty(baseEntry.InstallLocation) && !string.IsNullOrEmpty(otherEntry.InstallLocation))
{
AddScore(ref score, -8, 0, -3, baseEntry.InstallLocation.Contains(otherEntry.InstallLocation,
StringComparison.InvariantCultureIgnoreCase));
}
AddScore(ref score, -5, 0, 3, baseEntry.Is64Bit != MachineType.Unknown && otherEntry.Is64Bit != MachineType.Unknown ?
baseEntry.Is64Bit == otherEntry.Is64Bit : (bool?)null);
AddScore(ref score, -3, -1, 5, CompareDates(baseEntry.InstallDate, otherEntry.InstallDate));
AddScore(ref score, -2, 0, 5, CompareStrings(baseEntry.DisplayVersion, otherEntry.DisplayVersion, true));
AddScore(ref score, -5, 0, 5, CompareStrings(baseEntry.Publisher, otherEntry.Publisher));
// Check if base entry was installed from inside other entry's install directory
if (string.IsNullOrEmpty(baseEntry.InstallLocation) && !string.IsNullOrEmpty(baseEntry.InstallSource) &&
!string.IsNullOrEmpty(otherEntry.InstallLocation) && otherEntry.InstallLocation.Length >= 5)
{
AddScore(ref score, 0, 0, 5, baseEntry.InstallSource.Contains(
otherEntry.InstallLocation, StringComparison.InvariantCultureIgnoreCase));
}
var nameSimilarity = CompareStrings(baseEntry.DisplayName, otherEntry.DisplayName);
AddScore(ref score, -5, -2, 8, nameSimilarity);
if (!nameSimilarity.HasValue || nameSimilarity == false)
{
var trimmedSimilarity = CompareStrings(baseEntry.DisplayNameTrimmed, otherEntry.DisplayNameTrimmed);
// Don't risk it if names can't be compared at all
//if (!trimmedSimilarity.HasValue && !nameSimilarity.HasValue) return false;
AddScore(ref score, -5, -2, 8, trimmedSimilarity);
}
try
{
AddScore(ref score, -2, -2, 5, CompareStrings(baseEntry.DisplayNameTrimmed.Length < 5 ?
baseEntry.DisplayName : baseEntry.DisplayNameTrimmed, Path.GetFileName(otherEntry.InstallLocation)));
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
//Debug.Assert(score <= 0);
return(score);
}
// TODO read the app manifests for more info, requires json parsing - var manifest = Path.Combine(installDir, "current\\manifest.json");
public IEnumerable <ApplicationUninstallerEntry> GetUninstallerEntries(ListGenerationProgress.ListGenerationCallback progressCallback)
{
if (!ScoopIsAvailable)
{
yield break;
}
// Make uninstaller for scoop itself
var scoopEntry = new ApplicationUninstallerEntry();
scoopEntry.RawDisplayName = "Scoop";
scoopEntry.Comment = "Automated program installer";
scoopEntry.AboutUrl = "https://github.com/lukesampson/scoop";
scoopEntry.InstallLocation = _scoopUserPath;
// Make sure the global directory gets removed as well
var junk = new FileSystemJunk(new DirectoryInfo(_scoopGlobalPath), scoopEntry, null);
junk.Confidence.Add(ConfidenceRecords.ExplicitConnection);
junk.Confidence.Add(4);
scoopEntry.AdditionalJunk.Add(junk);
scoopEntry.UninstallString = MakeScoopCommand("uninstall scoop").ToString();
scoopEntry.UninstallerKind = UninstallerType.PowerShell;
yield return(scoopEntry);
// Make uninstallers for apps installed by scoop
var result = RunScoopCommand("export");
if (string.IsNullOrEmpty(result))
{
yield break;
}
var appEntries = result.Split(StringTools.NewLineChars.ToArray(), StringSplitOptions.RemoveEmptyEntries);
var exeSearcher = new AppExecutablesSearcher();
foreach (var str in appEntries)
{
var startIndex = str.IndexOf("(v:", StringComparison.Ordinal);
var verEndIndex = str.IndexOf(')', startIndex);
var name = str.Substring(0, startIndex - 1);
var version = str.Substring(startIndex + 3, verEndIndex - startIndex - 3);
var isGlobal = str.Substring(verEndIndex).Contains("*global*");
var entry = new ApplicationUninstallerEntry();
entry.RawDisplayName = name;
entry.DisplayVersion = version;
entry.RatingId = "Scoop " + name;
var installDir = Path.Combine(isGlobal ? _scoopGlobalPath : _scoopUserPath, "apps\\" + name);
if (Directory.Exists(installDir))
{
// Avoid looking for executables in old versions
entry.InstallLocation = Path.Combine(installDir, "current");
exeSearcher.AddMissingInformation(entry);
entry.InstallLocation = installDir;
}
entry.UninstallerKind = UninstallerType.PowerShell;
entry.UninstallString = MakeScoopCommand("uninstall " + name + (isGlobal ? " --global" : "")).ToString();
yield return(entry);
}
}
public RegistryValueJunk(string containingKeyPath, string valueName, ApplicationUninstallerEntry application,
IJunkCreator source) : base(containingKeyPath, application, source)
{
ValueName = valueName;
}
protected JunkBase(ApplicationUninstallerEntry entry, IEnumerable <ApplicationUninstallerEntry> otherUninstallers)
{
Uninstaller = entry;
OtherUninstallers = otherUninstallers;
}
private static IEnumerable <ApplicationUninstallerEntry> GetSteamApps()
{
if (!SteamHelperIsAvailable)
{
yield break;
}
var output = FactoryTools.StartProcessAndReadOutput(SteamHelperPath, "list");
if (string.IsNullOrEmpty(output) || output.Contains("error", StringComparison.InvariantCultureIgnoreCase))
{
yield break;
}
foreach (var idString in output.SplitNewlines(StringSplitOptions.RemoveEmptyEntries))
{
int appId;
if (!int.TryParse(idString, out appId))
{
continue;
}
output = FactoryTools.StartProcessAndReadOutput(SteamHelperPath,
"info " + appId.ToString("G"));
if (string.IsNullOrEmpty(output) ||
output.Contains("error", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
var lines = output.SplitNewlines(StringSplitOptions.RemoveEmptyEntries).Select(x =>
{
var o = x.Split(new[] { " - " }, StringSplitOptions.None);
return(new KeyValuePair <string, string>(o[0], o[1]));
}).ToList();
var entry = new ApplicationUninstallerEntry
{
DisplayName =
lines.Single(x => x.Key.Equals("Name", StringComparison.InvariantCultureIgnoreCase)).Value,
UninstallString =
lines.Single(x => x.Key.Equals("UninstallString", StringComparison.InvariantCultureIgnoreCase))
.Value,
InstallLocation =
lines.Single(x => x.Key.Equals("InstallDirectory", StringComparison.InvariantCultureIgnoreCase))
.Value,
UninstallerKind = UninstallerType.Steam,
IsValid = true,
IsOrphaned = true,
RatingId = "Steam App " + appId.ToString("G")
};
long bytes;
if (
long.TryParse(
lines.Single(x => x.Key.Equals("SizeOnDisk", StringComparison.InvariantCultureIgnoreCase)).Value,
out bytes))
{
entry.EstimatedSize = FileSize.FromBytes(bytes);
}
yield return(entry);
}
}
public IEnumerable <ApplicationUninstallerEntry> GetUninstallerEntries(ListGenerationProgress.ListGenerationCallback progressCallback)
{
if (!ChocoIsAvailable)
{
yield break;
}
var result = StartProcessAndReadOutput(ChocoLocation, @"list -l -nocolor -y -r");
if (string.IsNullOrEmpty(result))
{
yield break;
}
var appEntries = result.Split(NewlineSeparators, StringSplitOptions.RemoveEmptyEntries);
var appNames = appEntries.Select(x =>
{
var i = x.IndexOf('|');
if (i <= 0)
{
return(null);
}
return(new { name = x.Substring(0, i), version = x.Substring(i + 1) });
}).Where(x => x != null);
foreach (var appName in appNames)
{
var info = StartProcessAndReadOutput(ChocoLocation, "info -l -nocolor -y -v " + appName.name);
var kvps = ExtractPackageInformation(info);
if (kvps.Count == 0)
{
continue;
}
var entry = new ApplicationUninstallerEntry();
AddInfo(entry, kvps, "Title", (e, s) => e.RawDisplayName = s);
entry.DisplayVersion = appName.version;
entry.RatingId = "Choco " + appName.name;
entry.UninstallerKind = UninstallerType.Chocolatey;
AddInfo(entry, kvps, "Summary", (e, s) => e.Comment = s);
if (string.IsNullOrEmpty(entry.Comment))
{
AddInfo(entry, kvps, "Description", (e, s) => e.Comment = s);
if (string.IsNullOrEmpty(entry.Comment))
{
AddInfo(entry, kvps, "Tags", (e, s) => e.Comment = s);
}
}
AddInfo(entry, kvps, "Documentation", (e, s) => e.AboutUrl = s);
if (string.IsNullOrEmpty(entry.AboutUrl))
{
AddInfo(entry, kvps, "Software Site", (e, s) => e.AboutUrl = s);
if (string.IsNullOrEmpty(entry.AboutUrl))
{
AddInfo(entry, kvps, "Chocolatey Package Source", (e, s) => e.AboutUrl = s);
}
}
var psc = new ProcessStartCommand(ChocoLocation, $"uninstall {appName.name} -y -r");
entry.UninstallString = psc.ToString();
// Prevent chocolatey from trying to run the original uninstaller (it's deleted by now), only remove the package
psc.Arguments += " -n --skipautouninstaller";
var junk = new Junk.Containers.RunProcessJunk(entry, null, psc, Localisation.ChocolateyFactory_UninstallInChocolateyJunkName);
junk.Confidence.Add(Junk.Confidence.ConfidenceRecords.ExplicitConnection);
entry.AdditionalJunk.Add(junk);
yield return(entry);
}
}
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);
}
private static string GetFullName(ApplicationUninstallerEntry entry)
{
return(entry.DisplayName);
}
public static IEnumerable <ConfidenceRecord> GenerateConfidence(string itemName, ApplicationUninstallerEntry applicationUninstallerEntry)
{
return(GenerateConfidence(itemName, null, 0, applicationUninstallerEntry));
}
private static bool CheckAreEntriesRelated(ApplicationUninstallerEntry baseEntry, ApplicationUninstallerEntry otherEntry)
{
if (PathTools.PathsEqual(baseEntry.InstallLocation, otherEntry.InstallLocation))
{
return(true);
}
if (!string.IsNullOrEmpty(baseEntry.UninstallerLocation) && (!string.IsNullOrEmpty(otherEntry.InstallLocation) &&
baseEntry.UninstallerLocation.StartsWith(otherEntry.InstallLocation, StringComparison.InvariantCultureIgnoreCase)))
{
return(true);
}
if (!string.IsNullOrEmpty(baseEntry.UninstallString) && !string.IsNullOrEmpty(otherEntry.InstallLocation) &&
baseEntry.UninstallString.Contains(otherEntry.InstallLocation))
{
return(true);
}
if (CompareStrings(baseEntry.Publisher, otherEntry.Publisher))
{
if (CompareStrings(baseEntry.DisplayName, otherEntry.DisplayName))
{
return(true);
}
if (CompareStrings(baseEntry.DisplayNameTrimmed, otherEntry.DisplayNameTrimmed))
{
return(true);
}
try
{
if (CompareStrings(baseEntry.DisplayNameTrimmed, Path.GetFileName(otherEntry.InstallLocation)))
{
return(true);
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
}
return(false);
}
internal static IEnumerable <ConfidenceRecord> GenerateConfidence(string itemName, string itemParentPath, int level, ApplicationUninstallerEntry applicationUninstallerEntry)
{
var matchResult = MatchStringToProductName(applicationUninstallerEntry, itemName);
return(GenerateConfidence(itemName, matchResult, itemParentPath, level, applicationUninstallerEntry));
}
public override string CategoryName => Localisation.Junk_Clsid_GroupName; // "COM Objects";
public override IEnumerable <IJunkResult> FindJunk(ApplicationUninstallerEntry target)
{
if (string.IsNullOrEmpty(target.InstallLocation))
{
yield break;
}
try
{
if (UninstallToolsGlobalConfig.IsSystemDirectory(target.InstallLocation))
{
yield break;
}
}
catch (ArgumentException ex) { Console.WriteLine(ex); }
foreach (var comEntry in _comEntries.Where(x => PathTools.SubPathIsInsideBasePath(target.InstallLocation, x.FullFilename, true)))
{
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));
}
}
}
}
}
}
}
}
}
}
}
public IList <ApplicationUninstallerEntry> GetUninstallerEntries(
ListGenerationProgress.ListGenerationCallback progressCallback)
{
var results = new List <ApplicationUninstallerEntry>();
if (StoreAppHelperPath == null)
{
return(results);
}
var output = FactoryTools.StartHelperAndReadOutput(StoreAppHelperPath, "/query");
if (string.IsNullOrEmpty(output))
{
return(results);
}
var windowsPath = WindowsTools.GetEnvironmentPath(CSIDL.CSIDL_WINDOWS);
foreach (var data in FactoryTools.ExtractAppDataSetsFromHelperOutput(output))
{
if (!data.ContainsKey("InstalledLocation") || !Directory.Exists(data["InstalledLocation"]))
{
continue;
}
var fullName = data["FullName"];
var uninstallStr = $"\"{StoreAppHelperPath}\" /uninstall \"{fullName}\"";
var isProtected = data.ContainsKey("IsProtected") && Convert.ToBoolean(data["IsProtected"], CultureInfo.InvariantCulture);
var result = new ApplicationUninstallerEntry
{
Comment = fullName,
CacheIdOverride = fullName,
RatingId = fullName.Substring(0, fullName.IndexOf("_", StringComparison.Ordinal)),
UninstallString = uninstallStr,
QuietUninstallString = uninstallStr,
RawDisplayName = string.IsNullOrEmpty(data["DisplayName"]) ? fullName : data["DisplayName"],
Publisher = data["PublisherDisplayName"],
IsValid = true,
UninstallerKind = UninstallerType.StoreApp,
InstallLocation = data["InstalledLocation"],
InstallDate = Directory.GetCreationTime(data["InstalledLocation"]),
IsProtected = isProtected,
SystemComponent = isProtected
};
if (File.Exists(data["Logo"]))
{
try
{
result.DisplayIcon = data["Logo"];
result.IconBitmap = DrawingTools.IconFromImage(new Bitmap(data["Logo"]));
}
catch
{
result.DisplayIcon = null;
result.IconBitmap = null;
}
}
if (result.InstallLocation.StartsWith(windowsPath, StringComparison.InvariantCultureIgnoreCase))
{
result.SystemComponent = true;
//result.IsProtected = true;
}
results.Add(result);
}
return(results);
}
private static void CreateFromDirectoryHelper(ICollection <ApplicationUninstallerEntry> results,
DirectoryInfo directory, int level, ICollection <string> dirsToSkip)
{
// Level 0 is for the pf folder itself. First subfolder is level 1.
if (level > 2 || dirsToSkip.Any(x => directory.FullName.Contains(x, StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
// Get contents of this installDir
AppExecutablesSearcher.ScanDirectoryResult result;
try
{
result = AppExecutablesSearcher.ScanDirectory(directory);
}
catch (IOException)
{
return;
}
catch (UnauthorizedAccessException)
{
return;
}
// Check if it is potentially dangerous to process this installDir.
if (result.ExecutableFiles.Count > 40)
{
return;
}
var anyFiles = result.ExecutableFiles.Any();
if (!anyFiles && !result.BinSubdirs.Any())
{
foreach (var dir in result.OtherSubdirs)
{
CreateFromDirectoryHelper(results, dir, level + 1, dirsToSkip);
}
}
else if (anyFiles)
{
var entry = new ApplicationUninstallerEntry();
// Parse directories into useful information
if (level > 0 && directory.Name.StartsWithAny(AppExecutablesSearcher.BinaryDirectoryNames, StringComparison.OrdinalIgnoreCase))
{
entry.InstallLocation = directory.Parent?.FullName;
entry.RawDisplayName = directory.Parent?.Name;
}
else
{
entry.InstallLocation = directory.FullName;
entry.RawDisplayName = directory.Name;
if (level > 0)
{
entry.Publisher = directory.Parent?.Name;
}
}
var sorted = AppExecutablesSearcher.SortListExecutables(result.ExecutableFiles, entry.DisplayNameTrimmed).ToArray();
entry.SortedExecutables = sorted.Select(x => x.FullName).ToArray();
entry.InstallDate = directory.CreationTime;
//entry.IconBitmap = TryExtractAssociatedIcon(compareBestMatchFile.FullName);
// Extract info from file metadata and overwrite old values
var compareBestMatchFile = sorted.First();
ExecutableAttributeExtractor.FillInformationFromFileAttribs(entry, compareBestMatchFile.FullName, false);
results.Add(entry);
}
}
public IList <ApplicationUninstallerEntry> GetUninstallerEntries(
ListGenerationProgress.ListGenerationCallback progressCallback)
{
var results = new List <ApplicationUninstallerEntry>();
if (ScriptHelperPath == null)
{
return(results);
}
var result = FactoryTools.StartHelperAndReadOutput(ScriptHelperPath, string.Empty);
if (string.IsNullOrEmpty(result))
{
return(results);
}
var dataSets = FactoryTools.ExtractAppDataSetsFromHelperOutput(result);
foreach (var dataSet in dataSets)
{
var entry = new ApplicationUninstallerEntry();
// Automatically fill in any supplied static properties
foreach (var entryProp in EntryProps)
{
if (!dataSet.TryGetValue(entryProp.Name, out var item) || string.IsNullOrEmpty(item))
{
continue;
}
try
{
entryProp.SetValue(entry, item, null);
}
catch (SystemException ex)
{
Console.WriteLine(ex);
}
}
if (!entry.UninstallPossible && !entry.QuietUninstallPossible)
{
continue;
}
if (string.IsNullOrEmpty(entry.Publisher))
{
entry.Publisher = "Script";
}
if (dataSet.TryGetValue("SystemIcon", out var icon) && !string.IsNullOrEmpty(icon))
{
var iconObj = SystemIconProps
.FirstOrDefault(p => p.Name.Equals(icon, StringComparison.OrdinalIgnoreCase))
?.GetValue(null, null) as Icon;
entry.IconBitmap = iconObj;
}
results.Add(entry);
}
return(results);
}
