ArchiSteamFarm/Core/ASF.cs

   1 // ----------------------------------------------------------------------------------------------
   2 //     _                _      _  ____   _                           _____
   3 //    / \    _ __  ___ | |__  (_)/ ___| | |_  ___   __ _  _ __ ___  |  ___|__ _  _ __  _ __ ___
   4 //   / _ \  | '__|/ __|| '_ \ | |\___ \ | __|/ _ \ / _` || '_ ` _ \ | |_  / _` || '__|| '_ ` _ \
   5 //  / ___ \ | |  | (__ | | | || | ___) || |_|  __/| (_| || | | | | ||  _|| (_| || |   | | | | | |
   6 // /_/   \_\|_|   \___||_| |_||_||____/  \__|\___| \__,_||_| |_| |_||_|   \__,_||_|   |_| |_| |_|
   7 // ----------------------------------------------------------------------------------------------
   8 // |
   9 // Copyright 2015-2024 Łukasz "JustArchi" Domeradzki
  10 // Contact: JustArchi@JustArchi.net
  11 // |
  12 // Licensed under the Apache License, Version 2.0 (the "License");
  13 // you may not use this file except in compliance with the License.
  14 // You may obtain a copy of the License at
  15 // |
  16 // http://www.apache.org/licenses/LICENSE-2.0
  17 // |
  18 // Unless required by applicable law or agreed to in writing, software
  19 // distributed under the License is distributed on an "AS IS" BASIS,
  20 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21 // See the License for the specific language governing permissions and
  22 // limitations under the License.
  23
  24 using System;
  25 using System.Collections.Concurrent;
  26 using System.Collections.Frozen;
  27 using System.Collections.Generic;
  28 using System.ComponentModel;
  29 using System.Diagnostics.CodeAnalysis;
  30 using System.Globalization;
  31 using System.IO;
  32 using System.IO.Compression;
  33 using System.Linq;
  34 using System.Reflection;
  35 using System.Threading;
  36 using System.Threading.Tasks;
  37 using ArchiSteamFarm.Helpers;
  38 using ArchiSteamFarm.IPC;
  39 using ArchiSteamFarm.Localization;
  40 using ArchiSteamFarm.NLog;
  41 using ArchiSteamFarm.Plugins;
  42 using ArchiSteamFarm.Steam;
  43 using ArchiSteamFarm.Steam.Integration;
  44 using ArchiSteamFarm.Storage;
  45 using ArchiSteamFarm.Web;
  46 using ArchiSteamFarm.Web.GitHub;
  47 using ArchiSteamFarm.Web.GitHub.Data;
  48 using ArchiSteamFarm.Web.Responses;
  49 using JetBrains.Annotations;
  50 using SteamKit2;
  51 using SteamKit2.Discovery;
  52
  53 namespace ArchiSteamFarm.Core;
  54
  55 public static class ASF {
  56         // This is based on internal Valve guidelines, we're not using it as a hard limit
  57         private const byte MaximumRecommendedBotsCount = 10;
  58
  59         [PublicAPI]
  60         public static readonly ArchiLogger ArchiLogger = new(SharedInfo.ASF);
  61
  62         [PublicAPI]
  63         public static byte LoadBalancingDelay => Math.Max(GlobalConfig?.LoginLimiterDelay ?? 0, GlobalConfig.DefaultLoginLimiterDelay);
  64
  65         [PublicAPI]
  66         public static GlobalConfig? GlobalConfig { get; internal set; }
  67
  68         [PublicAPI]
  69         public static GlobalDatabase? GlobalDatabase { get; internal set; }
  70
  71         [PublicAPI]
  72         public static WebBrowser? WebBrowser { get; private set; }
  73
  74         internal static readonly SemaphoreSlim OpenConnectionsSemaphore = new(WebBrowser.MaxConnections, WebBrowser.MaxConnections);
  75
  76         internal static string DebugDirectory => Path.Combine(SharedInfo.DebugDirectory, OS.ProcessStartTime.ToString("yyyy-MM-dd-THH-mm-ss", CultureInfo.InvariantCulture));
  77
  78         internal static ICrossProcessSemaphore? ConfirmationsSemaphore { get; private set; }
  79         internal static ICrossProcessSemaphore? GiftsSemaphore { get; private set; }
  80         internal static ICrossProcessSemaphore? InventorySemaphore { get; private set; }
  81         internal static ICrossProcessSemaphore? LoginRateLimitingSemaphore { get; private set; }
  82         internal static ICrossProcessSemaphore? LoginSemaphore { get; private set; }
  83         internal static ICrossProcessSemaphore? RateLimitingSemaphore { get; private set; }
  84         internal static FrozenDictionary<Uri, (ICrossProcessSemaphore RateLimitingSemaphore, SemaphoreSlim OpenConnectionsSemaphore)>? WebLimitingSemaphores { get; private set; }
  85
  86         private static readonly FrozenSet<string> AssembliesNeededBeforeUpdate = new HashSet<string>(1, StringComparer.Ordinal) { "System.IO.Pipes" }.ToFrozenSet(StringComparer.Ordinal);
  87         private static readonly SemaphoreSlim UpdateSemaphore = new(1, 1);
  88
  89         private static Timer? AutoUpdatesTimer;
  90         private static FileSystemWatcher? FileSystemWatcher;
  91         private static ConcurrentDictionary<string, object>? LastWriteEvents;
  92
  93         [PublicAPI]
  94         public static bool IsOwner(ulong steamID) {
  95                 if ((steamID == 0) || !new SteamID(steamID).IsIndividualAccount) {
  96                         throw new ArgumentOutOfRangeException(nameof(steamID));
  97                 }
  98
  99                 return steamID == GlobalConfig?.SteamOwnerID;
 100         }
 101
 102         internal static string GetFilePath(EFileType fileType) {
 103                 if (!Enum.IsDefined(fileType)) {
 104                         throw new InvalidEnumArgumentException(nameof(fileType), (int) fileType, typeof(EFileType));
 105                 }
 106
 107                 return fileType switch {
 108                         EFileType.Config => Path.Combine(SharedInfo.ConfigDirectory, SharedInfo.GlobalConfigFileName),
 109                         EFileType.Database => Path.Combine(SharedInfo.ConfigDirectory, SharedInfo.GlobalDatabaseFileName),
 110                         EFileType.Crash => Path.Combine(SharedInfo.ConfigDirectory, SharedInfo.GlobalCrashFileName),
 111                         _ => throw new InvalidOperationException(nameof(fileType))
 112                 };
 113         }
 114
 115         internal static async Task<bool> Init() {
 116                 if (GlobalConfig == null) {
 117                         throw new InvalidOperationException(nameof(GlobalConfig));
 118                 }
 119
 120                 WebBrowser = new WebBrowser(ArchiLogger, GlobalConfig.WebProxy, true);
 121
 122                 if (!await PluginsCore.InitPlugins().ConfigureAwait(false)) {
 123                         return false;
 124                 }
 125
 126                 await UpdateAndRestart().ConfigureAwait(false);
 127
 128                 if (!Program.IgnoreUnsupportedEnvironment && !await ProtectAgainstCrashes().ConfigureAwait(false)) {
 129                         ArchiLogger.LogFatalError(Strings.ErrorTooManyCrashes);
 130
 131                         return true;
 132                 }
 133
 134                 Program.AllowCrashFileRemoval = true;
 135
 136                 await PluginsCore.OnASFInitModules(GlobalConfig.AdditionalProperties).ConfigureAwait(false);
 137                 await InitRateLimiters().ConfigureAwait(false);
 138
 139                 StringComparer botsComparer = await PluginsCore.GetBotsComparer().ConfigureAwait(false);
 140
 141                 Bot.Init(botsComparer);
 142
 143                 if (!Program.Service && !GlobalConfig.Headless && !Console.IsInputRedirected) {
 144                         Logging.StartInteractiveConsole();
 145                 }
 146
 147                 if (GlobalConfig.IPC) {
 148                         await ArchiKestrel.Start().ConfigureAwait(false);
 149                 }
 150
 151                 uint changeNumberToStartFrom = await PluginsCore.GetChangeNumberToStartFrom().ConfigureAwait(false);
 152
 153                 SteamPICSChanges.Init(changeNumberToStartFrom);
 154
 155                 await RegisterBots().ConfigureAwait(false);
 156
 157                 if (Program.ConfigWatch) {
 158                         InitConfigWatchEvents();
 159                 }
 160
 161                 return true;
 162         }
 163
 164         internal static bool IsValidBotName(string botName) {
 165                 ArgumentException.ThrowIfNullOrEmpty(botName);
 166
 167                 if (botName[0] == '.') {
 168                         return false;
 169                 }
 170
 171                 if (botName.Equals(SharedInfo.ASF, StringComparison.OrdinalIgnoreCase)) {
 172                         return false;
 173                 }
 174
 175                 return Path.GetRelativePath(".", botName) == botName;
 176         }
 177
 178         internal static async Task RestartOrExit() {
 179                 if (GlobalConfig == null) {
 180                         throw new InvalidOperationException(nameof(GlobalConfig));
 181                 }
 182
 183                 if (Program.RestartAllowed && GlobalConfig.AutoRestart) {
 184                         ArchiLogger.LogGenericInfo(Strings.Restarting);
 185                         await Task.Delay(SharedInfo.ShortInformationDelay).ConfigureAwait(false);
 186                         await Program.Restart().ConfigureAwait(false);
 187                 } else {
 188                         ArchiLogger.LogGenericInfo(Strings.Exiting);
 189                         await Task.Delay(SharedInfo.ShortInformationDelay).ConfigureAwait(false);
 190                         await Program.Exit().ConfigureAwait(false);
 191                 }
 192         }
 193
 194         internal static async Task<(bool Updated, Version? NewVersion)> Update(GlobalConfig.EUpdateChannel? updateChannel = null, bool updateOverride = false, bool forced = false) {
 195                 if (updateChannel.HasValue && !Enum.IsDefined(updateChannel.Value)) {
 196                         throw new InvalidEnumArgumentException(nameof(updateChannel), (int) updateChannel, typeof(GlobalConfig.EUpdateChannel));
 197                 }
 198
 199                 if (GlobalConfig == null) {
 200                         throw new InvalidOperationException(nameof(GlobalConfig));
 201                 }
 202
 203                 (bool updated, Version? newVersion) = await UpdateASF(updateChannel, updateOverride, forced).ConfigureAwait(false);
 204
 205                 if (!updated) {
 206                         // ASF wasn't updated as part of the process, update the plugins alone
 207                         updated = await PluginsCore.UpdatePlugins(SharedInfo.Version, false, updateChannel, updateOverride, forced).ConfigureAwait(false);
 208                 }
 209
 210                 return (updated, newVersion);
 211         }
 212
 213         private static async Task<bool> CanHandleWriteEvent(string filePath) {
 214                 ArgumentException.ThrowIfNullOrEmpty(filePath);
 215
 216                 if (LastWriteEvents == null) {
 217                         throw new InvalidOperationException(nameof(LastWriteEvents));
 218                 }
 219
 220                 // Save our event in dictionary
 221                 object currentWriteEvent = new();
 222                 LastWriteEvents[filePath] = currentWriteEvent;
 223
 224                 // Wait a second for eventual other events to arrive
 225                 await Task.Delay(1000).ConfigureAwait(false);
 226
 227                 // We're allowed to handle this event if the one that is saved after full second is our event and we succeed in clearing it (we don't care what we're clearing anymore, it doesn't have to be atomic operation)
 228                 return LastWriteEvents.TryGetValue(filePath, out object? savedWriteEvent) && (currentWriteEvent == savedWriteEvent) && LastWriteEvents.TryRemove(filePath, out _);
 229         }
 230
 231         private static HashSet<string> GetLoadedAssembliesNames() {
 232                 Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
 233
 234                 return loadedAssemblies.Select(static loadedAssembly => loadedAssembly.FullName).Where(static name => !string.IsNullOrEmpty(name)).ToHashSet(StringComparer.Ordinal)!;
 235         }
 236
 237         private static void InitConfigWatchEvents() {
 238                 if ((FileSystemWatcher != null) || (LastWriteEvents != null)) {
 239                         return;
 240                 }
 241
 242                 if (Bot.BotsComparer == null) {
 243                         throw new InvalidOperationException(nameof(Bot.BotsComparer));
 244                 }
 245
 246                 FileSystemWatcher = new FileSystemWatcher(SharedInfo.ConfigDirectory) { NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite };
 247
 248                 FileSystemWatcher.Changed += OnChanged;
 249                 FileSystemWatcher.Created += OnCreated;
 250                 FileSystemWatcher.Deleted += OnDeleted;
 251                 FileSystemWatcher.Renamed += OnRenamed;
 252
 253                 LastWriteEvents = new ConcurrentDictionary<string, object>(Bot.BotsComparer);
 254
 255                 FileSystemWatcher.EnableRaisingEvents = true;
 256         }
 257
 258         private static async Task InitRateLimiters() {
 259                 ConfirmationsSemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(ConfirmationsSemaphore)).ConfigureAwait(false);
 260                 GiftsSemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(GiftsSemaphore)).ConfigureAwait(false);
 261                 InventorySemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(InventorySemaphore)).ConfigureAwait(false);
 262                 LoginRateLimitingSemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(LoginRateLimitingSemaphore)).ConfigureAwait(false);
 263                 LoginSemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(LoginSemaphore)).ConfigureAwait(false);
 264                 RateLimitingSemaphore ??= await PluginsCore.GetCrossProcessSemaphore(nameof(RateLimitingSemaphore)).ConfigureAwait(false);
 265
 266                 WebLimitingSemaphores ??= new Dictionary<Uri, (ICrossProcessSemaphore RateLimitingSemaphore, SemaphoreSlim OpenConnectionsSemaphore)>(5) {
 267                         { ArchiWebHandler.SteamCheckoutURL, (await PluginsCore.GetCrossProcessSemaphore($"{nameof(ArchiWebHandler)}-{nameof(ArchiWebHandler.SteamCheckoutURL)}").ConfigureAwait(false), new SemaphoreSlim(WebBrowser.MaxConnections, WebBrowser.MaxConnections)) },
 268                         { ArchiWebHandler.SteamCommunityURL, (await PluginsCore.GetCrossProcessSemaphore($"{nameof(ArchiWebHandler)}-{nameof(ArchiWebHandler.SteamCommunityURL)}").ConfigureAwait(false), new SemaphoreSlim(WebBrowser.MaxConnections, WebBrowser.MaxConnections)) },
 269                         { ArchiWebHandler.SteamHelpURL, (await PluginsCore.GetCrossProcessSemaphore($"{nameof(ArchiWebHandler)}-{nameof(ArchiWebHandler.SteamHelpURL)}").ConfigureAwait(false), new SemaphoreSlim(WebBrowser.MaxConnections, WebBrowser.MaxConnections)) },
 270                         { ArchiWebHandler.SteamStoreURL, (await PluginsCore.GetCrossProcessSemaphore($"{nameof(ArchiWebHandler)}-{nameof(ArchiWebHandler.SteamStoreURL)}").ConfigureAwait(false), new SemaphoreSlim(WebBrowser.MaxConnections, WebBrowser.MaxConnections)) },
 271                         { WebAPI.DefaultBaseAddress, (await PluginsCore.GetCrossProcessSemaphore($"{nameof(ArchiWebHandler)}-{nameof(WebAPI)}").ConfigureAwait(false), new SemaphoreSlim(WebBrowser.MaxConnections, WebBrowser.MaxConnections)) }
 272                 }.ToFrozenDictionary();
 273         }
 274
 275         private static void LoadAllAssemblies() {
 276                 HashSet<string> loadedAssembliesNames = GetLoadedAssembliesNames();
 277
 278                 LoadAssembliesRecursively(Assembly.GetExecutingAssembly(), loadedAssembliesNames);
 279         }
 280
 281         private static void LoadAssembliesNeededBeforeUpdate() {
 282                 HashSet<string> loadedAssembliesNames = GetLoadedAssembliesNames();
 283
 284                 foreach (string assemblyName in AssembliesNeededBeforeUpdate.Where(loadedAssembliesNames.Add)) {
 285                         Assembly assembly;
 286
 287                         try {
 288                                 assembly = Assembly.Load(assemblyName);
 289                         } catch (Exception e) {
 290                                 ArchiLogger.LogGenericDebuggingException(e);
 291
 292                                 continue;
 293                         }
 294
 295                         LoadAssembliesRecursively(assembly, loadedAssembliesNames);
 296                 }
 297         }
 298
 299         [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode", Justification = "We don't care about trimmed assemblies, as we need it to work only with the known (used) ones")]
 300         private static void LoadAssembliesRecursively(Assembly assembly, ISet<string> loadedAssembliesNames) {
 301                 ArgumentNullException.ThrowIfNull(assembly);
 302
 303                 if ((loadedAssembliesNames == null) || (loadedAssembliesNames.Count == 0)) {
 304                         throw new ArgumentNullException(nameof(loadedAssembliesNames));
 305                 }
 306
 307                 foreach (AssemblyName assemblyName in assembly.GetReferencedAssemblies().Where(assemblyName => loadedAssembliesNames.Add(assemblyName.FullName))) {
 308                         Assembly loadedAssembly;
 309
 310                         try {
 311                                 loadedAssembly = Assembly.Load(assemblyName);
 312                         } catch (Exception e) {
 313                                 ArchiLogger.LogGenericDebuggingException(e);
 314
 315                                 continue;
 316                         }
 317
 318                         LoadAssembliesRecursively(loadedAssembly, loadedAssembliesNames);
 319                 }
 320         }
 321
 322         private static async void OnAutoUpdatesTimer(object? state = null) => await UpdateAndRestart().ConfigureAwait(false);
 323
 324         private static async void OnChanged(object sender, FileSystemEventArgs e) {
 325                 ArgumentNullException.ThrowIfNull(sender);
 326                 ArgumentNullException.ThrowIfNull(e);
 327
 328                 if (string.IsNullOrEmpty(e.Name)) {
 329                         throw new InvalidOperationException(nameof(e.Name));
 330                 }
 331
 332                 if (string.IsNullOrEmpty(e.FullPath)) {
 333                         throw new InvalidOperationException(nameof(e.FullPath));
 334                 }
 335
 336                 await OnChangedFile(e.Name, e.FullPath).ConfigureAwait(false);
 337         }
 338
 339         private static async Task OnChangedConfigFile(string name, string fullPath) {
 340                 ArgumentException.ThrowIfNullOrEmpty(name);
 341                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 342
 343                 await OnCreatedConfigFile(name, fullPath).ConfigureAwait(false);
 344         }
 345
 346         private static async Task OnChangedConfigFile(string name) {
 347                 ArgumentException.ThrowIfNullOrEmpty(name);
 348
 349                 if (!name.Equals(SharedInfo.IPCConfigFile, StringComparison.OrdinalIgnoreCase) || (GlobalConfig?.IPC != true)) {
 350                         return;
 351                 }
 352
 353                 if (!await CanHandleWriteEvent(name).ConfigureAwait(false)) {
 354                         return;
 355                 }
 356
 357                 ArchiLogger.LogGenericInfo(Strings.IPCConfigChanged);
 358                 await ArchiKestrel.Stop().ConfigureAwait(false);
 359                 await ArchiKestrel.Start().ConfigureAwait(false);
 360         }
 361
 362         private static async Task OnChangedFile(string name, string fullPath) {
 363                 ArgumentException.ThrowIfNullOrEmpty(name);
 364                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 365
 366                 string extension = Path.GetExtension(name);
 367
 368                 switch (extension) {
 369                         case SharedInfo.JsonConfigExtension:
 370                         case SharedInfo.IPCConfigExtension:
 371                                 await OnChangedConfigFile(name, fullPath).ConfigureAwait(false);
 372
 373                                 break;
 374                         case SharedInfo.KeysExtension:
 375                                 await OnChangedKeysFile(name, fullPath).ConfigureAwait(false);
 376
 377                                 break;
 378                 }
 379         }
 380
 381         private static async Task OnChangedKeysFile(string name, string fullPath) {
 382                 ArgumentException.ThrowIfNullOrEmpty(name);
 383                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 384
 385                 await OnCreatedKeysFile(name, fullPath).ConfigureAwait(false);
 386         }
 387
 388         private static async Task OnConfigChanged() {
 389                 string globalConfigFile = GetFilePath(EFileType.Config);
 390
 391                 if (string.IsNullOrEmpty(globalConfigFile)) {
 392                         throw new InvalidOperationException(nameof(globalConfigFile));
 393                 }
 394
 395                 (GlobalConfig? globalConfig, _) = await GlobalConfig.Load(globalConfigFile).ConfigureAwait(false);
 396
 397                 if (globalConfig == null) {
 398                         // Invalid config file, we allow user to fix it without destroying the ASF instance right away
 399                         return;
 400                 }
 401
 402                 if (globalConfig == GlobalConfig) {
 403                         return;
 404                 }
 405
 406                 ArchiLogger.LogGenericInfo(Strings.GlobalConfigChanged);
 407                 await RestartOrExit().ConfigureAwait(false);
 408         }
 409
 410         private static async void OnCreated(object sender, FileSystemEventArgs e) {
 411                 ArgumentNullException.ThrowIfNull(sender);
 412                 ArgumentNullException.ThrowIfNull(e);
 413
 414                 if (string.IsNullOrEmpty(e.Name)) {
 415                         throw new InvalidOperationException(nameof(e.Name));
 416                 }
 417
 418                 if (string.IsNullOrEmpty(e.FullPath)) {
 419                         throw new InvalidOperationException(nameof(e.FullPath));
 420                 }
 421
 422                 await OnCreatedFile(e.Name, e.FullPath).ConfigureAwait(false);
 423         }
 424
 425         private static async Task OnCreatedConfigFile(string name, string fullPath) {
 426                 ArgumentException.ThrowIfNullOrEmpty(name);
 427                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 428
 429                 string extension = Path.GetExtension(name);
 430
 431                 switch (extension) {
 432                         case SharedInfo.IPCConfigExtension:
 433                                 await OnChangedConfigFile(name).ConfigureAwait(false);
 434
 435                                 break;
 436                         case SharedInfo.JsonConfigExtension:
 437                                 await OnCreatedJsonFile(name, fullPath).ConfigureAwait(false);
 438
 439                                 break;
 440                 }
 441         }
 442
 443         private static async Task OnCreatedFile(string name, string fullPath) {
 444                 ArgumentException.ThrowIfNullOrEmpty(name);
 445                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 446
 447                 string extension = Path.GetExtension(name);
 448
 449                 switch (extension) {
 450                         case SharedInfo.JsonConfigExtension:
 451                                 await OnCreatedConfigFile(name, fullPath).ConfigureAwait(false);
 452
 453                                 break;
 454
 455                         case SharedInfo.KeysExtension:
 456                                 await OnCreatedKeysFile(name, fullPath).ConfigureAwait(false);
 457
 458                                 break;
 459                 }
 460         }
 461
 462         private static async Task OnCreatedJsonFile(string name, string fullPath) {
 463                 ArgumentException.ThrowIfNullOrEmpty(name);
 464                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 465
 466                 if (Bot.Bots == null) {
 467                         throw new InvalidOperationException(nameof(Bot.Bots));
 468                 }
 469
 470                 string botName = Path.GetFileNameWithoutExtension(name);
 471
 472                 if (string.IsNullOrEmpty(botName) || (botName[0] == '.')) {
 473                         return;
 474                 }
 475
 476                 if (!await CanHandleWriteEvent(fullPath).ConfigureAwait(false)) {
 477                         return;
 478                 }
 479
 480                 if (botName.Equals(SharedInfo.ASF, StringComparison.OrdinalIgnoreCase)) {
 481                         await OnConfigChanged().ConfigureAwait(false);
 482
 483                         return;
 484                 }
 485
 486                 if (!IsValidBotName(botName)) {
 487                         return;
 488                 }
 489
 490                 if (Bot.Bots.TryGetValue(botName, out Bot? bot)) {
 491                         await bot.OnConfigChanged(false).ConfigureAwait(false);
 492                 } else {
 493                         await Bot.RegisterBot(botName).ConfigureAwait(false);
 494
 495                         if (Bot.Bots.Count > MaximumRecommendedBotsCount) {
 496                                 ArchiLogger.LogGenericWarning(string.Format(CultureInfo.CurrentCulture, Strings.WarningExcessiveBotsCount, MaximumRecommendedBotsCount));
 497                         }
 498                 }
 499         }
 500
 501         private static async Task OnCreatedKeysFile(string name, string fullPath) {
 502                 ArgumentException.ThrowIfNullOrEmpty(name);
 503                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 504
 505                 if (Bot.Bots == null) {
 506                         throw new InvalidOperationException(nameof(Bot.Bots));
 507                 }
 508
 509                 string botName = Path.GetFileNameWithoutExtension(name);
 510
 511                 if (string.IsNullOrEmpty(botName) || (botName[0] == '.')) {
 512                         return;
 513                 }
 514
 515                 if (!await CanHandleWriteEvent(fullPath).ConfigureAwait(false)) {
 516                         return;
 517                 }
 518
 519                 if (!Bot.Bots.TryGetValue(botName, out Bot? bot)) {
 520                         return;
 521                 }
 522
 523                 await bot.ImportKeysToRedeem(fullPath).ConfigureAwait(false);
 524         }
 525
 526         private static async void OnDeleted(object sender, FileSystemEventArgs e) {
 527                 ArgumentNullException.ThrowIfNull(sender);
 528                 ArgumentNullException.ThrowIfNull(e);
 529
 530                 if (string.IsNullOrEmpty(e.Name)) {
 531                         throw new InvalidOperationException(nameof(e.Name));
 532                 }
 533
 534                 if (string.IsNullOrEmpty(e.FullPath)) {
 535                         throw new InvalidOperationException(nameof(e.FullPath));
 536                 }
 537
 538                 await OnDeletedFile(e.Name, e.FullPath).ConfigureAwait(false);
 539         }
 540
 541         private static async Task OnDeletedConfigFile(string name, string fullPath) {
 542                 ArgumentException.ThrowIfNullOrEmpty(name);
 543                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 544
 545                 string extension = Path.GetExtension(name);
 546
 547                 switch (extension) {
 548                         case SharedInfo.IPCConfigExtension:
 549                                 await OnChangedConfigFile(name).ConfigureAwait(false);
 550
 551                                 break;
 552                         case SharedInfo.JsonConfigExtension:
 553                                 await OnDeletedJsonConfigFile(name, fullPath).ConfigureAwait(false);
 554
 555                                 break;
 556                 }
 557         }
 558
 559         private static async Task OnDeletedFile(string name, string fullPath) {
 560                 ArgumentException.ThrowIfNullOrEmpty(name);
 561                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 562
 563                 string extension = Path.GetExtension(name);
 564
 565                 switch (extension) {
 566                         case SharedInfo.JsonConfigExtension:
 567                         case SharedInfo.IPCConfigExtension:
 568                                 await OnDeletedConfigFile(name, fullPath).ConfigureAwait(false);
 569
 570                                 break;
 571                 }
 572         }
 573
 574         private static async Task OnDeletedJsonConfigFile(string name, string fullPath) {
 575                 ArgumentException.ThrowIfNullOrEmpty(name);
 576                 ArgumentException.ThrowIfNullOrEmpty(fullPath);
 577
 578                 if (Bot.Bots == null) {
 579                         throw new InvalidOperationException(nameof(Bot.Bots));
 580                 }
 581
 582                 string botName = Path.GetFileNameWithoutExtension(name);
 583
 584                 if (string.IsNullOrEmpty(botName)) {
 585                         return;
 586                 }
 587
 588                 if (!await CanHandleWriteEvent(fullPath).ConfigureAwait(false)) {
 589                         return;
 590                 }
 591
 592                 if (botName.Equals(SharedInfo.ASF, StringComparison.OrdinalIgnoreCase)) {
 593                         if (File.Exists(fullPath)) {
 594                                 return;
 595                         }
 596
 597                         // Some editors might decide to delete file and re-create it in order to modify it
 598                         // If that's the case, we wait for maximum of 5 seconds before shutting down
 599                         await Task.Delay(5000).ConfigureAwait(false);
 600
 601                         if (File.Exists(fullPath)) {
 602                                 return;
 603                         }
 604
 605                         ArchiLogger.LogGenericError(Strings.ErrorGlobalConfigRemoved);
 606                         await Program.Exit(1).ConfigureAwait(false);
 607
 608                         return;
 609                 }
 610
 611                 if (!IsValidBotName(botName)) {
 612                         return;
 613                 }
 614
 615                 if (Bot.Bots.TryGetValue(botName, out Bot? bot)) {
 616                         await bot.OnConfigChanged(true).ConfigureAwait(false);
 617                 }
 618         }
 619
 620         private static async void OnRenamed(object sender, RenamedEventArgs e) {
 621                 // This function can be called with a possibility of OldName or (new) Name being null, we have to take it into account
 622                 ArgumentNullException.ThrowIfNull(sender);
 623                 ArgumentNullException.ThrowIfNull(e);
 624
 625                 if (!string.IsNullOrEmpty(e.OldName) && !string.IsNullOrEmpty(e.OldFullPath)) {
 626                         await OnDeletedFile(e.OldName, e.OldFullPath).ConfigureAwait(false);
 627                 }
 628
 629                 if (!string.IsNullOrEmpty(e.Name) && !string.IsNullOrEmpty(e.FullPath)) {
 630                         await OnCreatedFile(e.Name, e.FullPath).ConfigureAwait(false);
 631                 }
 632         }
 633
 634         private static async Task<bool> ProtectAgainstCrashes() {
 635                 if (Debugging.IsDebugBuild) {
 636                         // Allow debug builds to run unconditionally, we expect to crash a lot in those
 637                         return true;
 638                 }
 639
 640                 string crashFilePath = GetFilePath(EFileType.Crash);
 641
 642                 CrashFile crashFile = await CrashFile.CreateOrLoad(crashFilePath).ConfigureAwait(false);
 643
 644                 if (crashFile.StartupCount >= WebBrowser.MaxTries) {
 645                         // We've reached maximum allowed count of recent crashes, return failure
 646                         return false;
 647                 }
 648
 649                 DateTime now = DateTime.UtcNow;
 650
 651                 if (now - crashFile.LastStartup > TimeSpan.FromMinutes(5)) {
 652                         // Last crash was long ago, restart counter
 653                         crashFile.StartupCount = 1;
 654                 } else if (++crashFile.StartupCount >= WebBrowser.MaxTries) {
 655                         // We've reached maximum allowed count of recent crashes, return failure
 656                         return false;
 657                 }
 658
 659                 crashFile.LastStartup = now;
 660
 661                 // We're allowing this run to proceed
 662                 return true;
 663         }
 664
 665         private static async Task RegisterBots() {
 666                 if (GlobalConfig == null) {
 667                         throw new InvalidOperationException(nameof(GlobalConfig));
 668                 }
 669
 670                 if (GlobalDatabase == null) {
 671                         throw new InvalidOperationException(nameof(GlobalDatabase));
 672                 }
 673
 674                 if (WebBrowser == null) {
 675                         throw new InvalidOperationException(nameof(WebBrowser));
 676                 }
 677
 678                 // Ensure that we ask for a list of servers if we don't have any saved servers available
 679                 IEnumerable<ServerRecord> servers = await GlobalDatabase.ServerListProvider.FetchServerListAsync().ConfigureAwait(false);
 680
 681                 if (!servers.Any()) {
 682                         ArchiLogger.LogGenericInfo(string.Format(CultureInfo.CurrentCulture, Strings.Initializing, nameof(SteamDirectory)));
 683
 684                         SteamConfiguration steamConfiguration = SteamConfiguration.Create(static builder => builder.WithProtocolTypes(GlobalConfig.SteamProtocols).WithCellID(GlobalDatabase.CellID).WithServerListProvider(GlobalDatabase.ServerListProvider).WithHttpClientFactory(static () => WebBrowser.GenerateDisposableHttpClient()));
 685
 686                         try {
 687                                 await SteamDirectory.LoadAsync(steamConfiguration).ConfigureAwait(false);
 688                                 ArchiLogger.LogGenericInfo(Strings.Success);
 689                         } catch (Exception e) {
 690                                 ArchiLogger.LogGenericWarningException(e);
 691                                 ArchiLogger.LogGenericWarning(Strings.BotSteamDirectoryInitializationFailed);
 692                         }
 693                 }
 694
 695                 HashSet<string> botNames;
 696
 697                 try {
 698                         botNames = Directory.EnumerateFiles(SharedInfo.ConfigDirectory, $"*{SharedInfo.JsonConfigExtension}").Select(Path.GetFileNameWithoutExtension).Where(static botName => !string.IsNullOrEmpty(botName) && IsValidBotName(botName)).ToHashSet(Bot.BotsComparer)!;
 699                 } catch (Exception e) {
 700                         ArchiLogger.LogGenericException(e);
 701
 702                         return;
 703                 }
 704
 705                 switch (botNames.Count) {
 706                         case 0:
 707                                 ArchiLogger.LogGenericWarning(Strings.ErrorNoBotsDefined);
 708
 709                                 return;
 710                         case > MaximumRecommendedBotsCount:
 711                                 ArchiLogger.LogGenericWarning(string.Format(CultureInfo.CurrentCulture, Strings.WarningExcessiveBotsCount, MaximumRecommendedBotsCount));
 712                                 await Task.Delay(SharedInfo.InformationDelay).ConfigureAwait(false);
 713
 714                                 break;
 715                 }
 716
 717                 await Utilities.InParallel(botNames.OrderBy(static botName => botName, Bot.BotsComparer).Select(Bot.RegisterBot)).ConfigureAwait(false);
 718         }
 719
 720         private static async Task UpdateAndRestart() {
 721                 if (GlobalConfig == null) {
 722                         throw new InvalidOperationException(nameof(GlobalConfig));
 723                 }
 724
 725                 if (GlobalConfig.UpdateChannel == GlobalConfig.EUpdateChannel.None) {
 726                         return;
 727                 }
 728
 729                 if ((AutoUpdatesTimer == null) && (GlobalConfig.UpdatePeriod > 0)) {
 730                         TimeSpan autoUpdatePeriod = TimeSpan.FromHours(GlobalConfig.UpdatePeriod);
 731
 732                         AutoUpdatesTimer = new Timer(
 733                                 OnAutoUpdatesTimer,
 734                                 null,
 735                                 autoUpdatePeriod, // Delay
 736                                 autoUpdatePeriod // Period
 737                         );
 738
 739                         ArchiLogger.LogGenericInfo(string.Format(CultureInfo.CurrentCulture, Strings.AutoUpdateCheckInfo, autoUpdatePeriod.ToHumanReadable()));
 740                 }
 741
 742                 (bool updated, Version? newVersion) = await Update().ConfigureAwait(false);
 743
 744                 if (!updated) {
 745                         if ((newVersion != null) && (SharedInfo.Version > newVersion)) {
 746                                 // User is running version newer than their channel allows
 747                                 ArchiLogger.LogGenericWarning(Strings.WarningPreReleaseVersion);
 748                                 await Task.Delay(SharedInfo.InformationDelay).ConfigureAwait(false);
 749                         }
 750
 751                         return;
 752                 }
 753
 754                 // Allow crash file recovery, if needed
 755                 Program.AllowCrashFileRemoval = true;
 756
 757                 await RestartOrExit().ConfigureAwait(false);
 758         }
 759
 760         private static async Task<(bool Updated, Version? NewVersion)> UpdateASF(GlobalConfig.EUpdateChannel? channel = null, bool updateOverride = false, bool forced = false) {
 761                 if (channel.HasValue && !Enum.IsDefined(channel.Value)) {
 762                         throw new InvalidEnumArgumentException(nameof(channel), (int) channel, typeof(GlobalConfig.EUpdateChannel));
 763                 }
 764
 765                 if (GlobalConfig == null) {
 766                         throw new InvalidOperationException(nameof(GlobalConfig));
 767                 }
 768
 769                 if (WebBrowser == null) {
 770                         throw new InvalidOperationException(nameof(WebBrowser));
 771                 }
 772
 773                 channel ??= GlobalConfig.UpdateChannel;
 774
 775                 if (!SharedInfo.BuildInfo.CanUpdate || (channel == GlobalConfig.EUpdateChannel.None)) {
 776                         return (false, null);
 777                 }
 778
 779                 string targetFile;
 780
 781                 await UpdateSemaphore.WaitAsync().ConfigureAwait(false);
 782
 783                 try {
 784                         // If directories from previous update exist, it's a good idea to purge them now
 785                         if (!await Utilities.UpdateCleanup(SharedInfo.HomeDirectory).ConfigureAwait(false)) {
 786                                 return (false, null);
 787                         }
 788
 789                         ArchiLogger.LogGenericInfo(Strings.UpdateCheckingNewVersion);
 790
 791                         ReleaseResponse? releaseResponse = await GitHubService.GetLatestRelease(SharedInfo.GithubRepo, channel == GlobalConfig.EUpdateChannel.Stable).ConfigureAwait(false);
 792
 793                         if (releaseResponse == null) {
 794                                 ArchiLogger.LogGenericWarning(Strings.ErrorUpdateCheckFailed);
 795
 796                                 return (false, null);
 797                         }
 798
 799                         if (string.IsNullOrEmpty(releaseResponse.Tag)) {
 800                                 ArchiLogger.LogGenericWarning(Strings.ErrorUpdateCheckFailed);
 801
 802                                 return (false, null);
 803                         }
 804
 805                         Version newVersion = new(releaseResponse.Tag);
 806
 807                         ArchiLogger.LogGenericInfo(string.Format(CultureInfo.CurrentCulture, Strings.UpdateVersionInfo, SharedInfo.Version, newVersion));
 808
 809                         if (!forced && (SharedInfo.Version >= newVersion)) {
 810                                 return (false, newVersion);
 811                         }
 812
 813                         if (!updateOverride && (GlobalConfig.UpdatePeriod == 0)) {
 814                                 ArchiLogger.LogGenericInfo(Strings.UpdateNewVersionAvailable);
 815                                 await Task.Delay(SharedInfo.ShortInformationDelay).ConfigureAwait(false);
 816
 817                                 return (false, newVersion);
 818                         }
 819
 820                         // Auto update logic starts here
 821                         if (releaseResponse.Assets.IsEmpty) {
 822                                 ArchiLogger.LogGenericWarning(Strings.ErrorUpdateNoAssets);
 823
 824                                 return (false, newVersion);
 825                         }
 826
 827                         targetFile = $"{SharedInfo.ASF}-{SharedInfo.BuildInfo.Variant}.zip";
 828                         ReleaseAsset? binaryAsset = releaseResponse.Assets.FirstOrDefault(asset => !string.IsNullOrEmpty(asset.Name) && asset.Name.Equals(targetFile, StringComparison.OrdinalIgnoreCase));
 829
 830                         if (binaryAsset == null) {
 831                                 ArchiLogger.LogGenericWarning(Strings.ErrorUpdateNoAssetForThisVersion);
 832
 833                                 return (false, newVersion);
 834                         }
 835
 836                         ArchiLogger.LogGenericInfo(Strings.FetchingChecksumFromRemoteServer);
 837
 838                         // Keep short timeout allowed for this call, as we don't want to hold the flow for too long
 839                         using CancellationTokenSource archiNetCancellation = new(TimeSpan.FromSeconds(15));
 840
 841                         string? remoteChecksum = await ArchiNet.FetchBuildChecksum(newVersion, SharedInfo.BuildInfo.Variant, archiNetCancellation.Token).ConfigureAwait(false);
 842
 843                         switch (remoteChecksum) {
 844                                 case null:
 845                                         // Timeout or error, refuse to update as a security measure
 846                                         ArchiLogger.LogGenericWarning(Strings.ChecksumTimeout);
 847
 848                                         return (false, newVersion);
 849                                 case "":
 850                                         // Unknown checksum, release too new or actual malicious build published, no need to scare the user as it's 99.99% the first
 851                                         ArchiLogger.LogGenericWarning(Strings.ChecksumMissing);
 852
 853                                         return (false, newVersion);
 854                         }
 855
 856                         if (!string.IsNullOrEmpty(releaseResponse.ChangelogPlainText)) {
 857                                 ArchiLogger.LogGenericInfo(releaseResponse.ChangelogPlainText);
 858                         }
 859
 860                         ArchiLogger.LogGenericInfo(string.Format(CultureInfo.CurrentCulture, Strings.UpdateDownloadingNewVersion, newVersion, binaryAsset.Size / 1024 / 1024));
 861
 862                         Progress<byte> progressReporter = new();
 863
 864                         progressReporter.ProgressChanged += onProgressChanged;
 865
 866                         BinaryResponse? response;
 867
 868                         try {
 869                                 // ReSharper disable once MethodSupportsCancellation - the token initialized above is not meant to be passed here
 870                                 response = await WebBrowser.UrlGetToBinary(binaryAsset.DownloadURL, progressReporter: progressReporter).ConfigureAwait(false);
 871                         } finally {
 872                                 progressReporter.ProgressChanged -= onProgressChanged;
 873                         }
 874
 875                         if (response?.Content == null) {
 876                                 return (false, newVersion);
 877                         }
 878
 879                         ArchiLogger.LogGenericInfo(Strings.VerifyingChecksumWithRemoteServer);
 880
 881                         byte[] responseBytes = response.Content as byte[] ?? response.Content.ToArray();
 882
 883                         string checksum = Utilities.GenerateChecksumFor(responseBytes);
 884
 885                         if (!checksum.Equals(remoteChecksum, StringComparison.OrdinalIgnoreCase)) {
 886                                 ArchiLogger.LogGenericError(Strings.ChecksumWrong);
 887
 888                                 return (false, newVersion);
 889                         }
 890
 891                         await PluginsCore.OnUpdateProceeding(newVersion).ConfigureAwait(false);
 892
 893                         bool kestrelWasRunning = ArchiKestrel.IsRunning;
 894
 895                         if (kestrelWasRunning) {
 896                                 // We disable ArchiKestrel here as the update process moves the core files and might result in IPC crash
 897                                 // TODO: It might fail if the update was triggered from the API, this should be something to improve in the future, by changing the structure into request -> return response -> finish update
 898                                 try {
 899                                         await ArchiKestrel.Stop().ConfigureAwait(false);
 900                                 } catch (Exception e) {
 901                                         ArchiLogger.LogGenericWarningException(e);
 902                                 }
 903                         }
 904
 905                         ArchiLogger.LogGenericInfo(Strings.PatchingFiles);
 906
 907                         try {
 908                                 MemoryStream memoryStream = new(responseBytes);
 909
 910                                 await using (memoryStream.ConfigureAwait(false)) {
 911                                         using ZipArchive zipArchive = new(memoryStream);
 912
 913                                         if (!await UpdateFromArchive(newVersion, channel.Value, updateOverride, forced, zipArchive).ConfigureAwait(false)) {
 914                                                 ArchiLogger.LogGenericError(Strings.WarningFailed);
 915                                         }
 916                                 }
 917                         } catch (Exception e) {
 918                                 ArchiLogger.LogGenericException(e);
 919
 920                                 if (kestrelWasRunning) {
 921                                         // We've temporarily disabled ArchiKestrel but the update has failed, let's bring it back up
 922                                         // We can't even be sure if it's possible to bring it back up in this state, but it's worth trying anyway
 923                                         try {
 924                                                 await ArchiKestrel.Start().ConfigureAwait(false);
 925                                         } catch (Exception ex) {
 926                                                 ArchiLogger.LogGenericWarningException(ex);
 927                                         }
 928                                 }
 929
 930                                 return (false, newVersion);
 931                         }
 932
 933                         ArchiLogger.LogGenericInfo(Strings.UpdateFinished);
 934
 935                         await PluginsCore.OnUpdateFinished(newVersion).ConfigureAwait(false);
 936
 937                         return (true, newVersion);
 938                 } finally {
 939                         UpdateSemaphore.Release();
 940                 }
 941
 942                 void onProgressChanged(object? sender, byte progressPercentage) {
 943                         ArgumentOutOfRangeException.ThrowIfGreaterThan(progressPercentage, 100);
 944
 945                         Utilities.OnProgressChanged(targetFile, progressPercentage);
 946                 }
 947         }
 948
 949         private static async Task<bool> UpdateFromArchive(Version newVersion, GlobalConfig.EUpdateChannel updateChannel, bool updateOverride, bool forced, ZipArchive zipArchive) {
 950                 ArgumentNullException.ThrowIfNull(newVersion);
 951
 952                 if (!Enum.IsDefined(updateChannel)) {
 953                         throw new InvalidEnumArgumentException(nameof(updateChannel), (int) updateChannel, typeof(GlobalConfig.EUpdateChannel));
 954                 }
 955
 956                 ArgumentNullException.ThrowIfNull(zipArchive);
 957
 958                 if (SharedInfo.HomeDirectory == AppContext.BaseDirectory) {
 959                         // We're running a build that includes our dependencies in ASF's home
 960                         // Before actually moving files in update procedure, let's minimize the risk of some assembly not being loaded that we may need in the process
 961                         LoadAllAssemblies();
 962                 } else {
 963                         // This is a tricky one, for some reason we might need to preload some selected assemblies even in OS-specific builds that normally should be self-contained...
 964                         // It's as if the executable file was directly mapped to memory and moving it out of the original path caused the whole thing to crash
 965                         // TODO: This is a total hack, I wish we could get to the bottom of this hole and find out what is really going on there in regards to the above
 966                         LoadAssembliesNeededBeforeUpdate();
 967                 }
 968
 969                 // We're ready to start update process, handle any plugin updates ready for new version
 970                 await PluginsCore.UpdatePlugins(newVersion, true, updateChannel, updateOverride, forced).ConfigureAwait(false);
 971
 972                 return await Utilities.UpdateFromArchive(zipArchive, SharedInfo.HomeDirectory).ConfigureAwait(false);
 973         }
 974
 975         [PublicAPI]
 976         public enum EUserInputType : byte {
 977                 None,
 978                 Login,
 979                 Password,
 980                 SteamGuard,
 981                 SteamParentalCode,
 982                 TwoFactorAuthentication,
 983                 Cryptkey,
 984                 DeviceConfirmation
 985         }
 986
 987         internal enum EFileType : byte {
 988                 Config,
 989                 Database,
 990                 Crash
 991         }
 992 }