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); }