void bw_DoWorkUninstall(object sender, DoWorkEventArgs e)
{
List <UninstallFileInfo> filesToUninstall = new List <UninstallFileInfo>();
List <string> foldersToDelete = new List <string>();
List <RegChange> registryToDelete = new List <RegChange>();
List <UninstallFileInfo> comDllsToUnreg = new List <UninstallFileInfo>();
List <string> servicesToStop = new List <string>();
// Load the list of files, folders etc. from the client file (Filename)
RollbackUpdate.ReadUninstallData(Filename, filesToUninstall, foldersToDelete, registryToDelete, comDllsToUnreg, servicesToStop);
// uninstall files
foreach (UninstallFileInfo file in filesToUninstall)
{
try
{
if (file.DeleteFile)
{
File.Delete(file.Path);
}
}
catch { }
}
//uninstall folders
for (int i = foldersToDelete.Count - 1; i >= 0; i--)
{
//delete the last folder first (this fixes the problem of nested folders)
try
{
//directory must be empty in order to delete it
Directory.Delete(foldersToDelete[i]);
}
catch { }
}
// tell the sender that we're uninstalling reg now:
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.None, null });
//uninstall registry
foreach (RegChange reg in registryToDelete)
{
try
{
reg.ExecuteOperation();
}
catch { }
}
// All done
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
}
void bw_DoWorkRegistry(object sender, DoWorkEventArgs e)
{
List <RegChange> rollbackRegistry = new List <RegChange>();
//parse variables in the regChanges
for (int i = 0; i < UpdtDetails.RegistryModifications.Count; i++)
{
UpdtDetails.RegistryModifications[i] = ParseRegChange(UpdtDetails.RegistryModifications[i]);
}
Exception except = null;
try
{
UpdateRegistry(rollbackRegistry);
}
catch (Exception ex)
{
except = ex;
}
RollbackUpdate.WriteRollbackRegistry(Path.Combine(TempDirectory, "backup\\regList.bak"), rollbackRegistry);
if (IsCancelled() || except != null)
{
// rollback the registry
bw.ReportProgress(1, true);
RollbackUpdate.RollbackRegistry(TempDirectory);
// rollback files
bw.ReportProgress(1, false);
RollbackUpdate.RollbackFiles(TempDirectory, ProgramDirectory);
// rollback unregged COM
RollbackUpdate.RollbackUnregedCOM(TempDirectory);
// rollback stopped services
RollbackUpdate.RollbackStoppedServices(TempDirectory);
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
}
else
{
// registry modification completed sucessfully
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
}
}
void bw_DoWorkProcessesCheck(object sender, DoWorkEventArgs e)
{
// processes
List <FileInfo> files = null;
List <Process> rProcesses = null;
// rollback list for stopped services
List <string> stoppedServices = new List <string>();
Exception except = null; // store any errors
// create the backup folder
Directory.CreateDirectory(Path.Combine(TempDirectory, "backup"));
try
{
files = new List <FileInfo>(new DirectoryInfo(ProgramDirectory).GetFiles("*.exe", SearchOption.AllDirectories));
RemoveSelfFromProcesses(files);
//check for (and delete) a newer client if it exists
DeleteClientInPath(ProgramDirectory, Path.Combine(TempDirectory, "base"));
rProcesses = ProcessesNeedClosing(files);
if (rProcesses.Count == 0)
{
// no processes need closing, all done
files = null;
rProcesses = null;
}
else if (SkipUIReporting) // and rProcesses.Count > 0
{
// check every second for 20 seconds.
for (int i = 0; i < 20; ++i)
{
// sleep for 1 second
Thread.Sleep(1000);
rProcesses = ProcessesNeedClosing(files);
if (rProcesses.Count == 0)
{
break;
}
}
if (rProcesses.Count != 0)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(rProcesses.Count + " processes are running:\r\n");
foreach (Process proc in rProcesses)
{
sb.AppendLine(proc.MainWindowTitle + " (" + proc.ProcessName + ".exe)");
}
// tell the user about the open processes
throw new Exception(sb.ToString());
}
}
}
catch (Exception ex)
{
except = ex;
}
// save rollback info
RollbackUpdate.WriteRollbackServices(Path.Combine(TempDirectory, "backup\\stoppedServices.bak"), stoppedServices);
if (IsCancelled() || except != null)
{
bw.ReportProgress(1, false);
// rollback stopped services
RollbackUpdate.RollbackStoppedServices(TempDirectory);
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
}
else // completed successfully
{
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, new object[] { files, rProcesses } });
}
}
void bw_DoWorkPreExecute(object sender, DoWorkEventArgs e)
{
// simply update the progress bar to show the 3rd step is entirely complete
bw.ReportProgress(0, new object[] { GetRelativeProgess(3, 0), 0, string.Empty, ProgressStatus.None, null });
List <UninstallFileInfo> rollbackCOM = new List <UninstallFileInfo>();
Exception except = null;
for (int i = 0; i < UpdtDetails.UpdateFiles.Count; i++)
{
bool unregister = (UpdtDetails.UpdateFiles[i].RegisterCOMDll &
(COMRegistration.UnRegister | COMRegistration.PreviouslyRegistered)) != 0;
// skip non-executing files, skip execute "after" updates
if ((!UpdtDetails.UpdateFiles[i].Execute || !UpdtDetails.UpdateFiles[i].ExBeforeUpdate) && !unregister)
{
continue;
}
// form the absolute path of the file to execute or unregister
string fullFile = FixUpdateDetailsPaths(UpdtDetails.UpdateFiles[i].RelativePath);
if (string.IsNullOrEmpty(fullFile))
{
continue;
}
if (!unregister)
{
try
{
// we only support starting non-elevated on Vista+
// And the user must be an admin (otherwise starting as the same elevation as wyUpdate is ample)
if (UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.NotElevated &&
IsAdmin &&
Win32.AtLeastVista())
{
int exitCode = (int)LimitedProcess.Start(fullFile,
string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs)
? null
: ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs), false,
UpdtDetails.UpdateFiles[i].WaitForExecution,
UpdtDetails.UpdateFiles[i].ProcessWindowStyle);
// if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && exitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
!UpdtDetails.UpdateFiles[i].RetExceptions.Contains(exitCode)))
{
except = new Exception("\"" + fullFile + "\" returned " + exitCode + ".");
break;
}
}
else // Same as wyUpdate or elevated
{
ProcessStartInfo psi = new ProcessStartInfo
{
FileName = fullFile,
WindowStyle = UpdtDetails.UpdateFiles[i].ProcessWindowStyle
};
// command line arguments
if (!string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs))
{
psi.Arguments = ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs);
}
// only elevate if the current process isn't already elevated
if (!IsAdmin && UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.Elevated)
{
psi.Verb = "runas";
psi.ErrorDialog = true;
psi.ErrorDialogParentHandle = MainWindowHandle;
}
//start the process
Process p = Process.Start(psi);
if (UpdtDetails.UpdateFiles[i].WaitForExecution && p != null)
{
p.WaitForExit();
// if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && p.ExitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
!UpdtDetails.UpdateFiles[i].RetExceptions.Contains(p.ExitCode)))
{
except = new Exception("\"" + psi.FileName + "\" returned " + p.ExitCode + ".");
break;
}
}
}
}
catch (Exception ex)
{
// failure when executing the file
except = new Exception("Failed to execute the file \"" + fullFile + "\": " + ex.Message, ex);
break;
}
}
}
// save rollback info
RollbackUpdate.WriteRollbackCOM(Path.Combine(TempDirectory, "backup\\unreggedComList.bak"), rollbackCOM);
if (IsCancelled() || except != null)
{
// rollback unregged COM
bw.ReportProgress(1, false);
RollbackUpdate.RollbackUnregedCOM(TempDirectory);
// rollback stopped services
RollbackUpdate.RollbackStoppedServices(TempDirectory);
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
}
else
{
// registry modification completed sucessfully
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
}
}
void bw_DoWorkUpdateFiles(object sender, DoWorkEventArgs e)
{
//check if folders exist, and count files to be moved
string backupFolder = Path.Combine(TempDirectory, "backup");
string[] backupFolders = new string[13];
//Note: InstallShortcuts() requires the position in array to remain constant
string[] origFolders = { "base", "system", "64system", "root", "appdata", "lappdata", "comappdata", "comdesktop", "comstartmenu", "cp86", "cp64", "curdesk", "curstart" };
string[] destFolders = { ProgramDirectory,
SystemFolders.GetSystem32x86(),
SystemFolders.GetSystem32x64(),
SystemFolders.GetRootDrive(),
SystemFolders.GetCurrentUserAppData(),
SystemFolders.GetCurrentUserLocalAppData(),
SystemFolders.GetCommonAppData(),
SystemFolders.GetCommonDesktop(),
SystemFolders.GetCommonProgramsStartMenu(),
SystemFolders.GetCommonProgramFilesx86(),
SystemFolders.GetCommonProgramFilesx64(),
SystemFolders.GetCurrentUserDesktop(),
SystemFolders.GetCurrentUserProgramsStartMenu() };
List <FileFolder> rollbackList = new List <FileFolder>();
int totalDone = 0;
Exception except = null;
try
{
int totalFiles = 0;
// count the files and create backup folders
for (int i = 0; i < origFolders.Length; i++)
{
// does orig folder exist?
if (!Directory.Exists(Path.Combine(TempDirectory, origFolders[i])))
{
continue;
}
//orig folder exists, set backup & orig folder locations
backupFolders[i] = Path.Combine(backupFolder, origFolders[i]);
origFolders[i] = Path.Combine(TempDirectory, origFolders[i]);
Directory.CreateDirectory(backupFolders[i]);
// delete "newer" client, if it will overwrite this client
DeleteClientInPath(destFolders[i], origFolders[i]);
// count the total files
totalFiles += new DirectoryInfo(origFolders[i]).GetFiles("*", SearchOption.AllDirectories).Length;
}
//run the backup & replace
for (int i = 0; i < origFolders.Length; i++)
{
if (IsCancelled())
{
break;
}
if (backupFolders[i] != null) //if the backup folder exists
{
UpdateFiles(origFolders[i], destFolders[i], backupFolders[i], rollbackList, ref totalDone, ref totalFiles);
}
}
DeleteFiles(backupFolder, rollbackList);
InstallShortcuts(destFolders, backupFolder, rollbackList);
}
catch (Exception ex)
{
except = ex;
}
// write the list of newly created files and folders
RollbackUpdate.WriteRollbackFiles(Path.Combine(backupFolder, "fileList.bak"), rollbackList);
if (IsCancelled() || except != null)
{
// rollback files
bw.ReportProgress(1, false);
RollbackUpdate.RollbackFiles(TempDirectory, ProgramDirectory);
// rollback unregged COM
RollbackUpdate.RollbackUnregedCOM(TempDirectory);
// rollback stopped services
RollbackUpdate.RollbackStoppedServices(TempDirectory);
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
}
else
{
// backup & replace was successful
bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
}
}
