First bits of the Context overhaul.

Reintroduces separate contexts for users, channels, connections (now split into sessions and connections) and user-channel associations.
It builds which is as much assurance as I can give about the stability of this commit, but its also the bare minimum of what i like to commit sooooo
A lot of things still need to be broadcast through events throughout the application in order to keep states consistent but we'll cross that bridge when we get to it.
I really need to stop using that phrase thingy, I'm overusing it.

SharpChat.SockChat/SharpChatWebSocketServer.cs

@@ -0,0 +1,171 @@
+#nullable disable
+
+using Fleck;
+using Microsoft.Extensions.Logging;
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using ZLogger;
+
+// Near direct reimplementation of Fleck's WebSocketServer with address reusing
+// Fleck's Socket wrapper doesn't provide any way to do this with the normally provided APIs
+// https://github.com/statianzo/Fleck/blob/1.1.0/src/Fleck/WebSocketServer.cs
+
+namespace SharpChat.SockChat;
+
+public class SharpChatWebSocketServer : IWebSocketServer {
+    private readonly ILogger Logger;
+    private readonly string _scheme;
+    private readonly IPAddress _locationIP;
+    private Action<IWebSocketConnection> _config;
+
+    public SharpChatWebSocketServer(ILogger logger, string location, bool supportDualStack = true) {
+        Logger = logger;
+
+        Uri uri = new(location);
+
+        Port = uri.Port;
+        Location = location;
+        SupportDualStack = supportDualStack;
+
+        _locationIP = ParseIPAddress(uri);
+        _scheme = uri.Scheme;
+        Socket socket = new(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
+        socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
+
+        if(SupportDualStack && Type.GetType("Mono.Runtime") == null && RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
+            socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
+        }
+
+        ListenerSocket = new SocketWrapper(socket);
+        SupportedSubProtocols = [];
+    }
+
+    public ISocket ListenerSocket { get; set; }
+    public string Location { get; private set; }
+    public bool SupportDualStack { get; }
+    public int Port { get; private set; }
+    public X509Certificate2 Certificate { get; set; }
+    public SslProtocols EnabledSslProtocols { get; set; }
+    public IEnumerable<string> SupportedSubProtocols { get; set; }
+    public bool RestartAfterListenError { get; set; }
+
+    public bool IsSecure {
+        get { return _scheme == "wss" && Certificate != null; }
+    }
+
+    public void Dispose() {
+        ListenerSocket.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+    private static IPAddress ParseIPAddress(Uri uri) {
+        string ipStr = uri.Host;
+
+        if(ipStr == "0.0.0.0") {
+            return IPAddress.Any;
+        } else if(ipStr == "[0000:0000:0000:0000:0000:0000:0000:0000]") {
+            return IPAddress.IPv6Any;
+        } else {
+            try {
+                return IPAddress.Parse(ipStr);
+            } catch(Exception ex) {
+                throw new FormatException("Failed to parse the IP address part of the location. Please make sure you specify a valid IP address. Use 0.0.0.0 or [::] to listen on all interfaces.", ex);
+            }
+        }
+    }
+
+    public void Start(Action<IWebSocketConnection> config) {
+        IPEndPoint ipLocal = new(_locationIP, Port);
+        ListenerSocket.Bind(ipLocal);
+        ListenerSocket.Listen(100);
+        Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
+        Logger.ZLogInformation($"Server started at {Location} (actual port {Port})");
+        if(_scheme == "wss") {
+            if(Certificate == null) {
+                Logger.ZLogError($"Scheme cannot be 'wss' without a Certificate");
+                return;
+            }
+
+            // makes dotnet shut up, TLS is handled by NGINX anyway
+            // if(EnabledSslProtocols == SslProtocols.None) {
+            //     EnabledSslProtocols = SslProtocols.Tls;
+            //     Logger.ZLogDebug($"Using default TLS 1.0 security protocol.");
+            // }
+        }
+        ListenForClients();
+        _config = config;
+    }
+
+    private void ListenForClients() {
+        ListenerSocket.Accept(OnClientConnect, e => {
+            Logger.ZLogError($"Listener socket is closed: {e}");
+            if(RestartAfterListenError) {
+                Logger.ZLogInformation($"Listener socket restarting");
+                try {
+                    ListenerSocket.Dispose();
+                    Socket socket = new(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
+                    socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
+                    ListenerSocket = new SocketWrapper(socket);
+                    Start(_config);
+                    Logger.ZLogInformation($"Listener socket restarted");
+                } catch(Exception ex) {
+                    Logger.ZLogError($"Listener could not be restarted: {ex}");
+                }
+            }
+        });
+    }
+
+    private void OnClientConnect(ISocket clientSocket) {
+        if(clientSocket == null) return; // socket closed
+
+        Logger.ZLogDebug($"Client connected from {clientSocket.RemoteIpAddress}:{clientSocket.RemotePort}");
+        ListenForClients();
+
+        WebSocketConnection connection = null;
+
+        connection = new WebSocketConnection(
+            clientSocket,
+            _config,
+            bytes => RequestParser.Parse(bytes, _scheme),
+            r => {
+                try {
+                    return HandlerFactory.BuildHandler(
+                        r, s => connection.OnMessage(s), connection.Close, b => connection.OnBinary(b),
+                        b => connection.OnPing(b), b => connection.OnPong(b)
+                    );
+                } catch(WebSocketException) {
+                    const string responseMsg = "HTTP/1.1 200 OK\r\n"
+                                             + "Date: {0}\r\n"
+                                             + "Server: SharpChat\r\n"
+                                             + "Content-Length: {1}\r\n"
+                                             + "Content-Type: text/html; charset=utf-8\r\n"
+                                             + "Connection: close\r\n"
+                                             + "\r\n"
+                                             + "{2}";
+                    string responseBody = File.Exists("http-motd.txt") ? File.ReadAllText("http-motd.txt") : "SharpChat";
+
+                    clientSocket.Stream.Write(Encoding.UTF8.GetBytes(string.Format(
+                        responseMsg, DateTimeOffset.Now.ToString("r"), responseBody.CountUtf8Bytes(), responseBody
+                    )));
+                    clientSocket.Close();
+                    return null;
+                }
+            },
+            s => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
+
+        if(IsSecure) {
+            Logger.ZLogDebug($"Authenticating Secure Connection");
+            clientSocket
+                .Authenticate(Certificate,
+                              EnabledSslProtocols,
+                              connection.StartReceiving,
+                              e => Logger.ZLogWarning($"Failed to Authenticate: {e}"));
+        } else {
+            connection.StartReceiving();
+        }
+    }
+}