IW4M-Admin/Application/IW4MServer.cs

1754 lines
71 KiB
C#
Raw Normal View History

using IW4MAdmin.Application.IO;
using IW4MAdmin.Application.Misc;
2018-04-08 02:44:42 -04:00
using SharedLibraryCore;
using SharedLibraryCore.Configuration;
2018-04-08 02:44:42 -04:00
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Dtos;
using SharedLibraryCore.Exceptions;
using SharedLibraryCore.Helpers;
using SharedLibraryCore.Interfaces;
using System;
using System.Collections.Generic;
2023-04-05 10:54:57 -04:00
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
2021-07-11 18:26:30 -04:00
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Data.Abstractions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Serilog.Context;
using static SharedLibraryCore.Database.Models.EFClient;
using Data.Models;
using Data.Models.Server;
using IW4MAdmin.Application.Alerts;
using IW4MAdmin.Application.Commands;
2023-04-04 19:24:13 -04:00
using IW4MAdmin.Application.Plugin.Script;
using IW4MAdmin.Plugins.Stats.Helpers;
2021-07-08 22:12:09 -04:00
using Microsoft.EntityFrameworkCore;
using SharedLibraryCore.Alerts;
2023-04-05 10:54:57 -04:00
using SharedLibraryCore.Events.Management;
using SharedLibraryCore.Events.Server;
using SharedLibraryCore.Interfaces.Events;
using static Data.Models.Client.EFClient;
2015-03-08 17:20:10 -04:00
namespace IW4MAdmin
{
public class IW4MServer : Server
2015-03-08 17:20:10 -04:00
{
private static readonly SharedLibraryCore.Localization.TranslationLookup loc = Utilities.CurrentLocalization.LocalizationIndex;
public GameLogEventDetection LogEvent;
private readonly ITranslationLookup _translationLookup;
2022-03-23 09:43:57 -04:00
private readonly IMetaServiceV2 _metaService;
private const int REPORT_FLAG_COUNT = 4;
private long lastGameTime = 0;
private readonly IServiceProvider _serviceProvider;
private readonly IClientNoticeMessageFormatter _messageFormatter;
private readonly ILookupCache<EFServer> _serverCache;
private readonly CommandConfiguration _commandConfiguration;
2023-04-05 10:54:57 -04:00
private EFServer _cachedDatabaseServer;
private readonly StatManager _statManager;
private readonly ApplicationConfiguration _appConfig;
public IW4MServer(
ServerConfiguration serverConfiguration,
CommandConfiguration commandConfiguration,
ITranslationLookup lookup,
2022-03-23 09:43:57 -04:00
IMetaServiceV2 metaService,
IServiceProvider serviceProvider,
IClientNoticeMessageFormatter messageFormatter,
ILookupCache<EFServer> serverCache) : base(serviceProvider.GetRequiredService<ILogger<Server>>(),
2022-01-26 11:32:16 -05:00
#pragma warning disable CS0612
serviceProvider.GetRequiredService<SharedLibraryCore.Interfaces.ILogger>(),
2022-01-26 11:32:16 -05:00
#pragma warning restore CS0612
serverConfiguration,
serviceProvider.GetRequiredService<IManager>(),
serviceProvider.GetRequiredService<IRConConnectionFactory>(),
serviceProvider.GetRequiredService<IGameLogReaderFactory>(), serviceProvider)
{
_translationLookup = lookup;
_metaService = metaService;
_serviceProvider = serviceProvider;
_messageFormatter = messageFormatter;
_serverCache = serverCache;
_commandConfiguration = commandConfiguration;
2023-04-05 10:54:57 -04:00
_statManager = serviceProvider.GetRequiredService<StatManager>();
_appConfig = serviceProvider.GetService<ApplicationConfiguration>();
2023-04-05 10:54:57 -04:00
IGameServerEventSubscriptions.MonitoringStarted += async (gameEvent, token) =>
{
if (gameEvent.Server.Id != Id)
{
return;
}
await EnsureServerAdded();
await _statManager.EnsureServerAdded(gameEvent.Server, token);
};
}
public override async Task<EFClient> OnClientConnected(EFClient clientFromLog)
2015-03-08 17:20:10 -04:00
{
ServerLogger.LogDebug("Client slot #{clientNumber} now reserved", clientFromLog.ClientNumber);
var client = await Manager.GetClientService().GetUnique(clientFromLog.NetworkId, GameName);
2015-03-08 17:20:10 -04:00
// first time client is connecting to server
if (client == null)
{
ServerLogger.LogDebug("Client {client} first time connecting", clientFromLog.ToString());
clientFromLog.CurrentServer = this;
client = await Manager.GetClientService().Create(clientFromLog);
}
2021-06-03 11:51:03 -04:00
client.CopyAdditionalProperties(clientFromLog);
// this is only a temporary version until the IPAddress is transmitted
client.CurrentAlias = new EFAlias()
{
Name = clientFromLog.Name,
IPAddress = clientFromLog.IPAddress
};
// Do the player specific stuff
client.ClientNumber = clientFromLog.ClientNumber;
client.Score = clientFromLog.Score;
client.Ping = clientFromLog.Ping;
client.Team = clientFromLog.Team;
2022-03-28 17:05:00 -04:00
client.TeamName = clientFromLog.TeamName;
client.CurrentServer = this;
client.State = ClientState.Connecting;
Clients[client.ClientNumber] = client;
ServerLogger.LogDebug("End PreConnect for {client}", client.ToString());
2023-04-05 10:54:57 -04:00
var e = new GameEvent
2015-03-08 17:20:10 -04:00
{
Origin = client,
Owner = this,
Type = GameEvent.EventType.Connect
};
Manager.AddEvent(e);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientStateInitializeEvent
{
Client = client,
Source = this,
});
return client;
2015-03-08 17:20:10 -04:00
}
public override async Task OnClientDisconnected(EFClient client)
2015-03-08 17:20:10 -04:00
{
if (GetClientsAsList().All(eachClient => eachClient.NetworkId != client.NetworkId))
{
using (LogContext.PushProperty("Server", ToString()))
{
ServerLogger.LogWarning("{client} disconnecting, but they are not connected", client.ToString());
}
return;
}
2018-11-07 21:30:11 -05:00
#if DEBUG == true
2019-02-17 19:48:40 -05:00
if (client.ClientNumber >= 0)
2015-03-16 16:40:30 -04:00
{
2019-02-17 19:48:40 -05:00
#endif
ServerLogger.LogDebug("Client {@client} disconnecting...", new { client=client.ToString(), client.State });
2020-02-06 22:05:50 -05:00
Clients[client.ClientNumber] = null;
await client.OnDisconnect();
2020-02-06 22:05:50 -05:00
var e = new GameEvent()
{
Origin = client,
Owner = this,
Type = GameEvent.EventType.Disconnect
};
2015-03-08 17:20:10 -04:00
Manager.AddEvent(e);
2019-02-17 19:48:40 -05:00
#if DEBUG == true
}
#endif
2015-03-08 17:20:10 -04:00
}
public override async Task ExecuteEvent(GameEvent E)
{
using (LogContext.PushProperty("Server", ToString()))
2018-09-23 20:45:54 -04:00
{
if (E.IsBlocking)
2018-05-10 01:34:29 -04:00
{
await E.Origin.Lock();
2018-05-10 01:34:29 -04:00
}
try
2015-08-20 15:23:13 -04:00
{
if (!await ProcessEvent(E))
{
return;
}
Command command = null;
if (E.Type == GameEvent.EventType.Command)
{
try
{
command = await SharedLibraryCore.Commands.CommandProcessing.ValidateCommand(E, Manager.GetApplicationSettings().Configuration(), _commandConfiguration);
}
catch (CommandException e)
{
ServerLogger.LogWarning(e, "Error validating command from event {@Event}",
new { E.Type, E.Data, E.Message, E.Subtype, E.IsRemote, E.CorrelationId });
E.FailReason = GameEvent.EventFailReason.Invalid;
}
if (command != null)
{
E.Extra = command;
}
}
var canExecuteCommand = Manager.CommandInterceptors.All(interceptor =>
{
try
{
return interceptor(E);
}
catch
{
return true;
}
});
if (!canExecuteCommand)
{
E.Origin.Tell(_translationLookup["SERVER_COMMANDS_INTERCEPTED"]);
}
else if (E.Type == GameEvent.EventType.Command && E.Extra is Command cmd)
{
ServerLogger.LogInformation("Executing command {Command} for {Client}", cmd.Name,
E.Origin.ToString());
await cmd.ExecuteAsync(E);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientExecuteCommandEvent
{
Command = cmd,
Client = E.Origin,
Source = this,
CommandText = E.Data
});
}
2023-04-05 10:54:57 -04:00
var pluginTasks = Manager.Plugins.Where(plugin => !plugin.IsParser)
.Select(plugin => CreatePluginTask(plugin, E));
await Task.WhenAll(pluginTasks);
}
catch (Exception e)
{
ServerLogger.LogError(e, "Unexpected exception occurred processing event");
if (E.Origin != null && E.Type == GameEvent.EventType.Command)
{
E.Origin.Tell(_translationLookup["SERVER_ERROR_COMMAND_INGAME"]);
}
}
finally
{
if (E.IsBlocking)
{
E.Origin?.Unlock();
}
}
}
}
private async Task CreatePluginTask(IPlugin plugin, GameEvent gameEvent)
{
// we don't want to run the events on parser plugins
2022-02-13 22:38:40 -05:00
if (plugin is ScriptPlugin { IsParser: true })
{
return;
}
using var tokenSource = new CancellationTokenSource();
tokenSource.CancelAfter(Utilities.DefaultCommandTimeout);
try
{
2023-04-05 10:54:57 -04:00
await plugin.OnEventAsync(gameEvent, this);
}
2022-02-13 22:38:40 -05:00
catch (OperationCanceledException)
{
ServerLogger.LogWarning("Timed out executing event {EventType} for {Plugin}", gameEvent.Type,
plugin.Name);
}
catch (Exception ex)
{
2021-11-20 20:01:25 -05:00
Console.WriteLine(loc["SERVER_PLUGIN_ERROR"].FormatExt(plugin.Name, ex.GetType().Name));
ServerLogger.LogError(ex, "Could not execute {methodName} for plugin {plugin}",
nameof(plugin.OnEventAsync), plugin.Name);
}
}
/// <summary>
/// Perform the server specific tasks when an event occurs
/// </summary>
/// <param name="E"></param>
/// <returns></returns>
protected override async Task<bool> ProcessEvent(GameEvent E)
{
using (LogContext.PushProperty("Server", ToString()))
using (LogContext.PushProperty("EventType", E.Type))
{
ServerLogger.LogDebug("processing event of type {type}", E.Type);
2023-04-05 10:54:57 -04:00
if (E.Type == GameEvent.EventType.ConnectionLost)
{
var exception = E.Extra as Exception;
ServerLogger.LogError(exception,
"Connection lost with {server}", ToString());
if (!Manager.GetApplicationSettings().Configuration().IgnoreServerConnectionLost)
{
Console.WriteLine(loc["SERVER_ERROR_COMMUNICATION"].FormatExt($"{ListenAddress}:{ListenPort}"));
var alert = Alert.AlertState.Build().OfType(E.Type.ToString())
.WithCategory(Alert.AlertCategory.Error)
.FromSource("System")
.WithMessage(loc["SERVER_ERROR_COMMUNICATION"].FormatExt($"{ListenAddress}:{ListenPort}"))
.ExpiresIn(TimeSpan.FromDays(1));
Manager.AlertManager.AddAlert(alert);
}
Throttled = true;
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.ConnectionRestored)
{
ServerLogger.LogInformation(
"Connection restored with {Server}", ToString());
if (!Manager.GetApplicationSettings().Configuration().IgnoreServerConnectionLost)
{
Console.WriteLine(loc["MANAGER_CONNECTION_REST"].FormatExt($"{ListenAddress}:{ListenPort}"));
var alert = Alert.AlertState.Build().OfType(E.Type.ToString())
.WithCategory(Alert.AlertCategory.Information)
.FromSource("System")
.WithMessage(loc["MANAGER_CONNECTION_REST"].FormatExt($"{ListenAddress}:{ListenPort}"))
.ExpiresIn(TimeSpan.FromDays(1));
Manager.AlertManager.AddAlert(alert);
}
2021-09-18 19:28:37 -04:00
if (!string.IsNullOrEmpty(CustomSayName))
{
await this.SetDvarAsync("sv_sayname", CustomSayName, Manager.CancellationToken);
2021-09-18 19:28:37 -04:00
}
Throttled = false;
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.ChangePermission)
{
var newPermission = (Permission) E.Extra;
2023-04-05 10:54:57 -04:00
var oldPermission = E.Target.Level;
ServerLogger.LogInformation("{origin} is setting {target} to permission level {newPermission}",
E.Origin.ToString(), E.Target.ToString(), newPermission);
await Manager.GetClientService().UpdateLevel(newPermission, E.Target, E.Origin);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPermissionChangeEvent
{
Client = E.Origin,
Source = this,
OldPermission = oldPermission,
NewPermission = newPermission
});
}
else if (E.Type == GameEvent.EventType.Connect)
{
if (E.Origin.State != ClientState.Connected)
{
E.Origin.State = ClientState.Connected;
E.Origin.Connections += 1;
ChatHistory.Add(new ChatInfo()
{
Name = E.Origin.Name,
Message = "CONNECTED",
Time = DateTime.UtcNow
});
2022-03-23 09:43:57 -04:00
var clientTag = await _metaService.GetPersistentMetaByLookup(EFMeta.ClientTagV2,
EFMeta.ClientTagNameV2, E.Origin.ClientId, Manager.CancellationToken);
if (clientTag?.Value != null)
{
2022-07-08 21:39:58 -04:00
E.Origin.Tag = clientTag.Value;
}
2021-07-08 22:12:09 -04:00
try
{
var factory = _serviceProvider.GetRequiredService<IDatabaseContextFactory>();
2022-01-28 10:35:01 -05:00
await using var context = factory.CreateContext(enableTracking: false);
2021-07-08 22:12:09 -04:00
var messageCount = await context.InboxMessages
.CountAsync(msg => msg.DestinationClientId == E.Origin.ClientId && !msg.IsDelivered);
if (messageCount > 0)
{
E.Origin.Tell(_translationLookup["SERVER_JOIN_OFFLINE_MESSAGES"]);
}
}
catch (Exception ex)
{
ServerLogger.LogError(ex, "Could not get offline message count for {Client}", E.Origin.ToString());
throw;
}
await E.Origin.OnJoin(E.Origin.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
}
}
else if (E.Type == GameEvent.EventType.PreConnect)
{
ServerLogger.LogInformation("Detected PreConnect for {client} from {source}", E.Origin.ToString(), E.Source);
// we don't want to track bots in the database at all if ignore bots is requested
if (E.Origin.IsBot && Manager.GetApplicationSettings().Configuration().IgnoreBots)
{
return false;
}
if (E.Origin.CurrentServer == null)
{
ServerLogger.LogWarning("Preconnecting client {client} did not have a current server specified",
E.Origin.ToString());
E.Origin.CurrentServer = this;
}
var existingClient = GetClientsAsList().FirstOrDefault(_client => _client.Equals(E.Origin));
// they're already connected
if (existingClient != null && existingClient.ClientNumber == E.Origin.ClientNumber &&
!E.Origin.IsBot)
{
ServerLogger.LogInformation("{client} is already connected, so we are ignoring their PreConnect",
E.Origin.ToString());
return false;
}
// this happens for some reason rarely where the client spots get out of order
// possible a connect/reconnect game event before we get to process it here
// it appears that new games decide to switch client slots between maps (even if the clients aren't disconnecting)
// bots can have duplicate names which causes conflicting GUIDs
if (existingClient != null && existingClient.ClientNumber != E.Origin.ClientNumber &&
!E.Origin.IsBot)
2018-11-07 21:30:11 -05:00
{
ServerLogger.LogWarning(
"client {client} is trying to connect in client slot {newClientSlot}, but they are already registered in client slot {oldClientSlot}, swapping...",
E.Origin.ToString(), E.Origin.ClientNumber, existingClient.ClientNumber);
// we need to remove them so the client spots can swap
await OnClientDisconnected(Clients[existingClient.ClientNumber]);
2018-11-07 21:30:11 -05:00
}
if (Clients[E.Origin.ClientNumber] == null)
{
ServerLogger.LogDebug("Begin PreConnect for {origin}", E.Origin.ToString());
// we can go ahead and put them in so that they don't get re added
Clients[E.Origin.ClientNumber] = E.Origin;
try
{
E.Origin.GameName = (Reference.Game)GameName;
E.Origin = await OnClientConnected(E.Origin);
E.Target = E.Origin;
}
catch (Exception ex)
{
Console.WriteLine($"{loc["SERVER_ERROR_ADDPLAYER"]} {E.Origin}");
ServerLogger.LogError(ex, "Could not add player {player}", E.Origin.ToString());
Clients[E.Origin.ClientNumber] = null;
return false;
}
if (E.Origin.Level > Permission.Moderator)
{
E.Origin.Tell(loc["SERVER_REPORT_COUNT_V2"].FormatExt(E.Owner.Reports.Count));
}
}
// for some reason there's still a client in the spot
else
{
ServerLogger.LogWarning(
"{origin} is connecting but {existingClient} is currently in that client slot",
E.Origin.ToString(), Clients[E.Origin.ClientNumber].ToString());
}
}
else if (E.Type == GameEvent.EventType.Flag)
{
DateTime? expires = null;
if (E.Extra is TimeSpan ts)
{
expires = DateTime.UtcNow + ts;
}
// todo: maybe move this to a seperate function
var newPenalty = new EFPenalty()
{
Type = EFPenalty.PenaltyType.Flag,
Expires = expires,
Offender = E.Target,
Offense = E.Data,
Punisher = E.ImpersonationOrigin ?? E.Origin,
When = DateTime.UtcNow,
Link = E.Target.AliasLink
};
2021-08-21 11:40:03 -04:00
await Manager.GetPenaltyService().Create(newPenalty);
E.Target.SetLevel(Permission.Flagged, E.Origin);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = E.Target,
Penalty = newPenalty
});
}
else if (E.Type == GameEvent.EventType.Unflag)
{
2022-02-22 18:09:50 -05:00
var unflagPenalty = new EFPenalty
{
Type = EFPenalty.PenaltyType.Unflag,
Expires = DateTime.UtcNow,
Offender = E.Target,
Offense = E.Data,
Punisher = E.ImpersonationOrigin ?? E.Origin,
When = DateTime.UtcNow,
Link = E.Target.AliasLink
};
E.Target.SetLevel(Permission.User, E.Origin);
2022-02-22 18:09:50 -05:00
await Manager.GetPenaltyService().RemoveActivePenalties(E.Target.AliasLinkId, E.Target.NetworkId,
E.Target.GameName, E.Target.CurrentAlias?.IPAddress, new[] {EFPenalty.PenaltyType.Flag});
await Manager.GetPenaltyService().Create(unflagPenalty);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyRevokeEvent
{
Client = E.Target,
Penalty = unflagPenalty
});
}
else if (E.Type == GameEvent.EventType.Report)
{
Reports.Add(new Report()
{
Origin = E.Origin,
Target = E.Target,
2022-04-19 19:43:58 -04:00
Reason = E.Data,
ReportedOn = DateTime.UtcNow
});
var newReport = new EFPenalty()
{
Type = EFPenalty.PenaltyType.Report,
Expires = DateTime.UtcNow,
Offender = E.Target,
Offense = E.Message,
Punisher = E.ImpersonationOrigin ?? E.Origin,
Active = true,
When = DateTime.UtcNow,
Link = E.Target.AliasLink
};
await Manager.GetPenaltyService().Create(newReport);
var reportNum = await Manager.GetClientService().GetClientReportCount(E.Target.ClientId);
var canBeAutoFlagged = await Manager.GetClientService().CanBeAutoFlagged(E.Target.ClientId);
if (!E.Target.IsPrivileged() && reportNum >= REPORT_FLAG_COUNT && canBeAutoFlagged)
{
E.Target.Flag(
Utilities.CurrentLocalization.LocalizationIndex["SERVER_AUTO_FLAG_REPORT"]
.FormatExt(reportNum), Utilities.IW4MAdminClient(E.Owner));
}
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = E.Target,
Penalty = newReport,
Source = this
});
}
else if (E.Type == GameEvent.EventType.TempBan)
{
await TempBan(E.Data, (TimeSpan) E.Extra, E.Target, E.ImpersonationOrigin ?? E.Origin);
}
else if (E.Type == GameEvent.EventType.Ban)
{
bool isEvade = E.Extra != null ? (bool) E.Extra : false;
await Ban(E.Data, E.Target, E.ImpersonationOrigin ?? E.Origin, isEvade);
}
else if (E.Type == GameEvent.EventType.Unban)
{
await Unban(E.Data, E.Target, E.ImpersonationOrigin ?? E.Origin);
}
else if (E.Type == GameEvent.EventType.Kick)
{
await Kick(E.Data, E.Target, E.ImpersonationOrigin ?? E.Origin, E.Extra as EFPenalty);
}
else if (E.Type == GameEvent.EventType.Warn)
{
await Warn(E.Data, E.Target, E.ImpersonationOrigin ?? E.Origin);
}
else if (E.Type == GameEvent.EventType.Disconnect)
{
ChatHistory.Add(new ChatInfo()
{
Name = E.Origin.Name,
Message = "DISCONNECTED",
Time = DateTime.UtcNow
});
await _metaService.SetPersistentMeta("LastMapPlayed", CurrentMap.Alias, E.Origin.ClientId);
await _metaService.SetPersistentMeta("LastServerPlayed", E.Owner.Hostname, E.Origin.ClientId);
}
2018-10-03 22:20:49 -04:00
else if (E.Type == GameEvent.EventType.PreDisconnect)
{
ServerLogger.LogInformation("Detected PreDisconnect for {client} from {source}",
E.Origin.ToString(), E.Source);
bool isPotentialFalseQuit = E.GameTime.HasValue && E.GameTime.Value == lastGameTime;
if (isPotentialFalseQuit)
{
ServerLogger.LogDebug(
"Received PreDisconnect event for {origin}, but it occured at game time {gameTime}, which is the same last map change, so we're ignoring",
E.Origin.ToString(), E.GameTime);
return false;
}
// predisconnect comes from minimal rcon polled players and minimal log players
// so we need to disconnect the "full" version of the client
var client = GetClientsAsList().FirstOrDefault(_client => _client.Equals(E.Origin));
if (client == null)
{
// this can happen when the status picks up the connect before the log does
ServerLogger.LogInformation(
"Ignoring PreDisconnect for {origin} because they are no longer on the client list",
E.Origin.ToString());
return false;
}
2018-11-07 21:30:11 -05:00
else if (client.State != ClientState.Unknown)
{
await OnClientDisconnected(client);
return true;
}
else
{
ServerLogger.LogWarning(
"Expected disconnecting client {client} to be in state {state}, but is in state {clientState}",
client.ToString(), ClientState.Connected.ToString(), client.State);
return false;
}
2018-11-07 21:30:11 -05:00
}
else if (E.Type == GameEvent.EventType.Update)
{
ServerLogger.LogDebug("Begin Update for {origin}", E.Origin.ToString());
await OnClientUpdate(E.Origin);
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.Say)
{
if (E.Data?.Length > 0)
{
string message = E.Data;
if (E.Data.IsQuickMessage())
{
try
{
message = _serviceProvider.GetRequiredService<DefaultSettings>()
.QuickMessages
.First(_qm => _qm.Game == GameName)
.Messages[E.Data.Substring(1)];
}
catch
{
message = E.Data.Substring(1);
}
}
2022-04-19 19:43:58 -04:00
ChatHistory.Add(new ChatInfo
{
Name = E.Origin.Name,
Message = message,
Time = DateTime.UtcNow,
IsHidden = !string.IsNullOrEmpty(GamePassword)
});
}
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.MapChange)
{
ServerLogger.LogInformation("New map loaded - {ClientCount} active players", ClientNum);
// iw4 doesn't log the game info
if (E.Extra == null)
{
var dict = await this.GetInfoAsync(new TimeSpan(0, 0, 20));
if (dict == null)
{
ServerLogger.LogWarning("Map change event response doesn't have any data");
}
else
{
if (dict.ContainsKey("gametype"))
{
UpdateGametype(dict["gametype"]);
}
if (dict.ContainsKey("hostname"))
{
UpdateHostname(dict["hostname"]);
}
var newMapName = dict.ContainsKey("mapname")
? dict["mapname"] ?? CurrentMap.Name
: CurrentMap.Name;
UpdateMap(newMapName);
}
}
else
{
var dict = (Dictionary<string, string>)E.Extra;
if (dict.ContainsKey("g_gametype"))
{
UpdateGametype(dict["g_gametype"]);
}
if (dict.ContainsKey("sv_hostname"))
{
UpdateHostname(dict["sv_hostname"]);
}
if (dict.ContainsKey("sv_maxclients"))
{
UpdateMaxPlayers(int.Parse(dict["sv_maxclients"]));
}
else if (dict.ContainsKey("com_maxclients"))
{
UpdateMaxPlayers(int.Parse(dict["com_maxclients"]));
}
2023-04-05 10:54:57 -04:00
else if (dict.ContainsKey("com_maxplayers"))
{
UpdateMaxPlayers(int.Parse(dict["com_maxplayers"]));
2023-04-05 10:54:57 -04:00
}
if (dict.ContainsKey("mapname"))
{
UpdateMap(dict["mapname"]);
}
}
if (E.GameTime.HasValue)
{
lastGameTime = E.GameTime.Value;
}
MatchStartTime = DateTime.Now;
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.MapEnd)
{
ServerLogger.LogInformation("Game ending...");
if (E.GameTime.HasValue)
{
lastGameTime = E.GameTime.Value;
}
MatchEndTime = DateTime.Now;
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.Tell)
{
await Tell(E.Message, E.Target);
}
2022-02-15 21:05:50 -05:00
else if (E.Type == GameEvent.EventType.Broadcast)
{
if (!Utilities.IsDevelopment && E.Data != null) // hides broadcast when in development mode
{
await E.Owner.ExecuteCommandAsync(E.Data);
}
}
else if (E.Type == GameEvent.EventType.JoinTeam)
{
E.Origin.UpdateTeam(E.Extra as string);
}
lock (ChatHistory)
{
while (ChatHistory.Count > Math.Ceiling(ClientNum / 2.0))
{
ChatHistory.RemoveAt(0);
}
}
// the last client hasn't fully disconnected yet
// so there will still be at least 1 client left
if (ClientNum < 2)
{
ChatHistory.Clear();
}
return true;
}
}
2023-04-05 10:54:57 -04:00
public async Task EnsureServerAdded()
{
var gameServer = await _serverCache
.FirstAsync(server => server.EndPoint == base.Id);
if (gameServer == null)
{
gameServer = new EFServer
{
Port = ListenPort,
EndPoint = base.Id,
ServerId = BuildLegacyDatabaseId(),
GameName = (Reference.Game?)GameName,
HostName = ServerName
};
await _serverCache.AddAsync(gameServer);
}
await using var context = _serviceProvider.GetRequiredService<IDatabaseContextFactory>()
.CreateContext(enableTracking: false);
context.Servers.Attach(gameServer);
// we want to set the gamename up if it's never been set, or it changed
if (!gameServer.GameName.HasValue || gameServer.GameName.Value != GameCode)
{
gameServer.GameName = GameCode;
context.Entry(gameServer).Property(property => property.GameName).IsModified = true;
}
if (gameServer.HostName == null || gameServer.HostName != ServerName)
{
gameServer.HostName = ServerName;
context.Entry(gameServer).Property(property => property.HostName).IsModified = true;
}
if (gameServer.IsPasswordProtected != !string.IsNullOrEmpty(GamePassword))
{
gameServer.IsPasswordProtected = !string.IsNullOrEmpty(GamePassword);
context.Entry(gameServer).Property(property => property.IsPasswordProtected).IsModified = true;
}
await context.SaveChangesAsync();
_cachedDatabaseServer = gameServer;
}
private async Task OnClientUpdate(EFClient origin)
2018-11-07 21:30:11 -05:00
{
var client = GetClientsAsList().FirstOrDefault(c => c.NetworkId == origin.NetworkId);
if (client == null)
{
2021-10-31 12:57:32 -04:00
ServerLogger.LogWarning("{Origin} expected to exist in client list for update, but they do not", origin.ToString());
return;
}
2018-11-07 21:30:11 -05:00
client.Ping = origin.Ping;
client.Score = origin.Score;
2018-11-07 21:30:11 -05:00
// update their IP if it hasn't been set yet
if (client.IPAddress == null &&
!client.IsBot &&
client.State == ClientState.Connected)
{
try
2018-11-07 21:30:11 -05:00
{
await client.OnJoin(origin.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
}
catch (Exception e)
{
using(LogContext.PushProperty("Server", ToString()))
{
ServerLogger.LogError(e, "Could not execute on join for {origin}", origin.ToString());
}
2018-11-07 21:30:11 -05:00
}
}
2021-10-31 12:57:32 -04:00
else if (client.IPAddress != null && client.State == ClientState.Disconnecting ||
client.Level == Permission.Banned)
{
2021-10-31 12:57:32 -04:00
ServerLogger.LogWarning("{Client} state is Unknown (probably kicked), but they are still connected. trying to kick again...", origin.ToString());
await client.CanConnect(client.IPAddress, Manager.GetApplicationSettings().Configuration().EnableImplicitAccountLinking);
}
2018-11-07 21:30:11 -05:00
}
/// <summary>
/// lists the connecting and disconnecting clients via RCon response
/// array index 0 = connecting clients
/// array index 1 = disconnecting clients
/// array index 2 = updated clients
/// </summary>
/// <returns></returns>
async Task<List<EFClient>[]> PollPlayersAsync(CancellationToken token)
2015-03-08 17:20:10 -04:00
{
if (DateTime.Now - (MatchEndTime ?? MatchStartTime) < TimeSpan.FromSeconds(15))
{
ServerLogger.LogDebug("Skipping status poll attempt because the match ended recently");
return null;
}
var currentClients = GetClientsAsList();
var statusResponse = await this.GetStatusAsync(token);
if (statusResponse is null)
{
return null;
}
2021-06-03 11:51:03 -04:00
var polledClients = statusResponse.Clients.AsEnumerable();
if (Manager.GetApplicationSettings().Configuration().IgnoreBots)
{
polledClients = polledClients.Where(c => !c.IsBot);
}
var disconnectingClients = currentClients.Except(polledClients);
2018-11-07 21:30:11 -05:00
var connectingClients = polledClients.Except(currentClients);
var updatedClients = polledClients.Except(connectingClients).Except(disconnectingClients);
2021-06-03 11:51:03 -04:00
UpdateMap(statusResponse.Map);
UpdateGametype(statusResponse.GameType);
UpdateHostname(statusResponse.Hostname);
UpdateMaxPlayers(statusResponse.MaxClients);
2019-11-18 15:02:35 -05:00
2021-06-03 11:51:03 -04:00
return new []
2018-11-07 21:30:11 -05:00
{
connectingClients.ToList(),
disconnectingClients.ToList(),
updatedClients.ToList()
};
}
public override async Task<long> GetIdForServer(Server server = null)
{
server ??= this;
2023-04-05 10:54:57 -04:00
return (await _serverCache.FirstAsync(cachedServer =>
cachedServer.EndPoint == server.Id || cachedServer.ServerId == server.EndPoint)).ServerId;
}
2023-04-05 10:54:57 -04:00
private long BuildLegacyDatabaseId()
{
long id = HashCode.Combine(ListenAddress, ListenPort);
return id < 0 ? Math.Abs(id) : id;
}
2015-03-08 17:20:10 -04:00
private void UpdateMap(string mapName)
2019-11-18 15:02:35 -05:00
{
if (string.IsNullOrEmpty(mapName))
2019-11-18 15:02:35 -05:00
{
return;
}
var foundMap = Maps.Find(m => m.Name == mapName) ?? new Map
{
Alias = mapName,
Name = mapName
};
if (foundMap == CurrentMap)
{
return;
}
CurrentMap = foundMap;
using(LogContext.PushProperty("Server", Id))
{
ServerLogger.LogDebug("Updating map to {@CurrentMap}", CurrentMap);
2019-11-18 15:02:35 -05:00
}
}
2020-08-05 10:30:02 -04:00
private void UpdateGametype(string gameType)
{
if (string.IsNullOrEmpty(gameType))
{
return;
}
Gametype = gameType;
using(LogContext.PushProperty("Server", Id))
2020-08-05 10:30:02 -04:00
{
ServerLogger.LogDebug("Updating gametype to {Gametype}", gameType);
2020-08-05 10:30:02 -04:00
}
}
2021-06-03 11:51:03 -04:00
private void UpdateHostname(string hostname)
{
if (string.IsNullOrEmpty(hostname) || Hostname == hostname)
{
return;
}
using(LogContext.PushProperty("Server", Id))
2021-06-03 11:51:03 -04:00
{
ServerLogger.LogDebug("Updating hostname to {HostName}", hostname);
}
Hostname = hostname;
}
private void UpdateMaxPlayers(int? maxPlayers)
{
if (maxPlayers == null || maxPlayers == MaxClients)
{
return;
}
using(LogContext.PushProperty("Server", Id))
2021-06-03 11:51:03 -04:00
{
ServerLogger.LogDebug("Updating max clients to {MaxPlayers}", maxPlayers);
}
MaxClients = maxPlayers.Value;
}
private async Task ShutdownInternal()
{
foreach (var client in GetClientsAsList())
{
await client.OnDisconnect();
2023-04-05 10:54:57 -04:00
var e = new GameEvent
{
Type = GameEvent.EventType.Disconnect,
Owner = this,
Origin = client
};
Manager.AddEvent(e);
await e.WaitAsync(Utilities.DefaultCommandTimeout, new CancellationTokenRegistration().Token);
}
2023-04-05 10:54:57 -04:00
using var tokenSource = new CancellationTokenSource();
tokenSource.CancelAfter(Utilities.DefaultCommandTimeout);
Manager.QueueEvent(new MonitorStopEvent
{
Server = this
});
}
private DateTime _lastMessageSent = DateTime.Now;
private DateTime _lastPlayerCount = DateTime.Now;
2015-03-08 17:20:10 -04:00
public override async Task<bool> ProcessUpdatesAsync(CancellationToken token)
{
try
{
if (token.IsCancellationRequested)
{
await ShutdownInternal();
2018-11-07 21:30:11 -05:00
return true;
}
try
{
if (Manager.GetApplicationSettings().Configuration().RConPollRate == int.MaxValue &&
Utilities.IsDevelopment)
{
return true;
}
var polledClients = await PollPlayersAsync(token);
if (polledClients is null)
{
return true;
}
foreach (var disconnectingClient in polledClients[1]
.Where(client => !client.IsZombieClient /* ignores "fake" zombie clients */))
{
2020-04-26 13:32:41 -04:00
disconnectingClient.CurrentServer = this;
var e = new GameEvent
{
2018-11-07 21:30:11 -05:00
Type = GameEvent.EventType.PreDisconnect,
Origin = disconnectingClient,
Owner = this,
Source = GameEvent.EventSource.Status
};
Manager.AddEvent(e);
await e.WaitAsync(Utilities.DefaultCommandTimeout, Manager.CancellationToken);
}
// this are our new connecting clients
foreach (var client in polledClients[0].Where(client =>
!string.IsNullOrEmpty(client.Name) && (client.Ping != 999 || client.IsBot)))
{
2020-04-26 13:32:41 -04:00
client.CurrentServer = this;
client.GameName = (Reference.Game)GameName;
2022-04-22 17:03:34 -04:00
var e = new GameEvent
{
2018-11-07 21:30:11 -05:00
Type = GameEvent.EventType.PreConnect,
Origin = client,
Owner = this,
IsBlocking = true,
Extra = client.GetAdditionalProperty<string>("BotGuid"),
2022-04-22 17:03:34 -04:00
Source = GameEvent.EventSource.Status,
2018-11-07 21:30:11 -05:00
};
Manager.AddEvent(e);
await e.WaitAsync(Utilities.DefaultCommandTimeout, Manager.CancellationToken);
}
2018-11-07 21:30:11 -05:00
// these are the clients that have updated
foreach (var client in polledClients[2])
{
2020-04-26 13:32:41 -04:00
client.CurrentServer = this;
var gameEvent = new GameEvent
{
2018-11-07 21:30:11 -05:00
Type = GameEvent.EventType.Update,
Origin = client,
Owner = this
};
Manager.AddEvent(gameEvent);
}
2023-04-05 10:54:57 -04:00
if (polledClients[2].Any())
{
Manager.QueueEvent(new ClientDataUpdateEvent
{
Clients = new ReadOnlyCollection<EFClient>(polledClients[2]),
Server = this,
Source = this,
});
}
if (Throttled)
{
var gameEvent = new GameEvent
{
Type = GameEvent.EventType.ConnectionRestored,
Owner = this,
Origin = Utilities.IW4MAdminClient(this),
Target = Utilities.IW4MAdminClient(this)
};
Manager.AddEvent(gameEvent);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ConnectionRestoreEvent
{
Server = this,
Source = this
});
}
2018-11-07 21:30:11 -05:00
LastPoll = DateTime.Now;
}
catch (NetworkException ex)
{
if (Throttled)
{
return true;
}
var gameEvent = new GameEvent
{
Type = GameEvent.EventType.ConnectionLost,
Owner = this,
Origin = Utilities.IW4MAdminClient(this),
Target = Utilities.IW4MAdminClient(this),
Extra = ex,
Data = ConnectionErrors.ToString()
};
2022-03-29 18:18:41 -04:00
Manager.AddEvent(gameEvent);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ConnectionInterruptEvent
{
Server = this,
Source = this
});
return true;
}
finally
{
RunServerCollection();
}
if (DateTime.Now - _lastMessageSent <=
TimeSpan.FromSeconds(Manager.GetApplicationSettings().Configuration().AutoMessagePeriod) ||
BroadcastMessages.Count <= 0 || ClientNum <= 0)
{
return true;
}
// send out broadcast messages
var messages =
(await this.ProcessMessageToken(Manager.GetMessageTokens(), BroadcastMessages[NextMessage])).Split(
Environment.NewLine);
await BroadcastAsync(messages, token: Manager.CancellationToken);
NextMessage = NextMessage == BroadcastMessages.Count - 1 ? 0 : NextMessage + 1;
_lastMessageSent = DateTime.Now;
return true;
}
catch (TaskCanceledException)
{
await ShutdownInternal();
return true;
}
// this one is ok
catch (Exception e) when (e is ServerException || e is RConException)
{
using (LogContext.PushProperty("Server", ToString()))
{
ServerLogger.LogWarning(e, "Undesirable exception occured during processing updates");
}
return false;
}
catch (Exception e)
{
using (LogContext.PushProperty("Server", ToString()))
{
ServerLogger.LogError(e, "Unexpected exception occured during processing updates");
}
Console.WriteLine(loc["SERVER_ERROR_EXCEPTION"].FormatExt($"[{ListenAddress}:{ListenPort}]"));
return false;
2015-03-08 17:20:10 -04:00
}
}
2022-03-29 18:18:41 -04:00
private void RunServerCollection()
{
if (DateTime.Now - _lastPlayerCount < _appConfig?.ServerDataCollectionInterval)
2022-03-29 18:18:41 -04:00
{
return;
}
var maxItems = Math.Ceiling(_appConfig!.MaxClientHistoryTime.TotalMinutes /
_appConfig.ServerDataCollectionInterval.TotalMinutes);
2022-03-29 18:18:41 -04:00
while (ClientHistory.ClientCounts.Count > maxItems)
{
ClientHistory.ClientCounts.RemoveAt(0);
}
ClientHistory.ClientCounts.Add(new ClientCountSnapshot
{
ClientCount = ClientNum,
ConnectionInterrupted = Throttled,
Time = DateTime.UtcNow,
Map = CurrentMap.Name
});
_lastPlayerCount = DateTime.Now;
2022-03-29 18:18:41 -04:00
}
public async Task Initialize()
2015-03-08 17:20:10 -04:00
{
2021-07-11 18:26:30 -04:00
try
{
ResolvedIpEndPoint =
new IPEndPoint(
(await Dns.GetHostAddressesAsync(ListenAddress)).First(address =>
address.AddressFamily == AddressFamily.InterNetwork), ListenPort);
2021-07-11 18:26:30 -04:00
}
catch (Exception ex)
{
ServerLogger.LogWarning(ex, "Could not resolve hostname or IP for RCon connection {Address}:{Port}", ListenAddress, ListenPort);
ResolvedIpEndPoint = new IPEndPoint(IPAddress.Parse(ListenAddress), ListenPort);
2021-07-11 18:26:30 -04:00
}
2019-02-02 21:19:24 -05:00
RconParser = Manager.AdditionalRConParsers
.FirstOrDefault(parser =>
parser.Version == ServerConfig.RConParserVersion ||
parser.Name == ServerConfig.RConParserVersion);
2019-02-01 20:49:25 -05:00
2019-02-02 21:19:24 -05:00
EventParser = Manager.AdditionalEventParsers
.FirstOrDefault(parser =>
parser.Version == ServerConfig.EventParserVersion ||
parser.Name == ServerConfig.RConParserVersion);
2019-02-01 20:49:25 -05:00
2021-06-11 12:52:30 -04:00
RconParser ??= Manager.AdditionalRConParsers[0];
EventParser ??= Manager.AdditionalEventParsers[0];
2019-02-02 19:54:30 -05:00
2021-07-11 18:26:30 -04:00
RemoteConnection = RConConnectionFactory.CreateConnection(ResolvedIpEndPoint, Password, RconParser.RConEngine);
RemoteConnection.SetConfiguration(RconParser);
var version = await this.GetMappedDvarValueOrDefaultAsync<string>("version", token: Manager.CancellationToken);
Version = version.Value;
2021-04-16 14:35:51 -04:00
GameName = Utilities.GetGame(version.Value ?? RconParser.Version);
if (GameName == Game.UKN)
{
GameName = RconParser.GameName;
}
if (version.Value?.Length != 0)
2019-02-02 21:19:24 -05:00
{
var matchedRconParser = Manager.AdditionalRConParsers.FirstOrDefault(_parser => _parser.Version == version.Value);
RconParser.Configuration = matchedRconParser != null ? matchedRconParser.Configuration : RconParser.Configuration;
2019-02-03 21:47:05 -05:00
EventParser = Manager.AdditionalEventParsers.FirstOrDefault(_parser => _parser.Version == version.Value) ?? EventParser;
Version = RconParser.Version;
2019-02-02 21:19:24 -05:00
}
var svRunning = await this.GetMappedDvarValueOrDefaultAsync<string>("sv_running", token: Manager.CancellationToken);
if (!string.IsNullOrEmpty(svRunning.Value) && svRunning.Value != "1")
{
throw new ServerException(loc["SERVER_ERROR_NOT_RUNNING"].FormatExt(this.ToString()));
}
2019-02-01 20:49:25 -05:00
var infoResponse = RconParser.Configuration.CommandPrefixes.RConGetInfo != null ? await this.GetInfoAsync() : null;
var hostname = (await this.GetMappedDvarValueOrDefaultAsync<string>("sv_hostname", "hostname", infoResponse, token: Manager.CancellationToken)).Value;
var mapname = (await this.GetMappedDvarValueOrDefaultAsync<string>("mapname", infoResponse: infoResponse, token: Manager.CancellationToken)).Value;
var maxplayers = (await this.GetMappedDvarValueOrDefaultAsync<int>("sv_maxclients", infoResponse: infoResponse, token: Manager.CancellationToken)).Value;
var gametype = (await this.GetMappedDvarValueOrDefaultAsync<string>("g_gametype", "gametype", infoResponse, token: Manager.CancellationToken)).Value;
var basepath = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basepath", token: Manager.CancellationToken);
var basegame = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_basegame", token: Manager.CancellationToken);
var homepath = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_homepath", token: Manager.CancellationToken);
var game = await this.GetMappedDvarValueOrDefaultAsync<string>("fs_game", infoResponse: infoResponse, token: Manager.CancellationToken);
var logfile = await this.GetMappedDvarValueOrDefaultAsync<string>("g_log", token: Manager.CancellationToken);
var logsync = await this.GetMappedDvarValueOrDefaultAsync<int>("g_logsync", token: Manager.CancellationToken);
var ip = await this.GetMappedDvarValueOrDefaultAsync<string>("net_ip", token: Manager.CancellationToken);
var gamePassword = await this.GetMappedDvarValueOrDefaultAsync("g_password", overrideDefault: "", token: Manager.CancellationToken);
var privateClients = await this.GetMappedDvarValueOrDefaultAsync("sv_privateClients", overrideDefault: 0,
token: Manager.CancellationToken);
if (Manager.GetApplicationSettings().Configuration().EnableCustomSayName)
{
await this.SetDvarAsync("sv_sayname", CustomSayName,
Manager.CancellationToken);
}
try
{
var website = await this.GetMappedDvarValueOrDefaultAsync<string>("_website", token: Manager.CancellationToken);
// this occurs for games that don't give us anything back when
// the dvar is not set
if (string.IsNullOrWhiteSpace(website.Value))
{
throw new DvarException("value is empty");
}
Website = website.Value;
}
2015-10-10 22:32:12 -04:00
catch (DvarException)
{
Website = loc["SERVER_WEBSITE_GENERIC"];
}
// todo: remove this once _website is weaned off
if (string.IsNullOrEmpty(Manager.GetApplicationSettings().Configuration().ContactUri))
{
Manager.GetApplicationSettings().Configuration().ContactUri = Website;
}
var defaultConfig = _serviceProvider.GetRequiredService<DefaultSettings>();
var gameMaps = defaultConfig?.Maps?.FirstOrDefault(map => map.Game == GameName);
2015-08-23 17:58:48 -04:00
if (gameMaps != null)
{
Maps.AddRange(gameMaps.Maps);
}
2018-03-14 14:22:04 -04:00
WorkingDirectory = basepath.Value;
Hostname = hostname;
MaxClients = maxplayers;
FSGame = game.Value;
Gametype = gametype;
IP = ip.Value is "localhost" or "0.0.0.0" ? ServerConfig.IPAddress : ip.Value ?? ServerConfig.IPAddress;
GamePassword = gamePassword.Value;
PrivateClientSlots = privateClients.Value;
2019-11-18 15:02:35 -05:00
UpdateMap(mapname);
if (RconParser.CanGenerateLogPath && string.IsNullOrEmpty(ServerConfig.ManualLogPath))
{
if (logsync.Value == 0)
{
await this.SetDvarAsync("g_logsync", 2, Manager.CancellationToken); // set to 2 for continous in other games, clamps to 1 for IW4
}
if (string.IsNullOrWhiteSpace(logfile.Value))
{
logfile.Value = "games_mp.log";
await this.SetDvarAsync("g_log", logfile.Value, Manager.CancellationToken);
}
// this DVAR isn't set until the a map is loaded
await this.SetDvarAsync("logfile", 2, Manager.CancellationToken);
}
CustomCallback = await ScriptLoaded();
2019-02-17 19:48:40 -05:00
// they've manually specified the log path
if (!string.IsNullOrEmpty(ServerConfig.ManualLogPath) || !RconParser.CanGenerateLogPath)
{
LogPath = ServerConfig.ManualLogPath;
if (string.IsNullOrEmpty(LogPath) && !RconParser.CanGenerateLogPath)
{
throw new ServerException(loc["SERVER_ERROR_REQUIRES_PATH"].FormatExt(GameName.ToString()));
}
}
else
{
var logInfo = new LogPathGeneratorInfo()
{
BaseGameDirectory = basegame.Value,
BasePathDirectory = basepath.Value,
2021-08-27 21:47:06 -04:00
HomePathDirectory = homepath.Value,
GameDirectory = EventParser.Configuration.GameDirectory ?? "",
ModDirectory = game.Value ?? "",
LogFile = logfile.Value,
IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows),
IsOneLog = RconParser.IsOneLog
};
LogPath = GenerateLogPath(logInfo);
ServerLogger.LogInformation("Game log information {@logInfo}", logInfo);
2019-02-09 22:24:54 -05:00
if (!File.Exists(LogPath) && ServerConfig.GameLogServerUrl == null)
{
Console.WriteLine(loc["SERVER_ERROR_DNE"].FormatExt(LogPath));
ServerLogger.LogCritical("Game log path does not exist {logPath}", LogPath);
throw new ServerException(loc["SERVER_ERROR_DNE"].FormatExt(LogPath));
}
}
ServerLogger.LogInformation("Generated game log path is {logPath}", LogPath);
LogEvent = new GameLogEventDetection( _serviceProvider.GetRequiredService<ILogger<GameLogEventDetection>>(),
this,
GenerateUriForLog(LogPath, ServerConfig.GameLogServerUrl?.AbsoluteUri), gameLogReaderFactory);
await _serverCache.InitializeAsync();
_ = Task.Run(() => LogEvent.PollForChanges());
if (!Utilities.IsDevelopment)
{
Broadcast(loc["BROADCAST_ONLINE"]);
}
2015-03-08 17:20:10 -04:00
}
public Uri[] GenerateUriForLog(string logPath, string gameLogServerUrl)
{
2021-06-03 11:51:03 -04:00
var logUri = new Uri(logPath, UriKind.Absolute);
if (string.IsNullOrEmpty(gameLogServerUrl))
{
return new[] { logUri };
}
else
{
return new[] { new Uri(gameLogServerUrl), logUri };
}
}
public static string GenerateLogPath(LogPathGeneratorInfo logInfo)
{
string logPath;
var workingDirectory = logInfo.BasePathDirectory;
2021-08-27 21:47:06 -04:00
bool IsValidGamePath (string path)
{
var baseGameIsDirectory = !string.IsNullOrWhiteSpace(path) &&
path.IndexOfAny(Utilities.DirectorySeparatorChars) != -1;
2021-08-27 21:47:06 -04:00
var baseGameIsRelative = path.FixDirectoryCharacters()
.Equals(logInfo.GameDirectory.FixDirectoryCharacters(), StringComparison.InvariantCultureIgnoreCase);
2021-08-27 21:47:06 -04:00
return baseGameIsDirectory && !baseGameIsRelative;
}
// we want to see if base game is provided and it 'looks' like a directory
2021-08-27 21:47:06 -04:00
if (IsValidGamePath(logInfo.HomePathDirectory))
{
workingDirectory = logInfo.HomePathDirectory;
}
else if (IsValidGamePath(logInfo.BaseGameDirectory))
{
workingDirectory = logInfo.BaseGameDirectory;
}
if (string.IsNullOrWhiteSpace(logInfo.ModDirectory) || logInfo.IsOneLog)
{
logPath = Path.Combine(workingDirectory, logInfo.GameDirectory, logInfo.LogFile);
}
else
{
logPath = Path.Combine(workingDirectory, logInfo.ModDirectory, logInfo.LogFile);
}
// fix wine drive name mangling
if (!logInfo.IsWindows)
{
logPath = $"{Path.DirectorySeparatorChar}{Regex.Replace(logPath, @"[A-Z]:(\/|\\)", "")}";
}
return logPath.FixDirectoryCharacters();
}
public override async Task Warn(string reason, EFClient targetClient, EFClient targetOrigin)
{
2017-11-29 19:35:50 -05:00
// ensure player gets warned if command not performed on them in game
2021-10-31 12:57:32 -04:00
var activeClient = Manager.FindActiveClient(targetClient);
2017-11-29 19:35:50 -05:00
2021-10-31 12:57:32 -04:00
var newPenalty = new EFPenalty
2017-11-29 19:35:50 -05:00
{
Type = EFPenalty.PenaltyType.Warning,
2017-11-29 19:35:50 -05:00
Expires = DateTime.UtcNow,
Offender = targetClient,
Punisher = targetOrigin,
Offense = reason,
Link = targetClient.AliasLink
2017-11-29 19:35:50 -05:00
};
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Creating warn penalty for {TargetClient}", targetClient.ToString());
await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
2021-10-31 12:57:32 -04:00
if (activeClient.IsIngame)
{
2021-10-31 12:57:32 -04:00
if (activeClient.Warnings >= 4)
{
2021-10-31 12:57:32 -04:00
activeClient.Kick(loc["SERVER_WARNLIMT_REACHED"], Utilities.IW4MAdminClient(this));
2017-11-29 19:35:50 -05:00
return;
}
var message = loc["COMMANDS_WARNING_FORMAT_V2"]
2021-10-31 12:57:32 -04:00
.FormatExt(activeClient.Warnings, activeClient.Name, reason);
activeClient.CurrentServer.Broadcast(message);
}
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = targetClient,
Penalty = newPenalty
});
}
public override async Task Kick(string reason, EFClient targetClient, EFClient originClient, EFPenalty previousPenalty)
{
2021-10-31 12:57:32 -04:00
var activeClient = Manager.FindActiveClient(targetClient);
2017-11-29 19:35:50 -05:00
2021-10-31 12:57:32 -04:00
var newPenalty = new EFPenalty
2017-11-29 19:35:50 -05:00
{
Type = EFPenalty.PenaltyType.Kick,
2017-11-29 19:35:50 -05:00
Expires = DateTime.UtcNow,
Offender = targetClient,
Offense = reason,
Punisher = originClient,
Link = targetClient.AliasLink
2017-11-29 19:35:50 -05:00
};
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Creating kick penalty for {TargetClient}", targetClient.ToString());
await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
2021-10-31 12:57:32 -04:00
if (activeClient.IsIngame)
2017-11-29 19:35:50 -05:00
{
2021-10-31 12:57:32 -04:00
var gameEvent = new GameEvent
2017-11-29 19:35:50 -05:00
{
Type = GameEvent.EventType.PreDisconnect,
2021-10-31 12:57:32 -04:00
Origin = activeClient,
Owner = this
};
2021-10-31 12:57:32 -04:00
Manager.AddEvent(gameEvent);
2021-06-03 11:51:03 -04:00
var formattedKick = string.Format(RconParser.Configuration.CommandPrefixes.Kick,
2021-10-31 12:57:32 -04:00
activeClient.TemporalClientNumber,
_messageFormatter.BuildFormattedMessage(RconParser.Configuration,
newPenalty,
previousPenalty));
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Executing tempban kick command for {ActiveClient}", activeClient.ToString());
await activeClient.CurrentServer.ExecuteCommandAsync(formattedKick);
}
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = targetClient,
Penalty = newPenalty
});
}
public override Task<string[]> ExecuteCommandAsync(string command, CancellationToken token = default) =>
Utilities.ExecuteCommandAsync(this, command, token);
public override Task SetDvarAsync(string name, object value, CancellationToken token = default) =>
Utilities.SetDvarAsync(this, name, value, token);
2021-10-31 12:57:32 -04:00
public override async Task TempBan(string reason, TimeSpan length, EFClient targetClient, EFClient originClient)
{
// ensure player gets kicked if command not performed on them in the same server
2021-10-31 12:57:32 -04:00
var activeClient = Manager.FindActiveClient(targetClient);
2017-11-29 19:35:50 -05:00
2021-10-31 12:57:32 -04:00
var newPenalty = new EFPenalty
{
Type = EFPenalty.PenaltyType.TempBan,
Expires = DateTime.UtcNow + length,
Offender = targetClient,
2021-10-31 12:57:32 -04:00
Offense = reason,
Punisher = originClient,
Link = targetClient.AliasLink
};
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Creating tempban penalty for {TargetClient}", targetClient.ToString());
await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
2022-07-01 10:14:57 -04:00
foreach (var reports in Manager.GetServers().Select(server => server.Reports))
{
reports.RemoveAll(report => report.Target.ClientId == targetClient.ClientId);
}
2021-10-31 12:57:32 -04:00
if (activeClient.IsIngame)
2017-11-29 19:35:50 -05:00
{
var formattedKick = string.Format(RconParser.Configuration.CommandPrefixes.Kick,
2021-10-31 12:57:32 -04:00
activeClient.TemporalClientNumber,
_messageFormatter.BuildFormattedMessage(RconParser.Configuration, newPenalty));
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Executing tempban kick command for {ActiveClient}", activeClient.ToString());
await activeClient.CurrentServer.ExecuteCommandAsync(formattedKick);
2017-11-29 19:35:50 -05:00
}
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = targetClient,
Penalty = newPenalty
});
}
2017-11-29 19:35:50 -05:00
public override async Task Ban(string reason, EFClient targetClient, EFClient originClient, bool isEvade = false)
{
// ensure player gets kicked if command not performed on them in the same server
2021-10-31 12:57:32 -04:00
var activeClient = Manager.FindActiveClient(targetClient);
2017-11-29 19:35:50 -05:00
2021-10-31 12:57:32 -04:00
var newPenalty = new EFPenalty
{
Type = EFPenalty.PenaltyType.Ban,
Expires = null,
Offender = targetClient,
Offense = reason,
Punisher = originClient,
IsEvadedOffense = isEvade
};
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Creating ban penalty for {TargetClient}", targetClient.ToString());
activeClient.SetLevel(Permission.Banned, originClient);
await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
2022-07-01 10:14:57 -04:00
foreach (var reports in Manager.GetServers().Select(server => server.Reports))
{
reports.RemoveAll(report => report.Target.ClientId == targetClient.ClientId);
}
2021-10-31 12:57:32 -04:00
if (activeClient.IsIngame)
{
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Attempting to kicking newly banned client {ActiveClient}", activeClient.ToString());
2021-06-03 11:51:03 -04:00
var formattedString = string.Format(RconParser.Configuration.CommandPrefixes.Kick,
2021-10-31 12:57:32 -04:00
activeClient.TemporalClientNumber,
_messageFormatter.BuildFormattedMessage(RconParser.Configuration, newPenalty));
2021-10-31 12:57:32 -04:00
await activeClient.CurrentServer.ExecuteCommandAsync(formattedString);
}
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyEvent
{
Client = targetClient,
Penalty = newPenalty
});
2015-03-08 17:20:10 -04:00
}
2021-10-31 12:57:32 -04:00
public override async Task Unban(string reason, EFClient targetClient, EFClient originClient)
2015-03-08 17:20:10 -04:00
{
2021-10-31 12:57:32 -04:00
var unbanPenalty = new EFPenalty
{
Type = EFPenalty.PenaltyType.Unban,
Expires = DateTime.Now,
2021-10-31 12:57:32 -04:00
Offender = targetClient,
Offense = reason,
2021-10-31 12:57:32 -04:00
Punisher = originClient,
When = DateTime.UtcNow,
Active = true,
2021-10-31 12:57:32 -04:00
Link = targetClient.AliasLink
};
2021-10-31 12:57:32 -04:00
ServerLogger.LogDebug("Creating unban penalty for {targetClient}", targetClient.ToString());
targetClient.SetLevel(Permission.User, originClient);
2022-02-22 18:09:50 -05:00
await Manager.GetPenaltyService().RemoveActivePenalties(targetClient.AliasLink.AliasLinkId,
targetClient.NetworkId, targetClient.GameName, targetClient.CurrentAlias?.IPAddress);
await Manager.GetPenaltyService().Create(unbanPenalty);
2023-04-05 10:54:57 -04:00
Manager.QueueEvent(new ClientPenaltyRevokeEvent
{
Client = targetClient,
Penalty = unbanPenalty
});
}
2021-10-31 12:57:32 -04:00
public override void InitializeTokens()
{
Manager.GetMessageTokens().Add(new MessageToken("TOTALPLAYERS", (Server s) => Task.Run(async () => (await Manager.GetClientService().GetTotalClientsAsync()).ToString())));
Manager.GetMessageTokens().Add(new MessageToken("VERSION", (Server s) => Task.FromResult(Application.Program.Version.ToString())));
Manager.GetMessageTokens().Add(new MessageToken("NEXTMAP", (Server s) => SharedLibraryCore.Commands.NextMapCommand.GetNextMap(s, _translationLookup)));
Manager.GetMessageTokens().Add(new MessageToken("ADMINS", (Server s) => Task.FromResult(ListAdminsCommand.OnlineAdmins(s, _translationLookup))));
}
2023-04-05 10:54:57 -04:00
public override long LegacyDatabaseId => _cachedDatabaseServer.ServerId;
2015-03-08 17:20:10 -04:00
}
}