--- /dev/null
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading.Tasks;
+using Content.Server.Administration.Systems;
+using Content.Server.GameTicking;
+using Content.Server.GameTicking.Presets;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Maps;
+using Content.Server.RoundEnd;
+using Content.Shared.Administration.Managers;
+using Content.Shared.CCVar;
+using Content.Shared.Prototypes;
+using Robust.Server.ServerStatus;
+using Robust.Shared.Asynchronous;
+using Robust.Shared.Configuration;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Server.Administration;
+
+public sealed class ServerApi : IPostInjectInit
+{
+ [Dependency] private readonly IStatusHost _statusHost = default!;
+ [Dependency] private readonly IConfigurationManager _config = default!;
+ [Dependency] private readonly ISharedPlayerManager _playerManager = default!; // Players
+ [Dependency] private readonly ISharedAdminManager _adminManager = default!; // Admins
+ [Dependency] private readonly IGameMapManager _gameMapManager = default!; // Map name
+ [Dependency] private readonly IServerNetManager _netManager = default!; // Kick
+ [Dependency] private readonly IPrototypeManager _prototypeManager = default!; // Game rules
+ [Dependency] private readonly IComponentFactory _componentFactory = default!; // Needed to circumvent the "IoC has no context on this thread" error until I figure out how to do it properly
+ [Dependency] private readonly ITaskManager _taskManager = default!; // game explodes when calling stuff from the non-game thread
+ [Dependency] private readonly EntityManager _entityManager = default!;
+
+ [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
+
+ private string _token = default!;
+ private ISawmill _sawmill = default!;
+ private string _motd = default!;
+
+ public void PostInject()
+ {
+ _sawmill = Logger.GetSawmill("serverApi");
+
+ // Get
+ _statusHost.AddHandler(InfoHandler);
+ _statusHost.AddHandler(GetGameRules);
+ _statusHost.AddHandler(GetForcePresets);
+
+ // Post
+ _statusHost.AddHandler(ActionRoundStatus);
+ _statusHost.AddHandler(ActionKick);
+ _statusHost.AddHandler(ActionAddGameRule);
+ _statusHost.AddHandler(ActionEndGameRule);
+ _statusHost.AddHandler(ActionForcePreset);
+ _statusHost.AddHandler(ActionForceMotd);
+ _statusHost.AddHandler(ActionPanicPunker);
+
+ // Bandaid fix for the test fails
+ // "System.Collections.Generic.KeyNotFoundException : The given key 'server.admin_api_token' was not present in the dictionary."
+ // TODO: Figure out why this happens
+ try
+ {
+ _config.OnValueChanged(CCVars.AdminApiToken, UpdateToken, true);
+ _config.OnValueChanged(CCVars.MOTD, UpdateMotd, true);
+ }
+ catch (Exception e)
+ {
+ _sawmill.Error("Failed to subscribe to config vars: {0}", e);
+ }
+
+ }
+
+ public void Shutdown()
+ {
+ _config.UnsubValueChanged(CCVars.AdminApiToken, UpdateToken);
+ _config.UnsubValueChanged(CCVars.MOTD, UpdateMotd);
+ }
+
+ private void UpdateToken(string token)
+ {
+ _token = token;
+ }
+
+ private void UpdateMotd(string motd)
+ {
+ _motd = motd;
+ }
+
+
+#region Actions
+
+ /// <summary>
+ /// Changes the panic bunker settings.
+ /// </summary>
+ private async Task<bool> ActionPanicPunker(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/panic_bunker")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var actionSupplied = context.RequestHeaders.TryGetValue("Action", out var action);
+ if (!actionSupplied)
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var valueSupplied = context.RequestHeaders.TryGetValue("Value", out var value);
+ if (!valueSupplied)
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ switch (action) // TODO: This looks bad, there has to be a better way to do this.
+ {
+ case "enabled":
+ if (!bool.TryParse(value.ToString(), out var enabled))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerEnabled, enabled);
+ });
+ break;
+ case "disable_with_admins":
+ if (!bool.TryParse(value.ToString(), out var disableWithAdmins))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerDisableWithAdmins, disableWithAdmins);
+ });
+ break;
+ case "enable_without_admins":
+ if (!bool.TryParse(value.ToString(), out var enableWithoutAdmins))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerEnableWithoutAdmins, enableWithoutAdmins);
+ });
+ break;
+ case "count_deadminned_admins":
+ if (!bool.TryParse(value.ToString(), out var countDeadminnedAdmins))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerCountDeadminnedAdmins, countDeadminnedAdmins);
+ });
+ break;
+ case "show_reason":
+ if (!bool.TryParse(value.ToString(), out var showReason))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerShowReason, showReason);
+ });
+ break;
+ case "min_account_age_hours":
+ if (!int.TryParse(value.ToString(), out var minAccountAgeHours))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerMinAccountAge, minAccountAgeHours * 60);
+ });
+ break;
+ case "min_overall_hours":
+ if (!int.TryParse(value.ToString(), out var minOverallHours))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _config.SetCVar(CCVars.PanicBunkerMinOverallHours, minOverallHours * 60);
+ });
+ break;
+ }
+
+ _sawmill.Info($"Panic bunker setting {action} changed to {value} by {actor!.Name}({actor!.Guid}).");
+ await context.RespondAsync("Success", HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Sets the current MOTD.
+ /// </summary>
+ private async Task<bool> ActionForceMotd(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/set_motd")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var motdSupplied = context.RequestHeaders.TryGetValue("MOTD", out var motd);
+ if (!motdSupplied)
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _sawmill.Info($"MOTD changed to \"{motd}\" by {actor!.Name}({actor!.Guid}).");
+
+ _taskManager.RunOnMainThread(() => _config.SetCVar(CCVars.MOTD, motd.ToString()));
+ // A hook in the MOTD system sends the changes to each client
+ await context.RespondAsync("Success", HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Forces the next preset-
+ /// </summary>
+ private async Task<bool> ActionForcePreset(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/force_preset")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
+
+ if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
+ {
+ _sawmill.Info($"Attempted to force preset {actor!.Name}({actor!.Guid}) while the game was not in the pre-round lobby.");
+ await context.RespondAsync("This can only be executed while the game is in the pre-round lobby.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var presetSupplied = context.RequestHeaders.TryGetValue("PresetId", out var preset);
+ if (!presetSupplied)
+ {
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var result = await RunOnMainThread(() => ticker.FindGamePreset(preset.ToString()));
+ if (result == null)
+ {
+ await context.RespondAsync($"No preset exists with name {preset}.", HttpStatusCode.NotFound);
+ return true;
+ }
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ ticker.SetGamePreset(result);
+ });
+ _sawmill.Info($"Forced the game to start with preset {preset} by {actor!.Name}({actor!.Guid}).");
+ await context.RespondAsync("Success", HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Ends an active game rule.
+ /// </summary>
+ private async Task<bool> ActionEndGameRule(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/end_game_rule")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var gameRuleSupplied = context.RequestHeaders.TryGetValue("GameRuleId", out var gameRule);
+ if (!gameRuleSupplied)
+ {
+ _sawmill.Info($"Attempted to end game rule without supplying a game rule name by {actor!.Name}({actor!.Guid}).");
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+ var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
+ var gameRuleEntity = await RunOnMainThread(() => ticker
+ .GetActiveGameRules()
+ .FirstOrNull(rule => _entityManager.MetaQuery.GetComponent(rule).EntityPrototype?.ID == gameRule.ToString()));
+
+ if (gameRuleEntity == null) // Game rule not found
+ {
+ _sawmill.Info($"Attempted to end game rule {gameRule} by {actor!.Name}({actor!.Guid}), but it was not found.");
+ await context.RespondAsync("Gamerule not found or not active",HttpStatusCode.NotFound);
+ return true;
+ }
+
+ _sawmill.Info($"Ended game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
+ _taskManager.RunOnMainThread(() => ticker.EndGameRule((EntityUid) gameRuleEntity));
+ await context.RespondAsync($"Ended game rule {gameRule}({gameRuleEntity})", HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Adds a game rule to the current round.
+ /// </summary>
+ private async Task<bool> ActionAddGameRule(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/add_game_rule")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var gameRuleSupplied = context.RequestHeaders.TryGetValue("GameRuleId", out var gameRule);
+ if (!gameRuleSupplied)
+ {
+ _sawmill.Info($"Attempted to add game rule without supplying a game rule name by {actor!.Name}({actor!.Guid}).");
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
+
+ var tsc = new TaskCompletionSource<EntityUid>();
+ _taskManager.RunOnMainThread(() =>
+ {
+ var ruleEntity = ticker.AddGameRule(gameRule.ToString());
+ _sawmill.Info($"Added game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
+ if (ticker.RunLevel == GameRunLevel.InRound)
+ {
+ ticker.StartGameRule(ruleEntity);
+ _sawmill.Info($"Started game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
+ }
+ tsc.TrySetResult(ruleEntity);
+ });
+
+ var ruleEntity = await tsc.Task;
+ await context.RespondAsync($"Added game rule {ruleEntity}", HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Kicks a player.
+ /// </summary>
+ private async Task<bool> ActionKick(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/kick")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var playerSupplied = context.RequestHeaders.TryGetValue("Guid", out var guid);
+ if (!playerSupplied)
+ {
+ _sawmill.Info($"Attempted to kick player without supplying a username by {actor!.Name}({actor!.Guid}).");
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var session = await RunOnMainThread(() =>
+ {
+ // There is no function to get a session by GUID, so we have to iterate over all sessions and check their GUIDs.
+ foreach (var player in _playerManager.Sessions)
+ {
+ if (player.UserId.UserId.ToString() == guid.ToString())
+ {
+ return player;
+ }
+ }
+ return null;
+ });
+
+ if (session == null)
+ {
+ _sawmill.Info($"Attempted to kick player {guid} by {actor!.Name}({actor!.Guid}), but they were not found.");
+ await context.RespondAsync("Player not found", HttpStatusCode.NotFound);
+ return true;
+ }
+
+ var reasonSupplied = context.RequestHeaders.TryGetValue("Reason", out var reason);
+ if (!reasonSupplied)
+ {
+ reason = "No reason supplied";
+ }
+
+ reason += " (kicked by admin)";
+
+ _taskManager.RunOnMainThread(() =>
+ {
+ _netManager.DisconnectChannel(session.Channel, reason.ToString());
+ });
+ await context.RespondAsync("Success", HttpStatusCode.OK);
+ _sawmill.Info("Kicked player {0} ({1}) for {2} by {3}({4})", session.Name, session.UserId.UserId.ToString(), reason, actor!.Name, actor!.Guid);
+ return true;
+ }
+
+ /// <summary>
+ /// Round restart/end
+ /// </summary>
+ private async Task<bool> ActionRoundStatus(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/round")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ // Not using body, because that's a stream and I don't want to deal with that
+ var actionSupplied = context.RequestHeaders.TryGetValue("Action", out var action);
+ if (!actionSupplied)
+ {
+ _sawmill.Info($"Attempted to {action} round without supplying an action by {actor!.Name}({actor!.Guid}).");
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
+ var roundEndSystem = _entitySystemManager.GetEntitySystem<RoundEndSystem>();
+ switch (action)
+ {
+ case "start":
+ if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
+ {
+ await context.RespondAsync("Round already started", HttpStatusCode.BadRequest);
+ _sawmill.Info("Forced round start failed: round already started");
+ return true;
+ }
+ _taskManager.RunOnMainThread(() =>
+ {
+ ticker.StartRound();
+ });
+ _sawmill.Info("Forced round start");
+ break;
+ case "end":
+ if (ticker.RunLevel != GameRunLevel.InRound)
+ {
+ await context.RespondAsync("Round already ended", HttpStatusCode.BadRequest);
+ _sawmill.Info("Forced round end failed: round is not in progress");
+ return true;
+ }
+ _taskManager.RunOnMainThread(() =>
+ {
+ roundEndSystem.EndRound();
+ });
+ _sawmill.Info("Forced round end");
+ break;
+ case "restart":
+ if (ticker.RunLevel != GameRunLevel.InRound)
+ {
+ await context.RespondAsync("Round already ended", HttpStatusCode.BadRequest);
+ _sawmill.Info("Forced round restart failed: round is not in progress");
+ return true;
+ }
+ _taskManager.RunOnMainThread(() =>
+ {
+ roundEndSystem.EndRound();
+ });
+ _sawmill.Info("Forced round restart");
+ break;
+ case "restartnow": // You should restart yourself NOW!!!
+ _taskManager.RunOnMainThread(() =>
+ {
+ ticker.RestartRound();
+ });
+ _sawmill.Info("Forced instant round restart");
+ break;
+ default:
+ await context.RespondErrorAsync(HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ _sawmill.Info($"Round {action} by {actor!.Name}({actor!.Guid}).");
+ await context.RespondAsync("Success", HttpStatusCode.OK);
+ return true;
+ }
+#endregion
+
+#region Fetching
+
+ /// <summary>
+ /// Returns an array containing all presets.
+ /// </summary>
+ private async Task<bool> GetForcePresets(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/force_presets")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ var jObject = new JsonObject();
+ var presets = new List<string>();
+ foreach (var preset in _prototypeManager.EnumeratePrototypes<GamePresetPrototype>())
+ {
+ presets.Add(preset.ID);
+ }
+
+ jObject["presets"] = JsonNode.Parse(JsonSerializer.Serialize(presets));
+ await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
+ return true;
+ }
+
+ /// <summary>
+ /// Returns an array containing all game rules.
+ /// </summary>
+ private async Task<bool> GetGameRules(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/game_rules")
+ {
+ return false;
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ var jObject = new JsonObject();
+ var gameRules = new List<string>();
+ foreach (var gameRule in _prototypeManager.EnumeratePrototypes<EntityPrototype>())
+ {
+ if (gameRule.Abstract)
+ continue;
+
+ if (gameRule.HasComponent<GameRuleComponent>(_componentFactory))
+ gameRules.Add(gameRule.ID);
+ }
+
+ jObject["game_rules"] = JsonNode.Parse(JsonSerializer.Serialize(gameRules));
+ await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
+ return true;
+ }
+
+
+ /// <summary>
+ /// Handles fetching information.
+ /// </summary>
+ private async Task<bool> InfoHandler(IStatusHandlerContext context)
+ {
+ if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/info" || _token == string.Empty)
+ {
+ return false;
+ // 404
+ }
+
+ if (!CheckAccess(context))
+ {
+ await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
+ return true;
+ }
+
+ if (!CheckActor(context, out var actor))
+ {
+ await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
+ return true;
+ }
+
+ /* Information to display
+ Round number
+ Connected players
+ Active admins
+ Active game rules
+ Active game preset
+ Active map
+ MOTD
+ Panic bunker status
+ */
+
+ var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
+ var adminSystem = _entitySystemManager.GetEntitySystem<AdminSystem>();
+
+ var jObject = new JsonObject();
+
+ jObject["round_id"] = await RunOnMainThread(() => ticker.RoundId);
+
+ var players = new List<Player>();
+ var onlineAdmins = new List<Player>();
+ var onlineAdminsDeadmined = new List<Player>();
+
+ foreach (var player in _playerManager.Sessions)
+ {
+ players.Add(new Player
+ {
+ Guid = player.UserId.UserId.ToString(),
+ Name = player.Name
+ });
+ if (await RunOnMainThread(() => _adminManager.IsAdmin(player)))
+ {
+ onlineAdmins.Add(new Player
+ {
+ Guid = player.UserId.UserId.ToString(),
+ Name = player.Name
+ });
+ }
+ else if (await RunOnMainThread(() => _adminManager.IsAdmin(player, true)))
+ {
+ onlineAdminsDeadmined.Add(new Player
+ {
+ Guid = player.UserId.UserId.ToString(),
+ Name = player.Name
+ });
+ }
+ }
+
+ // The JsonSerializer.Serialize into JsonNode.Parse is a bit of a hack
+ jObject["players"] = JsonNode.Parse(JsonSerializer.Serialize(players));
+ jObject["admins"] = JsonNode.Parse(JsonSerializer.Serialize(onlineAdmins));
+ jObject["deadmined"] = JsonNode.Parse(JsonSerializer.Serialize(onlineAdminsDeadmined));
+
+ var gameRules = new List<string>();
+ foreach (var addedGameRule in await RunOnMainThread(() => ticker.GetActiveGameRules()))
+ {
+ var meta = _entityManager.MetaQuery.GetComponent(addedGameRule);
+ gameRules.Add(meta.EntityPrototype?.ID ?? meta.EntityPrototype?.Name ?? "Unknown");
+ }
+
+ jObject["game_rules"] = JsonNode.Parse(JsonSerializer.Serialize(gameRules));
+ jObject["game_preset"] = ticker.CurrentPreset?.ID;
+ jObject["map"] = await RunOnMainThread(() => _gameMapManager.GetSelectedMap()?.MapName ?? "Unknown");
+ jObject["motd"] = _motd;
+ jObject["panic_bunker"] = new JsonObject();
+ jObject["panic_bunker"]!["enabled"] = adminSystem.PanicBunker.Enabled;
+ jObject["panic_bunker"]!["disable_with_admins"] = adminSystem.PanicBunker.DisableWithAdmins;
+ jObject["panic_bunker"]!["enable_without_admins"] = adminSystem.PanicBunker.EnableWithoutAdmins;
+ jObject["panic_bunker"]!["count_deadminned_admins"] = adminSystem.PanicBunker.CountDeadminnedAdmins;
+ jObject["panic_bunker"]!["show_reason"] = adminSystem.PanicBunker.ShowReason;
+ jObject["panic_bunker"]!["min_account_age_hours"] = adminSystem.PanicBunker.MinAccountAgeHours;
+ jObject["panic_bunker"]!["min_overall_hours"] = adminSystem.PanicBunker.MinOverallHours;
+
+ _sawmill.Info($"Info requested by {actor!.Name}({actor!.Guid}).");
+ await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
+ return true;
+ }
+
+#endregion
+
+ private bool CheckAccess(IStatusHandlerContext context)
+ {
+ var auth = context.RequestHeaders.TryGetValue("Authorization", out var authToken);
+ if (!auth)
+ {
+ _sawmill.Info(@"Unauthorized access attempt to admin API. No auth header");
+ return false;
+ } // No auth header, no access
+
+ if (authToken == _token)
+ return true;
+
+ // Invalid auth header, no access
+ _sawmill.Info(@"Unauthorized access attempt to admin API. ""{0}""", authToken.ToString());
+ return false;
+ }
+
+ /// <summary>
+ /// Async helper function which runs a task on the main thread and returns the result.
+ /// </summary>
+ private async Task<T> RunOnMainThread<T>(Func<T> func)
+ {
+ var taskCompletionSource = new TaskCompletionSource<T>();
+ _taskManager.RunOnMainThread(() =>
+ {
+ taskCompletionSource.TrySetResult(func());
+ });
+
+ var result = await taskCompletionSource.Task;
+ return result;
+ }
+
+ private bool CheckActor(IStatusHandlerContext context, out Player? actor)
+ {
+ // We are trusting the header to be correct.
+ // This is fine because the header is set by the SS14.Admin backend.
+ var actorSupplied = context.RequestHeaders.TryGetValue("Actor", out var actorHeader);
+ if (!actorSupplied)
+ {
+ actor = null;
+ return false;
+ }
+
+ var stringRep = actorHeader.ToString();
+ actor = new Player()
+ {
+ // GUID_NAME format
+ Guid = stringRep[..stringRep.IndexOf('_')],
+ Name = stringRep[(stringRep.IndexOf('_') + 1)..]
+ };
+ return true;
+ }
+
+ private sealed class Player
+ {
+ public string Guid { get; set; } = default!;
+ public string Name { get; set; } = default!;
+ }
+}
projects / space-station-14.git / commitdiff