Fixed Invalid Discord URL for Button

LukeZurg22 · LukeZurg22 · commit bde8f8d78707 · 2025-02-24T00:30:22.000-06:00
Added Exit Codes to Program.cs
Minor stylistic changes
diff --git a/SS14.Launcher/Api/AuthApi.cs b/SS14.Launcher/Api/AuthApi.cs
@@ -53,22 +53,22 @@ public async Task<AuthenticateResult> AuthenticateAsync(AuthenticateRequest requ
             Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());
             // Unknown error? uh oh.
             return new AuthenticateResult(
-                new[] { "Server returned unknown error" },
+                ["Server returned unknown error"],
                 AuthenticateDenyResponseCode.UnknownError);
         }
         catch (JsonException e)
         {
             Log.Error(e, "JsonException in AuthenticateAsync");
             return new AuthenticateResult(
-                new[] { "Server sent invalid response" },
+                ["Server sent invalid response"],
                 AuthenticateDenyResponseCode.UnknownError);
         }
         catch (HttpRequestException httpE)
         {
             Log.Error(httpE, "HttpRequestException in AuthenticateAsync");
             HttpSelfTest.StartSelfTest();
             return new AuthenticateResult(
-                new[] { $"Connection error to authentication server: {httpE.Message}" },
+                [$"Connection error to authentication server: {httpE.Message}"],
                 AuthenticateDenyResponseCode.UnknownError);
         }
     }
@@ -99,18 +99,18 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s
             Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);
             Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());
             // Unknown error? uh oh.
-            return new RegisterResult(new[] { "Server returned unknown error" });
+            return new RegisterResult(["Server returned unknown error"]);
         }
         catch (JsonException e)
         {
             Log.Error(e, "JsonException in RegisterAsync");
-            return new RegisterResult(new[] { "Server sent invalid response" });
+            return new RegisterResult(["Server sent invalid response"]);
         }
         catch (HttpRequestException httpE)
         {
             Log.Error(httpE, "HttpRequestException in RegisterAsync");
             HttpSelfTest.StartSelfTest();
-            return new RegisterResult(new[] { $"Connection error to authentication server: {httpE.Message}" });
+            return new RegisterResult([$"Connection error to authentication server: {httpE.Message}"]);
         }
     }
 
@@ -133,12 +133,12 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s
             // Unknown error? uh oh.
             Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);
             Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());
-            return new[] { "Server returned unknown error" };
+            return ["Server returned unknown error"];
         }
         catch (HttpRequestException httpE)
         {
             Log.Error(httpE, "HttpRequestException in ForgotPasswordAsync");
-            return new[] { $"Connection error to authentication server: {httpE.Message}" };
+            return [$"Connection error to authentication server: {httpE.Message}"];
         }
     }
 
@@ -160,13 +160,13 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s
             // Unknown error? uh oh.
             Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);
             Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());
-            return new[] { "Server returned unknown error" };
+            return ["Server returned unknown error"];
         }
         catch (HttpRequestException httpE)
         {
             Log.Error(httpE, "HttpRequestException in ResendConfirmationAsync");
             HttpSelfTest.StartSelfTest();
-            return new[] { $"Connection error to authentication server: {httpE.Message}" };
+            return [$"Connection error to authentication server: {httpE.Message}"];
         }
     }
 
diff --git a/SS14.Launcher/ConfigConstants.cs b/SS14.Launcher/ConfigConstants.cs
@@ -39,7 +39,7 @@ public static class ConfigConstants
         new("https://hub.singularity14.co.uk/"),
         new("https://hub.spacestation14.com/"),
     };
-    public const string DiscordUrl = "https://discord.gg/49KeKwXc8g/";
+    public const string DiscordUrl = "https://discord.gg/Z5PsYHY6fM";
     public const string AccountBaseUrl = "https://account.spacestation14.com/Identity/Account/";
     public const string AccountManagementUrl = $"{AccountBaseUrl}Manage";
     public const string AccountRegisterUrl = $"{AccountBaseUrl}Register";
diff --git a/SS14.Loader/ContentDbFileApi.cs b/SS14.Loader/ContentDbFileApi.cs
@@ -21,7 +21,7 @@ internal sealed class ContentDbFileApi : IFileApi, IDisposable
 {
     private readonly Dictionary<string, (long id, int length, ContentCompressionScheme compr)> _files = new();
     private readonly SemaphoreSlim _dbConnectionsSemaphore;
-    private readonly ConcurrentBag<ConPoolEntry> _dbConnections = new();
+    private readonly ConcurrentBag<ConPoolEntry> _dbConnections = [];
     private readonly int _connectionPoolSize;
 
     public unsafe ContentDbFileApi(string contentDbPath, long version)
diff --git a/SS14.Loader/Program.cs b/SS14.Loader/Program.cs
@@ -9,15 +9,29 @@
 using NSec.Cryptography;
 using Robust.LoaderApi;
 
+
 namespace SS14.Loader;
 
+internal enum ExitCode
+{
+    Success = 0,
+    InvalidSignature = 1,
+    InvalidFilename = 2,
+    FailedProgramExecution = 3,
+}
+
 internal class Program
 {
     private readonly string[] _engineArgs;
     private const string RobustAssemblyName = "Robust.Client";
 
     private readonly IFileApi _fileApi;
 
+    /// <summary>
+    /// Main Program class constructor. Loads assembly contexts.
+    /// </summary>
+    /// <param name="robustPath"></param>
+    /// <param name="engineArgs"></param>
     private Program(string robustPath, string[] engineArgs)
     {
         _engineArgs = engineArgs;
@@ -45,9 +59,13 @@ private IntPtr LoadContextOnResolvingUnmanaged(Assembly assembly, string unmanag
         return IntPtr.Zero;
     }
 
+    /// <summary>
+    /// Runs the program.
+    /// </summary>
+    /// <returns></returns>
     private bool Run()
     {
-        if (!TryOpenAssembly(RobustAssemblyName, out var clientAssembly))
+        if (!TryOpenAssembly(RobustAssemblyName, out Assembly? clientAssembly))
         {
             Console.WriteLine("Unable to locate Robust.Client.dll in engine build!");
             return false;
@@ -80,6 +98,7 @@ private bool Run()
         {
             contentApi?.Dispose();
         }
+
         return true;
     }
 
@@ -101,7 +120,7 @@ private static bool TryGetLoader(Assembly clientAssembly, [NotNullWhen(true)] ou
             return false;
         }
 
-        loader = (ILoaderEntryPoint) Activator.CreateInstance(type)!;
+        loader = (ILoaderEntryPoint)Activator.CreateInstance(type)!;
         return true;
     }
 
@@ -137,10 +156,11 @@ private bool TryOpenAssemblyStream(string name, [NotNullWhen(true)] out Stream?
     [STAThread]
     internal static int Main(string[] args)
     {
+        // TEMP: Arguments can be parsed separately for tighter error handling.
         if (args.Length < 3)
         {
             Console.WriteLine("Usage: SS14.Loader <robustPath> <signature> <public key> [engineArg [engineArg...]]");
-            return 1;
+            return (int)ExitCode.InvalidSignature;
         }
 
         var robustPath = args[0];
@@ -167,16 +187,17 @@ internal static int Main(string[] args)
 #endif
             {
                 Console.WriteLine("Failed to verify engine signature!");
-                return 2;
+                return (int)ExitCode.InvalidSignature;
             }
         }
 
         var program = new Program(robustPath, args[3..]);
         if (!program.Run())
         {
-            return 3;
+            return (int)ExitCode.FailedProgramExecution;
         }
 
+        // WIP: Remove if not needed.
         /*Console.WriteLine("lsasm dump:");
         foreach (var asmLoadContext in AssemblyLoadContext.All)
         {
@@ -187,6 +208,6 @@ internal static int Main(string[] args)
             }
         }*/
 
-        return 0;
+        return (int)ExitCode.Success;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -53,22 +53,22 @@ public async Task<AuthenticateResult> AuthenticateAsync(AuthenticateRequest requ`
`53`	`53`	`Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());`
`54`	`54`	`// Unknown error? uh oh.`
`55`	`55`	`return new AuthenticateResult(`
`56`		`- new[] { "Server returned unknown error" },`
	`56`	`+ ["Server returned unknown error"],`
`57`	`57`	`AuthenticateDenyResponseCode.UnknownError);`
`58`	`58`	`}`
`59`	`59`	`catch (JsonException e)`
`60`	`60`	`{`
`61`	`61`	`Log.Error(e, "JsonException in AuthenticateAsync");`
`62`	`62`	`return new AuthenticateResult(`
`63`		`- new[] { "Server sent invalid response" },`
	`63`	`+ ["Server sent invalid response"],`
`64`	`64`	`AuthenticateDenyResponseCode.UnknownError);`
`65`	`65`	`}`
`66`	`66`	`catch (HttpRequestException httpE)`
`67`	`67`	`{`
`68`	`68`	`Log.Error(httpE, "HttpRequestException in AuthenticateAsync");`
`69`	`69`	`HttpSelfTest.StartSelfTest();`
`70`	`70`	`return new AuthenticateResult(`
`71`		`- new[] { $"Connection error to authentication server: {httpE.Message}" },`
	`71`	`+ [$"Connection error to authentication server: {httpE.Message}"],`
`72`	`72`	`AuthenticateDenyResponseCode.UnknownError);`
`73`	`73`	`}`
`74`	`74`	`}`
`@@ -99,18 +99,18 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s`
`99`	`99`	`Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);`
`100`	`100`	`Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());`
`101`	`101`	`// Unknown error? uh oh.`
`102`		`- return new RegisterResult(new[] { "Server returned unknown error" });`
	`102`	`+ return new RegisterResult(["Server returned unknown error"]);`
`103`	`103`	`}`
`104`	`104`	`catch (JsonException e)`
`105`	`105`	`{`
`106`	`106`	`Log.Error(e, "JsonException in RegisterAsync");`
`107`		`- return new RegisterResult(new[] { "Server sent invalid response" });`
	`107`	`+ return new RegisterResult(["Server sent invalid response"]);`
`108`	`108`	`}`
`109`	`109`	`catch (HttpRequestException httpE)`
`110`	`110`	`{`
`111`	`111`	`Log.Error(httpE, "HttpRequestException in RegisterAsync");`
`112`	`112`	`HttpSelfTest.StartSelfTest();`
`113`		`- return new RegisterResult(new[] { $"Connection error to authentication server: {httpE.Message}" });`
	`113`	`+ return new RegisterResult([$"Connection error to authentication server: {httpE.Message}"]);`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`@@ -133,12 +133,12 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s`
`133`	`133`	`// Unknown error? uh oh.`
`134`	`134`	`Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);`
`135`	`135`	`Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());`
`136`		`- return new[] { "Server returned unknown error" };`
	`136`	`+ return ["Server returned unknown error"];`
`137`	`137`	`}`
`138`	`138`	`catch (HttpRequestException httpE)`
`139`	`139`	`{`
`140`	`140`	`Log.Error(httpE, "HttpRequestException in ForgotPasswordAsync");`
`141`		`- return new[] { $"Connection error to authentication server: {httpE.Message}" };`
	`141`	`+ return [$"Connection error to authentication server: {httpE.Message}"];`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`@@ -160,13 +160,13 @@ public async Task<RegisterResult> RegisterAsync(string username, string email, s`
`160`	`160`	`// Unknown error? uh oh.`
`161`	`161`	`Log.Error("Server returned unexpected HTTP status code: {responseCode}", resp.StatusCode);`
`162`	`162`	`Log.Debug("Response for error:\n{response}\n{content}", resp, await resp.Content.ReadAsStringAsync());`
`163`		`- return new[] { "Server returned unknown error" };`
	`163`	`+ return ["Server returned unknown error"];`
`164`	`164`	`}`
`165`	`165`	`catch (HttpRequestException httpE)`
`166`	`166`	`{`
`167`	`167`	`Log.Error(httpE, "HttpRequestException in ResendConfirmationAsync");`
`168`	`168`	`HttpSelfTest.StartSelfTest();`
`169`		`- return new[] { $"Connection error to authentication server: {httpE.Message}" };`
	`169`	`+ return [$"Connection error to authentication server: {httpE.Message}"];`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ internal sealed class ContentDbFileApi : IFileApi, IDisposable`
`21`	`21`	`{`
`22`	`22`	`private readonly Dictionary<string, (long id, int length, ContentCompressionScheme compr)> _files = new();`
`23`	`23`	`private readonly SemaphoreSlim _dbConnectionsSemaphore;`
`24`		`- private readonly ConcurrentBag<ConPoolEntry> _dbConnections = new();`
	`24`	`+ private readonly ConcurrentBag<ConPoolEntry> _dbConnections = [];`
`25`	`25`	`private readonly int _connectionPoolSize;`
`26`	`26`
`27`	`27`	`public unsafe ContentDbFileApi(string contentDbPath, long version)`
Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,29 @@`
`9`	`9`	`using NSec.Cryptography;`
`10`	`10`	`using Robust.LoaderApi;`
`11`	`11`
	`12`	`+`
`12`	`13`	`namespace SS14.Loader;`
`13`	`14`
	`15`	`+internal enum ExitCode`
	`16`	`+{`
	`17`	`+ Success = 0,`
	`18`	`+ InvalidSignature = 1,`
	`19`	`+ InvalidFilename = 2,`
	`20`	`+ FailedProgramExecution = 3,`
	`21`	`+}`
	`22`	`+`
`14`	`23`	`internal class Program`
`15`	`24`	`{`
`16`	`25`	`private readonly string[] _engineArgs;`
`17`	`26`	`private const string RobustAssemblyName = "Robust.Client";`
`18`	`27`
`19`	`28`	`private readonly IFileApi _fileApi;`
`20`	`29`
	`30`	`+ /// <summary>`
	`31`	`+ /// Main Program class constructor. Loads assembly contexts.`
	`32`	`+ /// </summary>`
	`33`	`+ /// <param name="robustPath"></param>`
	`34`	`+ /// <param name="engineArgs"></param>`
`21`	`35`	`private Program(string robustPath, string[] engineArgs)`
`22`	`36`	`{`
`23`	`37`	`_engineArgs = engineArgs;`
`@@ -45,9 +59,13 @@ private IntPtr LoadContextOnResolvingUnmanaged(Assembly assembly, string unmanag`
`45`	`59`	`return IntPtr.Zero;`
`46`	`60`	`}`
`47`	`61`
	`62`	`+ /// <summary>`
	`63`	`+ /// Runs the program.`
	`64`	`+ /// </summary>`
	`65`	`+ /// <returns></returns>`
`48`	`66`	`private bool Run()`
`49`	`67`	`{`
`50`		`- if (!TryOpenAssembly(RobustAssemblyName, out var clientAssembly))`
	`68`	`+ if (!TryOpenAssembly(RobustAssemblyName, out Assembly? clientAssembly))`
`51`	`69`	`{`
`52`	`70`	`Console.WriteLine("Unable to locate Robust.Client.dll in engine build!");`
`53`	`71`	`return false;`
`@@ -80,6 +98,7 @@ private bool Run()`
`80`	`98`	`{`
`81`	`99`	`contentApi?.Dispose();`
`82`	`100`	`}`
	`101`	`+`
`83`	`102`	`return true;`
`84`	`103`	`}`
`85`	`104`
`@@ -101,7 +120,7 @@ private static bool TryGetLoader(Assembly clientAssembly, [NotNullWhen(true)] ou`
`101`	`120`	`return false;`
`102`	`121`	`}`
`103`	`122`
`104`		`- loader = (ILoaderEntryPoint) Activator.CreateInstance(type)!;`
	`123`	`+ loader = (ILoaderEntryPoint)Activator.CreateInstance(type)!;`
`105`	`124`	`return true;`
`106`	`125`	`}`
`107`	`126`
`@@ -137,10 +156,11 @@ private bool TryOpenAssemblyStream(string name, [NotNullWhen(true)] out Stream?`
`137`	`156`	`[STAThread]`
`138`	`157`	`internal static int Main(string[] args)`
`139`	`158`	`{`
	`159`	`+ // TEMP: Arguments can be parsed separately for tighter error handling.`
`140`	`160`	`if (args.Length < 3)`
`141`	`161`	`{`
`142`	`162`	`Console.WriteLine("Usage: SS14.Loader <robustPath> <signature> <public key> [engineArg [engineArg...]]");`
`143`		`- return 1;`
	`163`	`+ return (int)ExitCode.InvalidSignature;`
`144`	`164`	`}`
`145`	`165`
`146`	`166`	`var robustPath = args[0];`
`@@ -167,16 +187,17 @@ internal static int Main(string[] args)`
`167`	`187`	`#endif`
`168`	`188`	`{`
`169`	`189`	`Console.WriteLine("Failed to verify engine signature!");`
`170`		`- return 2;`
	`190`	`+ return (int)ExitCode.InvalidSignature;`
`171`	`191`	`}`
`172`	`192`	`}`
`173`	`193`
`174`	`194`	`var program = new Program(robustPath, args[3..]);`
`175`	`195`	`if (!program.Run())`
`176`	`196`	`{`
`177`		`- return 3;`
	`197`	`+ return (int)ExitCode.FailedProgramExecution;`
`178`	`198`	`}`
`179`	`199`
	`200`	`+ // WIP: Remove if not needed.`
`180`	`201`	`/*Console.WriteLine("lsasm dump:");`
`181`	`202`	`foreach (var asmLoadContext in AssemblyLoadContext.All)`
`182`	`203`	`{`
`@@ -187,6 +208,6 @@ internal static int Main(string[] args)`
`187`	`208`	`}`
`188`	`209`	`}*/`
`189`	`210`
`190`		`- return 0;`
	`211`	`+ return (int)ExitCode.Success;`
`191`	`212`	`}`
`192`	`213`	`}`