836 lines
27 KiB
C#
836 lines
27 KiB
C#
/*
|
|
* Copyright (c) 2021 ETH Zürich, Educational Development and Technology (LET)
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using SafeExamBrowser.Applications.Contracts;
|
|
using SafeExamBrowser.Browser.Contracts;
|
|
using SafeExamBrowser.Browser.Contracts.Events;
|
|
using SafeExamBrowser.Client.Operations.Events;
|
|
using SafeExamBrowser.Communication.Contracts.Data;
|
|
using SafeExamBrowser.Communication.Contracts.Events;
|
|
using SafeExamBrowser.Communication.Contracts.Hosts;
|
|
using SafeExamBrowser.Communication.Contracts.Proxies;
|
|
using SafeExamBrowser.Configuration.Contracts.Cryptography;
|
|
using SafeExamBrowser.Core.Contracts.OperationModel;
|
|
using SafeExamBrowser.Core.Contracts.OperationModel.Events;
|
|
using SafeExamBrowser.I18n.Contracts;
|
|
using SafeExamBrowser.Logging.Contracts;
|
|
using SafeExamBrowser.Monitoring.Contracts.Applications;
|
|
using SafeExamBrowser.Monitoring.Contracts.Display;
|
|
using SafeExamBrowser.Monitoring.Contracts.System;
|
|
using SafeExamBrowser.Server.Contracts;
|
|
using SafeExamBrowser.Server.Contracts.Data;
|
|
using SafeExamBrowser.Settings;
|
|
using SafeExamBrowser.UserInterface.Contracts;
|
|
using SafeExamBrowser.UserInterface.Contracts.FileSystemDialog;
|
|
using SafeExamBrowser.UserInterface.Contracts.MessageBox;
|
|
using SafeExamBrowser.UserInterface.Contracts.Shell;
|
|
using SafeExamBrowser.UserInterface.Contracts.Windows;
|
|
using SafeExamBrowser.UserInterface.Contracts.Windows.Data;
|
|
using SafeExamBrowser.WindowsApi.Contracts;
|
|
|
|
namespace SafeExamBrowser.Client
|
|
{
|
|
internal class ClientController
|
|
{
|
|
private IActionCenter actionCenter;
|
|
private IApplicationMonitor applicationMonitor;
|
|
private ClientContext context;
|
|
private IDisplayMonitor displayMonitor;
|
|
private IExplorerShell explorerShell;
|
|
private IFileSystemDialog fileSystemDialog;
|
|
private IHashAlgorithm hashAlgorithm;
|
|
private ILogger logger;
|
|
private IMessageBox messageBox;
|
|
private IOperationSequence operations;
|
|
private IRuntimeProxy runtime;
|
|
private bool sessionLocked;
|
|
private Action shutdown;
|
|
private ISplashScreen splashScreen;
|
|
private ISystemMonitor systemMonitor;
|
|
private ITaskbar taskbar;
|
|
private IText text;
|
|
private IUserInterfaceFactory uiFactory;
|
|
|
|
private IBrowserApplication Browser => context.Browser;
|
|
private IClientHost ClientHost => context.ClientHost;
|
|
private IServerProxy Server => context.Server;
|
|
private AppSettings Settings => context.Settings;
|
|
|
|
internal ClientController(
|
|
IActionCenter actionCenter,
|
|
IApplicationMonitor applicationMonitor,
|
|
ClientContext context,
|
|
IDisplayMonitor displayMonitor,
|
|
IExplorerShell explorerShell,
|
|
IFileSystemDialog fileSystemDialog,
|
|
IHashAlgorithm hashAlgorithm,
|
|
ILogger logger,
|
|
IMessageBox messageBox,
|
|
IOperationSequence operations,
|
|
IRuntimeProxy runtime,
|
|
Action shutdown,
|
|
ISplashScreen splashScreen,
|
|
ISystemMonitor systemMonitor,
|
|
ITaskbar taskbar,
|
|
IText text,
|
|
IUserInterfaceFactory uiFactory)
|
|
{
|
|
this.actionCenter = actionCenter;
|
|
this.applicationMonitor = applicationMonitor;
|
|
this.context = context;
|
|
this.displayMonitor = displayMonitor;
|
|
this.explorerShell = explorerShell;
|
|
this.fileSystemDialog = fileSystemDialog;
|
|
this.hashAlgorithm = hashAlgorithm;
|
|
this.logger = logger;
|
|
this.messageBox = messageBox;
|
|
this.operations = operations;
|
|
this.runtime = runtime;
|
|
this.shutdown = shutdown;
|
|
this.splashScreen = splashScreen;
|
|
this.systemMonitor = systemMonitor;
|
|
this.taskbar = taskbar;
|
|
this.text = text;
|
|
this.uiFactory = uiFactory;
|
|
}
|
|
|
|
internal bool TryStart()
|
|
{
|
|
logger.Info("Initiating startup procedure...");
|
|
|
|
operations.ActionRequired += Operations_ActionRequired;
|
|
operations.ProgressChanged += Operations_ProgressChanged;
|
|
operations.StatusChanged += Operations_StatusChanged;
|
|
|
|
splashScreen.Show();
|
|
splashScreen.BringToForeground();
|
|
|
|
var success = operations.TryPerform() == OperationResult.Success;
|
|
|
|
if (success)
|
|
{
|
|
RegisterEvents();
|
|
ShowShell();
|
|
AutoStartApplications();
|
|
|
|
var communication = runtime.InformClientReady();
|
|
|
|
if (communication.Success)
|
|
{
|
|
logger.Info("Application successfully initialized.");
|
|
logger.Log(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
success = false;
|
|
logger.Error("Failed to inform runtime that client is ready!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
logger.Info("Application startup aborted!");
|
|
logger.Log(string.Empty);
|
|
}
|
|
|
|
splashScreen.Hide();
|
|
|
|
return success;
|
|
}
|
|
|
|
internal void Terminate()
|
|
{
|
|
logger.Log(string.Empty);
|
|
logger.Info("Initiating shutdown procedure...");
|
|
|
|
splashScreen.Show();
|
|
splashScreen.BringToForeground();
|
|
|
|
CloseShell();
|
|
DeregisterEvents();
|
|
|
|
var success = operations.TryRevert() == OperationResult.Success;
|
|
|
|
if (success)
|
|
{
|
|
logger.Info("Application successfully finalized.");
|
|
logger.Log(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
logger.Info("Shutdown procedure failed!");
|
|
logger.Log(string.Empty);
|
|
}
|
|
|
|
splashScreen.Close();
|
|
}
|
|
|
|
internal void UpdateAppConfig()
|
|
{
|
|
splashScreen.AppConfig = context.AppConfig;
|
|
}
|
|
|
|
private void RegisterEvents()
|
|
{
|
|
actionCenter.QuitButtonClicked += Shell_QuitButtonClicked;
|
|
applicationMonitor.ExplorerStarted += ApplicationMonitor_ExplorerStarted;
|
|
applicationMonitor.TerminationFailed += ApplicationMonitor_TerminationFailed;
|
|
Browser.ConfigurationDownloadRequested += Browser_ConfigurationDownloadRequested;
|
|
Browser.SessionIdentifierDetected += Browser_SessionIdentifierDetected;
|
|
Browser.TerminationRequested += Browser_TerminationRequested;
|
|
ClientHost.ExamSelectionRequested += ClientHost_ExamSelectionRequested;
|
|
ClientHost.MessageBoxRequested += ClientHost_MessageBoxRequested;
|
|
ClientHost.PasswordRequested += ClientHost_PasswordRequested;
|
|
ClientHost.ReconfigurationAborted += ClientHost_ReconfigurationAborted;
|
|
ClientHost.ReconfigurationDenied += ClientHost_ReconfigurationDenied;
|
|
ClientHost.ServerFailureActionRequested += ClientHost_ServerFailureActionRequested;
|
|
ClientHost.Shutdown += ClientHost_Shutdown;
|
|
displayMonitor.DisplayChanged += DisplayMonitor_DisplaySettingsChanged;
|
|
runtime.ConnectionLost += Runtime_ConnectionLost;
|
|
systemMonitor.SessionSwitched += SystemMonitor_SessionSwitched;
|
|
taskbar.QuitButtonClicked += Shell_QuitButtonClicked;
|
|
|
|
foreach (var activator in context.Activators.OfType<ITerminationActivator>())
|
|
{
|
|
activator.Activated += TerminationActivator_Activated;
|
|
}
|
|
|
|
if (Server != null)
|
|
{
|
|
Server.TerminationRequested += Server_TerminationRequested;
|
|
}
|
|
}
|
|
|
|
private void DeregisterEvents()
|
|
{
|
|
actionCenter.QuitButtonClicked -= Shell_QuitButtonClicked;
|
|
applicationMonitor.ExplorerStarted -= ApplicationMonitor_ExplorerStarted;
|
|
applicationMonitor.TerminationFailed -= ApplicationMonitor_TerminationFailed;
|
|
displayMonitor.DisplayChanged -= DisplayMonitor_DisplaySettingsChanged;
|
|
runtime.ConnectionLost -= Runtime_ConnectionLost;
|
|
systemMonitor.SessionSwitched -= SystemMonitor_SessionSwitched;
|
|
taskbar.QuitButtonClicked -= Shell_QuitButtonClicked;
|
|
|
|
if (Browser != null)
|
|
{
|
|
Browser.ConfigurationDownloadRequested -= Browser_ConfigurationDownloadRequested;
|
|
Browser.SessionIdentifierDetected -= Browser_SessionIdentifierDetected;
|
|
Browser.TerminationRequested -= Browser_TerminationRequested;
|
|
}
|
|
|
|
if (ClientHost != null)
|
|
{
|
|
ClientHost.ExamSelectionRequested -= ClientHost_ExamSelectionRequested;
|
|
ClientHost.MessageBoxRequested -= ClientHost_MessageBoxRequested;
|
|
ClientHost.PasswordRequested -= ClientHost_PasswordRequested;
|
|
ClientHost.ReconfigurationAborted -= ClientHost_ReconfigurationAborted;
|
|
ClientHost.ReconfigurationDenied -= ClientHost_ReconfigurationDenied;
|
|
ClientHost.ServerFailureActionRequested -= ClientHost_ServerFailureActionRequested;
|
|
ClientHost.Shutdown -= ClientHost_Shutdown;
|
|
}
|
|
|
|
if (Server != null)
|
|
{
|
|
Server.TerminationRequested -= Server_TerminationRequested;
|
|
}
|
|
|
|
foreach (var activator in context.Activators.OfType<ITerminationActivator>())
|
|
{
|
|
activator.Activated -= TerminationActivator_Activated;
|
|
}
|
|
}
|
|
|
|
private void CloseShell()
|
|
{
|
|
if (Settings?.ActionCenter.EnableActionCenter == true)
|
|
{
|
|
actionCenter.Close();
|
|
}
|
|
|
|
if (Settings?.Taskbar.EnableTaskbar == true)
|
|
{
|
|
taskbar.Close();
|
|
}
|
|
}
|
|
|
|
private void ShowShell()
|
|
{
|
|
if (Settings.ActionCenter.EnableActionCenter)
|
|
{
|
|
actionCenter.Promote();
|
|
}
|
|
|
|
if (Settings.Taskbar.EnableTaskbar)
|
|
{
|
|
taskbar.Show();
|
|
}
|
|
}
|
|
|
|
private void AutoStartApplications()
|
|
{
|
|
if (Settings.Browser.EnableBrowser && Browser.AutoStart)
|
|
{
|
|
logger.Info("Auto-starting browser...");
|
|
Browser.Start();
|
|
}
|
|
|
|
foreach (var application in context.Applications)
|
|
{
|
|
if (application.AutoStart)
|
|
{
|
|
logger.Info($"Auto-starting '{application.Name}'...");
|
|
application.Start();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplicationMonitor_ExplorerStarted()
|
|
{
|
|
logger.Info("Trying to terminate Windows explorer...");
|
|
explorerShell.Terminate();
|
|
logger.Info("Re-initializing working area...");
|
|
displayMonitor.InitializePrimaryDisplay(Settings.Taskbar.EnableTaskbar ? taskbar.GetAbsoluteHeight() : 0);
|
|
logger.Info("Re-initializing shell...");
|
|
actionCenter.InitializeBounds();
|
|
taskbar.InitializeBounds();
|
|
logger.Info("Desktop successfully restored.");
|
|
}
|
|
|
|
private void ApplicationMonitor_TerminationFailed(IEnumerable<RunningApplication> applications)
|
|
{
|
|
var applicationList = string.Join(Environment.NewLine, applications.Select(a => $"- {a.Name}"));
|
|
var message = $"{text.Get(TextKey.LockScreen_ApplicationsMessage)}{Environment.NewLine}{Environment.NewLine}{applicationList}";
|
|
var title = text.Get(TextKey.LockScreen_Title);
|
|
var allowOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_ApplicationsAllowOption) };
|
|
var terminateOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_ApplicationsTerminateOption) };
|
|
|
|
logger.Warn("Detected termination failure of blacklisted application(s)!");
|
|
|
|
var result = ShowLockScreen(message, title, new[] { allowOption, terminateOption });
|
|
|
|
if (result.OptionId == allowOption.Id)
|
|
{
|
|
logger.Info($"The blacklisted application(s) {string.Join(", ", applications.Select(a => $"'{a.Name}'"))} will be temporarily allowed.");
|
|
}
|
|
else if (result.OptionId == terminateOption.Id)
|
|
{
|
|
logger.Info("Attempting to shutdown as requested by the user...");
|
|
TryRequestShutdown();
|
|
}
|
|
}
|
|
|
|
private void Browser_ConfigurationDownloadRequested(string fileName, DownloadEventArgs args)
|
|
{
|
|
var allow = false;
|
|
var hasQuitPassword = !string.IsNullOrWhiteSpace(Settings.Security.QuitPasswordHash);
|
|
var hasUrl = !string.IsNullOrWhiteSpace(Settings.Security.ReconfigurationUrl);
|
|
|
|
if (hasQuitPassword)
|
|
{
|
|
if (hasUrl)
|
|
{
|
|
var expression = Regex.Escape(Settings.Security.ReconfigurationUrl).Replace(@"\*", ".*");
|
|
var regex = new Regex($"^{expression}$", RegexOptions.IgnoreCase);
|
|
var sebUrl = args.Url.Replace(Uri.UriSchemeHttps, context.AppConfig.SebUriSchemeSecure).Replace(Uri.UriSchemeHttp, context.AppConfig.SebUriScheme);
|
|
|
|
allow = Settings.Security.AllowReconfiguration && (regex.IsMatch(args.Url) || regex.IsMatch(sebUrl));
|
|
}
|
|
else
|
|
{
|
|
logger.Warn("The active configuration does not contain a valid reconfiguration URL!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allow = Settings.ConfigurationMode == ConfigurationMode.ConfigureClient || Settings.Security.AllowReconfiguration;
|
|
}
|
|
|
|
if (allow)
|
|
{
|
|
args.AllowDownload = true;
|
|
args.Callback = Browser_ConfigurationDownloadFinished;
|
|
args.DownloadPath = Path.Combine(context.AppConfig.TemporaryDirectory, fileName);
|
|
|
|
splashScreen.Show();
|
|
splashScreen.BringToForeground();
|
|
splashScreen.SetIndeterminate();
|
|
splashScreen.UpdateStatus(TextKey.OperationStatus_InitializeSession, true);
|
|
|
|
logger.Info($"Allowed download request for configuration file '{fileName}'.");
|
|
}
|
|
else
|
|
{
|
|
args.AllowDownload = false;
|
|
logger.Info($"Denied download request for configuration file '{fileName}'.");
|
|
}
|
|
}
|
|
|
|
private void Browser_ConfigurationDownloadFinished(bool success, string url, string filePath = null)
|
|
{
|
|
if (success)
|
|
{
|
|
var communication = runtime.RequestReconfiguration(filePath, url);
|
|
|
|
if (communication.Success)
|
|
{
|
|
logger.Info($"Sent reconfiguration request for '{filePath}' to the runtime.");
|
|
}
|
|
else
|
|
{
|
|
logger.Error($"Failed to communicate reconfiguration request for '{filePath}'!");
|
|
messageBox.Show(TextKey.MessageBox_ReconfigurationError, TextKey.MessageBox_ReconfigurationErrorTitle, icon: MessageBoxIcon.Error, parent: splashScreen);
|
|
splashScreen.Hide();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
logger.Error($"Failed to download configuration file '{filePath}'!");
|
|
messageBox.Show(TextKey.MessageBox_ConfigurationDownloadError, TextKey.MessageBox_ConfigurationDownloadErrorTitle, icon: MessageBoxIcon.Error, parent: splashScreen);
|
|
splashScreen.Hide();
|
|
}
|
|
}
|
|
|
|
private void Browser_SessionIdentifierDetected(string identifier)
|
|
{
|
|
if (Settings.SessionMode == SessionMode.Server)
|
|
{
|
|
var response = Server.SendSessionIdentifier(identifier);
|
|
|
|
while (!response.Success)
|
|
{
|
|
logger.Error($"Failed to communicate session identifier with server! {response.Message}");
|
|
Thread.Sleep(Settings.Server.RequestAttemptInterval);
|
|
response = Server.SendSessionIdentifier(identifier);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Browser_TerminationRequested()
|
|
{
|
|
logger.Info("Attempting to shutdown as requested by the browser...");
|
|
TryRequestShutdown();
|
|
}
|
|
|
|
private void ClientHost_ExamSelectionRequested(ExamSelectionRequestEventArgs args)
|
|
{
|
|
logger.Info($"Received exam selection request with id '{args.RequestId}'.");
|
|
|
|
var exams = args.Exams.Select(e => new Exam { Id = e.id, LmsName = e.lms, Name = e.name, Url = e.url });
|
|
var dialog = uiFactory.CreateExamSelectionDialog(exams);
|
|
var result = dialog.Show();
|
|
|
|
runtime.SubmitExamSelectionResult(args.RequestId, result.Success, result.SelectedExam?.Id);
|
|
logger.Info($"Exam selection request with id '{args.RequestId}' is complete.");
|
|
}
|
|
|
|
private void ClientHost_MessageBoxRequested(MessageBoxRequestEventArgs args)
|
|
{
|
|
logger.Info($"Received message box request with id '{args.RequestId}'.");
|
|
|
|
var action = (MessageBoxAction) args.Action;
|
|
var icon = (MessageBoxIcon) args.Icon;
|
|
var result = messageBox.Show(args.Message, args.Title, action, icon, parent: splashScreen);
|
|
|
|
runtime.SubmitMessageBoxResult(args.RequestId, (int) result);
|
|
logger.Info($"Message box request with id '{args.RequestId}' yielded result '{result}'.");
|
|
}
|
|
|
|
private void ClientHost_PasswordRequested(PasswordRequestEventArgs args)
|
|
{
|
|
var message = default(TextKey);
|
|
var title = default(TextKey);
|
|
|
|
logger.Info($"Received input request with id '{args.RequestId}' for the {args.Purpose.ToString().ToLower()} password.");
|
|
|
|
switch (args.Purpose)
|
|
{
|
|
case PasswordRequestPurpose.LocalAdministrator:
|
|
message = TextKey.PasswordDialog_LocalAdminPasswordRequired;
|
|
title = TextKey.PasswordDialog_LocalAdminPasswordRequiredTitle;
|
|
break;
|
|
case PasswordRequestPurpose.LocalSettings:
|
|
message = TextKey.PasswordDialog_LocalSettingsPasswordRequired;
|
|
title = TextKey.PasswordDialog_LocalSettingsPasswordRequiredTitle;
|
|
break;
|
|
case PasswordRequestPurpose.Settings:
|
|
message = TextKey.PasswordDialog_SettingsPasswordRequired;
|
|
title = TextKey.PasswordDialog_SettingsPasswordRequiredTitle;
|
|
break;
|
|
}
|
|
|
|
var dialog = uiFactory.CreatePasswordDialog(text.Get(message), text.Get(title));
|
|
var result = dialog.Show();
|
|
|
|
runtime.SubmitPassword(args.RequestId, result.Success, result.Password);
|
|
logger.Info($"Password request with id '{args.RequestId}' was {(result.Success ? "successful" : "aborted by the user")}.");
|
|
}
|
|
|
|
private void ClientHost_ReconfigurationAborted()
|
|
{
|
|
logger.Info("The reconfiguration was aborted by the runtime.");
|
|
splashScreen.Hide();
|
|
}
|
|
|
|
private void ClientHost_ReconfigurationDenied(ReconfigurationEventArgs args)
|
|
{
|
|
logger.Info($"The reconfiguration request for '{args.ConfigurationPath}' was denied by the runtime!");
|
|
messageBox.Show(TextKey.MessageBox_ReconfigurationDenied, TextKey.MessageBox_ReconfigurationDeniedTitle, parent: splashScreen);
|
|
splashScreen.Hide();
|
|
}
|
|
|
|
private void ClientHost_ServerFailureActionRequested(ServerFailureActionRequestEventArgs args)
|
|
{
|
|
logger.Info($"Received server failure action request with id '{args.RequestId}'.");
|
|
|
|
var dialog = uiFactory.CreateServerFailureDialog(args.Message, args.ShowFallback);
|
|
var result = dialog.Show(splashScreen);
|
|
|
|
runtime.SubmitServerFailureActionResult(args.RequestId, result.Abort, result.Fallback, result.Retry);
|
|
logger.Info($"Server failure action request with id '{args.RequestId}' is complete.");
|
|
}
|
|
|
|
private void ClientHost_Shutdown()
|
|
{
|
|
shutdown.Invoke();
|
|
}
|
|
|
|
private void DisplayMonitor_DisplaySettingsChanged()
|
|
{
|
|
logger.Info("Re-initializing working area...");
|
|
displayMonitor.InitializePrimaryDisplay(Settings.Taskbar.EnableTaskbar ? taskbar.GetAbsoluteHeight() : 0);
|
|
logger.Info("Re-initializing shell...");
|
|
actionCenter.InitializeBounds();
|
|
taskbar.InitializeBounds();
|
|
logger.Info("Desktop successfully restored.");
|
|
|
|
if (!displayMonitor.ValidateConfiguration(Settings.Display).IsAllowed)
|
|
{
|
|
var continueOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_DisplayConfigurationContinueOption) };
|
|
var terminateOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_DisplayConfigurationTerminateOption) };
|
|
var message = text.Get(TextKey.LockScreen_DisplayConfigurationMessage);
|
|
var title = text.Get(TextKey.LockScreen_Title);
|
|
var result = ShowLockScreen(message, title, new[] { continueOption, terminateOption });
|
|
|
|
if (result.OptionId == terminateOption.Id)
|
|
{
|
|
logger.Info("Attempting to shutdown as requested by the user...");
|
|
TryRequestShutdown();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Operations_ActionRequired(ActionRequiredEventArgs args)
|
|
{
|
|
switch (args)
|
|
{
|
|
case ApplicationNotFoundEventArgs a:
|
|
AskForApplicationPath(a);
|
|
break;
|
|
case ApplicationInitializationFailedEventArgs a:
|
|
InformAboutFailedApplicationInitialization(a);
|
|
break;
|
|
case ApplicationTerminationEventArgs a:
|
|
AskForAutomaticApplicationTermination(a);
|
|
break;
|
|
case ApplicationTerminationFailedEventArgs a:
|
|
InformAboutFailedApplicationTermination(a);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void Operations_ProgressChanged(ProgressChangedEventArgs args)
|
|
{
|
|
if (args.CurrentValue.HasValue)
|
|
{
|
|
splashScreen.SetValue(args.CurrentValue.Value);
|
|
}
|
|
|
|
if (args.IsIndeterminate == true)
|
|
{
|
|
splashScreen.SetIndeterminate();
|
|
}
|
|
|
|
if (args.MaxValue.HasValue)
|
|
{
|
|
splashScreen.SetMaxValue(args.MaxValue.Value);
|
|
}
|
|
|
|
if (args.Progress == true)
|
|
{
|
|
splashScreen.Progress();
|
|
}
|
|
|
|
if (args.Regress == true)
|
|
{
|
|
splashScreen.Regress();
|
|
}
|
|
}
|
|
|
|
private void Operations_StatusChanged(TextKey status)
|
|
{
|
|
splashScreen.UpdateStatus(status, true);
|
|
}
|
|
|
|
private void Runtime_ConnectionLost()
|
|
{
|
|
logger.Error("Lost connection to the runtime!");
|
|
messageBox.Show(TextKey.MessageBox_ApplicationError, TextKey.MessageBox_ApplicationErrorTitle, icon: MessageBoxIcon.Error);
|
|
|
|
shutdown.Invoke();
|
|
}
|
|
|
|
private void Server_TerminationRequested()
|
|
{
|
|
logger.Info("Attempting to shutdown as requested by the server...");
|
|
TryRequestShutdown();
|
|
}
|
|
|
|
private void Shell_QuitButtonClicked(System.ComponentModel.CancelEventArgs args)
|
|
{
|
|
PauseActivators();
|
|
args.Cancel = !TryInitiateShutdown();
|
|
ResumeActivators();
|
|
}
|
|
|
|
private void SystemMonitor_SessionSwitched()
|
|
{
|
|
var allow = !Settings.Service.IgnoreService && (!Settings.Service.DisableUserLock || !Settings.Service.DisableUserSwitch);
|
|
var message = text.Get(TextKey.LockScreen_UserSessionMessage);
|
|
var title = text.Get(TextKey.LockScreen_Title);
|
|
var continueOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_UserSessionContinueOption) };
|
|
var terminateOption = new LockScreenOption { Text = text.Get(TextKey.LockScreen_UserSessionTerminateOption) };
|
|
|
|
if (allow)
|
|
{
|
|
logger.Info("Detected user session switch, but user lock and/or user switch are allowed.");
|
|
}
|
|
else
|
|
{
|
|
logger.Warn("Detected user session switch!");
|
|
|
|
if (!sessionLocked)
|
|
{
|
|
sessionLocked = true;
|
|
|
|
var result = ShowLockScreen(message, title, new[] { continueOption, terminateOption });
|
|
|
|
if (result.OptionId == terminateOption.Id)
|
|
{
|
|
logger.Info("Attempting to shutdown as requested by the user...");
|
|
TryRequestShutdown();
|
|
}
|
|
|
|
sessionLocked = false;
|
|
}
|
|
else
|
|
{
|
|
logger.Info("Lock screen is already active.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TerminationActivator_Activated()
|
|
{
|
|
PauseActivators();
|
|
TryInitiateShutdown();
|
|
ResumeActivators();
|
|
}
|
|
|
|
private void AskForAutomaticApplicationTermination(ApplicationTerminationEventArgs args)
|
|
{
|
|
var nl = Environment.NewLine;
|
|
var applicationList = string.Join(Environment.NewLine, args.RunningApplications.Select(a => a.Name));
|
|
var warning = text.Get(TextKey.MessageBox_ApplicationAutoTerminationDataLossWarning);
|
|
var message = $"{text.Get(TextKey.MessageBox_ApplicationAutoTerminationQuestion)}{nl}{nl}{warning}{nl}{nl}{applicationList}";
|
|
var title = text.Get(TextKey.MessageBox_ApplicationAutoTerminationQuestionTitle);
|
|
var result = messageBox.Show(message, title, MessageBoxAction.YesNo, MessageBoxIcon.Question, parent: splashScreen);
|
|
|
|
args.TerminateProcesses = result == MessageBoxResult.Yes;
|
|
}
|
|
|
|
private void AskForApplicationPath(ApplicationNotFoundEventArgs args)
|
|
{
|
|
var message = text.Get(TextKey.FolderDialog_ApplicationLocation).Replace("%%NAME%%", args.DisplayName).Replace("%%EXECUTABLE%%", args.ExecutableName);
|
|
var result = fileSystemDialog.Show(FileSystemElement.Folder, FileSystemOperation.Open, message: message, parent: splashScreen);
|
|
|
|
if (result.Success)
|
|
{
|
|
args.CustomPath = result.FullPath;
|
|
args.Success = true;
|
|
}
|
|
}
|
|
|
|
private void InformAboutFailedApplicationInitialization(ApplicationInitializationFailedEventArgs args)
|
|
{
|
|
var messageKey = TextKey.MessageBox_ApplicationInitializationFailure;
|
|
var titleKey = TextKey.MessageBox_ApplicationInitializationFailureTitle;
|
|
|
|
switch (args.Result)
|
|
{
|
|
case FactoryResult.NotFound:
|
|
messageKey = TextKey.MessageBox_ApplicationNotFound;
|
|
titleKey = TextKey.MessageBox_ApplicationNotFoundTitle;
|
|
break;
|
|
}
|
|
|
|
var message = text.Get(messageKey).Replace("%%NAME%%", $"'{args.DisplayName}' ({args.ExecutableName})");
|
|
var title = text.Get(titleKey);
|
|
|
|
messageBox.Show(message, title, icon: MessageBoxIcon.Error, parent: splashScreen);
|
|
}
|
|
|
|
private void InformAboutFailedApplicationTermination(ApplicationTerminationFailedEventArgs args)
|
|
{
|
|
var applicationList = string.Join(Environment.NewLine, args.Applications.Select(a => a.Name));
|
|
var message = $"{text.Get(TextKey.MessageBox_ApplicationTerminationFailure)}{Environment.NewLine}{Environment.NewLine}{applicationList}";
|
|
var title = text.Get(TextKey.MessageBox_ApplicationTerminationFailureTitle);
|
|
|
|
messageBox.Show(message, title, icon: MessageBoxIcon.Error, parent: splashScreen);
|
|
}
|
|
|
|
private void PauseActivators()
|
|
{
|
|
foreach (var activator in context.Activators)
|
|
{
|
|
activator.Pause();
|
|
}
|
|
}
|
|
|
|
private void ResumeActivators()
|
|
{
|
|
foreach (var activator in context.Activators)
|
|
{
|
|
activator.Resume();
|
|
}
|
|
}
|
|
|
|
private LockScreenResult ShowLockScreen(string message, string title, IEnumerable<LockScreenOption> options)
|
|
{
|
|
var hasQuitPassword = !string.IsNullOrEmpty(Settings.Security.QuitPasswordHash);
|
|
var lockScreen = uiFactory.CreateLockScreen(message, title, options);
|
|
var result = default(LockScreenResult);
|
|
|
|
logger.Info("Showing lock screen...");
|
|
PauseActivators();
|
|
lockScreen.Show();
|
|
|
|
for (var unlocked = false; !unlocked;)
|
|
{
|
|
result = lockScreen.WaitForResult();
|
|
|
|
if (hasQuitPassword)
|
|
{
|
|
var passwordHash = hashAlgorithm.GenerateHashFor(result.Password);
|
|
var isCorrect = Settings.Security.QuitPasswordHash.Equals(passwordHash, StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (isCorrect)
|
|
{
|
|
logger.Info("The user entered the correct unlock password.");
|
|
unlocked = true;
|
|
}
|
|
else
|
|
{
|
|
logger.Info("The user entered the wrong unlock password.");
|
|
messageBox.Show(TextKey.MessageBox_InvalidUnlockPassword, TextKey.MessageBox_InvalidUnlockPasswordTitle, icon: MessageBoxIcon.Warning, parent: lockScreen);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
logger.Warn($"No unlock password is defined, allowing user to resume session!");
|
|
unlocked = true;
|
|
}
|
|
}
|
|
|
|
lockScreen.Close();
|
|
ResumeActivators();
|
|
logger.Info("Closed lock screen.");
|
|
|
|
return result;
|
|
}
|
|
|
|
private bool TryInitiateShutdown()
|
|
{
|
|
var hasQuitPassword = !string.IsNullOrEmpty(Settings.Security.QuitPasswordHash);
|
|
var requestShutdown = false;
|
|
var succes = false;
|
|
|
|
if (hasQuitPassword)
|
|
{
|
|
requestShutdown = TryValidateQuitPassword();
|
|
}
|
|
else
|
|
{
|
|
requestShutdown = TryConfirmShutdown();
|
|
}
|
|
|
|
if (requestShutdown)
|
|
{
|
|
succes = TryRequestShutdown();
|
|
}
|
|
|
|
return succes;
|
|
}
|
|
|
|
private bool TryConfirmShutdown()
|
|
{
|
|
var result = messageBox.Show(TextKey.MessageBox_Quit, TextKey.MessageBox_QuitTitle, MessageBoxAction.YesNo, MessageBoxIcon.Question);
|
|
var quit = result == MessageBoxResult.Yes;
|
|
|
|
if (quit)
|
|
{
|
|
logger.Info("The user chose to terminate the application.");
|
|
}
|
|
|
|
return quit;
|
|
}
|
|
|
|
private bool TryValidateQuitPassword()
|
|
{
|
|
var dialog = uiFactory.CreatePasswordDialog(TextKey.PasswordDialog_QuitPasswordRequired, TextKey.PasswordDialog_QuitPasswordRequiredTitle);
|
|
var result = dialog.Show();
|
|
|
|
if (result.Success)
|
|
{
|
|
var passwordHash = hashAlgorithm.GenerateHashFor(result.Password);
|
|
var isCorrect = Settings.Security.QuitPasswordHash.Equals(passwordHash, StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (isCorrect)
|
|
{
|
|
logger.Info("The user entered the correct quit password, the application will now terminate.");
|
|
}
|
|
else
|
|
{
|
|
logger.Info("The user entered the wrong quit password.");
|
|
messageBox.Show(TextKey.MessageBox_InvalidQuitPassword, TextKey.MessageBox_InvalidQuitPasswordTitle, icon: MessageBoxIcon.Warning);
|
|
}
|
|
|
|
return isCorrect;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryRequestShutdown()
|
|
{
|
|
var communication = runtime.RequestShutdown();
|
|
|
|
if (!communication.Success)
|
|
{
|
|
logger.Error("Failed to communicate shutdown request to the runtime!");
|
|
messageBox.Show(TextKey.MessageBox_QuitError, TextKey.MessageBox_QuitErrorTitle, icon: MessageBoxIcon.Error);
|
|
}
|
|
|
|
return communication.Success;
|
|
}
|
|
}
|
|
}
|