private void ListRefreshThread(LoadingDialogInterface dialogInterface)
{
dialogInterface.SetSubProgressVisible(true);
var uninstallerEntries = ApplicationUninstallerFactory.GetUninstallerEntries(x =>
{
dialogInterface.SetMaximum(x.TotalCount);
dialogInterface.SetProgress(x.CurrentCount, x.Message);
var inner = x.Inner;
if (inner != null)
{
dialogInterface.SetSubMaximum(inner.TotalCount);
dialogInterface.SetSubProgress(inner.CurrentCount, inner.Message);
}
else
{
dialogInterface.SetSubMaximum(-1);
dialogInterface.SetSubProgress(0, string.Empty);
}
if (dialogInterface.Abort)
{
throw new OperationCanceledException();
}
});
if (!string.IsNullOrEmpty(Program.InstalledRegistryKeyName))
{
uninstallerEntries = uninstallerEntries
.Where(x => x.RegistryKeyName != Program.InstalledRegistryKeyName);
}
AllUninstallers = uninstallerEntries.ToList();
dialogInterface.SetMaximum(9);
dialogInterface.SetProgress(9, Localisable.Progress_Finishing);
dialogInterface.SetSubMaximum(5);
dialogInterface.SetSubProgress(2, Localisable.Progress_Finishing_Icons);
try
{
_iconGetter.UpdateIconList(AllUninstallers);
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
dialogInterface.SetSubProgress(4, Localisable.Progress_Finishing_Startup);
try
{
ReassignStartupEntries(false);
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
//dialogInterface.SetSubProgress(3, string.Empty);
}
private static IList <ApplicationUninstallerEntry> QueryApps(bool isQuiet, bool isUnattended, bool isVerbose)
{
ConfigureUninstallTools();
Console.WriteLine("Looking for applications...");
string previousMain = null;
var result = ApplicationUninstallerFactory.GetUninstallerEntries(report =>
{
if (previousMain != report.Message)
{
previousMain = report.Message;
Console.WriteLine(report.Message);
}
if (isVerbose)
{
if (!string.IsNullOrEmpty(report.Inner?.Message))
{
Console.Write("-> ");
Console.WriteLine(report.Inner.Message);
}
}
});
Console.WriteLine("Found {0} applications.", result.Count);
return(result);
}
public void AddMissingInformation(ApplicationUninstallerEntry target)
{
if (string.IsNullOrEmpty(target.DisplayVersion))
{
return;
}
ApplicationUninstallerFactory.CleanupDisplayVersion(target.DisplayVersion);
}
internal void ReassignStartupEntries(bool refreshListView, IEnumerable <StartupEntryBase> items)
{
ApplicationUninstallerFactory.AttachStartupEntries(AllUninstallers, items);
if (refreshListView)
{
RefreshList();
}
}
/// <summary>
/// Run the uninstaller on a new thread.
/// </summary>
internal void RunUninstaller(RunUninstallerOptions options)
{
lock (_operationLock)
{
if (Finished || IsRunning || CurrentStatus != UninstallStatus.Waiting)
{
return;
}
if (UninstallerEntry.IsRegistered && !UninstallerEntry.RegKeyStillExists())
{
CurrentStatus = UninstallStatus.Completed;
Finished = true;
return;
}
if (UninstallerEntry.UninstallerKind == UninstallerType.Msiexec)
{
var uninstallString = IsSilent && UninstallerEntry.QuietUninstallPossible
? UninstallerEntry.QuietUninstallString
: UninstallerEntry.UninstallString;
// Always reenumerate products in case any were uninstalled
if (ApplicationUninstallerFactory.PathPointsToMsiExec(uninstallString) &&
MsiTools.MsiEnumProducts().All(g => !g.Equals(UninstallerEntry.BundleProviderKey)))
{
CurrentStatus = UninstallStatus.Completed;
Finished = true;
return;
}
}
CurrentStatus = UninstallStatus.Uninstalling;
try
{
_worker = new Thread(UninstallThread)
{
Name = "RunBulkUninstall_Worker", IsBackground = false
};
_worker.Start(options);
}
catch
{
CurrentStatus = UninstallStatus.Failed;
Finished = true;
throw;
}
}
}
/// <summary>
/// Get the certificate associated to the uninstaller or application.
/// </summary>
public X509Certificate2 GetCertificate()
{
if (!_certificateGotten)
{
_certificateGotten = true;
_certificate = ApplicationUninstallerFactory.TryGetCertificate(this);
if (_certificate != null)
{
_certificateValid = _certificate.Verify();
}
}
return(_certificate);
}
public void AddMissingInformation(ApplicationUninstallerEntry entry)
{
if (entry.IconBitmap != null)
{
return;
}
// Check for any specified icons
if (!string.IsNullOrEmpty(entry.DisplayIcon) &&
!ApplicationUninstallerFactory.PathPointsToMsiExec(entry.DisplayIcon))
{
string resultFilename = null;
if (File.Exists(entry.DisplayIcon))
{
resultFilename = entry.DisplayIcon;
}
if (resultFilename == null)
{
try
{
var fName = ProcessTools.SeparateArgsFromCommand(entry.DisplayIcon).FileName;
if (fName != null && File.Exists(fName))
{
resultFilename = fName;
}
}
catch
{
// Ignore error and try another method
}
}
var icon = UninstallToolsGlobalConfig.TryExtractAssociatedIcon(resultFilename);
if (icon != null)
{
entry.DisplayIcon = resultFilename;
entry.IconBitmap = icon;
}
}
}
private void ListRefreshThread(LoadingDialogInterface dialogInterface)
{
dialogInterface.SetSubProgressVisible(true);
var progressMax = 0;
var uninstallerEntries = ApplicationUninstallerFactory.GetUninstallerEntries(x =>
{
progressMax = x.TotalCount + 2;
dialogInterface.SetMaximum(progressMax);
dialogInterface.SetProgress(x.CurrentCount, x.Message);
var inner = x.Inner;
if (inner != null)
{
dialogInterface.SetSubMaximum(inner.TotalCount);
dialogInterface.SetSubProgress(inner.CurrentCount, inner.Message);
}
else
{
dialogInterface.SetSubMaximum(-1);
dialogInterface.SetSubProgress(0, string.Empty);
}
if (dialogInterface.Abort)
{
throw new OperationCanceledException();
}
});
dialogInterface.SetProgress(progressMax - 1, Localisable.Progress_Finishing_Startup);
dialogInterface.SetSubMaximum(StartupManager.Factories.Count);
var i = 0;
var startupEntries = new List <StartupEntryBase>();
foreach (var factory in StartupManager.Factories)
{
dialogInterface.SetSubProgress(i++, factory.Key);
try
{
startupEntries.AddRange(factory.Value());
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
}
dialogInterface.SetProgress(progressMax, Localisable.Progress_Finishing, true);
dialogInterface.SetSubMaximum(3);
dialogInterface.SetSubProgress(0, string.Empty);
if (!string.IsNullOrEmpty(Program.InstalledRegistryKeyName))
{
uninstallerEntries.RemoveAll(x => PathTools.PathsEqual(x.RegistryKeyName, Program.InstalledRegistryKeyName));
}
AllUninstallers = uninstallerEntries;
dialogInterface.SetSubProgress(1, Localisable.MainWindow_Statusbar_RefreshingStartup);
try
{
ReassignStartupEntries(false, startupEntries);
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
dialogInterface.SetSubProgress(2, Localisable.Progress_Finishing_Icons);
try
{
_iconGetter.UpdateIconList(AllUninstallers);
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
dialogInterface.SetSubProgressVisible(false);
}
private void ListRefreshThread(LoadingDialogInterface dialogInterface)
{
dialogInterface.SetSubProgressVisible(true);
var progressMax = 0;
var uninstallerEntries = ApplicationUninstallerFactory.GetUninstallerEntries(x =>
{
progressMax = x.TotalCount + 1;
dialogInterface.SetMaximum(progressMax);
dialogInterface.SetProgress(x.CurrentCount, x.Message);
var inner = x.Inner;
if (inner != null)
{
dialogInterface.SetSubMaximum(inner.TotalCount);
dialogInterface.SetSubProgress(inner.CurrentCount, inner.Message);
}
else
{
dialogInterface.SetSubMaximum(-1);
dialogInterface.SetSubProgress(0, string.Empty);
}
if (dialogInterface.Abort)
{
throw new OperationCanceledException();
}
});
dialogInterface.SetProgress(progressMax, Localisable.Progress_Finishing, true);
dialogInterface.SetSubMaximum(2);
dialogInterface.SetSubProgress(0, string.Empty);
if (!string.IsNullOrEmpty(Program.InstalledRegistryKeyName))
{
uninstallerEntries.RemoveAll(
x => PathTools.PathsEqual(x.RegistryKeyName, Program.InstalledRegistryKeyName));
}
AllUninstallers = uninstallerEntries;
dialogInterface.SetSubProgress(1, Localisable.Progress_Finishing_Icons);
try
{
_iconGetter.UpdateIconList(AllUninstallers);
}
catch (Exception ex)
{
PremadeDialogs.GenericError(ex);
}
dialogInterface.SetSubProgressVisible(false);
// Fixes loading gettings stuck on finalizing if main window is minimized
_reference.SafeInvoke(() =>
{
if (_reference.WindowState == FormWindowState.Minimized)
{
_reference.WindowState = FormWindowState.Normal;
}
});
}
public static IEnumerable <ApplicationUninstallerEntry> GetApplicationsFromDrive(
IEnumerable <ApplicationUninstallerEntry> existingUninstallerEntries, GetUninstallerListCallback callback)
{
var existingUninstallers = existingUninstallerEntries as IList <ApplicationUninstallerEntry> ??
existingUninstallerEntries.ToList();
var pfDirectories = UninstallToolsGlobalConfig.GetProgramFilesDirectories(true).ToList();
// Get directories which are already used and should be skipped
var directoriesToSkip = existingUninstallers.SelectMany(x =>
{
if (!string.IsNullOrEmpty(x.DisplayIcon))
{
try
{
var iconFilename = x.DisplayIcon.Contains('.')
? ProcessTools.SeparateArgsFromCommand(x.DisplayIcon).FileName
: x.DisplayIcon;
return(new[] { x.InstallLocation, x.UninstallerLocation, PathTools.GetDirectory(iconFilename) });
}
catch
{
// Ignore invalid DisplayIcon paths
}
}
return(new[] { x.InstallLocation, x.UninstallerLocation });
}).Where(x => x.IsNotEmpty()).Select(PathTools.PathToNormalCase)
.Where(x => !pfDirectories.Any(pfd => pfd.Key.FullName.Contains(x, StringComparison.InvariantCultureIgnoreCase)))
.Distinct().ToList();
// Get sub directories which could contain user programs
var directoriesToCheck = pfDirectories.Aggregate(Enumerable.Empty <KeyValuePair <DirectoryInfo, bool?> >(),
(a, b) => a.Concat(b.Key.GetDirectories().Select(x => new KeyValuePair <DirectoryInfo, bool?>(x, b.Value))));
// Get directories that can be relatively safely checked
var inputs = directoriesToCheck.Where(x => !directoriesToSkip.Any(y =>
x.Key.FullName.Contains(y, StringComparison.InvariantCultureIgnoreCase) ||
y.Contains(x.Key.FullName, StringComparison.InvariantCultureIgnoreCase))).ToList();
var results = new List <ApplicationUninstallerEntry>();
var itemId = 0;
foreach (var directory in inputs)
{
itemId++;
var progress = new GetUninstallerListProgress(inputs.Count)
{
CurrentCount = itemId
};
callback(progress);
if (UninstallToolsGlobalConfig.IsSystemDirectory(directory.Key) ||
directory.Key.Name.StartsWith("Windows", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
//Try to get the main executable from the filtered folders. If no executables are present check subfolders.
var detectedEntries = ApplicationUninstallerFactory.TryCreateFromDirectory(directory.Key,
directory.Value);
results.AddRange(detectedEntries.Where(detected => !existingUninstallers.Any(existing =>
{
if (!string.IsNullOrEmpty(existing.DisplayName) && !string.IsNullOrEmpty(detected.DisplayNameTrimmed) &&
existing.DisplayName.Contains(detected.DisplayNameTrimmed))
{
return(!existing.IsInstallLocationValid() ||
detected.InstallLocation.Contains(existing.InstallLocation,
StringComparison.CurrentCultureIgnoreCase));
}
return(false);
})));
//if (result != null && !existingUninstallers.Any(x => x.DisplayName.Contains(result.DisplayNameTrimmed)))
// results.Add(result);
}
return(results);
}
/// <summary>
/// Search the system for valid uninstallers, parse them into coherent objects and return the resulting list.
/// </summary>
/// <exception cref="System.Security.SecurityException">
/// The user does not have the permissions required to read the
/// registry key.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="T:Microsoft.Win32.RegistryKey" /> is closed (closed keys
/// cannot be accessed).
/// </exception>
/// <exception cref="UnauthorizedAccessException">The user does not have the necessary registry rights.</exception>
/// <exception cref="IOException">A system error occurred, for example the current key has been deleted.</exception>
public static IEnumerable <ApplicationUninstallerEntry> GetUninstallerList(GetUninstallerListCallback callback)
{
PopulateWindowsInstallerValidGuids();
var keysToCheck = GetRegistryKeys();
var uninstallersToCreate = new List <KeyValuePair <RegistryKey, bool> >();
foreach (var kvp in keysToCheck.Where(kvp => kvp.Key != null))
{
uninstallersToCreate.AddRange(from subkeyName in kvp.Key.GetSubKeyNames()
select kvp.Key.OpenSubKey(subkeyName)
into subkey
where subkey != null
select new KeyValuePair <RegistryKey, bool>(subkey, kvp.Value));
kvp.Key.Close();
}
var itemId = 0;
var applicationUninstallers = new List <ApplicationUninstallerEntry>();
foreach (var uninstallerToCreate in uninstallersToCreate)
{
try
{
var entry = ApplicationUninstallerFactory.TryCreateFromRegistry(uninstallerToCreate.Key,
uninstallerToCreate.Value);
if (entry != null)
{
applicationUninstallers.Add(entry);
}
}
catch
{
//Uninstaller is invalid or there is no uninstaller in the first place. Skip it to avoid problems.
}
finally
{
uninstallerToCreate.Key.Close();
itemId++;
var progress = new GetUninstallerListProgress(uninstallersToCreate.Count)
{
CurrentCount = itemId
};
callback(progress);
}
}
applicationUninstallers.AddRange(ApplicationUninstallerFactory.GetStoreApps());
if (ApplicationUninstallerFactory.SteamHelperIsAvailable)
{
var steamAppsOnDisk = ApplicationUninstallerFactory.GetSteamApps().ToList();
foreach (var steamApp in applicationUninstallers.Where(x => x.UninstallerKind == UninstallerType.Steam))
{
var toRemove = steamAppsOnDisk.FindAll(x => x.InstallLocation.Equals(steamApp.InstallLocation, StringComparison.InvariantCultureIgnoreCase));
steamAppsOnDisk.RemoveAll(toRemove);
ApplicationUninstallerFactory.ChangeSteamAppUninstallStringToHelper(steamApp);
if (steamApp.EstimatedSize.IsDefault() && toRemove.Any())
{
steamApp.EstimatedSize = toRemove.First().EstimatedSize;
}
}
foreach (var steamApp in steamAppsOnDisk)
{
ApplicationUninstallerFactory.ChangeSteamAppUninstallStringToHelper(steamApp);
}
applicationUninstallers.AddRange(steamAppsOnDisk);
}
applicationUninstallers.AddRange(ApplicationUninstallerFactory.GetSpecialUninstallers(applicationUninstallers));
// Fill in missing information
foreach (var applicationUninstaller in applicationUninstallers)
{
if (applicationUninstaller.IconBitmap == null)
{
string iconPath;
applicationUninstaller.IconBitmap = ApplicationUninstallerFactory.TryGetIcon(
applicationUninstaller, out iconPath);
applicationUninstaller.DisplayIcon = iconPath;
}
if (applicationUninstaller.InstallDate.IsDefault() &&
Directory.Exists(applicationUninstaller.InstallLocation))
{
applicationUninstaller.InstallDate =
Directory.GetCreationTime(applicationUninstaller.InstallLocation);
}
}
return(applicationUninstallers);
}
public void UninstallFromDirectory(IEnumerable <ApplicationUninstallerEntry> allUninstallers)
{
if (!TryGetUninstallLock())
{
return;
}
var listRefreshNeeded = false;
var applicationUninstallerEntries = allUninstallers as IList <ApplicationUninstallerEntry> ?? allUninstallers.ToList();
try
{
var dialog = new FolderBrowserDialog
{
RootFolder = Environment.SpecialFolder.Desktop,
Description = Localisable.UninstallFromDirectory_FolderBrowse
};
if (dialog.ShowDialog(MessageBoxes.DefaultOwner) != DialogResult.OK)
{
return;
}
var items = new List <ApplicationUninstallerEntry>();
LoadingDialog.ShowDialog(Localisable.UninstallFromDirectory_ScanningTitle,
_ =>
{
items.AddRange(ApplicationUninstallerFactory.TryCreateFromDirectory(
new DirectoryInfo(dialog.SelectedPath), null));
});
if (items.Count == 0)
{
items.AddRange(applicationUninstallerEntries
.Where(x => PathTools.PathsEqual(dialog.SelectedPath, x.InstallLocation)));
}
if (items.Count == 0)
{
MessageBoxes.UninstallFromDirectoryNothingFound();
}
else
{
foreach (var item in items.ToList())
{
if (item.UninstallPossible && item.UninstallerKind != UninstallerType.SimpleDelete &&
MessageBoxes.UninstallFromDirectoryUninstallerFound(item.DisplayName, item.UninstallString))
{
item.RunUninstaller(false, Settings.Default.AdvancedSimulate).WaitForExit(60000);
items.Remove(item);
listRefreshNeeded = true;
}
else
{
var found = applicationUninstallerEntries.Where(
x => PathTools.PathsEqual(item.InstallLocation, x.InstallLocation)).ToList();
if (!found.Any())
{
continue;
}
items.Remove(item);
foreach (var entry in found)
{
if (entry.UninstallPossible && entry.UninstallerKind != UninstallerType.SimpleDelete &&
MessageBoxes.UninstallFromDirectoryUninstallerFound(entry.DisplayName, entry.UninstallString))
{
try { item.RunUninstaller(false, Settings.Default.AdvancedSimulate).WaitForExit(60000); }
catch (Exception ex) { PremadeDialogs.GenericError(ex); }
listRefreshNeeded = true;
}
else
{
items.Add(entry);
}
}
}
}
AdvancedUninstall(items, applicationUninstallerEntries.Where(
x => !items.Any(y => PathTools.PathsEqual(y.InstallLocation, x.InstallLocation))));
}
}
finally
{
ReleaseUninstallLock();
_lockApplication(false);
if (listRefreshNeeded)
{
_initiateListRefresh();
}
}
}
public static UninstallerType GetUninstallerType(string uninstallString)
{
// Detect MSI installer based on the uninstall string
//"C:\ProgramData\Package Cache\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}\vcredist_x86.exe" /uninstall
if (ApplicationUninstallerFactory.PathPointsToMsiExec(uninstallString) || uninstallString.ContainsAll(
new[] { @"\Package Cache\{", @"}\", ".exe" }, StringComparison.OrdinalIgnoreCase))
{
return(UninstallerType.Msiexec);
}
// Detect Sdbinst
if (uninstallString.Contains("sdbinst", StringComparison.OrdinalIgnoreCase) &&
uninstallString.Contains(".sdb", StringComparison.OrdinalIgnoreCase))
{
return(UninstallerType.SdbInst);
}
if (uninstallString.Contains(@"InstallShield Installation Information\{", StringComparison.OrdinalIgnoreCase))
{
return(UninstallerType.InstallShield);
}
ProcessStartCommand ps;
if (ProcessStartCommand.TryParse(uninstallString, out ps) && Path.IsPathRooted(ps.FileName) &&
File.Exists(ps.FileName))
{
try
{
var fileName = Path.GetFileNameWithoutExtension(ps.FileName);
// Detect Inno Setup
if (fileName != null && InnoSetupFilenameRegex.IsMatch(fileName))
{
// Check if Inno Setup Uninstall Log exists
if (File.Exists(ps.FileName.Substring(0, ps.FileName.Length - 3) + "dat"))
{
return(UninstallerType.InnoSetup);
}
}
// Detect NSIS Nullsoft.NSIS
using (var reader = new StreamReader(ps.FileName, Encoding.ASCII))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.Contains("Nullsoft", StringComparison.Ordinal))
{
return(UninstallerType.Nsis);
}
}
}
/* Unused/unnecessary
* if (result.Contains("InstallShield"))
* return UninstallerType.InstallShield;
* if (result.Contains("Inno.Setup") || result.Contains("Inno Setup"))
* return UninstallerType.InnoSetup;
* if(result.Contains(@"<description>Adobe Systems Incorporated Setup</description>"))
* return UninstallerType.AdobeSetup;
*/
}
catch (IOException) { }
catch (UnauthorizedAccessException) { }
catch (SecurityException) { }
}
return(UninstallerType.Unknown);
}
