sharp-chat/SharpChat.SockChat/PacketsC2S/AuthC2SPacketHandler.cs

using SharpChat.Config;
using SharpChat.Misuzu;
using SharpChat.SockChat.PacketsS2C;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace SharpChat.SockChat.PacketsC2S {
    public class AuthC2SPacketHandler : IC2SPacketHandler {
        public const string MOTD_FILE = @"welcome.txt";

        private readonly DateTimeOffset Started;
        private readonly MisuzuClient Misuzu;
        private readonly ChannelInfo DefaultChannel;
        private readonly CachedValue<int> MaxMessageLength;
        private readonly CachedValue<int> MaxConnections;

        public AuthC2SPacketHandler(
            DateTimeOffset started,
            MisuzuClient msz,
            ChannelInfo? defaultChannel,
            CachedValue<int> maxMsgLength,
            CachedValue<int> maxConns
        ) {
            Started = started;
            Misuzu = msz;
            DefaultChannel = defaultChannel ?? throw new ArgumentNullException(nameof(defaultChannel));
            MaxMessageLength = maxMsgLength;
            MaxConnections = maxConns;
        }

        public bool IsMatch(C2SPacketHandlerContext ctx) {
            return ctx.CheckPacketId("1");
        }

        public void Handle(C2SPacketHandlerContext ctx) {
            string[] args = ctx.SplitText(3);

            string? authMethod = args.ElementAtOrDefault(1);
            if(string.IsNullOrWhiteSpace(authMethod)) {
                ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.AuthInvalid));
                ctx.Connection.Close(1000);
                return;
            }

            string? authToken = args.ElementAtOrDefault(2);
            if(string.IsNullOrWhiteSpace(authToken)) {
                ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.AuthInvalid));
                ctx.Connection.Close(1000);
                return;
            }

            if(authMethod.All(c => c is >= '0' and <= '9') && authToken.Contains(':')) {
                string[] tokenParts = authToken.Split(':', 2);
                authMethod = tokenParts[0];
                authToken = tokenParts[1];
            }

            Task.Run(async () => {
                MisuzuAuthInfo? fai;
                string ipAddr = ctx.Connection.RemoteAddress;

                try {
                    fai = await Misuzu.AuthVerifyAsync(authMethod, authToken, ipAddr);
                } catch(Exception ex) {
                    Logger.Write($"<{ctx.Connection.RemoteEndPoint}> Failed to authenticate: {ex}");
                    ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.AuthInvalid));
                    ctx.Connection.Close(1000);
#if DEBUG
                    throw;
#else
                    return;
#endif
                }

                if(fai == null) {
                    Logger.Debug($"<{ctx.Connection.RemoteEndPoint}> Auth fail: <null>");
                    ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.Null));
                    ctx.Connection.Close(1000);
                    return;
                }

                if(!fai.Success) {
                    Logger.Debug($"<{ctx.Connection.RemoteEndPoint}> Auth fail: {fai.Reason}");
                    ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.AuthInvalid));
                    ctx.Connection.Close(1000);
                    return;
                }

                MisuzuBanInfo? fbi;
                try {
                    fbi = await Misuzu.CheckBanAsync(fai.UserId.ToString(), ipAddr);
                } catch(Exception ex) {
                    Logger.Write($"<{ctx.Connection.RemoteEndPoint}> Failed auth ban check: {ex}");
                    ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.AuthInvalid));
                    ctx.Connection.Close(1000);
#if DEBUG
                    throw;
#else
                    return;
#endif
                }

                if(fbi == null) {
                    Logger.Debug($"<{ctx.Connection.RemoteEndPoint}> Ban check fail: <null>");
                    ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.Null));
                    ctx.Connection.Close(1000);
                    return;
                }

                if(fbi.IsBanned && !fbi.HasExpired) {
                    Logger.Write($"<{ctx.Connection.RemoteEndPoint}> User is banned.");
                    ctx.Connection.Send(new AuthFailS2CPacket(fbi.ExpiresAt));
                    ctx.Connection.Close(1000);
                    return;
                }

                await ctx.Chat.ContextAccess.WaitAsync();
                try {
                    UserInfo? user = ctx.Chat.Users.Get(fai.UserId);

                    if(user == null)
                        user = new UserInfo(
                            fai.UserId,
                            fai.UserName ?? string.Empty,
                            fai.Colour,
                            fai.Rank,
                            fai.Permissions,
                            isSuper: fai.IsSuper
                        );
                    else
                        ctx.Chat.UpdateUser(
                            user,
                            userName: fai.UserName,
                            colour: fai.Colour,
                            rank: fai.Rank,
                            perms: fai.Permissions,
                            isSuper: fai.IsSuper
                        );

                    // Enforce a maximum amount of connections per user
                    if(ctx.Chat.Connections.GetCountForUser(user) >= MaxConnections) {
                        ctx.Connection.Send(new AuthFailS2CPacket(AuthFailS2CPacket.FailReason.MaxSessions));
                        ctx.Connection.Close(1000);
                        return;
                    }

                    ctx.Connection.BumpPing();
                    ctx.Chat.Connections.SetUser(ctx.Connection, user);
                    ctx.Connection.Send(new MOTDS2CPacket(Started, $"Welcome to Flashii Chat, {user.UserName}!"));

                    if(File.Exists(MOTD_FILE)) {
                        IEnumerable<string> lines = File.ReadAllLines(MOTD_FILE).Where(x => !string.IsNullOrWhiteSpace(x));
                        string? line = lines.ElementAtOrDefault(RNG.Next(lines.Count()));

                        if(!string.IsNullOrWhiteSpace(line))
                            ctx.Connection.Send(new MOTDS2CPacket(File.GetLastWriteTimeUtc(MOTD_FILE), line));
                    }

                    ctx.Chat.HandleJoin(user, DefaultChannel, ctx.Connection, MaxMessageLength);
                } finally {
                    ctx.Chat.ContextAccess.Release();
                }
            }).Wait();
        }
    }
}