public FactoryResult TryCreate(WhitelistApplication settings, out IApplication application)
{
var name = $"'{settings.DisplayName}' ({ settings.ExecutableName})";
application = default(IApplication);
try
{
var success = TryFindApplication(settings, out var executablePath);
if (success)
{
application = BuildApplication(executablePath, settings);
application.Initialize();
logger.Debug($"Successfully initialized application {name}.");
return(FactoryResult.Success);
}
logger.Error($"Could not find application {name}!");
return(FactoryResult.NotFound);
}
catch (Exception e)
{
logger.Error($"Unexpected error while trying to initialize application {name}!", e);
}
return(FactoryResult.Error);
}
private IApplication BuildApplication(string executablePath, WhitelistApplication settings)
{
var applicationLogger = logger.CloneFor(settings.DisplayName);
var application = new ExternalApplication(applicationMonitor, executablePath, applicationLogger, nativeMethods, processFactory, settings);
return(application);
}
public void Perform_MustAbortIfUserCancelsApplicationLocationSelection()
{
var application = new Mock <IApplication>().Object;
var applicationSettings = new WhitelistApplication {
AllowCustomPath = true
};
var args = default(ActionRequiredEventArgs);
context.Settings.Applications.Whitelist.Add(applicationSettings);
factory.Setup(f => f.TryCreate(It.IsAny <WhitelistApplication>(), out application)).Returns(FactoryResult.NotFound);
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(new InitializationResult());
sut.ActionRequired += (a) =>
{
args = a;
if (a is ApplicationNotFoundEventArgs n)
{
n.Success = false;
}
};
var result = sut.Perform();
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == applicationSettings), out application), Times.Once);
Assert.AreEqual(OperationResult.Success, result);
Assert.IsInstanceOfType(args, typeof(ApplicationInitializationFailedEventArgs));
}
public void Perform_MustInitializeApplications()
{
var application1 = new Mock <IApplication>().Object;
var application2 = new Mock <IApplication>().Object;
var application3 = new Mock <IApplication>().Object;
var application1Settings = new WhitelistApplication();
var application2Settings = new WhitelistApplication();
var application3Settings = new WhitelistApplication();
context.Settings.Applications.Whitelist.Add(application1Settings);
context.Settings.Applications.Whitelist.Add(application2Settings);
context.Settings.Applications.Whitelist.Add(application3Settings);
factory.Setup(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application1Settings), out application1)).Returns(FactoryResult.Success);
factory.Setup(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application2Settings), out application2)).Returns(FactoryResult.Success);
factory.Setup(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application3Settings), out application3)).Returns(FactoryResult.Success);
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(new InitializationResult());
var result = sut.Perform();
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application1Settings), out application1), Times.Once);
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application1Settings), out application2), Times.Once);
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == application1Settings), out application3), Times.Once);
monitor.Verify(m => m.Initialize(It.Is <ApplicationSettings>(s => s == context.Settings.Applications)), Times.Once);
monitor.Verify(m => m.TryTerminate(It.IsAny <RunningApplication>()), Times.Never);
Assert.AreEqual(OperationResult.Success, result);
}
public void Perform_MustAllowUserToChooseApplicationLocation()
{
var application = new Mock <IApplication>().Object;
var applicationSettings = new WhitelistApplication {
AllowCustomPath = true
};
var args = default(ActionRequiredEventArgs);
var attempt = 0;
var correct = new Random().Next(2, 50);
var factoryResult = new Func <FactoryResult>(() => ++ attempt == correct ? FactoryResult.Success : FactoryResult.NotFound);
context.Settings.Applications.Whitelist.Add(applicationSettings);
factory.Setup(f => f.TryCreate(It.IsAny <WhitelistApplication>(), out application)).Returns(factoryResult);
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(new InitializationResult());
sut.ActionRequired += (a) =>
{
args = a;
if (a is ApplicationNotFoundEventArgs n)
{
n.Success = true;
}
};
var result = sut.Perform();
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == applicationSettings), out application), Times.Exactly(correct));
Assert.AreEqual(OperationResult.Success, result);
Assert.IsInstanceOfType(args, typeof(ApplicationNotFoundEventArgs));
}
private void Initialize(WhitelistApplication settings)
{
var result = factory.TryCreate(settings, out var application);
while (result == FactoryResult.NotFound && settings.AllowCustomPath)
{
var args = new ApplicationNotFoundEventArgs(settings.DisplayName, settings.ExecutableName);
ActionRequired?.Invoke(args);
if (args.Success)
{
settings.ExecutablePath = args.CustomPath;
result = factory.TryCreate(settings, out application);
}
else
{
break;
}
}
if (result == FactoryResult.Success)
{
Context.Applications.Add(application);
}
else
{
logger.Error($"Failed to initialize application '{settings.DisplayName}' ({settings.ExecutableName}). Reason: {result}.");
ActionRequired?.Invoke(new ApplicationInitializationFailedEventArgs(settings.DisplayName, settings.ExecutableName, result));
}
}
private bool BelongsToApplication(IProcess process, WhitelistApplication application)
{
var ignoreOriginalName = string.IsNullOrWhiteSpace(application.OriginalName);
var sameName = process.Name.Equals(application.ExecutableName, StringComparison.OrdinalIgnoreCase);
var sameOriginalName = process.OriginalName?.Equals(application.OriginalName, StringComparison.OrdinalIgnoreCase) == true;
return(sameName && (ignoreOriginalName || sameOriginalName));
}
private bool TryFindApplication(WhitelistApplication settings, out string mainExecutable)
{
var paths = new List <string[]>();
var registryPath = QueryPathFromRegistry(settings);
mainExecutable = default(string);
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.System), settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.SystemX86), settings.ExecutableName });
paths.Add(new[] { Environment.GetEnvironmentVariable("MonitoPath"), settings.ExecutableName });
if (settings.ExecutablePath != default(string))
{
paths.Add(new[] { settings.ExecutablePath, settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), settings.ExecutablePath, settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), settings.ExecutablePath, settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.System), settings.ExecutablePath, settings.ExecutableName });
paths.Add(new[] { Environment.GetFolderPath(Environment.SpecialFolder.SystemX86), settings.ExecutablePath, settings.ExecutableName });
paths.Add(new[] { Environment.GetEnvironmentVariable("MonitoPath"), settings.ExecutablePath, settings.ExecutableName });
}
if (registryPath != default(string))
{
paths.Add(new[] { registryPath, settings.ExecutableName });
if (settings.ExecutablePath != default(string))
{
paths.Add(new[] { registryPath, settings.ExecutablePath, settings.ExecutableName });
}
}
foreach (var path in paths)
{
try
{
mainExecutable = Path.Combine(path);
mainExecutable = Environment.ExpandEnvironmentVariables(mainExecutable);
if (File.Exists(mainExecutable))
{
return(true);
}
}
catch (Exception e)
{
logger.Error($"Failed to test path {string.Join(@"\", path)}!", e);
}
}
return(false);
}
internal ExternalApplication(
IApplicationMonitor applicationMonitor,
string executablePath,
IModuleLogger logger,
INativeMethods nativeMethods,
IProcessFactory processFactory,
WhitelistApplication settings)
{
this.applicationMonitor = applicationMonitor;
this.executablePath = executablePath;
this.logger = logger;
this.nativeMethods = nativeMethods;
this.instances = new List <ExternalApplicationInstance>();
this.processFactory = processFactory;
this.settings = settings;
}
public void Perform_MustIndicateApplicationInitializationFailure()
{
var application = new Mock <IApplication>().Object;
var applicationSettings = new WhitelistApplication();
var args = default(ActionRequiredEventArgs);
context.Settings.Applications.Whitelist.Add(applicationSettings);
factory.Setup(f => f.TryCreate(It.IsAny <WhitelistApplication>(), out application)).Returns(FactoryResult.Error);
monitor.Setup(m => m.Initialize(It.IsAny <ApplicationSettings>())).Returns(new InitializationResult());
sut.ActionRequired += (a) => args = a;
var result = sut.Perform();
factory.Verify(f => f.TryCreate(It.Is <WhitelistApplication>(a => a == applicationSettings), out application), Times.Once);
Assert.AreEqual(OperationResult.Success, result);
Assert.IsInstanceOfType(args, typeof(ApplicationInitializationFailedEventArgs));
}
private string QueryPathFromRegistry(WhitelistApplication settings)
{
try
{
using (var key = Registry.LocalMachine.OpenSubKey($@"SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\{settings.ExecutableName}"))
{
if (key != null)
{
return(key.GetValue("Path") as string);
}
}
}
catch (Exception e)
{
logger.Error($"Failed to query path in registry for '{settings.ExecutableName}'!", e);
}
return(default(string));
}
public void Perform_MustNotAddApplicationsToShellIfNotEnabled()
{
var application1 = new Mock <IApplication>();
var application1Settings = new WhitelistApplication {
ShowInShell = true
};
var application2 = new Mock <IApplication>();
var application2Settings = new WhitelistApplication {
ShowInShell = true
};
var application3 = new Mock <IApplication>();
var application3Settings = new WhitelistApplication {
ShowInShell = true
};
application1.SetupGet(a => a.Id).Returns(application1Settings.Id);
application2.SetupGet(a => a.Id).Returns(application2Settings.Id);
application3.SetupGet(a => a.Id).Returns(application3Settings.Id);
context.Applications.Add(application1.Object);
context.Applications.Add(application2.Object);
context.Applications.Add(application3.Object);
context.Settings.ActionCenter.EnableActionCenter = false;
context.Settings.Taskbar.EnableTaskbar = false;
context.Settings.Applications.Whitelist.Add(application1Settings);
context.Settings.Applications.Whitelist.Add(application2Settings);
context.Settings.Applications.Whitelist.Add(application3Settings);
sut.Perform();
actionCenter.Verify(a => a.AddApplicationControl(It.IsAny <IApplicationControl>(), false), Times.Never);
taskbar.Verify(t => t.AddApplicationControl(It.IsAny <IApplicationControl>(), false), Times.Never);
taskview.Verify(t => t.Add(It.Is <IApplication>(a => a == application1.Object)), Times.Once);
taskview.Verify(t => t.Add(It.Is <IApplication>(a => a == application2.Object)), Times.Once);
taskview.Verify(t => t.Add(It.Is <IApplication>(a => a == application3.Object)), Times.Once);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application1.Object), Location.ActionCenter), Times.Never);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application1.Object), Location.Taskbar), Times.Never);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application2.Object), Location.ActionCenter), Times.Never);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application2.Object), Location.Taskbar), Times.Never);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application3.Object), Location.ActionCenter), Times.Never);
uiFactory.Verify(f => f.CreateApplicationControl(It.Is <IApplication>(a => a == application3.Object), Location.Taskbar), Times.Never);
}
public void MustRemoveLegacyBrowserEngines()
{
var settings = new AppSettings();
var firefox = new WhitelistApplication {
ExecutablePath = @"C:\Program Files (x86)\Mozilla Firefox", ExecutableName = "firefox.exe"
};
settings.Applications.Whitelist.Add(new WhitelistApplication {
ExecutablePath = @"C:\some\path\xulrunner\etc", ExecutableName = "firefox.exe"
});
settings.Applications.Whitelist.Add(new WhitelistApplication {
ExecutablePath = @"C:\some\path\xulrunner\etc", ExecutableName = "xulrunner.exe"
});
settings.Applications.Whitelist.Add(firefox);
sut.Process(Mock.Of <IDictionary <string, object> >(), settings);
Assert.AreEqual(1, settings.Applications.Whitelist.Count);
Assert.AreSame(firefox, settings.Applications.Whitelist[0]);
}
private void MapApplicationWhitelist(AppSettings settings, object value)
{
if (value is IList <object> applications)
{
foreach (var item in applications)
{
if (item is IDictionary <string, object> applicationData)
{
var isActive = applicationData.TryGetValue(Keys.Applications.Active, out var v) && v is bool active && active;
var isWindowsProcess = applicationData.TryGetValue(Keys.Applications.OperatingSystem, out v) && v is int os && os == Keys.WINDOWS;
if (isActive && isWindowsProcess)
{
var application = new WhitelistApplication();
if (applicationData.TryGetValue(Keys.Applications.AllowCustomPath, out v) && v is bool allowCustomPath)
{
application.AllowCustomPath = allowCustomPath;
}
if (applicationData.TryGetValue(Keys.Applications.AllowRunning, out v) && v is bool allowRunning)
{
application.AllowRunning = allowRunning;
}
if (applicationData.TryGetValue(Keys.Applications.Arguments, out v) && v is IList <object> arguments)
{
foreach (var argumentItem in arguments)
{
if (argumentItem is IDictionary <string, object> argumentData)
{
var argActive = argumentData.TryGetValue(Keys.Applications.Active, out v) && v is bool a && a;
if (argActive && argumentData.TryGetValue(Keys.Applications.Argument, out v) && v is string argument)
{
application.Arguments.Add(argument);
}
}
}
}
if (applicationData.TryGetValue(Keys.Applications.AutoStart, out v) && v is bool autoStart)
{
application.AutoStart = autoStart;
}
if (applicationData.TryGetValue(Keys.Applications.AutoTerminate, out v) && v is bool autoTerminate)
{
application.AutoTerminate = autoTerminate;
}
if (applicationData.TryGetValue(Keys.Applications.Description, out v) && v is string description)
{
application.Description = description;
}
if (applicationData.TryGetValue(Keys.Applications.DisplayName, out v) && v is string displayName)
{
application.DisplayName = displayName;
}
if (applicationData.TryGetValue(Keys.Applications.ExecutableName, out v) && v is string executableName)
{
application.ExecutableName = executableName;
}
if (applicationData.TryGetValue(Keys.Applications.ExecutablePath, out v) && v is string executablePath)
{
application.ExecutablePath = executablePath;
}
if (applicationData.TryGetValue(Keys.Applications.OriginalName, out v) && v is string originalName)
{
application.OriginalName = originalName;
}
if (applicationData.TryGetValue(Keys.Applications.ShowInShell, out v) && v is bool showInShell)
{
application.ShowInShell = showInShell;
}
settings.Applications.Whitelist.Add(application);
}
}
}
}
}
