Modernize administrator and Mono version checks

Cmdline/Main.cs

@@ -7,7 +7,6 @@
 using System.Net;
 using System.Diagnostics;
 using System.Linq;
-using System.Runtime.InteropServices;
 #if NET5_0_OR_GREATER
 using System.Runtime.Versioning;
 #endif
@@ -369,13 +368,4 @@ public class NoGameInstanceKraken : Kraken
     {
         public NoGameInstanceKraken() { }
     }
-
-    public class CmdLineUtil
-    {
-        public static uint GetUID()
-            => Platform.IsUnix || Platform.IsMac ? getuid() : 1;
-
-        [DllImport("libc")]
-        private static extern uint getuid();
-    }
 }

Cmdline/Options.cs

@@ -1,9 +1,6 @@
 using System;
-using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Collections.Generic;
-using System.Text.RegularExpressions;
 
 using log4net;
 using log4net.Core;
@@ -219,23 +216,21 @@ public class CommonOptions
         [Option("headless", DefaultValue = false, HelpText = "Set to disable all prompts")]
         public bool Headless { get; set; }
 
-        [Option("asroot", DefaultValue = false, HelpText = "Allows CKAN to run as root on Linux-based systems")]
+        [Option("asroot", DefaultValue = false, HelpText = "Allow CKAN to run as administrator")]
         public bool AsRoot { get; set; }
 
         [HelpVerbOption]
         public string GetUsage(string verb)
-        {
-            return HelpText.AutoBuild(this, verb);
-        }
+            => HelpText.AutoBuild(this, verb);
 
         public virtual int Handle(GameInstanceManager manager, IUser user)
         {
-            CheckMonoVersion(user, 3, 1, 0);
+            CheckMonoVersion(user);
 
             // Processes in Docker containers normally run as root.
             // If we are running in a Docker container, do not require --asroot.
             // Docker creates a .dockerenv file in the root of each container.
-            if ((Platform.IsUnix || Platform.IsMac) && CmdLineUtil.GetUID() == 0 && !File.Exists("/.dockerenv"))
+            if (Platform.IsAdministrator())
             {
                 if (!AsRoot)
                 {
@@ -286,40 +281,14 @@ public void Merge(CommonOptions otherOpts)
             }
         }
 
-        private static void CheckMonoVersion(IUser user, int rec_major, int rec_minor, int rec_patch)
+        private static void CheckMonoVersion(IUser user)
         {
-            try
-            {
-                Type type = Type.GetType("Mono.Runtime");
-                if (type == null)
-                {
-                    return;
-                }
-
-                MethodInfo display_name = type.GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
-                if (display_name != null)
-                {
-                    var version_string = (string) display_name.Invoke(null, null);
-                    var match = Regex.Match(version_string, @"^\D*(?<major>[\d]+)\.(?<minor>\d+)\.(?<revision>\d+).*$");
-
-                    if (match.Success)
-                    {
-                        int major = int.Parse(match.Groups["major"].Value);
-                        int minor = int.Parse(match.Groups["minor"].Value);
-                        int patch = int.Parse(match.Groups["revision"].Value);
-
-                        if (major < rec_major || (major == rec_major && minor < rec_minor))
-                        {
-                            user.RaiseMessage(Properties.Resources.OptionsMonoWarning,
-                                string.Join(".", major, minor, patch),
-                                string.Join(".", rec_major, rec_minor, rec_patch));
-                        }
-                    }
-                }
-            }
-            catch (Exception)
+            if (Platform.MonoVersion != null
+                && Platform.MonoVersion < Platform.RecommendedMonoVersion)
             {
-                // Ignored. This may be fragile and is just a warning method
+                user.RaiseMessage(Properties.Resources.OptionsMonoWarning,
+                                  Platform.MonoVersion.ToString(),
+                                  Platform.RecommendedMonoVersion.ToString());
             }
         }
 

Cmdline/Properties/Resources.resx

@@ -127,11 +127,10 @@
   <data name="MainUnknownCommand" xml:space="preserve"><value>Unknown command, try --help</value></data>
   <data name="MainMissingInstance" xml:space="preserve"><value>I don't know where a game instance is installed.
 Use 'ckan instance help' for assistance in setting this.</value></data>
-  <data name="OptionsRootError" xml:space="preserve"><value>You are trying to run CKAN as root.
+  <data name="OptionsRootError" xml:space="preserve"><value>You are trying to run CKAN as an administrator user.
 This is a bad idea and there is absolutely no good reason to do it. Please run CKAN from a user account (or use --asroot if you are feeling brave).</value></data>
-  <data name="OptionsRootWarning" xml:space="preserve"><value>Warning: Running CKAN as root!</value></data>
-  <data name="OptionsMonoWarning" xml:space="preserve"><value>Warning. Detected mono runtime of {0} is less than the recommended version of {1}.
-Update recommended!</value></data>
+  <data name="OptionsRootWarning" xml:space="preserve"><value>Warning: CKAN is running as an administrator user!</value></data>
+  <data name="OptionsMonoWarning" xml:space="preserve"><value>Warning: Detected Mono {0}, recommended version is {1} or later!</value></data>
   <data name="OptionsInstanceAndGameDir" xml:space="preserve"><value>--instance and --gamedir can't be specified at the same time</value></data>
   <data name="OptionsInvalidInstance" xml:space="preserve"><value>Invalid game instance specified "{0}", use '--gamedir' to specify by path, or 'instance list' to see known game instances</value></data>
   <data name="InstanceNotInstance" xml:space="preserve"><value>Sorry, {0} does not appear to be a game instance</value></data>

Core/Extensions/RegexExtensions.cs

@@ -0,0 +1,26 @@
+using System.Text.RegularExpressions;
+
+namespace CKAN.Extensions
+{
+    public static class RegexExtensions
+    {
+        /// <summary>
+        /// Functional-friendly wrapper around Regex.Match
+        /// </summary>
+        /// <param name="regex">The regex to match</param>
+        /// <param name="value">The string to check</param>
+        /// <param name="match">Object representing the match, if any</param>
+        /// <returns>True if the regex matched the value, false otherwise</returns>
+        public static bool TryMatch(this Regex regex, string value, out Match match)
+        {
+            if (value == null)
+            {
+                // Nothing matches null
+                match = null;
+                return false;
+            }
+            match = regex.Match(value);
+            return match.Success;
+        }
+    }
+}

Core/Platform.cs

@@ -1,10 +1,14 @@
 using System;
+using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
 #if NET6_0_OR_GREATER
 using System.Runtime.Versioning;
 #endif
 using System.Text.RegularExpressions;
+using System.Security.Principal;
+
+using CKAN.Extensions;
 
 namespace CKAN
 {
@@ -17,12 +21,6 @@ namespace CKAN
     /// </summary>
     public static class Platform
     {
-        static Platform()
-        {
-            // This call throws if we try to do it as a static initializer.
-            IsMonoFourOrLater = IsOnMonoFourOrLater();
-        }
-
         /// <summary>
         /// Are we on a Mac?
         /// </summary>
@@ -56,39 +54,53 @@ static Platform()
         /// </summary>
         public static readonly bool IsMono = Type.GetType("Mono.Runtime") != null;
 
-        /// <summary>
-        /// Are we running on a Mono with major version 4 or later?
-        /// </summary>
-        public static readonly bool IsMonoFourOrLater;
-
         /// <summary>
         /// Are we running in an X11 environment?
         /// </summary>
         public static readonly bool IsX11 =
             IsUnix
             && !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("DISPLAY"));
 
-        private static bool IsOnMonoFourOrLater()
+        public static bool IsAdministrator()
         {
-            if (!IsMono)
+            if (File.Exists("/.dockerenv"))
             {
+                // Treat as non-admin in a docker container, regardless of platform
                 return false;
             }
-
-            // Get Mono's display name and parse the version
-            string display_name =
-                (string)Type.GetType("Mono.Runtime")
-                            .GetMethod("GetDisplayName",
-                                       BindingFlags.NonPublic | BindingFlags.Static)
-                            .Invoke(null, null);
-
-            var match = versionMatcher.Match(display_name);
-            return match.Success
-                   && int.Parse(match.Groups["majorVersion"].Value) >= 4;
+            if (IsWindows)
+            {
+                // On Windows, check if we have administrator or system roles
+                using (var identity = WindowsIdentity.GetCurrent())
+                {
+                    var principal = new WindowsPrincipal(identity);
+                    return principal.IsInRole(WindowsBuiltInRole.Administrator)
+                        || principal.IsInRole(WindowsBuiltInRole.SystemOperator);
+                }
+            }
+            // Otherwise Unix-like; are we root?
+            return getuid() == 0;
         }
 
+        [DllImport("libc")]
+        private static extern uint getuid();
+
         private static readonly Regex versionMatcher =
-            new Regex("^\\s*(?<majorVersion>\\d+)\\.\\d+\\.\\d+\\s*\\(",
+            new Regex("^\\s*(?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+)\\s*\\(",
                       RegexOptions.Compiled);
+
+        public static readonly Version MonoVersion
+            = versionMatcher.TryMatch((string)Type.GetType("Mono.Runtime")
+                                                  ?.GetMethod("GetDisplayName",
+                                                              BindingFlags.NonPublic
+                                                              | BindingFlags.Static)
+                                                  ?.Invoke(null, null),
+                                      out Match match)
+                ? new Version(int.Parse(match.Groups["major"].Value),
+                              int.Parse(match.Groups["minor"].Value),
+                              int.Parse(match.Groups["patch"].Value))
+                : null;
+
+        public static readonly Version RecommendedMonoVersion = new Version(5, 0, 0);
     }
 }

Core/Relationships/RelationshipResolver.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 
 using log4net;