From 067e8ca0623f9ee7c6f80989e9bff2412ca02341 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 11:41:30 +0000 Subject: [PATCH] fix(setup): change only what starts a program setup installed; Server only inside Program Files Services, sign-in entries and shortcuts are matched against the full paths of the files the install log or the payload lists, never against everything under the install folder: an install into a shared folder such as D:\Apps or /DIR="C:\Program Files" no longer stops, starts or deletes other vendors' services or removes their Run values. The elevated step now takes the names the unelevated setup found (/SERVICES=... /NAMES=...) and reads each service again, acting only when it still starts a program of the folder's log or of its own payload (or, for Prune, a program of the folder that is gone). Programs are asked to close before any service is touched. On uninstall the services are deleted only once the programs have closed, just before the files go; a failed install or uninstall starts again the services it stopped, and after an upgrade setup starts exactly the services it stopped, whatever their start type. The Server component installs only for all users in a folder inside Program Files. In the window a custom folder outside it is invalid while the Server is selected, with a tooltip saying why; silent mode refuses it. An upgrade of an installation elsewhere cannot add the Server, and one it carried is dropped with its service. Sign-in entries use StartupCommand (the same file as on fix/shell-notify) and are removed by SetupRegistry.DeleteStartupEntries only when the client's or the Uploader's value starts a program the install log lists; an upgrade that drops a program removes its entry too. StartupEntries is gone. A shortcut that starts another product's existing copy is still left alone but now logged; uninstalling the product it starts hands it to another product of the same scope that lists it and has the same program, so the Uploader that stays keeps its shortcuts. Another registered Titano installation whose folder or log cannot be read now counts as using every program's data, so "Remove my data" never offers it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- deploy/releases-repo/README.md | 2 +- i18n/en/Tooltips.resx | 2 + i18n/it/Tooltips.it.resx | 2 + src/Titano.Core/IO/StartupCommand.cs | 61 +++++ src/Titano.Setup/Cli/SetupArguments.cs | 12 +- src/Titano.Setup/Engine/CommandProgram.cs | 33 ++- src/Titano.Setup/Engine/InstallEngine.cs | 45 +++- src/Titano.Setup/Engine/InstallLog.cs | 5 +- src/Titano.Setup/Engine/InstallPlan.cs | 44 ++-- src/Titano.Setup/Engine/InstalledServices.cs | 217 ++++++++++++------ src/Titano.Setup/Engine/SetupPaths.cs | 15 ++ src/Titano.Setup/Engine/SetupRegistry.cs | 49 +++- src/Titano.Setup/Engine/SilentSetup.cs | 89 +++++-- src/Titano.Setup/Engine/StartupEntries.cs | 46 ---- src/Titano.Setup/Engine/UninstallEngine.cs | 67 +++++- src/Titano.Setup/Engine/UserDataPlan.cs | 8 + src/Titano.Setup/Views/ComponentOption.cs | 12 +- src/Titano.Setup/Views/SetupViewModel.cs | 136 +++++++---- .../Infrastructure/StartupRegistration.cs | 9 +- .../Setup/SetupEngineTests.cs | 192 +++++++++++++--- .../Setup/UserDataPlanTests.cs | 12 + .../Foundation/StartupCommandTests.cs | 58 +++++ 22 files changed, 834 insertions(+), 282 deletions(-) create mode 100644 src/Titano.Core/IO/StartupCommand.cs delete mode 100644 src/Titano.Setup/Engine/StartupEntries.cs create mode 100644 tests/Titano.Core.Tests/Foundation/StartupCommandTests.cs diff --git a/deploy/releases-repo/README.md b/deploy/releases-repo/README.md index 83f3f7a6..b786e32f 100644 --- a/deploy/releases-repo/README.md +++ b/deploy/releases-repo/README.md @@ -42,7 +42,7 @@ for community review. Development happens elsewhere; please use the issues here in `SHA256SUMS` of the same release. 3. Run the setup. It installs for the current user into `%LOCALAPPDATA%\Programs\Titano` without administrator rights; choose *All users* to install into `Program Files` (Windows asks for permission). The *Server* component - runs as a Windows service, so choosing it installs for all users. + runs as a Windows service, so choosing it installs for all users, in a folder inside `Program Files`. - **Upgrade:** Titano checks this repository at start (you can turn this off in Settings › Updates) and shows a notice when a new version exists. *Download* fetches the setup, verifies it against `SHA256SUMS` and shows it in Explorer; diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx index 7c28df55..75f740b4 100644 --- a/i18n/en/Tooltips.resx +++ b/i18n/en/Tooltips.resx @@ -577,6 +577,7 @@ Add shortcuts to the desktop Where the programs are installed · your data stays in its own folder Enter a full folder path that is not a drive root or a system folder + {0} runs as a Windows service, so choose a folder inside Program Files Copy the selected programs and register them with Windows Folder of the installed programs Install in your user folder · no administrator rights needed @@ -586,6 +587,7 @@ Open the installed program Already installed here · uninstall it first to change folder or scope Runs as a Windows service, so it installs for all users only · this copy is installed for you alone; uninstall it first to add it + Runs as a Windows service, so it installs inside Program Files only · this copy is installed elsewhere; uninstall it first to add it Select at least one program to install Also delete %LOCALAPPDATA%\Titano: database, backups, cache, settings, logs, the uploader queue and sign-in · photos in archives are kept Also delete Titano’s database, backups, cache, settings and logs in %LOCALAPPDATA%\Titano · the Uploader’s files and photos in archives are kept diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx index bfa8bc87..6dedbcb0 100644 --- a/i18n/it/Tooltips.it.resx +++ b/i18n/it/Tooltips.it.resx @@ -577,6 +577,7 @@ Aggiungi collegamenti al desktop Dove vengono installati i programmi · i tuoi dati restano nella loro cartella Inserisci il percorso completo di una cartella che non sia la radice di un'unità o una cartella di sistema + {0} è un servizio di Windows, quindi scegli una cartella dentro Programmi Copia i programmi selezionati e registrali in Windows Cartella dei programmi installati Installa nella tua cartella utente · non servono diritti di amministratore @@ -586,6 +587,7 @@ Apri il programma installato Già installato qui · disinstallalo prima per cambiare cartella o ambito È un servizio di Windows, quindi si installa solo per tutti gli utenti · questa copia è installata solo per te; disinstallala prima per aggiungerlo + È un servizio di Windows, quindi si installa solo dentro Programmi · questa copia è installata altrove; disinstallala prima per aggiungerlo Seleziona almeno un programma da installare Elimina anche %LOCALAPPDATA%\Titano: database, backup, cache, impostazioni, log, coda e accesso dell'uploader · le foto negli archivi restano Elimina anche database, backup, cache, impostazioni e log di Titano in %LOCALAPPDATA%\Titano · i file dell'uploader e le foto negli archivi restano diff --git a/src/Titano.Core/IO/StartupCommand.cs b/src/Titano.Core/IO/StartupCommand.cs new file mode 100644 index 00000000..6e023874 --- /dev/null +++ b/src/Titano.Core/IO/StartupCommand.cs @@ -0,0 +1,61 @@ +namespace Titano.Core.IO; + +/// +/// The sign-in entries of Titano's programs: HKCU\Software\Microsoft\Windows\CurrentVersion\Run values whose +/// command starts one executable with one option ("C:\…\Titano.exe" --minimized). Shared by the programs that +/// write them and the uninstaller that removes them; the paths are Windows paths, compared ignoring case. +/// +public static class StartupCommand +{ + public const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run"; + + /// The client's value (Settings › General › Startup). + public const string ClientValue = "Titano"; + + /// The Uploader's value (its "Start with Windows"). + public const string UploaderValue = "Titano Uploader"; + + /// The command that starts with . + public static string Format(string executable, string option) => $"\"{executable}\" {option}"; + + /// + /// The program starts: its quoted first part, or the text up to the first space when it + /// is not quoted; null for an empty or malformed command. + /// + public static string? Executable(string? command) + { + var text = command?.Trim(); + if (string.IsNullOrEmpty(text)) return null; + if (text[0] == '"') + { + var end = text.IndexOf('"', 1); + return end > 1 ? text[1..end] : null; + } + var space = text.IndexOf(' ', StringComparison.Ordinal); + return space < 0 ? text : text[..space]; + } + + /// starts , not another copy of the program. + public static bool Starts(string? command, string? executable) => + executable is { Length: > 0 } && string.Equals(Executable(command), executable, StringComparison.OrdinalIgnoreCase); + + /// The program starts lies in or one of its folders. + public static bool StartsFrom(string? command, string directory) + { + ArgumentNullException.ThrowIfNull(directory); + var folder = directory.TrimEnd('\\', '/'); + return Executable(command) is { } exe && folder.Length > 0 && exe.Length > folder.Length + 1 + && exe.StartsWith(folder, StringComparison.OrdinalIgnoreCase) && exe[folder.Length] is '\\' or '/'; + } + + /// The folder of the program starts; null when it names none. + public static string? Folder(string? command) => Executable(command) is { } exe ? FolderOf(exe) : null; + + /// The folder part of a Windows path (on any platform); null when it has none. + public static string? FolderOf(string path) + { + ArgumentNullException.ThrowIfNull(path); + var slash = path.LastIndexOfAny(['\\', '/']); + return slash > 0 ? path[..slash] : null; + } +} diff --git a/src/Titano.Setup/Cli/SetupArguments.cs b/src/Titano.Setup/Cli/SetupArguments.cs index 52f52c29..4695f2ea 100644 --- a/src/Titano.Setup/Cli/SetupArguments.cs +++ b/src/Titano.Setup/Cli/SetupArguments.cs @@ -8,8 +8,8 @@ namespace Titano.Setup.Cli; /// /S silent · /DIR=path · /COMPONENTS=Titano,Uploader · /ALLUSERS · /NODESKTOP · /// /NOSTARTMENU · /LAUNCH · /LANG=it · /uninstall. /// Internal: /ELEVATED (relaunched for administrator rights), /CLEANUP=path /WAITPID=n (removes the -/// uninstaller after the uninstall process exits), /SERVICES=stop,prune,start,remove /DIR=path (the elevated -/// step that stops, starts or deletes the Windows services of an installation). +/// uninstaller after the uninstall process exits), /SERVICES=stop,prune,start,remove /NAMES=a,b /DIR=path (the +/// elevated step that stops, starts or deletes the named Windows services of an installation). /// internal sealed record SetupArguments { @@ -27,6 +27,9 @@ internal sealed record SetupArguments public int WaitProcessId { get; init; } public ServiceActions Services { get; init; } + /// The services applies to (key names, as the unelevated setup found them). + public IReadOnlyList? ServiceNames { get; init; } + /// Parses ; throws for unknown or malformed switches. public static SetupArguments Parse(IEnumerable args) { @@ -52,11 +55,13 @@ internal sealed record SetupArguments ("CLEANUP", { Length: > 0 }) => result with { CleanupTarget = value.Trim('"') }, ("WAITPID", { Length: > 0 }) when int.TryParse(value, out var pid) && pid > 0 => result with { WaitProcessId = pid }, ("SERVICES", { Length: > 0 }) => result with { Services = ParseServices(value) }, + ("NAMES", { Length: > 0 }) => result with { ServiceNames = value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) }, _ => throw new ArgumentException($"Unknown or malformed switch '{arg}'."), }; } if (result.CleanupTarget is not null && result.WaitProcessId == 0) throw new ArgumentException("/CLEANUP needs /WAITPID."); - if (result.Services != ServiceActions.None && result.Directory is null) throw new ArgumentException("/SERVICES needs /DIR."); + if (result.Services != ServiceActions.None && (result.Directory is null || result.ServiceNames is not { Count: > 0 })) + throw new ArgumentException("/SERVICES needs /DIR and /NAMES."); return result; } @@ -73,6 +78,7 @@ internal sealed record SetupArguments if (Launch) yield return "/LAUNCH"; if (Language is not null) yield return "/LANG=" + Language; if (Services != ServiceActions.None) yield return "/SERVICES=" + Services.ToString().Replace(" ", string.Empty, StringComparison.Ordinal).ToLowerInvariant(); + if (ServiceNames is not null) yield return "/NAMES=" + string.Join(',', ServiceNames); if (Elevated) yield return "/ELEVATED"; } diff --git a/src/Titano.Setup/Engine/CommandProgram.cs b/src/Titano.Setup/Engine/CommandProgram.cs index a734fbce..31d98946 100644 --- a/src/Titano.Setup/Engine/CommandProgram.cs +++ b/src/Titano.Setup/Engine/CommandProgram.cs @@ -1,8 +1,13 @@ using System.IO; +using Titano.Core.Packaging; namespace Titano.Setup.Engine; -/// The program a command line registered with Windows starts: a service's image path, a Run value. +/// +/// The program a command line registered with Windows starts (a service's image path, a Run value), and whether it is +/// one setup installed: setup changes only what starts a program its log or payload lists, never another program +/// that happens to live in the same folder. +/// internal static class CommandProgram { /// @@ -18,8 +23,30 @@ internal static class CommandProgram return first is not null && Path.IsPathFullyQualified(first) ? first : null; } - /// True when starts a program inside . - public static bool IsInside(string commandLine, string directory) => Of(commandLine) is { } program && IsPathInside(program, directory); + /// + /// Full paths of (an install log's or a manifest's files) under + /// , compared ignoring case: the programs setup installs or installed there. + /// + public static IReadOnlySet FullPaths(string directory, IEnumerable payloadPaths) + { + var paths = new HashSet(StringComparer.OrdinalIgnoreCase); + foreach (var path in payloadPaths.Where(PayloadPath.IsValid)) paths.Add(PayloadPath.Resolve(directory, path)); + return paths; + } + + /// True when (a full path, in any form Windows accepts) is one of . + public static bool IsAmong(string? program, IReadOnlySet programs) + { + if (string.IsNullOrEmpty(program) || !Path.IsPathFullyQualified(program)) return false; + try + { + return programs.Contains(Path.GetFullPath(program)); + } + catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException) + { + return false; + } + } /// that answers false for a path Windows cannot normalise. public static bool IsPathInside(string path, string directory) diff --git a/src/Titano.Setup/Engine/InstallEngine.cs b/src/Titano.Setup/Engine/InstallEngine.cs index 88cf5597..ca050ccc 100644 --- a/src/Titano.Setup/Engine/InstallEngine.cs +++ b/src/Titano.Setup/Engine/InstallEngine.cs @@ -74,7 +74,7 @@ internal sealed class InstallEngine(PayloadReader payload) // Saved before registration so that an uninstall can always undo whatever follows. log.Save(directory); - foreach (var (link, target, name) in shortcuts) ShellLink.Create(link, target, name); + foreach (var (link, target, name, _) in shortcuts.Where(s => s.Create)) ShellLink.Create(link, target, name); foreach (var a in fileTypes) SetupRegistry.RegisterFileType(request.Scope, a.Extension, a.ProgId, FileTypeName(a), PayloadPath.Resolve(directory, a.Target)); if (fileTypes.Count > 0 || previous?.Associations.Count > 0) NativeMethods.NotifyAssociationsChanged(); @@ -105,14 +105,15 @@ internal sealed class InstallEngine(PayloadReader payload) : null; /// - /// The shortcuts to create. A shortcut of the same name that starts an existing program elsewhere (the same - /// program installed by another Titano product, or the user's own) is left as it is and not logged, so neither - /// install retargets or removes the other's. + /// The shortcuts to log, and among them those to create. A shortcut of the same name that starts an existing program + /// elsewhere (the same program installed by another Titano product, or the user's own) is left as it is but logged: + /// neither install retargets or removes the other's, and when the other product is uninstalled it hands the + /// shortcut over to this copy (). /// - private List<(string Link, string Target, string Name)> PlanShortcuts(InstallRequest request, string directory) + private List<(string Link, string Target, string Name, bool Create)> PlanShortcuts(InstallRequest request, string directory) { var selected = new HashSet(request.Components, StringComparer.OrdinalIgnoreCase); - var result = new List<(string, string, string)>(); + var result = new List<(string, string, string, bool)>(); foreach (var s in Manifest.Shortcuts.Where(s => selected.Contains(s.Component))) { var target = PayloadPath.Resolve(directory, s.Target); @@ -123,12 +124,13 @@ internal sealed class InstallEngine(PayloadReader payload) void Add(string link, string target, string name) { + var create = true; if (ShellLink.TargetOf(link) is { } current && !CommandProgram.IsPathInside(current, directory) && File.Exists(current)) { Log.Info("setup", $"Shortcut '{link}' starts '{current}'; left as it is"); - return; + create = false; } - result.Add((link, target, name)); + result.Add((link, target, name, create)); } } @@ -138,13 +140,32 @@ internal sealed class InstallEngine(PayloadReader payload) return Manifest.Associations.Where(a => selected.Contains(a.Component)).ToList(); } - /// Removes what the previous version installed and this one no longer does (files, shortcuts, file types). + /// + /// Removes what the previous version installed and this one no longer does (files, the sign-in entries of those + /// programs, shortcuts, file types). + /// private static void RemoveLeftovers(string directory, InstallLog previous, InstallLog current) { var obsolete = previous.Files.Where(PayloadPath.IsValid).Except(current.Files, PayloadPath.Comparer).ToList(); - if (obsolete.Count > 0) InstalledFiles.Remove(directory, obsolete); - foreach (var link in previous.Shortcuts.Except(current.Shortcuts, StringComparer.OrdinalIgnoreCase)) - UninstallEngine.DeleteShortcut(link, previous.Scope, directory); + if (obsolete.Count > 0) + { + InstalledFiles.Remove(directory, obsolete); + try + { + // A dropped Uploader no longer starts at sign-in. + SetupRegistry.DeleteStartupEntries(CommandProgram.FullPaths(directory, obsolete)); + } + catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException or IOException) + { + Log.Warning("setup", "Sign-in entries not removed", ex); + } + } + var links = previous.Shortcuts.Except(current.Shortcuts, StringComparer.OrdinalIgnoreCase).ToList(); + if (links.Count > 0) + { + var others = SetupRegistry.OtherInstalls(directory, Publisher); + foreach (var link in links) UninstallEngine.DeleteShortcut(link, previous.Scope, directory, others); + } foreach (var a in previous.Associations.Except(current.Associations)) { if (SetupRegistry.IsValidFileType(a.Extension, a.ProgId)) SetupRegistry.UnregisterFileType(previous.Scope, a.Extension, a.ProgId); diff --git a/src/Titano.Setup/Engine/InstallLog.cs b/src/Titano.Setup/Engine/InstallLog.cs index 4cdc6f5c..c395a965 100644 --- a/src/Titano.Setup/Engine/InstallLog.cs +++ b/src/Titano.Setup/Engine/InstallLog.cs @@ -23,7 +23,10 @@ internal sealed class InstallLog /// Installed payload paths, relative to the install folder (the uninstaller and this log excluded). public List Files { get; set; } = []; - /// Full paths of the shortcuts setup created. + /// + /// Full paths of the shortcuts setup created, or would have created but found starting an existing program elsewhere + /// (another Titano product's copy, which hands them over to this one when it is uninstalled). + /// public List Shortcuts { get; set; } = []; public List Associations { get; set; } = []; diff --git a/src/Titano.Setup/Engine/InstallPlan.cs b/src/Titano.Setup/Engine/InstallPlan.cs index d89084d7..a3c28e58 100644 --- a/src/Titano.Setup/Engine/InstallPlan.cs +++ b/src/Titano.Setup/Engine/InstallPlan.cs @@ -8,7 +8,8 @@ namespace Titano.Setup.Engine; /// Where and what to install before the user changes anything: an existing installation fixes folder and scope /// (upgrade in place) and suggests its components; otherwise the switches, then the manifest defaults, apply. A /// component that installs for all users only (, the Server) makes a new -/// installation an all-users one; a per-user installation upgraded in place cannot take it. +/// installation an all-users one, in a folder inside Program Files; an installation upgraded in place elsewhere (for +/// the current user, or in another folder) cannot take it. /// internal sealed record InstallPlan(InstallScope Scope, string Directory, IReadOnlyList Components, ExistingInstall? Existing) { @@ -32,30 +33,39 @@ internal sealed record InstallPlan(InstallScope Scope, string Directory, IReadOn } var allUsersOnly = components.Where(id => manifest.FindComponent(id)!.AllUsersOnly).ToList(); - if (allUsersOnly.Count > 0 && scope == InstallScope.CurrentUser) + if (allUsersOnly.Count > 0 && existing is null) scope = InstallScope.AllUsers; + var directory = existing?.Directory ?? arguments.Directory ?? SetupPaths.DefaultDirectory(scope, manifest.Product); + if (allUsersOnly.Count > 0 && existing is not null && !IsServiceSafe(existing.Scope, existing.Directory)) { - if (existing is null) - { - scope = InstallScope.AllUsers; - } - else if (arguments.Components is not null) + if (arguments.Components is not null) { throw new SetupException(SetupExitCode.InvalidArguments, - $"{string.Join(", ", allUsersOnly)} installs for all users only; {manifest.Product} is installed for the current user."); - } - else - { - // An earlier per-user install carried it: the upgrade drops it, and its service with it (Prune). - Log.Warning("setup", $"{string.Join(", ", allUsersOnly)} not kept: it installs for all users only"); - components = [.. components.Except(allUsersOnly, StringComparer.OrdinalIgnoreCase)]; + $"{string.Join(", ", allUsersOnly)} installs for all users inside Program Files only; {manifest.Product} is installed in '{existing.Directory}' for {existing.Scope}."); } + // An earlier installation elsewhere carried it: the upgrade drops it, and its service with it (Prune). + Log.Warning("setup", $"{string.Join(", ", allUsersOnly)} not kept: it installs for all users inside Program Files only"); + components = [.. components.Except(allUsersOnly, StringComparer.OrdinalIgnoreCase)]; } - var directory = existing?.Directory ?? arguments.Directory ?? SetupPaths.DefaultDirectory(scope, manifest.Product); return new InstallPlan(scope, directory, components, existing); } - /// False for a component that installs for all users only when a per-user installation is upgraded. - public bool CanInstall(PayloadComponent component) => !(component.AllUsersOnly && Existing is { Scope: InstallScope.CurrentUser }); + /// + /// False for a component that installs for all users only when an installation that is not an all-users one inside + /// Program Files is upgraded. + /// + public bool CanInstall(PayloadComponent component) => !component.AllUsersOnly || Existing is null || IsServiceSafe(Existing.Scope, Existing.Directory); + + /// + /// True when may be installed in for + /// : a folder setup can use and, when one of them runs as a LocalSystem service, an + /// all-users folder inside Program Files, which standard users cannot change. + /// + public static bool IsValidDirectory(PayloadManifest manifest, InstallScope scope, string directory, IEnumerable components) => + SetupPaths.IsUsableInstallDirectory(directory) + && (!components.Any(id => manifest.FindComponent(id)?.AllUsersOnly == true) || IsServiceSafe(scope, directory)); + + /// True for an all-users installation inside Program Files: where a program a LocalSystem service starts may live. + public static bool IsServiceSafe(InstallScope scope, string directory) => scope == InstallScope.AllUsers && SetupPaths.IsInsideProgramFiles(directory); /// Executables to look for among running processes: the new payload's and the previous install's. public static IEnumerable Programs(PayloadManifest manifest, string directory) => diff --git a/src/Titano.Setup/Engine/InstalledServices.cs b/src/Titano.Setup/Engine/InstalledServices.cs index d01dd4e3..17d76712 100644 --- a/src/Titano.Setup/Engine/InstalledServices.cs +++ b/src/Titano.Setup/Engine/InstalledServices.cs @@ -5,18 +5,18 @@ using System.Security; using Microsoft.Win32; using Titano.Core.Diagnostics; using Titano.Core.Localization; +using Titano.Core.Packaging; using Titano.Setup.Cli; using static Titano.Setup.Interop.ServiceNative; namespace Titano.Setup.Engine; -/// A Windows service whose program lies inside an installation folder (Titano.Server.exe --install-service). +/// A Windows service that starts a program setup installed (Titano.Server.exe --install-service). /// Service key name (TitanoServer). /// Full path of the program the service starts. -/// Starts with Windows (start type automatic). -internal sealed record InstalledService(string Name, string DisplayName, string Program, bool AutoStart); +internal sealed record InstalledService(string Name, string DisplayName, string Program); -/// What setup does with the services of an installation; several may be combined. +/// What setup does with the services it is given; several may be combined. [Flags] internal enum ServiceActions { @@ -28,7 +28,7 @@ internal enum ServiceActions /// Deletes the ones whose program no longer exists (an upgrade dropped the component). Prune = 2, - /// Starts the automatic ones that are stopped (after an upgrade that stopped them). + /// Starts the stopped ones whose program exists (the ones setup stopped for an upgrade). Start = 4, /// Stops and deletes them all (uninstall), so no service is left pointing at a deleted program. @@ -36,11 +36,12 @@ internal enum ServiceActions } /// -/// Services registered from an installation folder. Setup ignored them before: an upgrade failed while the service -/// kept its files open, and an uninstall left an automatic LocalSystem service pointing at a deleted path. They are -/// found in the registry (no administrator rights needed) and stopped, started or deleted through the Service -/// Control Manager, which needs administrator rights: an unelevated setup runs that step in an elevated copy of -/// itself (/SERVICES=…). +/// Services that start a program setup installed. Setup ignored them before: an upgrade failed while the service kept +/// its files open, and an uninstall left an automatic LocalSystem service pointing at a deleted path. Only a service +/// whose program is one of the files an install log or the payload lists counts, never any other service that lives +/// in the same folder. They are found in the registry (no administrator rights needed) and stopped, started or +/// deleted through the Service Control Manager, which needs administrator rights: an unelevated setup runs that step +/// in an elevated copy of itself (/SERVICES=… /NAMES=…), which checks each named service again. /// internal static class InstalledServices { @@ -49,100 +50,100 @@ internal static class InstalledServices /// SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS: programs, not drivers. private const int Win32Service = 0x30; - private const int AutoStartType = 2; + /// A state that could not be read: treated as running, so setup never replaces files a service may hold. + private const uint StateUnknown = uint.MaxValue; /// How long a service may take to stop and its process to exit (as programs asked to close). public static readonly TimeSpan StopTimeout = TimeSpan.FromSeconds(30); - /// Services whose program lies inside ; services already marked for deletion are skipped. - public static IReadOnlyList Find(string directory) + /// + /// Services whose program is one of (); services + /// already marked for deletion are skipped. + /// + public static IReadOnlyList Find(IReadOnlySet programs) + { + if (programs.Count == 0) return []; + using var services = Registry.LocalMachine.OpenSubKey(ServicesKey); + return services is null ? [] : Find(services, programs); + } + + /// over the service keys under . + public static IReadOnlyList Find(RegistryKey services, IReadOnlySet programs) { var found = new List(); - using var services = Registry.LocalMachine.OpenSubKey(ServicesKey); - if (services is null) return found; foreach (var name in services.GetSubKeyNames()) { - try - { - using var key = services.OpenSubKey(name); - if (key is null || key.GetValue("Type") is not int type || (type & Win32Service) == 0) continue; - if (key.GetValue("DeleteFlag") is int deleting && deleting != 0) continue; - if (key.GetValue("ImagePath") is not string image || CommandProgram.Of(image) is not { } program || !CommandProgram.IsPathInside(program, directory)) continue; - var display = key.GetValue("DisplayName") as string; - found.Add(new InstalledService(name, display is { Length: > 0 } && display[0] != '@' ? display : name, program, key.GetValue("Start") is AutoStartType)); - } - catch (Exception ex) when (ex is SecurityException or IOException or UnauthorizedAccessException) - { - // A key this account may not read is not one setup registered. - Log.Debug("setup", $"Service key {name} not read: {ex.Message}"); - } + if (Read(services, name) is { } service && CommandProgram.IsAmong(service.Program, programs)) found.Add(service); } return found; } /// True when the service is not stopped (running, starting, stopping or paused), or its state cannot be read. - public static unsafe bool IsRunning(InstalledService service) - { - var manager = OpenSCManagerW(null, null, ScManagerConnect); - if (manager == 0) return true; - try - { - var handle = OpenServiceW(manager, service.Name, ServiceQueryStatus); - if (handle == 0) return Marshal.GetLastPInvokeError() != ErrorServiceDoesNotExist; - try - { - return !TryQuery(handle, out var status) || status.CurrentState != StateStopped; - } - finally - { - CloseServiceHandle(handle); - } - } - finally - { - CloseServiceHandle(manager); - } - } + public static bool IsRunning(InstalledService service) => State(service) is { } state && state != StateStopped; /// True when would change something about . - public static bool NeedsWork(IReadOnlyList services, ServiceActions actions) => services.Any(s => - actions.HasFlag(ServiceActions.Remove) - || (actions.HasFlag(ServiceActions.Prune) && !File.Exists(s.Program)) - || (actions.HasFlag(ServiceActions.Stop) && IsRunning(s)) - || (actions.HasFlag(ServiceActions.Start) && s.AutoStart && File.Exists(s.Program) && !IsRunning(s))); + public static bool NeedsWork(IReadOnlyList services, ServiceActions actions) => services.Any(s => NeedsWork(s, actions)); /// - /// Applies to the services of : in this process when it has - /// administrator rights, otherwise in an elevated copy (UAC prompt owned by ). Success - /// when there is nothing to do. + /// Applies to (found by + /// for ): in this process when it has administrator rights, otherwise in an elevated + /// copy (UAC prompt owned by ). Success when there is nothing to do. /// - public static async Task ApplyAsync(string directory, ServiceActions actions, IntPtr owner) + public static async Task ApplyAsync(string directory, IReadOnlyList services, ServiceActions actions, IntPtr owner) { - if (!NeedsWork(Find(directory), actions)) return SetupExitCode.Success; - if (Elevation.IsElevated) return await Task.Run(() => Apply(directory, actions)).ConfigureAwait(false); - Log.Info("setup", $"Asking for administrator rights to {actions} the services of '{directory}'"); - var arguments = new SetupArguments { Services = actions, Directory = directory, Language = Loc.Culture.Name }; + var pending = services.Where(s => NeedsWork(s, actions)).ToList(); + if (pending.Count == 0) return SetupExitCode.Success; + if (Elevation.IsElevated) return await Task.Run(() => Apply(pending, actions)).ConfigureAwait(false); + if (pending.FirstOrDefault(s => s.Name.Contains(',', StringComparison.Ordinal)) is { } unnamed) + { + // The elevated step takes a comma-separated list; Titano's own service is named TitanoServer. + Log.Error("setup", $"Service '{unnamed.Name}' cannot be passed to the elevated step"); + return SetupExitCode.Failed; + } + Log.Info("setup", $"Asking for administrator rights to {actions} {string.Join(", ", pending.Select(s => s.Name))}"); + var arguments = new SetupArguments { Services = actions, ServiceNames = [.. pending.Select(s => s.Name)], Directory = directory, Language = Loc.Culture.Name }; return Elevation.Start(arguments, owner) is { } child ? await Elevation.WaitAsync(child, null).ConfigureAwait(false) : SetupExitCode.ElevationDeclined; } /// - /// The elevated step (/SERVICES=… /DIR=…): applies the actions in this process. Refuses a folder setup would not - /// install to, and needs administrator rights. + /// The elevated step (/SERVICES=… /NAMES=… /DIR=…): reads each named service again and applies the actions + /// in this process. A name must still start a program of the folder's install log or of this setup's payload (or, + /// for , a program of the folder that no longer exists); otherwise nothing is done. + /// Refuses a folder setup would not install to, and needs administrator rights. /// public static SetupExitCode RunStep(SetupArguments arguments) { - if (arguments.Directory is not { } directory || !SetupPaths.IsUsableInstallDirectory(directory)) return SetupExitCode.InvalidArguments; - return Elevation.IsElevated ? Apply(directory, arguments.Services) : SetupExitCode.ElevationDeclined; + if (arguments.Directory is not { } directory || !SetupPaths.IsUsableInstallDirectory(directory) || arguments.ServiceNames is not { Count: > 0 } names) + return SetupExitCode.InvalidArguments; + if (!Elevation.IsElevated) return SetupExitCode.ElevationDeclined; + var owned = CommandProgram.FullPaths(directory, (InstallLog.TryLoad(directory)?.Files ?? []).Concat(PayloadFiles())); + using var root = Registry.LocalMachine.OpenSubKey(ServicesKey); + var services = new List(); + foreach (var name in names) + { + if ((root is null ? null : Read(root, name)) is not { } service) + { + Log.Info("setup", $"Service {name} no longer exists"); + continue; + } + var gone = arguments.Services.HasFlag(ServiceActions.Prune) && CommandProgram.IsPathInside(service.Program, directory) && !File.Exists(service.Program); + if (!CommandProgram.IsAmong(service.Program, owned) && !gone) + { + Log.Error("setup", $"Service {name} starts '{service.Program}', which setup did not install in '{directory}'"); + return SetupExitCode.InvalidArguments; + } + services.Add(service); + } + return Apply(services, arguments.Services); } /// - /// Applies in this process (administrator rights). Returns + /// Applies to in this process (administrator rights). Returns /// when a service did not stop in time, - /// when the Service Control Manager refused a step (logged). + /// when the Service Control Manager refused a step (logged). A service that no longer exists is skipped. /// - public static unsafe SetupExitCode Apply(string directory, ServiceActions actions) + public static unsafe SetupExitCode Apply(IReadOnlyList services, ServiceActions actions) { - var services = Find(directory); if (services.Count == 0) return SetupExitCode.Success; var manager = OpenSCManagerW(null, null, ScManagerConnect); if (manager == 0) return Failure("Service Control Manager not opened", null); @@ -165,7 +166,7 @@ internal static class InstalledServices if (!DeleteService(handle) && Marshal.GetLastPInvokeError() != ErrorServiceMarkedForDelete) return Failure("Service not deleted", service); Log.Info("setup", $"Service {service.Name} deleted"); } - else if (actions.HasFlag(ServiceActions.Start) && service.AutoStart && File.Exists(service.Program)) + else if (actions.HasFlag(ServiceActions.Start) && File.Exists(service.Program)) { if (!StartServiceW(handle, 0, 0) && Marshal.GetLastPInvokeError() != ErrorServiceAlreadyRunning) return Failure("Service not started", service); Log.Info("setup", $"Service {service.Name} started"); @@ -184,6 +185,76 @@ internal static class InstalledServices } } + private static bool NeedsWork(InstalledService service, ServiceActions actions) + { + if (actions.HasFlag(ServiceActions.Remove)) return State(service) is not null; + if (actions.HasFlag(ServiceActions.Prune) && !File.Exists(service.Program)) return State(service) is not null; + var state = State(service); + return (actions.HasFlag(ServiceActions.Stop) && state is { } running && running != StateStopped) + || (actions.HasFlag(ServiceActions.Start) && state == StateStopped && File.Exists(service.Program)); + } + + /// + /// The service named under when it is a Win32 service not marked + /// for deletion whose command names a full path; null otherwise, or when this account may not read its key. + /// + private static InstalledService? Read(RegistryKey services, string name) + { + try + { + using var key = services.OpenSubKey(name); + if (key is null || key.GetValue("Type") is not int type || (type & Win32Service) == 0) return null; + if (key.GetValue("DeleteFlag") is int deleting && deleting != 0) return null; + if (key.GetValue("ImagePath") is not string image || CommandProgram.Of(image) is not { } program) return null; + var display = key.GetValue("DisplayName") as string; + return new InstalledService(name, display is { Length: > 0 } && display[0] != '@' ? display : name, program); + } + catch (Exception ex) when (ex is SecurityException or IOException or UnauthorizedAccessException) + { + // A key this account may not read is not one setup registered. + Log.Debug("setup", $"Service key {name} not read: {ex.Message}"); + return null; + } + } + + /// The service's current state; null when it no longer exists, when it cannot be read. + private static unsafe uint? State(InstalledService service) + { + var manager = OpenSCManagerW(null, null, ScManagerConnect); + if (manager == 0) return StateUnknown; + try + { + var handle = OpenServiceW(manager, service.Name, ServiceQueryStatus); + if (handle == 0) return Marshal.GetLastPInvokeError() == ErrorServiceDoesNotExist ? null : StateUnknown; + try + { + return TryQuery(handle, out var status) ? status.CurrentState : StateUnknown; + } + finally + { + CloseServiceHandle(handle); + } + } + finally + { + CloseServiceHandle(manager); + } + } + + /// The files of the payload this setup carries; none for an uninstaller. + private static IReadOnlyList PayloadFiles() + { + try + { + using var payload = PayloadReader.OpenCurrentProcess(); + return [.. payload.Manifest.Files.Select(f => f.Path)]; + } + catch (PayloadException) + { + return []; + } + } + /// Stops the service and waits for its process to exit, so its files can be replaced; false on timeout. private static unsafe bool Stop(nint handle, InstalledService service) { diff --git a/src/Titano.Setup/Engine/SetupPaths.cs b/src/Titano.Setup/Engine/SetupPaths.cs index 4a1ac77d..17e32a9f 100644 --- a/src/Titano.Setup/Engine/SetupPaths.cs +++ b/src/Titano.Setup/Engine/SetupPaths.cs @@ -67,6 +67,21 @@ internal static class SetupPaths && !IsSameOrInside(UserData, full); } + /// + /// True for a folder inside Program Files (not Program Files itself), where only administrators may change the + /// programs: the only place a program run by a LocalSystem service may live. + /// + public static bool IsInsideProgramFiles(string? path) + { + if (!IsUsableInstallDirectory(path)) return false; + foreach (var special in (ReadOnlySpan)[Environment.SpecialFolder.ProgramFiles, Environment.SpecialFolder.ProgramFilesX86]) + { + var programFiles = Environment.GetFolderPath(special); + if (programFiles.Length > 0 && IsSameOrInside(path!, programFiles) && !IsSameOrInside(programFiles, path!)) return true; + } + return false; + } + /// True when is or lies inside it (case-insensitive). public static bool IsSameOrInside(string path, string folder) { diff --git a/src/Titano.Setup/Engine/SetupRegistry.cs b/src/Titano.Setup/Engine/SetupRegistry.cs index ab75aa1d..9d1f161d 100644 --- a/src/Titano.Setup/Engine/SetupRegistry.cs +++ b/src/Titano.Setup/Engine/SetupRegistry.cs @@ -2,12 +2,19 @@ using System.Globalization; using System.IO; using System.Text.RegularExpressions; using Microsoft.Win32; +using Titano.Core.IO; namespace Titano.Setup.Engine; /// An installation found in Add/Remove Programs. internal sealed record ExistingInstall(InstallScope Scope, string Directory, string Version); +/// +/// Another Titano installation registered in Add/Remove Programs: its folder, and its log when that can be read now +/// (null for a drive that is offline, a folder that is gone or a log that cannot be read). +/// +internal sealed record OtherInstall(string? Directory, InstallLog? Log); + /// Values written to the Add/Remove Programs entry. internal sealed record UninstallEntry(string DisplayName, string Version, string Publisher, string Directory, string UninstallerPath, string DisplayIcon, long EstimatedBytes, string? AboutUrl); @@ -36,12 +43,13 @@ internal static partial class SetupRegistry } /// - /// The logs of the other installations by (any product, either scope) except the one in - /// : what an uninstall must leave working (the user data they share). + /// The other installations by (any product, either scope) except the one in + /// : what an uninstall must leave working (the user data and shortcuts they share). + /// Every registered entry counts, also one whose folder or log cannot be read right now. /// - public static IReadOnlyList OtherInstalls(string directory, string publisher) + public static IReadOnlyList OtherInstalls(string directory, string publisher) { - var found = new List(); + var found = new List(); foreach (var scope in (ReadOnlySpan)[InstallScope.CurrentUser, InstallScope.AllUsers]) { using var root = Hive(scope).OpenSubKey(UninstallRoot.TrimEnd('\\')); @@ -52,9 +60,11 @@ internal static partial class SetupRegistry { using var key = root.OpenSubKey(name); if (key?.GetValue("Publisher") is not string p || !p.Equals(publisher, StringComparison.Ordinal)) continue; - if (key.GetValue("InstallLocation") is not string location || !Directory.Exists(location)) continue; - if (CommandProgram.IsPathInside(location, directory) && CommandProgram.IsPathInside(directory, location)) continue; - if (InstallLog.TryLoad(location) is { } log) found.Add(log); + var location = key.GetValue("InstallLocation") as string; + if (location is { Length: > 0 } && CommandProgram.IsPathInside(location, directory) && CommandProgram.IsPathInside(directory, location)) continue; + var log = location is { Length: > 0 } && Directory.Exists(location) ? InstallLog.TryLoad(location) : null; + if (log is null) Titano.Core.Diagnostics.Log.Info("setup", $"Installation '{name}' in '{location}' cannot be read now; it counts as using every program"); + found.Add(new OtherInstall(location, log)); } catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException or IOException) { @@ -86,6 +96,31 @@ internal static partial class SetupRegistry public static void DeleteUninstallEntry(InstallScope scope, string productKey) => Hive(scope).DeleteSubKeyTree(UninstallRoot + productKey, throwOnMissingSubKey: false); + /// + /// Removes the sign-in entries of the client and the Uploader (HKCU\…\Run, written by the programs + /// themselves) that start one of ( of the files an + /// installation lists); another copy's entries, and other programs' values, stay. + /// + public static void DeleteStartupEntries(IReadOnlySet programs) + { + using var run = Registry.CurrentUser.OpenSubKey(StartupCommand.RunKey, writable: true); + if (run is not null) DeleteStartupEntries(run, programs); + } + + /// in ; returns the names removed. + public static IReadOnlyList DeleteStartupEntries(RegistryKey run, IReadOnlySet programs) + { + var removed = new List(); + foreach (var name in (ReadOnlySpan)[StartupCommand.ClientValue, StartupCommand.UploaderValue]) + { + if (!CommandProgram.IsAmong(StartupCommand.Executable(run.GetValue(name) as string), programs)) continue; + run.DeleteValue(name, throwOnMissingValue: false); + removed.Add(name); + Titano.Core.Diagnostics.Log.Info("setup", $"Sign-in entry '{name}' removed"); + } + return removed; + } + /// Registers to open with "program" "%1" under . public static void RegisterFileType(InstallScope scope, string extension, string progId, string description, string program) { diff --git a/src/Titano.Setup/Engine/SilentSetup.cs b/src/Titano.Setup/Engine/SilentSetup.cs index 9d1e20da..a5db2409 100644 --- a/src/Titano.Setup/Engine/SilentSetup.cs +++ b/src/Titano.Setup/Engine/SilentSetup.cs @@ -7,9 +7,10 @@ namespace Titano.Setup.Engine; /// /// /S: install or uninstall without a window, reporting only through the exit code and the setup log. -/// Running programs are asked to close; if they do not, setup stops with . -/// Services of the installation are stopped (and started again after an upgrade, or deleted with the uninstall), -/// which asks for administrator approval when setup runs without it. Silent uninstall never removes user data. +/// Running programs are asked to close; if they do not, setup stops with +/// before touching anything. Then the services of the installed programs are stopped (and started again after the +/// upgrade, or when it fails) or deleted with the uninstall, which asks for administrator approval when setup runs +/// without it. Silent uninstall never removes user data. /// internal static class SilentSetup { @@ -45,20 +46,42 @@ internal static class SilentSetup var plan = InstallPlan.Resolve(engine.Manifest, arguments); if (plan.Existing is not null && arguments.Directory is not null && !SetupPaths.IsSameOrInside(arguments.Directory, plan.Directory)) Log.Warning("setup", $"/DIR ignored: {engine.Manifest.Product} is already installed in '{plan.Directory}'"); - if (!SetupPaths.IsUsableInstallDirectory(plan.Directory)) return SetupExitCode.InvalidArguments; + if (!InstallPlan.IsValidDirectory(engine.Manifest, plan.Scope, plan.Directory, plan.Components)) + { + Log.Error("setup", $"'{plan.Directory}' cannot take {string.Join(", ", plan.Components)} for {plan.Scope}"); + return SetupExitCode.InvalidArguments; + } if (plan.Components.Count == 0) return SetupExitCode.InvalidArguments; var launch = arguments.Launch && engine.LaunchTarget(plan.Components) is { } target ? PayloadPath.Resolve(plan.Directory, target) : null; if (plan.Scope == InstallScope.AllUsers && !Elevation.IsElevated) return arguments.Elevated ? SetupExitCode.ElevationDeclined : await Elevation.RunElevatedAsync(arguments, launch).ConfigureAwait(false); - var closed = await CloseProgramsAsync(plan.Directory, InstallPlan.Programs(engine.Manifest, plan.Directory), ServiceActions.Stop).ConfigureAwait(false); + // Read before the upgrade rewrites the log, so a program it drops still names its service. + var programs = InstallPlan.Programs(engine.Manifest, plan.Directory).ToList(); + var owned = CommandProgram.FullPaths(plan.Directory, programs); + var closed = await CloseProgramsAsync(plan.Directory, programs, owned).ConfigureAwait(false); if (closed.Code != SetupExitCode.Success) return closed.Code; - var request = new InstallRequest(plan.Directory, plan.Scope, plan.Components, !arguments.NoDesktopShortcut, !arguments.NoStartMenu); - engine.Install(request, null, CancellationToken.None); + var stopped = closed.Services; + try + { + var code = await InstalledServices.ApplyAsync(plan.Directory, stopped, ServiceActions.Stop, IntPtr.Zero).ConfigureAwait(false); + if (code != SetupExitCode.Success) + { + await StartAgainAsync(plan.Directory, stopped).ConfigureAwait(false); + return code; + } + var request = new InstallRequest(plan.Directory, plan.Scope, plan.Components, !arguments.NoDesktopShortcut, !arguments.NoStartMenu); + engine.Install(request, null, CancellationToken.None); + } + catch + { + await StartAgainAsync(plan.Directory, stopped).ConfigureAwait(false); + throw; + } // Services whose program the upgrade removed go; the ones stopped for it run again. - var services = await InstalledServices.ApplyAsync(plan.Directory, ServiceActions.Prune | (closed.StoppedServices ? ServiceActions.Start : ServiceActions.None), IntPtr.Zero) - .ConfigureAwait(false); + var after = InstalledServices.Find(owned).Where(s => !File.Exists(s.Program)).UnionBy(stopped, s => s.Name, StringComparer.OrdinalIgnoreCase).ToList(); + var services = await InstalledServices.ApplyAsync(plan.Directory, after, ServiceActions.Prune | ServiceActions.Start, IntPtr.Zero).ConfigureAwait(false); if (services != SetupExitCode.Success) return services; if (launch is null) return SetupExitCode.Success; @@ -73,11 +96,17 @@ internal static class SilentSetup if (product is null) return SetupExitCode.NotInstalled; if (product.Log.Scope == InstallScope.AllUsers && !Elevation.IsElevated) return arguments.Elevated ? SetupExitCode.ElevationDeclined : await Elevation.RunElevatedAsync(arguments, null).ConfigureAwait(false); - var closed = await CloseProgramsAsync(product.Directory, product.Log.Files, ServiceActions.Remove).ConfigureAwait(false); + var owned = CommandProgram.FullPaths(product.Directory, product.Log.Files); + var closed = await CloseProgramsAsync(product.Directory, product.Log.Files, owned).ConfigureAwait(false); if (closed.Code != SetupExitCode.Success) return closed.Code; - // Services that were not running are still registered: no service may outlive its program. - var services = await InstalledServices.ApplyAsync(product.Directory, ServiceActions.Remove, IntPtr.Zero).ConfigureAwait(false); - if (services != SetupExitCode.Success) return services; + // Only now that the programs are closed. Services that were not running are still registered: no service may + // outlive its program. If one cannot be deleted, the ones stopped here run again. + var services = await InstalledServices.ApplyAsync(product.Directory, InstalledServices.Find(owned), ServiceActions.Remove, IntPtr.Zero).ConfigureAwait(false); + if (services != SetupExitCode.Success) + { + await StartAgainAsync(product.Directory, closed.Services).ConfigureAwait(false); + return services; + } UninstallEngine.Uninstall(product, userData: null, null); return SetupExitCode.Success; } @@ -97,29 +126,39 @@ internal static class SilentSetup } /// - /// Applies to the running services of (an elevated step - /// when needed), then asks the running programs to close. + /// Asks the running programs of to close and returns the running services of + /// , which the caller stops or deletes: a program that does not close stops setup before + /// any service is touched. /// - private static async Task<(SetupExitCode Code, bool StoppedServices)> CloseProgramsAsync(string directory, IEnumerable programs, ServiceActions toServices) + private static async Task<(SetupExitCode Code, IReadOnlyList Services)> CloseProgramsAsync(string directory, IEnumerable programs, IReadOnlySet owned) { - var services = InstalledServices.Find(directory).Where(InstalledServices.IsRunning).ToList(); + var services = InstalledServices.Find(owned).Where(InstalledServices.IsRunning).ToList(); var running = RunningPrograms.Find(directory, programs, services); try { - if (services.Count > 0) - { - Log.Info("setup", $"Stopping {RunningPrograms.Describe([], services)}"); - var code = await InstalledServices.ApplyAsync(directory, toServices, IntPtr.Zero).ConfigureAwait(false); - if (code != SetupExitCode.Success) return (code, false); - } - if (running.Count == 0) return (SetupExitCode.Success, services.Count > 0); + if (running.Count == 0) return (SetupExitCode.Success, services); Log.Info("setup", $"Asking {RunningPrograms.Describe(running)} to close"); var still = await RunningPrograms.CloseAsync(running, CloseTimeout).ConfigureAwait(false); - return (still.Count == 0 ? SetupExitCode.Success : SetupExitCode.ProgramRunning, services.Count > 0); + return (still.Count == 0 ? SetupExitCode.Success : SetupExitCode.ProgramRunning, services); } finally { foreach (var p in running) p.Dispose(); } } + + /// After a failure, starts again the services setup stopped, so a failed upgrade does not leave the server down. + private static async Task StartAgainAsync(string directory, IReadOnlyList stopped) + { + if (stopped.Count == 0) return; + try + { + var code = await InstalledServices.ApplyAsync(directory, stopped, ServiceActions.Start, IntPtr.Zero).ConfigureAwait(false); + if (code != SetupExitCode.Success) Log.Warning("setup", $"Stopped services not started again: {code}"); + } + catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException or IOException) + { + Log.Warning("setup", "Stopped services not started again", ex); + } + } } diff --git a/src/Titano.Setup/Engine/StartupEntries.cs b/src/Titano.Setup/Engine/StartupEntries.cs deleted file mode 100644 index 73489a24..00000000 --- a/src/Titano.Setup/Engine/StartupEntries.cs +++ /dev/null @@ -1,46 +0,0 @@ -using System.IO; -using System.Security; -using Microsoft.Win32; -using Titano.Core.Diagnostics; - -namespace Titano.Setup.Engine; - -/// -/// "Start with Windows" values under HKCU\Software\Microsoft\Windows\CurrentVersion\Run (the Uploader writes -/// "Titano Uploader"). An uninstall removes every value that starts a program inside the folder it removes: Windows -/// would otherwise try to start a deleted program at each sign-in. Values of other programs are left alone. -/// -internal static class StartupEntries -{ - public const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run"; - - /// Removes the current user's Run values that start a program inside ; returns their names. - public static IReadOnlyList RemoveInside(string directory) - { - try - { - using var key = Registry.CurrentUser.OpenSubKey(RunKey, writable: true); - return key is null ? [] : RemoveInside(key, directory); - } - catch (Exception ex) when (ex is SecurityException or UnauthorizedAccessException or IOException) - { - // A leftover entry is harmless (Windows skips a missing program); it must not fail the uninstall. - Log.Warning("setup", "Startup entries not checked", ex); - return []; - } - } - - /// Removes the values of that start a program inside . - public static IReadOnlyList RemoveInside(RegistryKey runKey, string directory) - { - var removed = new List(); - foreach (var name in runKey.GetValueNames()) - { - if (runKey.GetValue(name) is not string command || !CommandProgram.IsInside(command, directory)) continue; - runKey.DeleteValue(name, throwOnMissingValue: false); - removed.Add(name); - Log.Info("setup", $"Startup entry '{name}' removed"); - } - return removed; - } -} diff --git a/src/Titano.Setup/Engine/UninstallEngine.cs b/src/Titano.Setup/Engine/UninstallEngine.cs index dae792ca..7eb8f8df 100644 --- a/src/Titano.Setup/Engine/UninstallEngine.cs +++ b/src/Titano.Setup/Engine/UninstallEngine.cs @@ -1,4 +1,5 @@ using System.IO; +using System.Runtime.InteropServices; using Titano.Core.Diagnostics; using Titano.Core.Packaging; using Titano.Setup.Cli; @@ -10,10 +11,11 @@ namespace Titano.Setup.Engine; internal sealed record InstalledProduct(string Directory, InstallLog Log); /// -/// Removes an installation using only its log: shortcuts that still start its programs, "Start with Windows" entries -/// pointing into its folder, file types, logged files, the log and the Add/Remove Programs entry, then the -/// uninstaller itself. Files the log does not list are left alone; user data is deleted only through a plan the user -/// saw and chose in the window. Windows services of the folder are stopped and deleted by the caller first +/// Removes an installation using only its log: shortcuts that still start its programs (handed to another Titano +/// product that installed the same program and shares them), file types, logged files, the log, the Add/Remove +/// Programs entry and the sign-in entries of its programs, then the uninstaller itself. Files the log does not list, +/// and anything that starts a program it does not list, are left alone; user data is deleted only through a plan the +/// user saw and chose in the window. The Windows services of its programs are stopped and deleted by the caller first /// (), as that may need an elevated step. /// internal static class UninstallEngine @@ -42,8 +44,11 @@ internal static class UninstallEngine Log.Info("setup", $"Removing {userData.Entries.Count} entries of '{userData.Folder}' at the user's request"); userData.Remove(); } - foreach (var link in log.Shortcuts) DeleteShortcut(link, log.Scope, directory); - StartupEntries.RemoveInside(directory); + if (log.Shortcuts.Count > 0) + { + var others = SetupRegistry.OtherInstalls(directory, InstallEngine.Publisher); + foreach (var link in log.Shortcuts) DeleteShortcut(link, log.Scope, directory, others); + } progress?.Report(new SetupProgress(0.1, string.Empty)); var fileTypes = log.Associations.Where(a => SetupRegistry.IsValidFileType(a.Extension, a.ProgId)).ToList(); @@ -64,6 +69,15 @@ internal static class UninstallEngine } SetupRegistry.DeleteUninstallEntry(log.Scope, log.ProductKey); + try + { + SetupRegistry.DeleteStartupEntries(CommandProgram.FullPaths(directory, log.Files)); + } + catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException or IOException) + { + // Windows skips a sign-in entry whose program is gone; not worth failing the removal. + Log.Warning("setup", "Sign-in entries not removed", ex); + } File.Delete(Path.Combine(directory, InstallLog.FileName)); var uninstaller = Path.Combine(directory, log.UninstallerName); try @@ -89,9 +103,11 @@ internal static class UninstallEngine /// /// Deletes a shortcut recorded in a log, but only a .lnk directly in the Start menu or desktop folder that /// still starts a program inside : another product installing a program of the same - /// name may have pointed it at its own copy since. + /// name may have pointed it at its own copy since. When another installation () shares + /// the shortcut and has the same program, the shortcut is pointed at that copy instead, so the program that stays + /// installed keeps its shortcut. /// - public static void DeleteShortcut(string link, InstallScope scope, string directory) + public static void DeleteShortcut(string link, InstallScope scope, string directory, IReadOnlyList others) { var folder = Path.GetDirectoryName(link); var allowed = folder is not null && link.EndsWith(".lnk", StringComparison.OrdinalIgnoreCase) @@ -110,11 +126,44 @@ internal static class UninstallEngine Log.Info("setup", $"Shortcut '{link}' now starts '{target}'; kept"); return; } + if (SharedCopy(link, scope, directory, target, others) is { } copy) + { + ShellLink.Create(link, copy, Path.GetFileNameWithoutExtension(link)); + Log.Info("setup", $"Shortcut '{link}' now starts '{copy}', which stays installed"); + return; + } File.Delete(link); } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or COMException) { Log.Warning("setup", $"Shortcut '{link}' not removed", ex); } } + + /// + /// The same program as (the same path inside its folder) installed by another product of + /// the same scope whose log lists too; null when there is none. + /// + private static string? SharedCopy(string link, InstallScope scope, string directory, string target, IReadOnlyList others) + { + string relative; + try + { + relative = PayloadPath.FromRelative(Path.GetRelativePath(directory, target)); + } + catch (Exception ex) when (ex is PayloadException or ArgumentException) + { + return null; + } + foreach (var other in others) + { + if (other is not { Directory: { } otherDirectory, Log: { } log } || log.Scope != scope) continue; + if (!log.Shortcuts.Contains(link, StringComparer.OrdinalIgnoreCase) || !log.Files.Contains(relative, PayloadPath.Comparer)) continue; + // The folder comes from another product's registry entry: one Windows cannot use is skipped. + if (!SetupPaths.IsUsableInstallDirectory(otherDirectory)) continue; + var copy = PayloadPath.Resolve(otherDirectory, relative); + if (File.Exists(copy)) return copy; + } + return null; + } } diff --git a/src/Titano.Setup/Engine/UserDataPlan.cs b/src/Titano.Setup/Engine/UserDataPlan.cs index 07642f84..c7461c70 100644 --- a/src/Titano.Setup/Engine/UserDataPlan.cs +++ b/src/Titano.Setup/Engine/UserDataPlan.cs @@ -115,4 +115,12 @@ internal static class UserDataOwners foreach (var other in others) owners.ExceptWith(other); return owners; } + + /// + /// for the installations registered + /// on this PC: one whose log cannot be read now (a drive that is offline, a damaged log) counts as using every + /// program's data, so its data is never offered for removal. + /// + public static IReadOnlySet RemovableBeside(IEnumerable components, IEnumerable others) => + Removable(components, others.Select(o => o.Log?.Components ?? (IEnumerable)All)); } diff --git a/src/Titano.Setup/Views/ComponentOption.cs b/src/Titano.Setup/Views/ComponentOption.cs index bf2bc283..a36a3f40 100644 --- a/src/Titano.Setup/Views/ComponentOption.cs +++ b/src/Titano.Setup/Views/ComponentOption.cs @@ -6,9 +6,11 @@ namespace Titano.Setup.Views; /// /// A component checkbox: localized name and tooltip (falling back to the manifest), size and selection. A component -/// that installs for all users only says so in its tooltip, and is unavailable when a per-user installation is upgraded. +/// that installs for all users only says so in its tooltip, and is unavailable when an installation that is not an +/// all-users one inside Program Files is upgraded. /// -internal sealed class ComponentOption(PayloadComponent component, bool selected, bool available, Action changed) : LocalizedViewModel +/// The tooltip key saying why it cannot be added here; null when it can. +internal sealed class ComponentOption(PayloadComponent component, bool selected, string? unavailableToolTip, Action changed) : LocalizedViewModel { private bool _selected = selected; @@ -19,10 +21,10 @@ internal sealed class ComponentOption(PayloadComponent component, bool selected, /// Installs for all users only (the Server runs as a LocalSystem service from Program Files). public bool AllUsersOnly => component.AllUsersOnly; - /// False when it cannot be installed here: it needs all users and this installation is for the current user. - public bool IsAvailable { get; } = available; + /// False when it cannot be installed here: it needs all users in Program Files and this installation is not. + public bool IsAvailable => unavailableToolTip is null; - public string ToolTip => !IsAvailable ? Loc.L("Tooltips.Setup.NeedsAllUsers") + public string ToolTip => unavailableToolTip is { } reason ? Loc.L(reason) : AllUsersOnly ? Loc.L("Tooltips.Setup.AllUsersOnly", Description) : Description; diff --git a/src/Titano.Setup/Views/SetupViewModel.cs b/src/Titano.Setup/Views/SetupViewModel.cs index 72c2ccfc..4989ae10 100644 --- a/src/Titano.Setup/Views/SetupViewModel.cs +++ b/src/Titano.Setup/Views/SetupViewModel.cs @@ -61,7 +61,9 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo private bool _accessDenied; private string? _launchProgram; private Func? _operation; - private bool _stoppedServices; + + /// The services setup stopped for the current step, started again after the upgrade or when the step fails. + private IReadOnlyList _stopped = []; private SetupViewModel(SetupArguments arguments, string product, string? version, PayloadReader? payload, InstalledProduct? installed, IReadOnlySet? dataOwners = null) @@ -73,8 +75,7 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo _installed = installed; // "Remove my data" covers the programs this product installed that no other installed Titano product still has. _dataOwners = installed is null ? new HashSet() - : dataOwners ?? UserDataOwners.Removable(installed.Log.Components, - SetupRegistry.OtherInstalls(installed.Directory, InstallEngine.Publisher).Select(l => (IEnumerable)l.Components)); + : dataOwners ?? UserDataOwners.RemovableBeside(installed.Log.Components, SetupRegistry.OtherInstalls(installed.Directory, InstallEngine.Publisher)); if (payload is not null) { _engine = new InstallEngine(payload); @@ -87,7 +88,7 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo _launchAfter = arguments.Launch; Components = _engine is null ? [] - : [.. _engine.Manifest.Components.Select(c => new ComponentOption(c, _plan!.Components.Contains(c.Id, StringComparer.OrdinalIgnoreCase), _plan.CanInstall(c), + : [.. _engine.Manifest.Components.Select(c => new ComponentOption(c, _plan!.Components.Contains(c.Id, StringComparer.OrdinalIgnoreCase), UnavailableReason(c), OnComponentsChanged))]; Languages = [.. Core.Localization.Languages.Shipped.Select(c => new LanguageOption(c, Core.Localization.Languages.NativeName(c)))]; @@ -198,6 +199,7 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo OnPropertyChanged(nameof(IsJustMe)); // Follow the scope while the folder is still the suggested one. if (string.Equals(Path.TrimEndingDirectorySeparator(_directory), before, StringComparison.OrdinalIgnoreCase)) Directory = DefaultDirectory(); + else OnDirectoryRuleChanged(); } } @@ -212,18 +214,25 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo get => _directory; set { - if (!Set(ref _directory, value ?? string.Empty)) return; - ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(Directory))); - OnPropertyChanged(nameof(DirectoryToolTip)); - OnPropertyChanged(nameof(InstallToolTip)); + if (Set(ref _directory, value ?? string.Empty)) OnDirectoryRuleChanged(); } } - private bool IsDirectoryValid => SetupPaths.IsUsableInstallDirectory(_directory); + /// + /// A folder setup can use; inside Program Files when a selected component runs as a LocalSystem service (a folder + /// such as C:\Titano would let standard users replace the program the service starts). + /// + private bool IsDirectoryValid => _engine is not null + && InstallPlan.IsValidDirectory(_engine.Manifest, _allUsers ? InstallScope.AllUsers : InstallScope.CurrentUser, _directory, SelectedComponents); + + /// Why the folder cannot be used: not a usable folder, or outside Program Files for a service. + private string FolderErrorText => SetupPaths.IsUsableInstallDirectory(_directory) && AllUsersComponent is { } component + ? Loc.L("Tooltips.Setup.FolderProgramFiles", component.Name) + : Loc.L("Tooltips.Setup.FolderInvalid"); public string DirectoryToolTip => !CanChangeLocation ? Loc.L("Tooltips.Setup.Locked") - : IsDirectoryValid ? Loc.L("Tooltips.Setup.Folder") : Loc.L("Tooltips.Setup.FolderInvalid"); + : IsDirectoryValid ? Loc.L("Tooltips.Setup.Folder") : FolderErrorText; /// Browse is disabled when upgrading; its tooltip then says why (DESIGN §4). public string BrowseToolTip => CanChangeLocation ? Loc.L("Tooltips.Setup.Browse") : Loc.L("Tooltips.Setup.Locked"); @@ -265,13 +274,13 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo /// What Install does, or why it is disabled: no program selected, or a folder it cannot use. public string InstallToolTip => !Components.Any(c => c.IsSelected) ? Loc.L("Tooltips.Setup.NoComponent") - : !IsDirectoryValid ? Loc.L("Tooltips.Setup.FolderInvalid") + : !IsDirectoryValid ? FolderErrorText : CanChangeLocation ? Loc.L("Tooltips.Setup.Install") : Loc.L("Tooltips.Setup.Update"); /// Removing user data waits for its plan, so the user has seen what goes before choosing Uninstall. private bool CanStart => IsOptions && (IsUninstall ? !_removeUserData || _dataPlan is not null - : IsInstall && IsDirectoryValid && Components.Any(c => c.IsSelected) && (_allUsers || AllUsersComponent is null)); + : IsInstall && IsDirectoryValid && Components.Any(c => c.IsSelected)); // ---- Uninstall options ---- @@ -384,7 +393,7 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo public bool HasErrors => IsInstall && !IsDirectoryValid; public IEnumerable GetErrors(string? propertyName) => - propertyName == nameof(Directory) && HasErrors ? new[] { Loc.L("Tooltips.Setup.FolderInvalid") } : Array.Empty(); + propertyName == nameof(Directory) && HasErrors ? new[] { FolderErrorText } : Array.Empty(); /// Called once the window is visible: an elevated copy continues the install the user already started. public void OnShown() @@ -425,6 +434,7 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo private async Task InstallAsync() { var engine = _engine!; + string? directory = null; try { var request = new InstallRequest( @@ -442,22 +452,31 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo await InstallElevatedAsync(request, program); return; } - if (!await EnsureProgramsClosedAsync(request.Directory, InstallPlan.Programs(engine.Manifest, request.Directory), ServiceActions.Stop)) return; + directory = request.Directory; + // Read before the upgrade rewrites the log, so a program it drops still names its service. + var programs = InstallPlan.Programs(engine.Manifest, request.Directory).ToList(); + var owned = CommandProgram.FullPaths(request.Directory, programs); + if (await CloseProgramsAsync(request.Directory, programs, owned) is not { } running) return; BeginWork(indeterminate: false); + if (running.Count > 0) + { + _stopped = running; + await ApplyToServicesAsync(request.Directory, running, ServiceActions.Stop); + } var progress = new Progress(ReportProgress); await Task.Run(() => engine.Install(request, progress, CancellationToken.None)); // Services whose program the upgrade removed go; the ones stopped for it run again. - var after = ServiceActions.Prune | (_stoppedServices ? ServiceActions.Start : ServiceActions.None); - var services = await InstalledServices.ApplyAsync(request.Directory, after, WindowHandle); - if (services != SetupExitCode.Success) throw new SetupException(services, $"Services not updated: {services}"); - _stoppedServices = false; + var after = InstalledServices.Find(owned).Where(s => !File.Exists(s.Program)).UnionBy(_stopped, s => s.Name, StringComparer.OrdinalIgnoreCase).ToList(); + _stopped = []; + await ApplyToServicesAsync(request.Directory, after, ServiceActions.Prune | ServiceActions.Start); _launchProgram = program; Complete(); if (launch is not null) Launch(); } catch (Exception ex) { + await StartStoppedAsync(directory); Fail(ex); } } @@ -489,11 +508,14 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo var installed = _installed!; try { - if (!await EnsureProgramsClosedAsync(installed.Directory, installed.Log.Files, ServiceActions.Remove)) return; + var owned = CommandProgram.FullPaths(installed.Directory, installed.Log.Files); + if (await CloseProgramsAsync(installed.Directory, installed.Log.Files, owned) is not { } running) return; BeginWork(indeterminate: false); - // A service that was not running is still registered: none may outlive its program. - var services = await InstalledServices.ApplyAsync(installed.Directory, ServiceActions.Remove, WindowHandle); - if (services != SetupExitCode.Success) throw new SetupException(services, $"Services not removed: {services}"); + // Only now that the programs are closed. A service that was not running is still registered: none may + // outlive its program. If one cannot be deleted, the ones stopped here run again. + _stopped = running; + await ApplyToServicesAsync(installed.Directory, InstalledServices.Find(owned), ServiceActions.Remove); + _stopped = []; var progress = new Progress(ReportProgress); var userData = _removeUserData ? _dataPlan : null; await Task.Run(() => UninstallEngine.Uninstall(installed, userData, progress)); @@ -501,44 +523,36 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo } catch (Exception ex) { + await StartStoppedAsync(installed.Directory); Fail(ex); } } /// - /// True when no installed program or service runs from . Otherwise the first call asks - /// the user (Confirm stage); after "Close programs" the services get (stopped, or - /// stopped and deleted; an elevated step when needed), the programs are asked to close and the operation continues. + /// Null when the user must first confirm (Confirm stage) that the programs and services running from + /// may close. Otherwise the running programs have closed, and the result lists the + /// running services of , which the caller stops or deletes: a program that does not close + /// stops setup before any service is touched. /// - private async Task EnsureProgramsClosedAsync(string directory, IEnumerable programs, ServiceActions toServices) + private async Task?> CloseProgramsAsync(string directory, IEnumerable programs, IReadOnlySet owned) { // A confirmation answers one prompt only; a later attempt asks again. var confirmed = _closeConfirmed; _closeConfirmed = false; - var services = InstalledServices.Find(directory).Where(InstalledServices.IsRunning).ToList(); + var services = InstalledServices.Find(owned).Where(InstalledServices.IsRunning).ToList(); var running = RunningPrograms.Find(directory, programs, services); try { - if (running.Count == 0 && services.Count == 0) return true; + if (running.Count == 0 && services.Count == 0) return services; _runningPrograms = RunningPrograms.Describe(running, services); if (!confirmed) { Stage = SetupStage.Confirm; - return false; + return null; } BeginWork(indeterminate: true); - if (services.Count > 0) - { - var code = await InstalledServices.ApplyAsync(directory, toServices, WindowHandle); - if (code != SetupExitCode.Success) - { - _runningPrograms = RunningPrograms.Describe([], services); - throw new SetupException(code, $"Services not stopped: {_runningPrograms}"); - } - _stoppedServices = true; - } var still = await RunningPrograms.CloseAsync(running, SilentSetup.CloseTimeout); - if (still.Count == 0) return true; + if (still.Count == 0) return services; _runningPrograms = RunningPrograms.Describe(still); throw new SetupException(SetupExitCode.ProgramRunning, $"Still running: {_runningPrograms}"); } @@ -548,6 +562,32 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo } } + /// Applies to (an elevated step when needed); throws when that fails. + private async Task ApplyToServicesAsync(string directory, IReadOnlyList services, ServiceActions actions) + { + var code = await InstalledServices.ApplyAsync(directory, services, actions, WindowHandle); + if (code == SetupExitCode.Success) return; + _runningPrograms = RunningPrograms.Describe([], services); + throw new SetupException(code, $"Services not updated ({actions}): {_runningPrograms}"); + } + + /// After a failure, starts again the services setup stopped for the step, so a failed upgrade does not leave the server down. + private async Task StartStoppedAsync(string? directory) + { + var stopped = _stopped; + _stopped = []; + if (directory is null || stopped.Count == 0) return; + try + { + var code = await InstalledServices.ApplyAsync(directory, stopped, ServiceActions.Start, WindowHandle); + if (code != SetupExitCode.Success) Log.Warning("setup", $"Stopped services not started again: {code}"); + } + catch (Exception ex) when (ex is Win32Exception or InvalidOperationException or IOException) + { + Log.Warning("setup", "Stopped services not started again", ex); + } + } + private void Browse() { if (PickFolder?.Invoke(_directory) is not { } folder) return; @@ -645,13 +685,27 @@ internal sealed class SetupViewModel : LocalizedViewModel, INotifyDataErrorInfo OnPropertyChanged(nameof(CanChooseJustMe)); OnPropertyChanged(nameof(JustMeToolTip)); OnPropertyChanged(nameof(RequiredSpaceText)); - OnPropertyChanged(nameof(InstallToolTip)); OnPropertyChanged(nameof(HasDesktopOption)); OnPropertyChanged(nameof(HasStartMenuOption)); OnPropertyChanged(nameof(HasLaunchOption)); + OnDirectoryRuleChanged(); + } + + /// The folder, the scope or the components changed: whether the folder is valid, and why not, may have too. + private void OnDirectoryRuleChanged() + { + ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(Directory))); + OnPropertyChanged(nameof(DirectoryToolTip)); + OnPropertyChanged(nameof(InstallToolTip)); CommandManager.InvalidateRequerySuggested(); } + /// The tooltip key saying why cannot be added to the installation upgraded here; null when it can. + private string? UnavailableReason(PayloadComponent component) => + _plan!.CanInstall(component) ? null + : _plan.Existing is { Scope: InstallScope.CurrentUser } ? "Tooltips.Setup.NeedsAllUsers" + : "Tooltips.Setup.NeedsProgramFiles"; + private IEnumerable SelectedShortcuts() { if (_engine is null) return []; diff --git a/src/Titano.Uploader/Infrastructure/StartupRegistration.cs b/src/Titano.Uploader/Infrastructure/StartupRegistration.cs index ff51ae65..4badfff3 100644 --- a/src/Titano.Uploader/Infrastructure/StartupRegistration.cs +++ b/src/Titano.Uploader/Infrastructure/StartupRegistration.cs @@ -1,6 +1,7 @@ using System.Security; using Microsoft.Win32; using Titano.Core.Diagnostics; +using Titano.Core.IO; namespace Titano.Uploader.Infrastructure; @@ -14,13 +15,13 @@ public interface IStartupRegistration /// /// HKCU\Software\Microsoft\Windows\CurrentVersion\Run value that starts the uploader in the tray at sign-in. -/// The registry stays the source of truth because Task Manager can turn it off. Uninstalling removes the value, as -/// setup deletes every Run value that starts a program in the folder it removes. +/// The registry stays the source of truth because Task Manager can turn it off. Uninstalling removes the value when +/// it starts the Uploader the uninstaller removes ( names it for both). /// public sealed class RunKeyStartupRegistration : IStartupRegistration { - private const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run"; - private const string ValueName = "Titano Uploader"; + private const string RunKey = StartupCommand.RunKey; + private const string ValueName = StartupCommand.UploaderValue; public bool IsEnabled { diff --git a/tests/Titano.App.Tests/Setup/SetupEngineTests.cs b/tests/Titano.App.Tests/Setup/SetupEngineTests.cs index 11ff998d..5f0d7cf5 100644 --- a/tests/Titano.App.Tests/Setup/SetupEngineTests.cs +++ b/tests/Titano.App.Tests/Setup/SetupEngineTests.cs @@ -10,12 +10,14 @@ using Titano.Testing; namespace Titano.App.Tests.Setup; /// -/// What setup leaves behind and what it registers: services and startup entries of the install folder (SETUP-1, -/// SETUP-2), shortcuts another product owns (SRS-09), the Server's all-users scope (SRS-06) and the file type name -/// in setup's language (SRS-04). +/// What setup leaves behind and what it registers: services and startup entries of the programs it installed, never +/// of other programs in the same folder (SETUP-1, SETUP-2), shortcuts another product owns or takes over (SRS-09), the +/// Server's all-users scope inside Program Files (SRS-06) and the file type name in setup's language (SRS-04). /// public sealed class SetupEngineTests(TestContext context) { + private const string TestsKey = @"Software\Titano.Tests"; + [Theory] [Case(@"""C:\Program Files\Titano\Titano.Server.exe"" --service", @"C:\Program Files\Titano\Titano.Server.exe")] [Case(@"C:\Program Files\Titano\Titano.Server.exe --service", @"C:\Program Files\Titano\Titano.Server.exe")] @@ -27,63 +29,115 @@ public sealed class SetupEngineTests(TestContext context) Assert.Equal(program, CommandProgram.Of(commandLine)); [Test] - public void ServiceStepsTravelToTheElevatedCopy() + public void ServiceStepsTravelToTheElevatedCopyWithTheirServices() { - var arguments = new SetupArguments { Services = ServiceActions.Prune | ServiceActions.Start, Directory = @"C:\Program Files\Titano", Elevated = true }; + var arguments = new SetupArguments + { + Services = ServiceActions.Prune | ServiceActions.Start, + ServiceNames = ["TitanoServer"], + Directory = @"C:\Program Files\Titano", + Elevated = true, + }; var switches = arguments.ToSwitches().ToList(); Assert.Contains("/SERVICES=prune,start", switches); - Assert.Equal(arguments, SetupArguments.Parse(switches)); + Assert.Contains("/NAMES=TitanoServer", switches); + var parsed = SetupArguments.Parse(switches); + Assert.Equal(arguments.Services, parsed.Services); + Assert.Equal(arguments.Directory, parsed.Directory); + Assert.SequenceEqual(["TitanoServer"], parsed.ServiceNames!); + Assert.True(parsed.Elevated); - Assert.Equal(ServiceActions.Remove, SetupArguments.Parse(["/SERVICES=Remove", "/DIR=C:\\Apps\\Titano"]).Services); - Assert.Throws(() => SetupArguments.Parse(["/SERVICES=stop"])); - Assert.Throws(() => SetupArguments.Parse(["/SERVICES=kill", "/DIR=C:\\Apps\\Titano"])); - Assert.Throws(() => SetupArguments.Parse(["/SERVICES=none", "/DIR=C:\\Apps\\Titano"])); + Assert.Equal(ServiceActions.Remove, SetupArguments.Parse(["/SERVICES=Remove", "/NAMES=TitanoServer", "/DIR=C:\\Apps\\Titano"]).Services); + // The step acts only on services the unelevated setup named. + Assert.Throws(() => SetupArguments.Parse(["/SERVICES=stop", "/NAMES=TitanoServer"])); + Assert.Throws(() => SetupArguments.Parse(["/SERVICES=stop", "/DIR=C:\\Apps\\Titano"])); + Assert.Throws(() => SetupArguments.Parse(["/SERVICES=kill", "/NAMES=TitanoServer", "/DIR=C:\\Apps\\Titano"])); + Assert.Throws(() => SetupArguments.Parse(["/SERVICES=none", "/NAMES=TitanoServer", "/DIR=C:\\Apps\\Titano"])); } [Test] [WindowsOnly] - public void AServiceWhoseProgramIsGoneIsPrunedAndNothingStartsIt() + public void OnlyTheServicesOfProgramsSetupInstalledAreFound() + { + var folder = Path.Combine(context.CreateTempDirectory("services"), "Apps"); + var owned = CommandProgram.FullPaths(folder, ["Titano.Server.exe", "Titano.exe", "lib/Titano.Core.dll"]); + var keyPath = TestsKey + @"\" + Guid.NewGuid().ToString("N"); + try + { + using var services = Registry.CurrentUser.CreateSubKey(keyPath, writable: true); + Service(services, "TitanoServer", 0x10, $"\"{Path.Combine(folder, "Titano.Server.exe")}\" --service"); + Service(services, "TitanoServerUnquoted", 0x10, Path.Combine(folder, "TITANO.SERVER.EXE") + " --service"); + // Another vendor's service, and a driver, that live in the same folder (a shared D:\Apps): never Titano's. + Service(services, "OtherVendor", 0x10, $"\"{Path.Combine(folder, "Other", "Other.exe")}\""); + Service(services, "OtherBeside", 0x10, $"\"{Path.Combine(folder, "Helper.exe")}\" /run"); + Service(services, "Driver", 0x1, Path.Combine(folder, "Titano.Server.exe")); + using (var deleting = services.CreateSubKey("Deleting", writable: true)) + { + deleting.SetValue("Type", 0x10, RegistryValueKind.DWord); + deleting.SetValue("DeleteFlag", 1, RegistryValueKind.DWord); + deleting.SetValue("ImagePath", Path.Combine(folder, "Titano.Server.exe"), RegistryValueKind.ExpandString); + } + + var found = InstalledServices.Find(services, owned); + Assert.SequenceEqual(["TitanoServer", "TitanoServerUnquoted"], found.Select(s => s.Name).Order(StringComparer.Ordinal)); + Assert.True(found.All(s => s.Program.Equals(Path.Combine(folder, "Titano.Server.exe"), StringComparison.OrdinalIgnoreCase))); + Assert.Empty(InstalledServices.Find(services, CommandProgram.FullPaths(folder, ["Titano.exe"]))); + } + finally + { + DeleteTestKey(keyPath); + } + + static void Service(RegistryKey services, string name, int type, string imagePath) + { + using var key = services.CreateSubKey(name, writable: true); + key.SetValue("Type", type, RegistryValueKind.DWord); + key.SetValue("ImagePath", imagePath, RegistryValueKind.ExpandString); + } + } + + [Test] + [WindowsOnly] + public void AServiceThatIsNotRegisteredNeedsNothing() { var folder = context.CreateTempDirectory("services"); - // No service is registered from a fresh folder, and nothing is asked of the Service Control Manager. - Assert.Empty(InstalledServices.Find(folder)); - Assert.Equal(SetupExitCode.Success, InstalledServices.Apply(folder, ServiceActions.Remove)); + // No service starts a program of a fresh folder, and nothing is asked of the Service Control Manager. + Assert.Empty(InstalledServices.Find(CommandProgram.FullPaths(folder, ["Titano.Server.exe"]))); + Assert.Equal(SetupExitCode.Success, InstalledServices.Apply([], ServiceActions.Remove)); - var gone = new InstalledService("TitanoTest" + Guid.NewGuid().ToString("N"), "Titano Server", Path.Combine(folder, "Titano.Server.exe"), AutoStart: true); + var gone = new InstalledService("TitanoTest" + Guid.NewGuid().ToString("N"), "Titano Server", Path.Combine(folder, "Titano.Server.exe")); Assert.False(InstalledServices.IsRunning(gone)); - Assert.True(InstalledServices.NeedsWork([gone], ServiceActions.Prune)); - Assert.True(InstalledServices.NeedsWork([gone], ServiceActions.Remove)); - Assert.False(InstalledServices.NeedsWork([gone], ServiceActions.Stop)); - Assert.False(InstalledServices.NeedsWork([gone], ServiceActions.Start)); - Assert.False(InstalledServices.NeedsWork([], ServiceActions.Remove)); + foreach (var action in (ServiceActions[])[ServiceActions.Stop, ServiceActions.Prune, ServiceActions.Start, ServiceActions.Remove]) + Assert.False(InstalledServices.NeedsWork([gone], action), $"{action} of a service that does not exist"); + // Applying to it skips it: a service deleted meanwhile is not a failure. + Assert.Equal(SetupExitCode.Success, InstalledServices.Apply([gone], ServiceActions.Remove | ServiceActions.Start)); } [Test] [WindowsOnly] - public void UninstallRemovesOnlyTheStartupEntriesOfItsFolder() + public void UninstallRemovesOnlyTheSignInEntriesOfTheProgramsItRemoves() { - var folder = Path.Combine(context.CreateTempDirectory("startup"), "Titano Uploader"); - const string testsKey = @"Software\Titano.Tests"; - var keyPath = testsKey + @"\" + Guid.NewGuid().ToString("N"); + var folder = Path.Combine(context.CreateTempDirectory("startup"), "Apps"); + var keyPath = TestsKey + @"\" + Guid.NewGuid().ToString("N"); try { using (var run = Registry.CurrentUser.CreateSubKey(keyPath, writable: true)) { - run.SetValue("Titano Uploader", $"\"{Path.Combine(folder, "Titano.Uploader.exe")}\" --tray"); - run.SetValue("Unquoted", Path.Combine(folder, "tools", "Helper.exe") + " /quiet"); - run.SetValue("Other", @"""C:\Program Files\Other\Other.exe"" --background"); + run.SetValue("Titano Uploader", $"\"{Path.Combine(folder, "Uploader", "Titano.Uploader.exe")}\" --tray"); + // A portable Titano unpacked in a subfolder of the same folder: not a program this installation lists. + run.SetValue("Titano", $"\"{Path.Combine(folder, "Portable", "Titano.exe")}\" --minimized"); + // Another program in the same folder, and a copy in a sibling folder. + run.SetValue("Other", $"\"{Path.Combine(folder, "Other.exe")}\" --background"); run.SetValue("Sibling", $"\"{folder} 2\\Titano.Uploader.exe\""); - Assert.SequenceEqual(["Titano Uploader", "Unquoted"], StartupEntries.RemoveInside(run, folder).Order(StringComparer.Ordinal)); - Assert.SequenceEqual(["Other", "Sibling"], run.GetValueNames().Order(StringComparer.Ordinal)); + var programs = CommandProgram.FullPaths(folder, ["Titano.exe", "Uploader/Titano.Uploader.exe", "Other.exe"]); + Assert.SequenceEqual(["Titano Uploader"], SetupRegistry.DeleteStartupEntries(run, programs)); + Assert.SequenceEqual(["Other", "Sibling", "Titano"], run.GetValueNames().Order(StringComparer.Ordinal)); } } finally { - Registry.CurrentUser.DeleteSubKeyTree(keyPath, throwOnMissingSubKey: false); - bool empty; - using (var tests = Registry.CurrentUser.OpenSubKey(testsKey)) empty = tests is { SubKeyCount: 0, ValueCount: 0 }; - if (empty) Registry.CurrentUser.DeleteSubKey(testsKey, throwOnMissingSubKey: false); + DeleteTestKey(keyPath); } } @@ -114,21 +168,80 @@ public sealed class SetupEngineTests(TestContext context) [Test] [WindowsOnly] - public void TheServerMakesANewInstallationAnAllUsersOne() + public void AnUninstalledProductHandsItsShortcutToTheProductThatKeepsTheProgram() + { + var root = context.CreateTempDirectory("handover"); + foreach (var product in (string[])["Product A", "Product B"]) + { + Directory.CreateDirectory(Path.Combine(root, product)); + File.WriteAllBytes(Path.Combine(root, product, "Titano.Uploader.exe"), [0x4D, 0x5A]); + } + // A uniquely named shortcut in the user's own Start menu, the only folder setup deletes shortcuts from. + var link = Path.Combine(SetupPaths.StartMenu(InstallScope.CurrentUser), "Titano Test " + Guid.NewGuid().ToString("N") + ".lnk"); + try + { + ShellLink.Create(link, Path.Combine(root, "Product A", "Titano.Uploader.exe"), "Titano Test"); + // The folders as the shell stores them (the long form of a short temporary path). + var productA = Path.GetDirectoryName(Assert.NotNull(ShellLink.TargetOf(link)))!; + var productB = Path.Combine(Path.GetDirectoryName(productA)!, "Product B"); + var logB = new InstallLog { Product = "Titano Uploader", Version = "1.0.0", Scope = InstallScope.CurrentUser, Files = ["Titano.Uploader.exe"], Shortcuts = [link] }; + + // Product B also has the program and lists the shortcut: uninstalling A points it at B's copy. + UninstallEngine.DeleteShortcut(link, InstallScope.CurrentUser, productA, [new OtherInstall(productB, logB)]); + var handed = Assert.NotNull(ShellLink.TargetOf(link)); + Assert.Equal("Product B", Path.GetFileName(Path.GetDirectoryName(handed))); + + // Uninstalling A again leaves B's shortcut alone; uninstalling B with nobody left deletes it. + UninstallEngine.DeleteShortcut(link, InstallScope.CurrentUser, productA, []); + Assert.FileExists(link); + UninstallEngine.DeleteShortcut(link, InstallScope.CurrentUser, productB, [new OtherInstall(productA, null)]); + Assert.FileMissing(link); + + // A product that does not list the shortcut, or whose folder cannot be read now, takes nothing over. + ShellLink.Create(link, Path.Combine(productA, "Titano.Uploader.exe"), "Titano Test"); + UninstallEngine.DeleteShortcut(link, InstallScope.CurrentUser, productA, [new OtherInstall(productB, new InstallLog { Product = "Titano", Version = "1.0.0", Files = ["Titano.Uploader.exe"] })]); + Assert.FileMissing(link); + } + finally + { + if (File.Exists(link)) File.Delete(link); + } + } + + [Test] + [WindowsOnly] + public void TheServerMakesANewInstallationAnAllUsersOneInsideProgramFiles() { var manifest = Manifest(); var plan = InstallPlan.Resolve(manifest, new SetupArguments { Components = ["Titano", "Server"] }); Assert.Equal(InstallScope.AllUsers, plan.Scope); Assert.Equal(SetupPaths.DefaultDirectory(InstallScope.AllUsers, manifest.Product), plan.Directory); + Assert.True(InstallPlan.IsValidDirectory(manifest, plan.Scope, plan.Directory, plan.Components)); + + // A folder standard users can change (C:\Titano, D:\Apps\Titano) would let them replace what the service starts. + var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); + var custom = Path.Combine(Path.GetPathRoot(programFiles)!, "Titano"); + Assert.False(InstallPlan.IsValidDirectory(manifest, InstallScope.AllUsers, custom, ["Titano", "Server"])); + Assert.True(InstallPlan.IsValidDirectory(manifest, InstallScope.AllUsers, custom, ["Titano"])); + Assert.True(InstallPlan.IsValidDirectory(manifest, InstallScope.CurrentUser, custom, ["Titano"])); + Assert.False(InstallPlan.IsValidDirectory(manifest, InstallScope.CurrentUser, Path.Combine(programFiles, "Titano"), ["Server"])); + Assert.True(InstallPlan.IsValidDirectory(manifest, InstallScope.AllUsers, Path.Combine(programFiles, "Vendor", "Titano"), ["Server"])); + Assert.False(SetupPaths.IsInsideProgramFiles(programFiles), "Program Files itself is shared by every program"); + Assert.False(SetupPaths.IsInsideProgramFiles(programFiles + " Extra" + Path.DirectorySeparatorChar + "Titano")); var desktop = InstallPlan.Resolve(manifest, new SetupArguments { Components = ["Titano"] }); Assert.Equal(InstallScope.CurrentUser, desktop.Scope); Assert.True(desktop.CanInstall(manifest.FindComponent("Server")!)); - // A per-user installation upgraded in place keeps its scope, so it cannot take the Server. + // A per-user installation upgraded in place keeps its scope, so it cannot take the Server; nor can an + // all-users one in a folder outside Program Files. var perUser = desktop with { Existing = new ExistingInstall(InstallScope.CurrentUser, desktop.Directory, "0.9.0") }; Assert.False(perUser.CanInstall(manifest.FindComponent("Server")!)); Assert.True(perUser.CanInstall(manifest.FindComponent("Titano")!)); + var elsewhere = desktop with { Existing = new ExistingInstall(InstallScope.AllUsers, custom, "0.9.0") }; + Assert.False(elsewhere.CanInstall(manifest.FindComponent("Server")!)); + var protectedFolder = desktop with { Existing = new ExistingInstall(InstallScope.AllUsers, Path.Combine(programFiles, "Titano"), "0.9.0") }; + Assert.True(protectedFolder.CanInstall(manifest.FindComponent("Server")!)); } [Test] @@ -142,6 +255,15 @@ public sealed class SetupEngineTests(TestContext context) Assert.Equal("Something else", InstallEngine.FileTypeName(unknown, CultureInfo.GetCultureInfo("it"))); } + /// Deletes a scratch key under , and that key too once it is empty. + private static void DeleteTestKey(string keyPath) + { + Registry.CurrentUser.DeleteSubKeyTree(keyPath, throwOnMissingSubKey: false); + bool empty; + using (var tests = Registry.CurrentUser.OpenSubKey(TestsKey)) empty = tests is { SubKeyCount: 0, ValueCount: 0 }; + if (empty) Registry.CurrentUser.DeleteSubKey(TestsKey, throwOnMissingSubKey: false); + } + /// A manifest under a product name no machine has installed, so the registry holds no installation of it. private static PayloadManifest Manifest() => new() { diff --git a/tests/Titano.App.Tests/Setup/UserDataPlanTests.cs b/tests/Titano.App.Tests/Setup/UserDataPlanTests.cs index ca636e13..8646284e 100644 --- a/tests/Titano.App.Tests/Setup/UserDataPlanTests.cs +++ b/tests/Titano.App.Tests/Setup/UserDataPlanTests.cs @@ -77,6 +77,18 @@ public sealed class UserDataPlanTests(TestContext context) Assert.Empty(UserDataOwners.Removable(["Server"], [])); } + [Test] + public void AnInstallationThatCannotBeReadNowKeepsEveryProgramsData() + { + string[] titano = ["Titano", "Uploader", "Server"]; + var uploader = new InstallLog { Product = "Titano Uploader", Version = "1.0.0", Components = ["Uploader"] }; + + Assert.SequenceEqual(["Titano"], UserDataOwners.RemovableBeside(titano, [new OtherInstall(@"D:\Titano Uploader", uploader)]).Order(StringComparer.Ordinal)); + // Its drive is offline, its folder is gone or its log is damaged: it may still use the desktop app's index. + Assert.Empty(UserDataOwners.RemovableBeside(titano, [new OtherInstall(@"E:\Titano Uploader", null)])); + Assert.Empty(UserDataOwners.RemovableBeside(titano, [new OtherInstall(null, null)])); + } + private static HashSet Owners(params string[] owners) => new(owners, StringComparer.OrdinalIgnoreCase); private string SampleFolder() diff --git a/tests/Titano.Core.Tests/Foundation/StartupCommandTests.cs b/tests/Titano.Core.Tests/Foundation/StartupCommandTests.cs new file mode 100644 index 00000000..6a24ece3 --- /dev/null +++ b/tests/Titano.Core.Tests/Foundation/StartupCommandTests.cs @@ -0,0 +1,58 @@ +using Titano.Core.IO; +using Titano.Testing; + +namespace Titano.Core.Tests.Foundation; + +/// The sign-in entries of the client and the Uploader: which copy they start, and which folder the uninstaller may clean. +public sealed class StartupCommandTests +{ + private const string Installed = @"C:\Users\ada\AppData\Local\Programs\Titano\Titano.exe"; + + [Test] + public void TheCommandNamesItsProgram() + { + var command = StartupCommand.Format(Installed, "--minimized"); + Assert.Equal("\"" + Installed + "\" --minimized", command); + Assert.Equal(Installed, StartupCommand.Executable(command)); + Assert.Equal(@"C:\Users\ada\AppData\Local\Programs\Titano", StartupCommand.Folder(command)); + // Written by hand or by an older tool: unquoted, or with spaces around. + Assert.Equal(@"D:\Titano\Titano.exe", StartupCommand.Executable(@" D:\Titano\Titano.exe --minimized ")); + Assert.Equal(@"D:\Titano\Titano.exe", StartupCommand.Executable(@"D:\Titano\Titano.exe")); + Assert.Null(StartupCommand.Executable(null)); + Assert.Null(StartupCommand.Executable(" ")); + Assert.Null(StartupCommand.Executable("\"unterminated --minimized")); + Assert.Null(StartupCommand.Executable("\"\" --minimized")); + Assert.Null(StartupCommand.Folder("Titano.exe")); + Assert.Equal(@"D:\Titano", StartupCommand.FolderOf(@"D:\Titano\Titano.exe")); + } + + [Test] + public void AnEntryBelongsToTheCopyItStarts() + { + var command = StartupCommand.Format(Installed, "--minimized"); + Assert.True(StartupCommand.Starts(command, Installed)); + Assert.True(StartupCommand.Starts(command, Installed.ToUpperInvariant()), "Windows paths ignore case"); + // A portable copy on a USB stick, a second install or a development build is another program. + Assert.False(StartupCommand.Starts(command, @"E:\Titano\Titano.exe")); + Assert.False(StartupCommand.Starts(command, @"C:\Users\ada\AppData\Local\Programs\Titano\Titano.exe.old")); + Assert.False(StartupCommand.Starts(command, null)); + Assert.False(StartupCommand.Starts(null, Installed)); + } + + [Test] + public void TheUninstallerRemovesOnlyTheEntriesOfItsFolder() + { + var client = StartupCommand.Format(Installed, "--minimized"); + var uploader = StartupCommand.Format(@"C:\Users\ada\AppData\Local\Programs\Titano\Uploader\Titano.Uploader.exe", "--tray"); + const string folder = @"C:\Users\ada\AppData\Local\Programs\Titano"; + Assert.True(StartupCommand.StartsFrom(client, folder)); + Assert.True(StartupCommand.StartsFrom(client, folder + @"\")); + Assert.True(StartupCommand.StartsFrom(uploader, folder.ToLowerInvariant())); + // A sibling folder that shares the name's start, another drive, or nothing at all stay. + Assert.False(StartupCommand.StartsFrom(StartupCommand.Format(@"C:\Users\ada\AppData\Local\Programs\Titano2\Titano.exe", "--minimized"), folder)); + Assert.False(StartupCommand.StartsFrom(StartupCommand.Format(@"E:\Titano\Titano.exe", "--minimized"), folder)); + Assert.False(StartupCommand.StartsFrom(StartupCommand.Format(folder, "--minimized"), folder)); + Assert.False(StartupCommand.StartsFrom(null, folder)); + Assert.False(StartupCommand.StartsFrom(client, @"\")); + } +}