WinMFCBackupThread.cpp

#include "stdafx.h"

#include <vector>
#include <errno.h>
#include <io.h>
#include <stdio.h>
#include <wchar.h>

#include "Common.h"
#include "WinMFCTaskbarList.h"
#include "WinMFCApp.h"
#include "resource.h"
#include "CommonBackupEvents.h"
#include "CommonSelfTest.h"

// Top Level Functions

// void ShowFastBackupHelp(HWND ParentWindow, DWORD HelpContextId);
// UINT __cdecl FastBackupThread(LPVOID Data);
// UINT __cdecl RestoreThread(LPVOID Data);

// Helper Functions

static int DisplayWindowsRepeatBackupTip(WVBString WToFolder);
static VBString GetFastBackupHelpFile();

// Globals

// Thresholds for displaying percentage updates of files.
__int64 gLargeFileThreshold, gVeryLargeFileThreshold, gVeryVeryLargeFileThreshold, gVeryVeryVeryLargeFileThreshold;

// Shared backup state used by the common engine and Windows callbacks.  These
// remain global because copy progress, logging, validation, and UI callbacks all
// need access without dragging large state objects through every call.
int gCurrentCopyProgressFlags, gDisplayFolderMidPosition, gAppState, gAbortingWorkerThread, gTimeTakenForCopyingThisFile, gDisplayExcludeCount;
int gUpdatedCount, gCopiedCount, gDeletedCount, gMovedCount, gVerifiedCount, gVerifiedAsDifferent, gFolderCount, gFileCount, gErrorCount, gWarningCount, gLongPathCopiedCount;
int gSkippedOneDriveCloudFileCount, gSkippedGoogleDriveCloudFileCount, gSkippedDropboxCloudFileCount, gSkippedOtherCloudFileCount;
WVBString gWToFolderRoot;
WVBString gWOldFolderRoot;
WVBString gWLogFolder;
WVBString gWHistoryLogFilename;
WVBString gWErrorLogFilename;
WVBString gWOldFolderShort;
WVBString gRecyclingBinFolder;
WVBString gExePath;
SYSTEMTIME gPrevTime;
SYSTEMTIME gPrevTimeForPercentDone;
int gProgressBarFolderListCount, gProgressBarTotalFiles, gDisplaySkippedMessages;
double gInternalProgressBar, gExternalProgressBar;
std::vector<FOLDERLIST> gProgressBarFolderList;
std::vector<VBString> gDisplayExcludeList;
std::vector<VBString> gDisplayBackedUpEmailList;
__int64 gPrevBytesCopied;
int gEmptyingRecycleBinOrOldFolder = false;
int gBackgroundFastBackupTrashFolderCleanup = false;
int gPreEmptiveDiskCleanupStep = 0;
int gAutorun = false;
int gLoadedFromCommandLine = false;
int gCommandLineMode = false;
int gCommandLineExitCode = 0;
int gDisplayBackedUpEmailMsg = false;
int gDisplayBackedUpOneDriveUserDataMsg = false;

// The GUI copies validated dialog settings here before starting the worker
// thread.  OptionsDlg has its own temporary COptions instance while it is open;
// the common backup code reads this global once the run begins.
COptions gGlobalOptions;

// Windows taskbar progress wrapper shared by the MFC event adapter.
CSafeTaskbarList gTaskBarList;

// External Globals

extern CFastBackupApp gTheApp;

// Defines

typedef HWND (WINAPI *HTML_HELP_A)(HWND, LPCSTR, UINT, DWORD_PTR);
#define FAST_BACKUP_HH_HELP_CONTEXT 0x000F

// Opens Fast-Backup's compiled HTML Help file at a specific help context.  The
// HTML Help control is loaded dynamically so the application can show a friendly
// message if Windows HTML Help is unavailable.
void ShowFastBackupHelp(HWND ParentWindow, DWORD HelpContextId)
{
	HMODULE HtmlHelpModule;
	HTML_HELP_A HtmlHelp;
	VBString HelpFile;

	// Locate the .chm before loading hhctrl.ocx so missing-help and missing-HTML
	// Help produce distinct messages.
	HelpFile = GetFastBackupHelpFile();
	if (HelpFile == "")
	{
		AfxMessageBox(L"Fast-Backup.chm could not be found.", MB_OK | MB_ICONEXCLAMATION);
		return;
	}

	// Load the HTML Help runtime only when it is needed.
	HtmlHelpModule = LoadLibraryA("hhctrl.ocx");
	if (HtmlHelpModule == NULL)
	{
		AfxMessageBox(L"Windows HTML Help is not available.", MB_OK | MB_ICONEXCLAMATION);
		return;
	}

	// Resolve HtmlHelpA dynamically from the loaded runtime.
	HtmlHelp = (HTML_HELP_A)GetProcAddress(HtmlHelpModule, "HtmlHelpA");
	if (HtmlHelp == NULL)
	{
		FreeLibrary(HtmlHelpModule);
		AfxMessageBox(L"Windows HTML Help is not available.", MB_OK | MB_ICONEXCLAMATION);
		return;
	}

	// Open the requested help context owned by the dialog/window that asked for
	// help.
	HtmlHelp(ParentWindow, HelpFile, FAST_BACKUP_HH_HELP_CONTEXT, (DWORD_PTR)HelpContextId);
}


// Worker-thread entry point for running a backup from the Windows app.  It owns
// the high-level backup lifecycle: prepare folders/logs, run the shared engine,
// summarise results, start background cleanup, and close autorun/CLI sessions.
UINT __cdecl FastBackupThread(LPVOID Data)
{
	int Success, BackupIsSuccessful, AddBlankLine, StartTrashCleanupAfterHistorySummary;
	WVBString WFromFolder, WToFolder, WOldFolder;

	// The Windows worker does not need a parameter because the main dialog has
	// already copied the selected options into gGlobalOptions before starting it.
	UNREFERENCED_PARAMETER(Data);

	// *** This Common Section Needs To Stay In Sync With wmain() in CLIMain.cpp for the Command line ***

	// Reset shared backup counters, progress state, and log state before taking
	// local copies of the source/destination folders.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #033.
	InitialiseBackupState();
	WFromFolder = gGlobalOptions.FromFolder;
	WToFolder   = gGlobalOptions.ToFolder;

	// Cache the destination and timestamped OLD folder paths in globals used by
	// progress, cleanup, and copy/move callbacks.
	gWToFolderRoot = WToFolder;
	WOldFolder = GetOldTimestampedFolder(WToFolder);
	gWOldFolderShort = WOldFolder.Mid(WToFolder.Length + 2);
	gWOldFolderRoot = WOldFolder;
#ifdef ENABLE_SELF_TEST_LOGIC
	// This lets a Windows autorun self-test parse a literal C:\ command line
	// but safely read from an emulated C drive under Self_Test instead.
	if (   gSelfTestCDriveSubstituteRoot.Length
		&& (   WFromFolder.EqualsNoCase(L"C:")
			|| WFromFolder.EqualsNoCase(L"C:\\")))
	{
		WFromFolder = gSelfTestCDriveSubstituteRoot;
		gGlobalOptions.FromFolder = WVBStringToVBString(WFromFolder);
	}
#endif

	// Start pre-backup trash cleanup as early as possible so stale trash is
	// removed before the main copy tries to use destination space.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #034.
	StartInitialFastBackupTrashFolderCleanup(WToFolder);

	// Create/check the destination support folders before any backup work starts.
	// If this fails the worker jumps to the shared cleanup/exit path.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #035.
	if (PrepareFastBackupAndOldFolders(WFromFolder, WToFolder) == false) { gAppState = BACKUP_FAILED; goto EXIT_WORKER_THREAD; }

	// After the first successful preparation step, record that this destination
	// has been initialised so later runs can skip first-backup wording.
	if (!gGlobalOptions.NoSettingsLogsFolder && ReadIni(gGlobalOptions.ToFolder, L"IsFirstBackup", L"Yes") == L"Yes")
		WriteIni(gGlobalOptions.ToFolder, L"IsFirstBackup", L"No");

	// Write the startup messages and history header before file scanning begins.
	DisplayCommonBackupStartupMessages(gGlobalOptions.FromFolder, gGlobalOptions.ToFolder, gGlobalOptions.Speed);
	LogBackupStartedHistoryLine(gGlobalOptions.FromFolder, gGlobalOptions.ToFolder);
	LogLargeFileThresholds(L"Initial values");

#ifndef MOVE_EXPIRED_OLD_FOLDERS_AT_THE_END
	// Optionally queue expired OLD folders for delayed deletion before the
	// backup starts, then launch the detached cleanup helper immediately.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #035A.
	if (CleanOutExpiredOldFolders())
		StartBackgroundFastBackupTrashFolderCleanup(WToFolder);
#endif

	// Refresh log links after the settings/log folders have been prepared.
	if (!gGlobalOptions.NoSettingsLogsFolder) EnableOrDisableViewLogLinkDependingOnStatus();

	// Count the work up front so the Windows progress bar can show overall
	// progress during the backup.
	Success = InitProgressBarCounts(WFromFolder);
	if (Success == false) { gAppState = BACKUP_FAILED; goto EXIT_WORKER_THREAD; }

	// Start the restore log before changing files, then run the shared backup
	// engine from the selected source to destination.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #036.
	ScreenLogActivity("");
	StartRestoreLog(WToFolder, WOldFolder);
	GetSystemTime(&gPrevTime);
	#ifdef LOG_ALL_SLEEP_TIMES // Windows only
	ScreenLogError("##Sleep timer initialised");
	#endif
	BackupIsSuccessful = BackupFilesInFolder(WFromFolder, WToFolder, WOldFolder, WFromFolder);

	// Immediate-exit requests skip the remaining summary/cleanup work so the UI
	// can close as quickly as possible.
	if (gAppState == USER_REQUESTED_IMMEDIATE_EXIT) goto EXIT_WORKER_THREAD;
	
	// Set the Windows progress indicators to either complete or inactive.
	if (BackupIsSuccessful)
	{
		FinaliseProgressBar();
	}
	else
	{
		SetProgressBarPos(0);
		SetTaskbarNoProgress();
	}

	// Do not mark the backup as finished yet.  The end-of-backup cleanup below
	// can still take time, especially when deleting expired _OLD_ folders, and
	// the user must still be able to Pause or Stop that work.  The final state
	// is set after cleanup has finished.
	if (gAppState == BACKUP_RUNNING && !BackupIsSuccessful) gAppState = BACKUP_FAILED;

	// Show shared end-of-backup notes before cleanup/summary so GUI and CLI
	// logs group email, C:\ user-data, and cloud-file messages consistently.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #037
	if (BackupIsSuccessful)
		WriteRestoreLog();
	else
		CancelRestoreLog();

	// Show supplementary notes such as email-folder/user-data/cloud-file messages.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #038.
	DisplayEndOfBackupSupplementaryMessages();

	// Successful backups either delete/move expired OLD folders here, or, when
	// the start-of-backup experiment is enabled, just report the oldest retained
	// OLD folder after the backup has succeeded.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #039.
	if (BackupIsSuccessful)
	{
#ifdef MOVE_EXPIRED_OLD_FOLDERS_AT_THE_END
		CleanOutExpiredOldFolders();
#endif
		if (gAppState == BACKUP_RUNNING) DisplayOldestKeptOldFolder();
	}

	// The main backup and the end-of-backup cleanup have both finished.  Only
	// now mark the run as complete; before this point the Pause button still
	// needs to behave as a real pause button for OLD-folder deletion.
	if (gAppState == BACKUP_RUNNING && BackupIsSuccessful) gAppState = BACKUP_FINISHED;
	
	// Display the summary on screen now. The history log is written later
	// because it groups the summary with warnings/options/details.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #040
	DisplayBackupSummary();

	// End-of-backup tips are shown after the summary.  Track whether a blank
	// separator is needed before the final completion line.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #041.
	AddBlankLine = false;
	if (BackupIsSuccessful && DisplayWindowsRepeatBackupTip(WToFolder))       AddBlankLine = true;
	if (BackupIsSuccessful && DisplayEndOfBackupTips(WToFolder)) AddBlankLine = true;

	// Delay final trash cleanup until after the history summary so the visible
	// run can finish promptly and cleanup can continue in the background.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #041A.
	StartTrashCleanupAfterHistorySummary = false;
	if (BackupIsSuccessful && !gGlobalOptions.EjectWhenFinished
		&& DirectoryExists(GetFastBackupTrashFolderPath(WToFolder)))
	{
		// Only display a message if there are enough items for cleanup to be
		// noticeably visible after the backup summary.
		if (FolderHasMoreItemsThanLimit(GetFastBackupTrashFolderPath(WToFolder), MIN_TRASH_ITEMS_FOR_CLEANUP_MESSAGE))
		{
			ScreenLogActivity("Cleanup of _Fast-Backup-Trash will continue in the background.");
			AddBlankLine = true;
		}
		StartTrashCleanupAfterHistorySummary = true;
	}

	// For Command line, see similar logic in wmain() in CLIMain.cpp #042
	if (BackupIsSuccessful && !gGlobalOptions.NoSettingsLogsFolder)
	{
		// Update the destination history settings only after a successful backup.
		RecordSuccessfulBackup(WToFolder);
	}

	// Show the final success line only for successful backups with no errors;
	// otherwise just play the failure/attention sound.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #043.
	if (BackupIsSuccessful && gErrorCount == 0)
	{
		if (AddBlankLine) ScreenLogActivity("");
		ScreenLogActivity("FAST-BACKUP COMPLETE !");
		PlayEndOfBackupBeep(true);
	}
	else
	{
		PlayEndOfBackupBeep(false);
	}

	// Write the permanent history-log summary after the end-of-backup messages,
	// while keeping the history file in its own summary/warnings/details order.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #044
	LogEndOfBackupHistorySummary();

	// Start the background trash cleanup only after the history summary is safely
	// written.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #045
	if (StartTrashCleanupAfterHistorySummary) StartBackgroundFastBackupTrashFolderCleanup(WToFolder);

	// Request safe removal.  Interactive runs retry in the background; /AUTORUN
	// waits here so its automatic close cannot terminate the eject worker.
	// For Command line, see similar logic in wmain() in CLIMain.cpp #046
	if (BackupIsSuccessful && gGlobalOptions.EjectWhenFinished)
	{
		ScreenLogActivity("");
		EjectWhenFinished_Windows(WToFolder, gAutorun);
	}

	// *** End of Common Section ***

	EXIT_WORKER_THREAD:;

	// Replace the last current folder with the final backup outcome.
	if (gAppState == BACKUP_FINISHED)
		gTheApp.m_MainDlg->UpdateCurrentFolder(L"Backup complete", true, true);
	else if (gAppState == BACKUP_STOPPED || gAppState == USER_REQUESTED_IMMEDIATE_EXIT)
		gTheApp.m_MainDlg->UpdateCurrentFolder(L"Backup stopped", true, true);
	else
		gTheApp.m_MainDlg->UpdateCurrentFolder(L"Backup failed", true, true);

	// Re-enable the view-log links now that no more foreground log setup is
	// pending.
	EnableOrDisableViewLogLinkDependingOnStatus();

	// Return the main dialog controls to their idle/error/finished state.
	EnableOrDisableButtonsDependingOnStatus();

#ifdef ENABLE_SELF_TEST_LOGIC
	// A Windows autorun self-test owns the next step itself, so leave the dialog
	// open for the self-test harness rather than posting WM_CLOSE here.
	if (gSelfTestRunningWindowsAutorunBackup)
	{
		return TRUE;
	}
#endif

	// Command-line-mode GUI runs close the dialog and report success/failure via
	// CFastBackupApp::ExitInstance().
	if (gCommandLineMode)
	{
		gCommandLineExitCode = (gAppState == BACKUP_FINISHED) ? 0 : 1;
		::PostMessage(gTheApp.m_MainDlg->GetSafeHwnd(), WM_CLOSE, 0, 0);
	}
	else if (  (gAutorun && gAppState == BACKUP_FINISHED)
		|| gAppState == USER_REQUESTED_IMMEDIATE_EXIT)
	{
		// Autorun and immediate-exit runs ask the UI thread to close the dialog.
		::PostMessage(gTheApp.m_MainDlg->GetSafeHwnd(), WM_CLOSE, 0, 0);
	}

	// The MFC worker-thread convention is a non-zero success return.
	return TRUE;
}


// Worker-thread entry point for running a restore from the Windows app.
// The selected restore-point folder and optional destination parent are passed
// in a heap-allocated structure so the UI can return immediately.
UINT __cdecl RestoreThread(LPVOID Data)
{
	RESTORE_THREAD_DATA *RestoreData;
	int Result;

	// The UI thread allocates the selected restore folder and hands ownership to
	// this worker so the dialog can return immediately after starting restore.
	RestoreData = (RESTORE_THREAD_DATA *)Data;

	// Restore uses its own running state so the main dialog can disable Start,
	// Restore, Options, and Pause while still leaving Stop available.
	gAppState = RESTORE_RUNNING;

	// Start restore with clean counters and a reset progress display.
	gErrorCount = 0;
	gWarningCount = 0;
	gExternalProgressBar = 0.0;
	SetProgressBarRange(0, 100);
	SetProgressBarPos(0);
	SetTaskbarNoProgress();

	// Refresh the dialog controls before the restore messages begin.
	EnableOrDisableButtonsDependingOnStatus();
	EnableOrDisableViewLogLinkDependingOnStatus();

	// Start each restore with clean activity and error panes, just as a normal
	// backup starts with a clean display.
	ScreenLogActivity(L"##CLEAR##");
	gTheApp.m_MainDlg->LogErrorMessage(L"##CLEAR##");

	// Run the shared restore implementation in Windows mode.
	Result = RunRestoreToRestoredFolder(RestoreData->RestoreFolder, TRUE, RestoreData->RestoreDestinationParent);

	// Release the heap object passed from the UI thread.
	delete RestoreData;
	RestoreData = NULL;

#ifdef _WINDOWS
	// The restore is no longer focused on a current folder.
	DisplayTheCurrentFolderForWindows(L"");
#endif

	// RunRestoreToRestoredFolder() returns a non-zero result for stopped,
	// failed, or completed-with-errors restores.  The activity/error logs
	// already contain the detail, so the state only drives buttons/taskbar.
	if (gAppState == BACKUP_STOPPED || Result != 0)
	{
		// A user-cancelled restore may leave a partial RESTORED_FOLDER, so make
		// that clear in the activity log.
		if (gAppState == BACKUP_STOPPED)
		{
			ScreenLogActivity("");
			ScreenLogActivity("Cancelled restore. RESTORED_FOLDER may be incomplete.");
		}

		// Treat stopped, failed, and completed-with-errors restores as failed for
		// button and taskbar state.
		gAppState = BACKUP_FAILED;
#ifdef _WINDOWS
		SetProgressBarPos(0);
		BackupSetTaskbarError();
#endif
	}
	else
	{
		// A clean restore uses the same finished state as a completed backup so
		// the main dialog returns to its normal idle controls.
		gAppState = BACKUP_FINISHED;
#ifdef _WINDOWS
		SetProgressBarPos(100);
		SetTaskbarProgressValue(100);
#endif
	}

	// Refresh log links and controls after the final restore state is known.
	EnableOrDisableViewLogLinkDependingOnStatus();
	EnableOrDisableButtonsDependingOnStatus();

	// The MFC worker-thread convention is a non-zero success return.
	return TRUE;
}


// Helper Functions

// Displays the repeat-backup tip at the end of a successful Windows backup.
// The message is suppressed when Fast-Backup.exe was itself launched from the
// destination _FAST-BACKUP folder, because that already proves the user knows
// about the repeat-backup shortcut.
static int DisplayWindowsRepeatBackupTip(WVBString WToFolder)
{
	VBString IsFirstRunForThisDestination;
	WVBString WTemp;

	// Work out whether this executable was launched from the destination copy.
	if (gExePath.Right(15) == L"FAST-BACKUP.EXE")
		WTemp = gExePath.Left(gExePath.Length - 15);
	else
		WTemp = gExePath;

	// Do not write settings or show repeat-backup guidance when the destination
	// is the executable folder or settings/log folders have been disabled.
	if (gGlobalOptions.NoSettingsLogsFolder || RemoveTrailingBackslash(WTemp) == RemoveTrailingBackslash(WToFolder)) return false;

	// First-run wording gives the user both the speed note and the repeat-backup
	// shortcut.  Later runs use the shorter reminder.
	IsFirstRunForThisDestination = WVBStringToVBString(ReadIni(WToFolder, L"IsFirstRunForThisDestination", L"No"));
	if (IsFirstRunForThisDestination == "No")
	{
		ScreenLogActivity("NOTE: Future backups will be much faster because only new and changed files need to be copied.");
		ScreenLogActivity("TIP:     To repeat this backup, open " + RemoveTrailingBackslash(WToFolder) + "\\_FAST-BACKUP and run Fast-Backup.exe");
		WriteIni(WToFolder, L"IsFirstRunForThisDestination", L"Yes");
	}
	else
	{
		ScreenLogActivity("TIP: To repeat this backup, open " + RemoveTrailingBackslash(WToFolder) + "\\_FAST-BACKUP and run Fast-Backup.exe");
	}

	// Tell the caller that the log now has an extra visible message.
	return true;
}


// Locates the compiled HTML Help file from the places a developer build,
// installed build, or copied executable is likely to find it.
static VBString GetFastBackupHelpFile()
{
	char ModuleFileName[MAX_PATH], Drive[_MAX_DRIVE], Dir[_MAX_DIR], HelpFile[MAX_PATH];
	VBString Candidate;

	// First look beside the running executable.
	GetModuleFileNameA(NULL, ModuleFileName, MAX_PATH);
	_splitpath(ModuleFileName, Drive, Dir, NULL, NULL);
	_makepath(HelpFile, Drive, Dir, "Fast-Backup", ".chm");
	Candidate = HelpFile;
	if (FileExists(Candidate)) return Candidate;

	// Developer builds normally find the help file under ..\Help.
	_makepath(HelpFile, Drive, Dir, "..\\Help\\Fast-Backup", ".chm");
	Candidate = HelpFile;
	if (FileExists(Candidate)) return Candidate;

	// Fall back to working-directory relative paths for command-line launches
	// from the repo or copied application folder.
	Candidate = "Help\\Fast-Backup.chm";
	if (FileExists(Candidate)) return Candidate;

	Candidate = "Fast-Backup.chm";
	if (FileExists(Candidate)) return Candidate;

	// Last, try the default installed location.
	Candidate = "C:\\Program Files\\Fast-Backup\\Fast-Backup.chm";
	if (FileExists(Candidate)) return Candidate;

	// The caller shows the user-facing error message.
	return "";
}