Пример #1
0
        private void InstallSendResults(Operations.SavedOpData updateData, RvSofOperation operation, List <RVsofResult.AppsToAdd2> appsToAdd = null, List <RVsofResult.AppsToDelete2> appsToDelete = null)
        {
            try
            {
                var results = new RVsofResult();

                results.AppsToAdd    = results.AppsToAdd != null ? appsToAdd : new List <RVsofResult.AppsToAdd2>();
                results.AppsToDelete = results.AppsToDelete != null ? appsToDelete : new List <RVsofResult.AppsToDelete2>();

                results.AppId          = updateData.filedata_app_id;
                results.Operation      = updateData.operation;
                results.OperationId    = updateData.operation_id;
                results.Error          = updateData.error;
                results.RebootRequired = updateData.reboot_required;
                results.Success        = updateData.success;

                switch (updateData.operation)
                {
                case OperationValue.InstallWindowsUpdate:
                    results             = WindowsUpdates.AddAppDetailsToResults(results);
                    operation.RawResult = RvFormatter.Install(results);
                    break;

                case OperationValue.InstallCustomApp:
                    results             = CustomAppsManager.AddAppDetailsToResults(results);
                    operation.RawResult = RvFormatter.Install(results);
                    break;

                case OperationValue.InstallSupportedApp:
                    results             = SupportedAppsManager.AddAppDetailsToResults(results);
                    operation.RawResult = RvFormatter.Install(results);
                    break;

                case OperationValue.InstallAgentUpdate:
                    results             = AgentUpdateManager.AddAppDetailsToResults(results);
                    operation.RawResult = RvFormatter.AgentUpdate(results);
                    break;

                case OperationValue.Uninstall:
                    operation.RawResult = RvFormatter.Install(results);
                    break;
                }

                operation.Id     = updateData.operation_id;
                operation.Plugin = "rv";

                Operations.UpdateStatus(updateData, Operations.OperationStatus.ResultsPending);

                Logger.Log("Sending back results for {0}.", LogLevel.Info, updateData.filedata_app_name);
                if (SendResults(operation))
                {
                    Operations.CleanAllOperationData(updateData);
                }
            }
            catch (Exception e)
            {
                Logger.Log("Failed when attempting to send back results, Exception inside InstallSendResults().");
                Logger.LogException(e);
            }
        }
        /// <summary>
        /// Uninstall updates on Windows 7 & Windows Server 2008 R2. (6.1)
        /// </summary>
        /// <param name="update">Update to uninstall.</param>
        private static UninstallerResults WinNT61Procedure(Application update)
        {
            // TODO: NOT FULLY BAKED!!!! Doesn't check registry for updates that could be there.

            IEnumerable <WindowsUpdates.QfeData> qfeList = WindowsUpdates.QueryWmiHotfixes();
            var temp = new UninstallerResults();

            foreach (WindowsUpdates.QfeData qfe in qfeList)
            {
                try
                {
                    if (qfe.HotFixId.Equals(update.KB))
                    {
                        return(WusaProcess(update.KB));
                    }
                }
                catch (Exception)
                {
                    temp.Message  = "This update does not appear to be Uninstallable. Unable to remove.";
                    temp.Success  = false;
                    temp.Restart  = false;
                    temp.ExitCode = WindowsExitCode.NotAllowed; //TODO: HARDCODED :) MUAHAHAHA. MUST FIX!
                }
            }
            return(temp);
        }
Пример #3
0
        private static List <Application> NewUpdatesAndApplications()
        {
            var applications = new List <Application>();

            applications.AddRange(WindowsUpdates.GetAvailableUpdates());
            applications.AddRange(WindowsUpdates.GetInstalledUpdates());
            applications.AddRange(SupportedAppsManager.GetInstalledApplications());

            return(applications);
        }
        private static Dictionary <string, string> ParseWinNT51_52Keys()
        {
            // With NT 5.1 and 5.2 (XP and Server 2003/XP 64bit) Windows uninstalled updates by the
            // SOFTWARE\Microsoft\Updates registry key. Then using the "UninstallCommand" key within.

            // Registry Keys used to uninstall updates. First is default; Second is for 32bit apps on 64bit Windows.
            var uninstallKeys = new List <string>();

            uninstallKeys.Add(@"SOFTWARE\Microsoft\Updates\Windows XP");

            var uninstallDict = new Dictionary <string, string>();

            // Ugly iteration of the registry keys.
            foreach (string key in uninstallKeys)
            {
                using (RegistryKey rootXpKey = Registry.LocalMachine.OpenSubKey(key))
                {
                    if (rootXpKey != null)
                    {
                        foreach (var subName in rootXpKey.GetSubKeyNames())
                        {
                            using (var subKey = rootXpKey.OpenSubKey(subName))
                            {
                                if (subKey != null)
                                {
                                    foreach (var kbName in subKey.GetSubKeyNames())
                                    {
                                        using (var kbKey = subKey.OpenSubKey(kbName))
                                        {
                                            if (kbKey != null && ((kbKey.GetValue("Description") != null) && (kbKey.GetValue("UninstallCommand") != null)))
                                            {
                                                var kbString        = WindowsUpdates.GetKbString(kbKey.GetValue("Description").ToString());
                                                var uninstallString = kbKey.GetValue("UninstallCommand").ToString();

                                                if (!uninstallDict.ContainsKey(kbString))
                                                {
                                                    uninstallDict.Add(kbString, uninstallString);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(uninstallDict);
        }
        private Dictionary <string, string> ParseUninstallKeys()
        {
            // This logic is only reliable for packages/applications that install system wide "UninstallString" keys in the
            // Windows registry (aka "the pit of horse shit").

            // Registry Keys used to uninstall apps. First is default; Second is for 32bit apps on 64bit Windows.
            var uninstallKeys = new List <string>();

            uninstallKeys.Add(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall");
            if (_win64)
            {
                uninstallKeys.Add(@"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall");
            }

            var programDict = new Dictionary <string, string>();

            foreach (var key in uninstallKeys)
            {
                using (var rKey = Registry.LocalMachine.OpenSubKey(key))
                {
                    if (rKey != null)
                    {
                        foreach (var skName in rKey.GetSubKeyNames())
                        {
                            using (var sk = rKey.OpenSubKey(skName))
                            {
                                if (sk != null && ((sk.GetValue("DisplayName") != null) && (sk.GetValue("UninstallString") != null)))
                                {
                                    var kbString        = WindowsUpdates.GetKbString(sk.GetValue("DisplayName").ToString());
                                    var uninstallString = sk.GetValue("UninstallString").ToString();

                                    if (!programDict.ContainsKey(kbString))
                                    {
                                        programDict.Add(kbString, uninstallString);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(programDict);
        }
Пример #6
0
        private void UninstallOperation(RvSofOperation operation)
        {
            var registry         = new RegistryReader();
            var tempAppsToAdd    = new List <RVsofResult.AppsToAdd2>();
            var tempAppsToDelete = new List <RVsofResult.AppsToDelete2>();
            var savedOperations  = Operations.LoadOpDirectory().Where(p => p.operation == OperationValue.Uninstall).ToList();

            if (!savedOperations.Any())
            {
                Logger.Log("There are no operations remaining, Unable to uninstall app: {0}", LogLevel.Warning, operation.Type);
                return;
            }

            foreach (var localOp in savedOperations)
            {
                if (operation.ListOfInstalledApps.Any())
                {
                    operation.ListOfInstalledApps.Clear();
                }
                if (operation.ListOfAppsAfterInstall.Any())
                {
                    operation.ListOfAppsAfterInstall.Clear();
                }

                //Retrieve a list of all updates installed in the system before uninstalling anything.
                operation.ListOfInstalledApps = registry.GetRegistryInstalledApplicationNames();
                Operations.UpdateStatus(localOp, Operations.OperationStatus.Processing);

                var msiUninstall = new MSIUninstaller.MSIprop();
                try
                {
                    if (localOp.filedata_app_name != String.Empty)
                    {
                        msiUninstall = MSIUninstaller.UnistallApp(localOp.filedata_app_name);
                    }
                }
                catch
                {
                    Logger.Log("MSIuninstaller crashed while attempting to uninstall {0}", LogLevel.Error, localOp.filedata_app_name);
                    msiUninstall.UninstallPass = false;
                }

                Application update = null;
                if (!msiUninstall.UninstallPass)
                {
                    var installedUpdates = WindowsUpdates.GetInstalledUpdates();
                    update = (from n in installedUpdates where n.Name == localOp.filedata_app_name select n).FirstOrDefault();
                }

                var uninstallerResults = new UninstallerResults();
                if (!msiUninstall.UninstallPass)
                {
                    try
                    {
                        uninstallerResults = WindowsUninstaller.Uninstall(update);
                    }
                    catch
                    {
                        Logger.Log("Windows Uninstall Update failed.", LogLevel.Error);
                        uninstallerResults.Success = false;
                    }
                }

                //Get all installed application after installing..
                operation.ListOfAppsAfterInstall = registry.GetRegistryInstalledApplicationNames();

                //GET DATA FOR APPSTOADD/APPSTODELETE
                var appListToDelete = RegistryReader.GetAppsToDelete(operation.ListOfInstalledApps, operation.ListOfAppsAfterInstall);
                var appListToAdd    = RegistryReader.GetAppsToAdd(operation.ListOfInstalledApps, operation.ListOfAppsAfterInstall);

                //APPS TO DELETE
                #region Apps to Delete
                if (appListToDelete != null)
                {
                    var temp = registry.GetAllInstalledApplicationDetails();
                    foreach (var app in appListToDelete)
                    {
                        var appsToDelete = new RVsofResult.AppsToDelete2();
                        var version      = (from d in temp where d.Name == localOp.filedata_app_name select d.Version).FirstOrDefault();

                        appsToDelete.Name    = (String.IsNullOrEmpty(app)) ? String.Empty : app;
                        appsToDelete.Version = (String.IsNullOrEmpty(version)) ? String.Empty : version;

                        tempAppsToDelete.Add(appsToDelete);
                    }
                }
                #endregion

                //APPS TO ADD
                #region Apps to Add
                if (appListToAdd != null)
                {
                    var installedAppsDetails = registry.GetAllInstalledApplicationDetails();

                    foreach (var app in appListToAdd)
                    {
                        var temp        = new RVsofResult.AppsToAdd2();
                        var localApp    = app;
                        var version     = (from d in installedAppsDetails where d.Name == localOp.filedata_app_name select d.Version).FirstOrDefault();       //Default NULL
                        var vendor      = (from d in installedAppsDetails where d.Name == localApp select d.VendorName).FirstOrDefault();                     //Default NULL
                        var installDate = Tools.ConvertDateToEpoch((from d in installedAppsDetails where d.Name == localApp select d.Date).FirstOrDefault()); //Default 0.0D

                        temp.AppsToAdd.Name           = (String.IsNullOrEmpty(localApp)) ? String.Empty : localApp;
                        temp.AppsToAdd.Version        = (String.IsNullOrEmpty(version)) ? String.Empty : version;
                        temp.AppsToAdd.InstallDate    = (installDate.Equals(0.0D)) ? 0.0D : installDate;
                        temp.AppsToAdd.VendorName     = (String.IsNullOrEmpty(vendor)) ? String.Empty : vendor;
                        temp.AppsToAdd.RebootRequired = "no";
                        temp.AppsToAdd.ReleaseDate    = 0.0;
                        temp.AppsToAdd.Status         = "installed";
                        temp.AppsToAdd.Description    = String.Empty;
                        temp.AppsToAdd.SupportUrl     = String.Empty;
                        temp.AppsToAdd.VendorId       = String.Empty;
                        temp.AppsToAdd.VendorSeverity = String.Empty;
                        temp.AppsToAdd.KB             = String.Empty;

                        tempAppsToAdd.Add(temp);
                    }
                }
                #endregion


                if (uninstallerResults.Success || msiUninstall.UninstallPass)
                {
                    // Success! Uinstalled OK
                    localOp.success         = true.ToString().ToLower();
                    localOp.reboot_required = String.IsNullOrEmpty(uninstallerResults.Restart.ToString()) ? "no" : uninstallerResults.Restart.ToString();
                    localOp.error           = string.Empty;

                    operation.Api  = ApiCalls.RvUninstallOperation();
                    operation.Type = OperationValue.Uninstall;
                    operation.Id   = localOp.operation_id;

                    InstallSendResults(localOp, operation, tempAppsToAdd, tempAppsToDelete);
                }
                else
                {
                    // Fail! Uinstalled Failed.
                    localOp.success         = false.ToString().ToLower();
                    localOp.reboot_required = String.IsNullOrEmpty(uninstallerResults.Restart.ToString()) ? "no" : uninstallerResults.Restart.ToString();
                    localOp.error           = "Unable to successfully uninstall application. If this is not a Windows Update Uninstall, ensure that the application is of type MSI We currently do not support other installers. Error: " + msiUninstall.Error;

                    operation.Api  = ApiCalls.RvUninstallOperation();
                    operation.Type = OperationValue.Uninstall;
                    operation.Id   = localOp.operation_id;

                    InstallSendResults(localOp, operation, tempAppsToAdd, tempAppsToDelete);
                }
            }
        }
Пример #7
0
        private void InstallWindowsUpdate(RvSofOperation operation)
        {
            var savedOperations = Operations.LoadOpDirectory().Where(p => p.operation == OperationValue.InstallWindowsUpdate).ToList();

            if (!savedOperations.Any())
            {
                Logger.Log("There are no operations remaining, Unable to install windows update: {0}", LogLevel.Warning, operation.Type);
                return;
            }

            WindowsUpdates.PopulateAvailableUpdatesList();
            WindowsUpdates.PopulateInstalledUpdatesList();

            foreach (var update in savedOperations)
            {
                //Check if update is already installed.
                ///////////////////////////////////////////////////////////////////////////////////////////
                if (WindowsUpdates.IsUpdateInstalled(update.filedata_app_name))
                {
                    Logger.Log("Update is already installed ({0}), sending back results.", LogLevel.Info, update.filedata_app_name);
                    Operations.UpdateStatus(update, Operations.OperationStatus.ResultsPending);
                    InstallSendResults(update, operation);
                    continue; //Move on to next update.
                }

                Logger.Log("Preparing to download");
                Operations.SavedOpData updateDownloadResults = Downloader.DownloadFile(update, Downloader.UpdateDirectories.OSUpdateDir);

                //If download fails, send back results to server and move to next package (if any).
                ////////////////////////////////////////////////////////////////////////////////////////////
                if (!String.IsNullOrEmpty(updateDownloadResults.error))
                {
                    Operations.UpdateStatus(updateDownloadResults, Operations.OperationStatus.ResultsPending);
                    InstallSendResults(updateDownloadResults, operation);
                    continue;
                }
                Logger.Log("Download completed for {0}", LogLevel.Info, update.filedata_app_name);

                Logger.Log("Installing {0} ", LogLevel.Info, update.filedata_app_name);
                Operations.SavedOpData updateInstallResults = WindowsUpdates.InstallWindowsUpdate(update);

                //If installation fails, send back results to server and move to next package (if any).
                /////////////////////////////////////////////////////////////////////////////////////////////
                if (!String.IsNullOrEmpty(updateInstallResults.error))
                {
                    Operations.UpdateStatus(updateDownloadResults, Operations.OperationStatus.ResultsPending);
                    InstallSendResults(updateInstallResults, operation);
                    continue;
                }
                Logger.Log("Installation of {0} was a success.", LogLevel.Info, update.filedata_app_name);
                Operations.UpdateStatus(updateDownloadResults, Operations.OperationStatus.ResultsPending);



                /////////////////////////////////////////////////////////////////////////////////////////////////////////
                //Check scenerio for this update, react accordingly.
                /////////////////////////////////////////////////////////////////////////////////////////////////////////
                if (Convert.ToBoolean(updateInstallResults.reboot_required) && Convert.ToBoolean(updateInstallResults.success) && (updateInstallResults.restart == "optional" || updateInstallResults.restart == "forced"))
                {
                    Operations.UpdateOperation(updateInstallResults, true, true, Operations.OperationStatus.Rebooting);
                    Operations.DeleteLocalUpdateBundleFolder(updateInstallResults);
                    Logger.Log("Rebooting system as per update requirement.");
                    RvUtils.RestartSystem();
                    Stop(); //System will restart to continue Windows update configuration, then ResumeOperations will start where we left off.
                }
                else if (Convert.ToBoolean(updateInstallResults.reboot_required) && !Convert.ToBoolean(updateInstallResults.success) && (updateInstallResults.restart == "optional" || updateInstallResults.restart == "forced"))
                {
                    Operations.UpdateOperation(updateInstallResults, false, true, Operations.OperationStatus.Rebooting);
                    Operations.DeleteLocalUpdateBundleFolder(updateInstallResults);
                    Logger.Log("Rebooting system as per update requirement.");
                    RvUtils.RestartSystem();
                    Stop(); //System will restart to continue Windows update configuration, then ResumeOperations will start where we left off.
                }
                else if (Convert.ToBoolean(updateInstallResults.reboot_required) && Convert.ToBoolean(updateInstallResults.success) && updateInstallResults.restart == "none")
                {
                    InstallSendResults(updateInstallResults, operation);
                }
                else if (Convert.ToBoolean(updateInstallResults.reboot_required) && !Convert.ToBoolean(updateInstallResults.success) && updateInstallResults.restart != "none")
                {
                    Operations.UpdateOperation(updateInstallResults, false, true, Operations.OperationStatus.Rebooting);
                    Operations.DeleteLocalUpdateBundleFolder(updateInstallResults);
                    RvUtils.RestartSystem();
                    Stop(); //System will restart to continue Windows update configuration, then ResumeOperations will start where we left off.
                }
                else if (Convert.ToBoolean(updateInstallResults.reboot_required) && updateInstallResults.restart != "none")
                {
                    var isInstalled = WindowsUpdates.IsUpdateInstalled(updateInstallResults.filedata_app_name);
                    Logger.Log("Rebooting system as per update requirement.");
                    Operations.UpdateOperation(updateInstallResults, isInstalled, true, Operations.OperationStatus.Rebooting);
                    RvUtils.RestartSystem();
                    Stop(); //System will restart to continue Windows update configuration, then ResumeOperations will start where we left off.
                }
                else
                {
                    InstallSendResults(updateInstallResults, operation);
                }
            }
        }