Merge branch 'dev' of https://github.com/Regalis11/Barotrauma into unstable

2022-09-29 12:13:55 -03:00
parent 2d5cff1752 9ae6e35760
commit 77c63541eb
602 changed files with 19759 additions and 16312 deletions
@@ -1,24 +1,45 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Linq;
+using Barotrauma.Steam;
 using Lidgren.Network;

 namespace Barotrauma.Networking
 {
-    class LidgrenServerPeer : ServerPeer
+    internal sealed class LidgrenServerPeer : ServerPeer
    {
-        private NetPeerConfiguration netPeerConfiguration;
-        private NetServer netServer;
+        private readonly NetPeerConfiguration netPeerConfiguration;
+        private NetServer? netServer;

        private readonly List<NetIncomingMessage> incomingLidgrenMessages;

-        public LidgrenServerPeer(int? ownKey, ServerSettings settings)
+        public LidgrenServerPeer(Option<int> ownKey, ServerSettings settings, Callbacks callbacks) : base(callbacks)
        {
            serverSettings = settings;

            netServer = null;

+            netPeerConfiguration = new NetPeerConfiguration("barotrauma")
+            {
+                AcceptIncomingConnections = true,
+                AutoExpandMTU = false,
+                MaximumConnections = NetConfig.MaxPlayers * 2,
+                EnableUPnP = serverSettings.EnableUPnP,
+                Port = serverSettings.Port
+            };
+
+            netPeerConfiguration.DisableMessageType(
+                NetIncomingMessageType.DebugMessage
+                | NetIncomingMessageType.WarningMessage
+                | NetIncomingMessageType.Receipt
+                | NetIncomingMessageType.ErrorMessage
+                | NetIncomingMessageType.Error
+                | NetIncomingMessageType.UnconnectedData);
+
+            netPeerConfiguration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
+
            connectedClients = new List<NetworkConnection>();
            pendingClients = new List<PendingClient>();

@@ -31,25 +52,7 @@ namespace Barotrauma.Networking
        {
            if (netServer != null) { return; }

-            var address = serverSettings.ListenIPAddress;
-            if (address == IPAddress.Any) address = IPAddress.IPv6Any;
-
-            netPeerConfiguration = new NetPeerConfiguration("barotrauma")
-            {
-                AcceptIncomingConnections = true,
-                AutoExpandMTU = false,
-                MaximumConnections = NetConfig.MaxPlayers * 2,
-                EnableUPnP = serverSettings.EnableUPnP,
-                Port = serverSettings.Port,
-                LocalAddress = address
-            };
-
-            netPeerConfiguration.DisableMessageType(NetIncomingMessageType.DebugMessage |
-                NetIncomingMessageType.WarningMessage | NetIncomingMessageType.Receipt |
-                NetIncomingMessageType.ErrorMessage | NetIncomingMessageType.Error |
-                NetIncomingMessageType.UnconnectedData);
-
-            netPeerConfiguration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
+            incomingLidgrenMessages.Clear();

            netServer = new NetServer(netPeerConfiguration);

@@ -65,21 +68,21 @@ namespace Barotrauma.Networking
            }
        }

-        public override void Close(string msg = null)
+        public override void Close()
        {
            if (netServer == null) { return; }

            for (int i = pendingClients.Count - 1; i >= 0; i--)
            {
-                RemovePendingClient(pendingClients[i], DisconnectReason.ServerShutdown, msg);
+                RemovePendingClient(pendingClients[i], PeerDisconnectPacket.WithReason(DisconnectReason.ServerShutdown));
            }

            for (int i = connectedClients.Count - 1; i >= 0; i--)
            {
-                Disconnect(connectedClients[i], msg ?? DisconnectReason.ServerShutdown.ToString());
+                Disconnect(connectedClients[i], PeerDisconnectPacket.WithReason(DisconnectReason.ServerShutdown));
            }

-            netServer.Shutdown(msg ?? DisconnectReason.ServerShutdown.ToString());
+            netServer.Shutdown(PeerDisconnectPacket.WithReason(DisconnectReason.ServerShutdown).ToLidgrenStringRepresentation());

            pendingClients.Clear();
            connectedClients.Clear();
@@ -88,21 +91,17 @@ namespace Barotrauma.Networking

            Steamworks.SteamServer.OnValidateAuthTicketResponse -= OnAuthChange;

-            OnShutdown?.Invoke();
+            callbacks.OnShutdown.Invoke();
        }

        public override void Update(float deltaTime)
        {
-            if (netServer == null) { return; }
+            if (netServer is null) { return; }

-            if (OnOwnerDetermined != null && OwnerConnection != null)
-            {
-                OnOwnerDetermined?.Invoke(OwnerConnection);
-                OnOwnerDetermined = null;
-            }
+            ToolBox.ThrowIfNull(incomingLidgrenMessages);

            netServer.ReadMessages(incomingLidgrenMessages);
-            
+
            //process incoming connections first
            foreach (NetIncomingMessage inc in incomingLidgrenMessages.Where(m => m.MessageType == NetIncomingMessageType.ConnectionApproval))
            {
@@ -129,7 +128,7 @@ namespace Barotrauma.Networking
            catch (Exception e)
            {
                string errorMsg = "Server failed to read an incoming message. {" + e + "}\n" + e.StackTrace.CleanupStackTrace();
-                GameAnalyticsManager.AddErrorEventOnce("LidgrenServerPeer.Update:ClientReadException" + e.TargetSite.ToString(), GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce($"LidgrenServerPeer.Update:ClientReadException{e.TargetSite}", GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
 #if DEBUG
                DebugConsole.ThrowError(errorMsg);
 #else
@@ -141,7 +140,8 @@ namespace Barotrauma.Networking
            {
                PendingClient pendingClient = pendingClients[i];

-                var connection = pendingClient.Connection as LidgrenConnection;
+                LidgrenConnection connection = (LidgrenConnection)pendingClient.Connection;
+
                if (connection.NetConnection.Status == NetConnectionStatus.InitiatedConnect ||
                    connection.NetConnection.Status == NetConnectionStatus.ReceivedInitiation ||
                    connection.NetConnection.Status == NetConnectionStatus.RespondedAwaitingApproval ||
@@ -149,6 +149,7 @@ namespace Barotrauma.Networking
                {
                    continue;
                }
+
                UpdatePendingClient(pendingClient);
                if (i >= pendingClients.Count || pendingClients[i] != pendingClient) { i--; }
            }
@@ -158,7 +159,9 @@ namespace Barotrauma.Networking

        private void InitUPnP()
        {
-            if (netServer == null) { return; }
+            if (netServer is null) { return; }
+
+            ToolBox.ThrowIfNull(netPeerConfiguration);

            netServer.UPnP.ForwardPort(netPeerConfiguration.Port, "barotrauma");
 #if USE_STEAM
@@ -193,71 +196,74 @@ namespace Barotrauma.Networking

            if (!skipDeny && connectedClients.Count >= serverSettings.MaxPlayers)
            {
-                inc.SenderConnection.Deny(DisconnectReason.ServerFull.ToString());
+                inc.SenderConnection.Deny(PeerDisconnectPacket.WithReason(DisconnectReason.ServerFull).ToLidgrenStringRepresentation());
                return;
            }

-            if (serverSettings.BanList.IsBanned(inc.SenderConnection.RemoteEndPoint.Address, 0, 0, out string banReason))
+            if (serverSettings.BanList.IsBanned(new LidgrenEndpoint(inc.SenderConnection.RemoteEndPoint), out string banReason))
            {
                //IP banned: deny immediately
-                inc.SenderConnection.Deny(DisconnectReason.Banned.ToString() + "/ " + banReason);
+                inc.SenderConnection.Deny(PeerDisconnectPacket.Banned(banReason).ToLidgrenStringRepresentation());
                return;
            }

-            PendingClient pendingClient = pendingClients.Find(c => c.Connection is LidgrenConnection l && l.NetConnection == inc.SenderConnection);
+            PendingClient? pendingClient = pendingClients.Find(c => c.Connection is LidgrenConnection l && l.NetConnection == inc.SenderConnection);

-            if (pendingClient == null)
+            if (pendingClient is null)
            {
-                pendingClient = new PendingClient(new LidgrenConnection("PENDING", inc.SenderConnection, 0));
+                pendingClient = new PendingClient(new LidgrenConnection(inc.SenderConnection));
                pendingClients.Add(pendingClient);
            }

            inc.SenderConnection.Approve();
        }

-        private void HandleDataMessage(NetIncomingMessage inc)
+        private void HandleDataMessage(NetIncomingMessage lidgrenMsg)
        {
            if (netServer == null) { return; }

-            PendingClient pendingClient = pendingClients.Find(c => (c.Connection is LidgrenConnection l) && l.NetConnection == inc.SenderConnection);
+            PendingClient? pendingClient = pendingClients.Find(c => c.Connection is LidgrenConnection l && l.NetConnection == lidgrenMsg.SenderConnection);

-            PacketHeader packetHeader = (PacketHeader)inc.ReadByte();
+            IReadMessage inc = lidgrenMsg.ToReadMessage();

-            if (packetHeader.IsConnectionInitializationStep() && pendingClient != null)
+            var (_, packetHeader, initialization) = INetSerializableStruct.Read<PeerPacketHeaders>(inc);
+
+            if (packetHeader.IsConnectionInitializationStep() && pendingClient != null && initialization.HasValue)
            {
-                ReadConnectionInitializationStep(pendingClient, new ReadWriteMessage(inc.Data, (int)inc.Position, inc.LengthBits, false));
+                ReadConnectionInitializationStep(pendingClient, inc, initialization.Value);
            }
            else if (!packetHeader.IsConnectionInitializationStep())
            {
-                LidgrenConnection conn = connectedClients.Find(c => (c is LidgrenConnection l) && l.NetConnection == inc.SenderConnection) as LidgrenConnection;
-                if (conn == null)
+                if (connectedClients.Find(c => c is LidgrenConnection l && l.NetConnection == lidgrenMsg.SenderConnection) is not LidgrenConnection conn)
                {
                    if (pendingClient != null)
                    {
-                        RemovePendingClient(pendingClient, DisconnectReason.AuthenticationRequired, "Received data message from unauthenticated client");
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.AuthenticationRequired));
                    }
-                    else if (inc.SenderConnection.Status != NetConnectionStatus.Disconnected &&
-                             inc.SenderConnection.Status != NetConnectionStatus.Disconnecting)
+                    else if (lidgrenMsg.SenderConnection.Status != NetConnectionStatus.Disconnected &&
+                             lidgrenMsg.SenderConnection.Status != NetConnectionStatus.Disconnecting)
                    {
-                        inc.SenderConnection.Disconnect(DisconnectReason.AuthenticationRequired.ToString() + "/ Received data message from unauthenticated client");
+                        lidgrenMsg.SenderConnection.Disconnect(PeerDisconnectPacket.WithReason(DisconnectReason.AuthenticationRequired).ToLidgrenStringRepresentation());
                    }
+
                    return;
                }
+
                if (pendingClient != null) { pendingClients.Remove(pendingClient); }
-                if (serverSettings.BanList.IsBanned(conn.IPEndPoint.Address, conn.SteamID, conn.OwnerSteamID, out string banReason))
+
+                if (serverSettings.BanList.IsBanned(conn.Endpoint, out string banReason)
+                    || (conn.AccountInfo.AccountId.TryUnwrap(out var accountId) && serverSettings.BanList.IsBanned(accountId, out banReason))
+                    || conn.AccountInfo.OtherMatchingIds.Any(id => serverSettings.BanList.IsBanned(id, out banReason)))
                {
-                    Disconnect(conn, DisconnectReason.Banned.ToString() + "/ " + banReason);
+                    Disconnect(conn, PeerDisconnectPacket.Banned(banReason));
                    return;
                }
-                UInt16 length = inc.ReadUInt16();

-                //DebugConsole.NewMessage(isCompressed + " " + isConnectionInitializationStep + " " + (int)incByte + " " + length);
-
-                IReadMessage msg = new ReadOnlyMessage(inc.Data, packetHeader.IsCompressed(), inc.PositionInBytes, length, conn);
-                OnMessageReceived?.Invoke(conn, msg);
+                var packet = INetSerializableStruct.Read<PeerPacketMessage>(inc);
+                callbacks.OnMessageReceived.Invoke(conn, packet.GetReadMessage(packetHeader.IsCompressed(), conn));
            }
        }
-        
+
        private void HandleStatusChanged(NetIncomingMessage inc)
        {
            if (netServer == null) { return; }
@@ -265,30 +271,29 @@ namespace Barotrauma.Networking
            switch (inc.SenderConnection.Status)
            {
                case NetConnectionStatus.Disconnected:
-                    string disconnectMsg;
-                    LidgrenConnection conn = connectedClients.Select(c => c as LidgrenConnection).FirstOrDefault(c => c.NetConnection == inc.SenderConnection);
+                    LidgrenConnection? conn = connectedClients.Cast<LidgrenConnection>().FirstOrDefault(c => c.NetConnection == inc.SenderConnection);
                    if (conn != null)
                    {
                        if (conn == OwnerConnection)
                        {
                            DebugConsole.NewMessage("Owner disconnected: closing the server...");
                            GameServer.Log("Owner disconnected: closing the server...", ServerLog.MessageType.ServerMessage);
-                            Close(DisconnectReason.ServerShutdown.ToString() + "/ Owner disconnected");
+                            Close();
                        }
                        else
                        {
-                            disconnectMsg = $"ServerMessage.HasDisconnected~[client]={conn.Name}";
-                            Disconnect(conn, disconnectMsg);
+                            Disconnect(conn, PeerDisconnectPacket.WithReason(DisconnectReason.Disconnected));
                        }
                    }
                    else
                    {
-                        PendingClient pendingClient = pendingClients.Find(c => (c.Connection is LidgrenConnection l) && l.NetConnection == inc.SenderConnection);
+                        PendingClient? pendingClient = pendingClients.Find(c => c.Connection is LidgrenConnection l && l.NetConnection == inc.SenderConnection);
                        if (pendingClient != null)
                        {
-                            RemovePendingClient(pendingClient, DisconnectReason.Unknown, $"ServerMessage.HasDisconnected~[client]={pendingClient.Name}");
+                            RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.Disconnected));
                        }
                    }
+
                    break;
            }
        }
@@ -298,44 +303,45 @@ namespace Barotrauma.Networking
            Steamworks.SteamServer.OnValidateAuthTicketResponse += OnAuthChange;
        }

-        private void OnAuthChange(Steamworks.SteamId steamID, Steamworks.SteamId ownerID, Steamworks.AuthResponse status)
+        private void OnAuthChange(Steamworks.SteamId steamId, Steamworks.SteamId ownerId, Steamworks.AuthResponse status)
        {
            if (netServer == null) { return; }

-            PendingClient pendingClient = pendingClients.Find(c => c.SteamID == steamID);
-            DebugConsole.Log(steamID + " validation: " + status+", "+(pendingClient!=null));
-            
-            if (pendingClient == null)
+            PendingClient? pendingClient = pendingClients.Find(c => c.AccountInfo.AccountId is Some<AccountId> { Value: SteamId id } && id.Value == steamId);
+            DebugConsole.Log($"{steamId} validation: {status}, {(pendingClient != null)}");
+
+            if (pendingClient is null)
            {
-                if (status != Steamworks.AuthResponse.OK)
+                if (status == Steamworks.AuthResponse.OK) { return; }
+
+                if (connectedClients.Find(c
+                        => c.AccountInfo.AccountId is Some<AccountId> { Value: SteamId id } && id.Value == steamId)
+                    is LidgrenConnection connection)
                {
-                    LidgrenConnection connection = connectedClients.Find(c => c.SteamID == steamID) as LidgrenConnection;
-                    if (connection != null)
-                    {
-                        Disconnect(connection, DisconnectReason.SteamAuthenticationFailed.ToString() + "/ Steam authentication status changed: " + status.ToString());
-                    }
+                    Disconnect(connection,  PeerDisconnectPacket.SteamAuthError(status));
                }
+
                return;
            }

-            LidgrenConnection pendingConnection = pendingClient.Connection as LidgrenConnection;
-            string banReason;
-            if (serverSettings.BanList.IsBanned(pendingConnection.NetConnection.RemoteEndPoint.Address, steamID, ownerID, out banReason))
+            LidgrenConnection pendingConnection = (LidgrenConnection)pendingClient.Connection;
+            if (serverSettings.BanList.IsBanned(pendingConnection.Endpoint, out string banReason)
+                || serverSettings.BanList.IsBanned(new SteamId(steamId), out banReason)
+                || serverSettings.BanList.IsBanned(new SteamId(ownerId), out banReason))
            {
-                RemovePendingClient(pendingClient, DisconnectReason.Banned, banReason);
+                RemovePendingClient(pendingClient, PeerDisconnectPacket.Banned(banReason));
                return;
            }

            if (status == Steamworks.AuthResponse.OK)
            {
-                pendingClient.OwnerSteamID = ownerID;
+                pendingClient.Connection.SetAccountInfo(new AccountInfo(new SteamId(steamId), new SteamId(ownerId)));
                pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
                pendingClient.UpdateTime = Timing.TotalTime;
            }
            else
            {
-                RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "Steam authentication failed: " + status.ToString());
-                return;
+                RemovePendingClient(pendingClient, PeerDisconnectPacket.SteamAuthError(status));
            }
        }

@@ -343,151 +349,144 @@ namespace Barotrauma.Networking
        {
            if (netServer == null) { return; }

-            if (!(conn is LidgrenConnection lidgrenConn)) return;
-            if (!connectedClients.Contains(lidgrenConn))
+            if (!connectedClients.Contains(conn))
            {
-                DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + lidgrenConn.IPString);
+                DebugConsole.ThrowError($"Tried to send message to unauthenticated connection: {conn.Endpoint.StringRepresentation}");
                return;
            }

-            NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-            switch (deliveryMethod)
-            {
-                case DeliveryMethod.Unreliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-                    break;
-                case DeliveryMethod.Reliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
-                    break;
-                case DeliveryMethod.ReliableOrdered:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
-                    break;
-            }
+            byte[] bufAux = msg.PrepareForSending(compressPastThreshold, out bool isCompressed, out _);

 #if DEBUG
+            ToolBox.ThrowIfNull(netPeerConfiguration);
            netPeerConfiguration.SimulatedDuplicatesChance = GameMain.Server.SimulatedDuplicatesChance;
            netPeerConfiguration.SimulatedMinimumLatency = GameMain.Server.SimulatedMinimumLatency;
            netPeerConfiguration.SimulatedRandomLatency = GameMain.Server.SimulatedRandomLatency;
            netPeerConfiguration.SimulatedLoss = GameMain.Server.SimulatedLoss;
 #endif

-            NetOutgoingMessage lidgrenMsg = netServer.CreateMessage();
-            byte[] msgData = new byte[msg.LengthBytes];
-            msg.PrepareForSending(ref msgData, compressPastThreshold, out bool isCompressed, out int length);
-            lidgrenMsg.Write((byte)(isCompressed ? PacketHeader.IsCompressed : PacketHeader.None));
-            lidgrenMsg.Write((UInt16)length);
-            lidgrenMsg.Write(msgData, 0, length);
-
-            NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
-            if (result != NetSendResult.Sent && result != NetSendResult.Queued)
+            var headers = new PeerPacketHeaders
            {
-                DebugConsole.NewMessage("Failed to send message to "+conn.Name+": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
-            }
+                DeliveryMethod = deliveryMethod,
+                PacketHeader = isCompressed ? PacketHeader.IsCompressed : PacketHeader.None,
+                Initialization = null
+            };
+            var body = new PeerPacketMessage
+            {
+                Buffer = bufAux
+            };
+            SendMsgInternal(conn, headers, body);
        }
-        
-        public override void Disconnect(NetworkConnection conn,string msg=null)
+
+        public override void Disconnect(NetworkConnection conn, PeerDisconnectPacket peerDisconnectPacket)
        {
            if (netServer == null) { return; }

-            if (!(conn is LidgrenConnection lidgrenConn)) { return; }
+            if (conn is not LidgrenConnection lidgrenConn) { return; }
+
            if (connectedClients.Contains(lidgrenConn))
            {
                lidgrenConn.Status = NetworkConnectionStatus.Disconnected;
                connectedClients.Remove(lidgrenConn);
-                OnDisconnect?.Invoke(conn, msg);
-                Steam.SteamManager.StopAuthSession(conn.SteamID);
+                callbacks.OnDisconnect.Invoke(conn, peerDisconnectPacket);
+                if (conn.AccountInfo.AccountId is Some<AccountId> { Value: SteamId steamId }) { SteamManager.StopAuthSession(steamId); }
            }
-            lidgrenConn.NetConnection.Disconnect(msg ?? "Disconnected");
+
+            lidgrenConn.NetConnection.Disconnect(peerDisconnectPacket.ToLidgrenStringRepresentation());
        }

-        protected override void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg)
+        protected override void SendMsgInternal(NetworkConnection conn, PeerPacketHeaders headers, INetSerializableStruct? body)
        {
-            LidgrenConnection lidgrenConn = conn as LidgrenConnection;
-            NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-            switch (deliveryMethod)
-            {
-                case DeliveryMethod.Unreliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
-                    break;
-                case DeliveryMethod.Reliable:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
-                    break;
-                case DeliveryMethod.ReliableOrdered:
-                    lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
-                    break;
-            }
+            IWriteMessage msgToSend = new WriteOnlyMessage();
+            msgToSend.WriteNetSerializableStruct(headers);
+            body?.Write(msgToSend);

-            NetOutgoingMessage lidgrenMsg = netServer.CreateMessage();
-            lidgrenMsg.Write(msg.Buffer, 0, msg.LengthBytes);
-            NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
+            NetSendResult result = ForwardToLidgren(msgToSend, conn, headers.DeliveryMethod);
            if (result != NetSendResult.Sent && result != NetSendResult.Queued)
            {
-                DebugConsole.NewMessage("Failed to send message to " + conn.Name + ": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
+                DebugConsole.NewMessage($"Failed to send message to {conn.Endpoint}: {result}", Microsoft.Xna.Framework.Color.Yellow);
            }
        }

        protected override void CheckOwnership(PendingClient pendingClient)
        {
-            LidgrenConnection l = pendingClient.Connection as LidgrenConnection;
-            if (OwnerConnection == null &&
-                    IPAddress.IsLoopback(l.NetConnection.RemoteEndPoint.Address.MapToIPv4NoThrow()) &&
-                    ownerKey != null && pendingClient.OwnerKey != 0 && pendingClient.OwnerKey == ownerKey)
+            if (OwnerConnection == null
+                && pendingClient.Connection is LidgrenConnection l
+                && IPAddress.IsLoopback(l.NetConnection.RemoteEndPoint.Address)
+                && ownerKey.IsSome() && pendingClient.OwnerKey == ownerKey)
            {
-                ownerKey = null;
+                ownerKey = Option<int>.None();
                OwnerConnection = pendingClient.Connection;
+                callbacks.OnOwnerDetermined.Invoke(OwnerConnection);
            }
        }

-        protected override void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket)
+        protected override void ProcessAuthTicket(ClientSteamTicketAndVersionPacket packet, PendingClient pendingClient)
        {
-            if (pendingClient.SteamID == null)
+            if (pendingClient.AccountInfo.AccountId.IsNone())
            {
                bool requireSteamAuth = GameSettings.CurrentConfig.RequireSteamAuthentication;
 #if DEBUG
                requireSteamAuth = false;
 #endif
+                bool hasSteamAuth = packet.SteamAuthTicket.TryUnwrap(out var ticket);

                //steam auth cannot be done (SteamManager not initialized or no ticket given),
                //but it's not required either -> let the client join without auth
-                if ((!Steam.SteamManager.IsInitialized || (ticket?.Length ?? 0) == 0) &&
-                    !requireSteamAuth)
+                if ((!SteamManager.IsInitialized || !hasSteamAuth) && !requireSteamAuth)
                {
-                    pendingClient.Connection.Name = name;
-                    pendingClient.Name = name;
-                    pendingClient.OwnerKey = ownKey;
+                    pendingClient.Name = packet.Name;
+                    pendingClient.OwnerKey = packet.OwnerKey;
                    pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
                }
                else
                {
-                    Steamworks.BeginAuthResult authSessionStartState = Steam.SteamManager.StartAuthSession(ticket, steamId);
-                    if (authSessionStartState != Steamworks.BeginAuthResult.OK)
+                    if (!packet.SteamId.TryUnwrap(out var id) || id is not SteamId steamId)
                    {
                        if (requireSteamAuth)
                        {
-                            RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "Steam auth session failed to start: " + authSessionStartState.ToString());
+                            RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.SteamAuthenticationFailed));
                            return;
                        }
-                        else
+                    }
+                    else
+                    {
+                        Steamworks.BeginAuthResult authSessionStartState = SteamManager.StartAuthSession(ticket, steamId);
+                        if (authSessionStartState != Steamworks.BeginAuthResult.OK)
                        {
-                            steamId = 0;
-                            pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
+                            if (requireSteamAuth)
+                            {
+                                RemovePendingClient(pendingClient, PeerDisconnectPacket.SteamAuthError(authSessionStartState));
+                            }
+                            else
+                            {
+                                packet.SteamId = Option<AccountId>.None();
+                                pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
+                            }
                        }
                    }
-                    pendingClient.SteamID = steamId;
-                    pendingClient.Connection.Name = name;
-                    pendingClient.Name = name;
-                    pendingClient.OwnerKey = ownKey;
+
+                    pendingClient.Connection.SetAccountInfo(new AccountInfo(packet.SteamId.Select(uid => (AccountId)uid)));
+                    pendingClient.Name = packet.Name;
+                    pendingClient.OwnerKey = packet.OwnerKey;
                    pendingClient.AuthSessionStarted = true;
                }
            }
            else
            {
-                if (pendingClient.SteamID != steamId)
+                if (pendingClient.AccountInfo.AccountId != packet.SteamId.Select(uid => (AccountId)uid))
                {
-                    RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "SteamID mismatch");
-                    return;
+                    RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.SteamAuthenticationFailed));
                }
            }
        }
+
+        private NetSendResult ForwardToLidgren(IWriteMessage msg, NetworkConnection connection, DeliveryMethod deliveryMethod)
+        {
+            ToolBox.ThrowIfNull(netServer);
+
+            LidgrenConnection conn = (LidgrenConnection)connection;
+            return netServer.SendMessage(msg.ToLidgren(netServer), conn.NetConnection, deliveryMethod.ToLidgren());
+        }
    }
-}
+}
@@ -1,75 +1,61 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Collections.Immutable;
 using System.Linq;
-using System.Text;
+using Barotrauma.Extensions;

 namespace Barotrauma.Networking
 {
-    abstract class ServerPeer
+    internal abstract class ServerPeer
    {
-        public delegate void MessageCallback(NetworkConnection connection, IReadMessage message);
-        public delegate void DisconnectCallback(NetworkConnection connection, string reason);
-        public delegate void InitializationCompleteCallback(NetworkConnection connection);
-        public delegate void ShutdownCallback();
-        public delegate void OwnerDeterminedCallback(NetworkConnection connection);
+        public readonly record struct Callbacks(
+            Callbacks.MessageCallback OnMessageReceived,
+            Callbacks.DisconnectCallback OnDisconnect,
+            Callbacks.InitializationCompleteCallback OnInitializationComplete,
+            Callbacks.ShutdownCallback OnShutdown,
+            Callbacks.OwnerDeterminedCallback OnOwnerDetermined)
+        {
+            public delegate void MessageCallback(NetworkConnection connection, IReadMessage message);
+            public delegate void DisconnectCallback(NetworkConnection connection, PeerDisconnectPacket peerDisconnectPacket);
+            public delegate void InitializationCompleteCallback(NetworkConnection connection, string? clientName);
+            public delegate void ShutdownCallback();
+            public delegate void OwnerDeterminedCallback(NetworkConnection connection);
+        }

-        public MessageCallback OnMessageReceived;
-        public DisconnectCallback OnDisconnect;
-        public InitializationCompleteCallback OnInitializationComplete;
-        public ShutdownCallback OnShutdown;
-        public OwnerDeterminedCallback OnOwnerDetermined;
-
-        protected int? ownerKey;
-
-        public NetworkConnection OwnerConnection { get; protected set; }
+        protected readonly Callbacks callbacks;

+        protected ServerPeer(Callbacks callbacks)
+        {
+            this.callbacks = callbacks;
+        }
+        
        public abstract void InitializeSteamServerCallbacks();

        public abstract void Start();
-        public abstract void Close(string msg = null);
+        public abstract void Close();
        public abstract void Update(float deltaTime);

-        public class PendingClient
+        protected sealed class PendingClient
        {
-            public string Name;
-            public int OwnerKey;
-            public NetworkConnection Connection;
+            public string? Name;
+            public Option<int> OwnerKey;
+            public readonly NetworkConnection Connection;
            public ConnectionInitialization InitializationStep;
            public double UpdateTime;
            public double TimeOut;
            public int Retries;
-            private UInt64? steamId;
-            public UInt64? SteamID
-            {
-                get { return steamId; }
-                set
-                {
-                    steamId = value;
-                    Connection.SetSteamIDIfUnknown(value ?? 0);
-                }
-            }
-            private UInt64? ownerSteamId;
-            public UInt64? OwnerSteamID
-            {
-                get { return ownerSteamId; }
-                set
-                {
-                    ownerSteamId = value;
-                    Connection.SetOwnerSteamIDIfUnknown(value ?? 0);
-                }
-            }
            public Int32? PasswordSalt;
            public bool AuthSessionStarted;
+            
+            public AccountInfo AccountInfo => Connection.AccountInfo;

            public PendingClient(NetworkConnection conn)
            {
-                OwnerKey = 0;
+                OwnerKey = Option<int>.None();
                Connection = conn;
                InitializationStep = ConnectionInitialization.SteamTicketAndVersion;
                Retries = 0;
-                SteamID = null;
-                OwnerSteamID = null;
                PasswordSalt = null;
                UpdateTime = Timing.TotalTime + Timing.Step * 3.0;
                TimeOut = NetworkConnection.TimeoutThreshold;
@@ -81,73 +67,70 @@ namespace Barotrauma.Networking
                TimeOut = NetworkConnection.TimeoutThreshold;
            }
        }
-        protected List<NetworkConnection> connectedClients;
-        protected List<PendingClient> pendingClients;

-        protected ServerSettings serverSettings;
+        protected List<NetworkConnection> connectedClients = null!;
+        protected List<PendingClient> pendingClients = null!;
+        protected ServerSettings serverSettings = null!;
+        protected Option<int> ownerKey = null!;
+        protected NetworkConnection? OwnerConnection;

-        protected void ReadConnectionInitializationStep(PendingClient pendingClient, IReadMessage inc)
+        protected void ReadConnectionInitializationStep(PendingClient pendingClient, IReadMessage inc, ConnectionInitialization initializationStep)
        {
            pendingClient.TimeOut = NetworkConnection.TimeoutThreshold;

-            ConnectionInitialization initializationStep = (ConnectionInitialization)inc.ReadByte();
-
-            if (pendingClient.InitializationStep != initializationStep) return;
+            if (pendingClient.InitializationStep != initializationStep) { return; }

            pendingClient.UpdateTime = Timing.TotalTime + Timing.Step;

            switch (initializationStep)
            {
                case ConnectionInitialization.SteamTicketAndVersion:
-                    string name = Client.SanitizeName(inc.ReadString());
-                    int ownerKey = inc.ReadInt32();
-                    UInt64 steamId = inc.ReadUInt64();
-                    UInt16 ticketLength = inc.ReadUInt16();
-                    byte[] ticketBytes = inc.ReadBytes(ticketLength);
+                    var authPacket = INetSerializableStruct.Read<ClientSteamTicketAndVersionPacket>(inc);

-                    if (!Client.IsValidName(name, serverSettings))
+                    if (!Client.IsValidName(authPacket.Name, serverSettings))
                    {
-                        RemovePendingClient(pendingClient, DisconnectReason.InvalidName, "");
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.InvalidName));
                        return;
                    }

-                    string version = inc.ReadString();
-                    bool isCompatibleVersion = NetworkMember.IsCompatible(version, GameMain.Version.ToString()) ?? false;
+                    bool isCompatibleVersion =
+                        Version.TryParse(authPacket.GameVersion, out var remoteVersion)
+                        && NetworkMember.IsCompatible(remoteVersion, GameMain.Version);
                    if (!isCompatibleVersion)
                    {
-                        RemovePendingClient(pendingClient, DisconnectReason.InvalidVersion,
-                                    $"DisconnectMessage.InvalidVersion~[version]={GameMain.Version}~[clientversion]={version}");
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.InvalidVersion());

-                        GameServer.Log($"{name} ({steamId}) couldn't join the server (incompatible game version)", ServerLog.MessageType.Error);
-                        DebugConsole.NewMessage($"{name} ({steamId}) couldn't join the server (incompatible game version)", Microsoft.Xna.Framework.Color.Red);
+                        GameServer.Log($"{authPacket.Name} ({authPacket.SteamId}) couldn't join the server (incompatible game version)", ServerLog.MessageType.Error);
+                        DebugConsole.NewMessage($"{authPacket.Name} ({authPacket.SteamId}) couldn't join the server (incompatible game version)", Microsoft.Xna.Framework.Color.Red);
                        return;
                    }

-                    LanguageIdentifier language = inc.ReadIdentifier().ToLanguageIdentifier();
-                    pendingClient.Connection.Language = language;
+                    pendingClient.Connection.Language = authPacket.Language.ToLanguageIdentifier();

-                    Client nameTaken = GameMain.Server.ConnectedClients.Find(c => Homoglyphs.Compare(c.Name.ToLower(), name.ToLower()));
+                    Client nameTaken = GameMain.Server.ConnectedClients.Find(c => Homoglyphs.Compare(c.Name.ToLower(), authPacket.Name.ToLower()));
                    if (nameTaken != null)
                    {
-                        RemovePendingClient(pendingClient, DisconnectReason.NameTaken, "");
-                        GameServer.Log($"{name} ({steamId}) couldn't join the server (name too similar to the name of the client \"" + nameTaken.Name + "\").", ServerLog.MessageType.Error);
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.NameTaken));
+                        GameServer.Log($"{authPacket.Name} ({authPacket.SteamId}) couldn't join the server (name too similar to the name of the client \"" + nameTaken.Name + "\").", ServerLog.MessageType.Error);
                        return;
                    }

                    if (!pendingClient.AuthSessionStarted)
                    {
-                        ProcessAuthTicket(name, ownerKey, steamId, pendingClient, ticketBytes);
+                        ProcessAuthTicket(authPacket, pendingClient);
                    }
+
                    break;
                case ConnectionInitialization.Password:
-                    int pwLength = inc.ReadByte();
-                    byte[] incPassword = inc.ReadBytes(pwLength);
-                    if (pendingClient.PasswordSalt == null)
+                    var passwordPacket = INetSerializableStruct.Read<ClientPeerPasswordPacket>(inc);
+
+                    if (pendingClient.PasswordSalt is null)
                    {
                        DebugConsole.ThrowError("Received password message from client without salt");
                        return;
                    }
-                    if (serverSettings.IsPasswordCorrect(incPassword, pendingClient.PasswordSalt.Value))
+
+                    if (serverSettings.IsPasswordCorrect(passwordPacket.Password, pendingClient.PasswordSalt.Value))
                    {
                        pendingClient.InitializationStep = ConnectionInitialization.ContentPackageOrder;
                    }
@@ -156,13 +139,13 @@ namespace Barotrauma.Networking
                        pendingClient.Retries++;
                        if (serverSettings.BanAfterWrongPassword && pendingClient.Retries > serverSettings.MaxPasswordRetriesBeforeBan)
                        {
-                            string banMsg = "Failed to enter correct password too many times";
+                            const string banMsg = "Failed to enter correct password too many times";
                            BanPendingClient(pendingClient, banMsg, null);
-
-                            RemovePendingClient(pendingClient, DisconnectReason.Banned, banMsg);
+                            RemovePendingClient(pendingClient, PeerDisconnectPacket.Banned(banMsg));
                            return;
                        }
                    }
+
                    pendingClient.UpdateTime = Timing.TotalTime;
                    break;
                case ConnectionInitialization.ContentPackageOrder:
@@ -172,37 +155,49 @@ namespace Barotrauma.Networking
            }
        }

-        protected abstract void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket);
+        protected abstract void ProcessAuthTicket(ClientSteamTicketAndVersionPacket packet, PendingClient pendingClient);

        protected void BanPendingClient(PendingClient pendingClient, string banReason, TimeSpan? duration)
        {
-            if (pendingClient.Connection is LidgrenConnection l)
+            void banAccountId(AccountId accountId)
            {
-                serverSettings.BanList.BanPlayer(pendingClient.Name, l.NetConnection.RemoteEndPoint.Address, banReason, duration);
+                serverSettings.BanList.BanPlayer(pendingClient.Name ?? "Player", accountId, banReason, duration);
            }
-            else if (pendingClient.Connection is SteamP2PConnection s)
+
+            if (pendingClient.AccountInfo.AccountId.TryUnwrap(out var id)) { banAccountId(id); }
+
+            pendingClient.AccountInfo.OtherMatchingIds.ForEach(banAccountId);
+            if (pendingClient.AccountInfo.AccountId.TryUnwrap(out var accountId))
            {
-                serverSettings.BanList.BanPlayer(pendingClient.Name, s.SteamID, banReason, duration);
-                serverSettings.BanList.BanPlayer(pendingClient.Name, s.OwnerSteamID, banReason, duration);
+                serverSettings.BanList.BanPlayer(pendingClient.Name ?? "Player", accountId, banReason, duration);
+            }
+            else
+            {
+                serverSettings.BanList.BanPlayer(pendingClient.Name ?? "Player", pendingClient.Connection.Endpoint, banReason, duration);
            }
        }

-        protected bool IsPendingClientBanned(PendingClient pendingClient, out string banReason)
+        protected bool IsPendingClientBanned(PendingClient pendingClient, out string? banReason)
        {
-            if (pendingClient.Connection is LidgrenConnection l)
+            bool isAccountIdBanned(AccountId accountId, out string? banReason)
            {
-                return serverSettings.BanList.IsBanned(l.NetConnection.RemoteEndPoint.Address, out banReason);
+                return serverSettings.BanList.IsBanned(accountId, out banReason);
            }
-            else if (pendingClient.Connection is SteamP2PConnection s)
+
+            banReason = default;
+            bool isBanned = pendingClient.AccountInfo.AccountId.TryUnwrap(out var id)
+                            && isAccountIdBanned(id, out banReason);
+            foreach (var otherId in pendingClient.AccountInfo.OtherMatchingIds)
            {
-                return serverSettings.BanList.IsBanned(s.SteamID, out banReason) ||
-                       serverSettings.BanList.IsBanned(s.OwnerSteamID, out banReason);
+                if (isBanned) { break; }
+
+                isBanned |= isAccountIdBanned(otherId, out banReason);
            }
-            banReason = null;
-            return false;
+
+            return isBanned;
        }

-        protected abstract void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg);
+        protected abstract void SendMsgInternal(NetworkConnection conn, PeerPacketHeaders headers, INetSerializableStruct? body);

        protected void UpdatePendingClient(PendingClient pendingClient)
        {
@@ -213,12 +208,12 @@ namespace Barotrauma.Networking

            if (!skipRemove && connectedClients.Count >= serverSettings.MaxPlayers)
            {
-                RemovePendingClient(pendingClient, DisconnectReason.ServerFull, "");
+                RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.ServerFull));
            }

-            if (IsPendingClientBanned(pendingClient, out string banReason))
+            if (IsPendingClientBanned(pendingClient, out string? banReason))
            {
-                RemovePendingClient(pendingClient, DisconnectReason.Banned, banReason);
+                RemovePendingClient(pendingClient, PeerDisconnectPacket.Banned(banReason));
                return;
            }

@@ -228,80 +223,86 @@ namespace Barotrauma.Networking
                connectedClients.Add(newConnection);
                pendingClients.Remove(pendingClient);

-                CheckOwnership(pendingClient);
+                callbacks.OnInitializationComplete.Invoke(newConnection, pendingClient.Name);

-                OnInitializationComplete?.Invoke(newConnection);
+                CheckOwnership(pendingClient);
            }

            pendingClient.TimeOut -= Timing.Step;
            if (pendingClient.TimeOut < 0.0)
            {
-                RemovePendingClient(pendingClient, DisconnectReason.Unknown, Lidgren.Network.NetConnection.NoResponseMessage);
+                RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.Timeout));
            }

            if (Timing.TotalTime < pendingClient.UpdateTime) { return; }
+
            pendingClient.UpdateTime = Timing.TotalTime + 1.0;

-            IWriteMessage outMsg = new WriteOnlyMessage();
-            outMsg.Write((byte)(PacketHeader.IsConnectionInitializationStep |
-                                PacketHeader.IsServerMessage));
-            outMsg.Write((byte)pendingClient.InitializationStep);
+            PeerPacketHeaders headers = new PeerPacketHeaders
+            {
+                DeliveryMethod = DeliveryMethod.Reliable,
+                PacketHeader = PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage,
+                Initialization = pendingClient.InitializationStep
+            };
+
+            INetSerializableStruct? structToSend = null;
+
            switch (pendingClient.InitializationStep)
            {
                case ConnectionInitialization.ContentPackageOrder:
-                    outMsg.Write(GameMain.Server.ServerName);

-                    var mpContentPackages = ContentPackageManager.EnabledPackages.All.Where(cp => cp.HasMultiplayerSyncedContent).ToList();
-                    outMsg.WriteVariableUInt32((UInt32)mpContentPackages.Count);
-                    for (int i = 0; i < mpContentPackages.Count; i++)
+                    DateTime timeNow = DateTime.UtcNow;
+                    structToSend = new ServerPeerContentPackageOrderPacket
                    {
-                        outMsg.Write(mpContentPackages[i].Name);
-                        byte[] hashBytes = mpContentPackages[i].Hash.ByteRepresentation;
-                        outMsg.WriteVariableUInt32((UInt32)hashBytes.Length);
-                        outMsg.Write(hashBytes, 0, hashBytes.Length);
-                        outMsg.Write(mpContentPackages[i].SteamWorkshopId);
-                        UInt32 installTimeDiffSeconds = (UInt32)((mpContentPackages[i].InstallTime ?? DateTime.UtcNow) - DateTime.UtcNow).TotalSeconds;
-                        outMsg.Write(installTimeDiffSeconds);
-                    }
+                        ServerName = GameMain.Server.ServerName,
+                        ContentPackages = ContentPackageManager.EnabledPackages.All.Where(cp => cp.HasMultiplayerSyncedContent || cp.Files.All(f => f is SubmarineFile))
+                            .Select(contentPackage => new ServerContentPackage(contentPackage, timeNow))
+                            .ToImmutableArray()
+                    };
+
                    break;
                case ConnectionInitialization.Password:
-                    outMsg.Write(pendingClient.PasswordSalt == null); outMsg.WritePadBits();
-                    if (pendingClient.PasswordSalt == null)
+                    structToSend = new ServerPeerPasswordPacket
                    {
-                        pendingClient.PasswordSalt = Lidgren.Network.CryptoRandom.Instance.Next();
-                        outMsg.Write(pendingClient.PasswordSalt.Value);
-                    }
-                    else
+                        Salt = GetSalt(pendingClient),
+                        RetriesLeft = Option<int>.Some(pendingClient.Retries)
+                    };
+
+                    static Option<int> GetSalt(PendingClient client)
                    {
-                        outMsg.Write(pendingClient.Retries);
+                        if (client.PasswordSalt is { } salt) { return Option<int>.Some(salt); }
+
+                        salt = Lidgren.Network.CryptoRandom.Instance.Next();
+                        client.PasswordSalt = salt;
+                        return Option<int>.Some(salt);
                    }
+
                    break;
            }

-            SendMsgInternal(pendingClient.Connection, DeliveryMethod.Reliable, outMsg);
+            SendMsgInternal(pendingClient.Connection, headers, structToSend);
        }

        protected virtual void CheckOwnership(PendingClient pendingClient) { }

-        public void RemovePendingClient(PendingClient pendingClient, DisconnectReason reason, string msg)
+        protected void RemovePendingClient(PendingClient pendingClient, PeerDisconnectPacket peerDisconnectPacket)
        {
            if (pendingClients.Contains(pendingClient))
            {
-                Disconnect(pendingClient.Connection, reason + "/" + msg);
+                Disconnect(pendingClient.Connection, peerDisconnectPacket);

                pendingClients.Remove(pendingClient);

-                if (pendingClient.AuthSessionStarted)
+                if (pendingClient.AuthSessionStarted && pendingClient.AccountInfo.AccountId is Some<AccountId> { Value: SteamId steamId })
                {
-                    Steam.SteamManager.StopAuthSession(pendingClient.SteamID.Value);
-                    pendingClient.SteamID = null;
-                    pendingClient.OwnerSteamID = null;
+                    Steam.SteamManager.StopAuthSession(steamId);
+                    pendingClient.Connection.SetAccountInfo(AccountInfo.None);
                    pendingClient.AuthSessionStarted = false;
                }
            }
        }

        public abstract void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod, bool compressPastThreshold = true);
-        public abstract void Disconnect(NetworkConnection conn, string msg = null);
+        public abstract void Disconnect(NetworkConnection conn, PeerDisconnectPacket peerDisconnectPacket);
    }
-}
+}
@@ -1,70 +1,61 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
-using System.Net;
-using System.Linq;
-using System.Threading;

 namespace Barotrauma.Networking
 {
-    class SteamP2PServerPeer : ServerPeer
+    internal sealed class SteamP2PServerPeer : ServerPeer
    {
        private bool started;

-        public UInt64 OwnerSteamID
-        {
-            get;
-            private set;
-        }
+        private readonly SteamId ownerSteamId;

-        private UInt64 ownerKey64 => unchecked((UInt64)ownerKey.Value);
-        
-        private UInt64 ReadSteamId(IReadMessage inc)
-            => inc.ReadUInt64() ^ ownerKey64;
-        private void WriteSteamId(IWriteMessage msg, UInt64 val)
-            => msg.Write(val ^ ownerKey64);
+        private UInt64 ownerKey64 => unchecked((UInt64)ownerKey.Fallback(0));

-        public SteamP2PServerPeer(UInt64 steamId, int ownerKey, ServerSettings settings)
+        private SteamId ReadSteamId(IReadMessage inc) => new SteamId(inc.ReadUInt64() ^ ownerKey64);
+        private void WriteSteamId(IWriteMessage msg, SteamId val) => msg.WriteUInt64(val.Value ^ ownerKey64);
+
+        public SteamP2PServerPeer(SteamId steamId, int ownerKey, ServerSettings settings, Callbacks callbacks) : base(callbacks)
        {
            serverSettings = settings;

            connectedClients = new List<NetworkConnection>();
            pendingClients = new List<PendingClient>();

-            this.ownerKey = ownerKey;
+            this.ownerKey = Option<int>.Some(ownerKey);

-            OwnerSteamID = steamId;
+            ownerSteamId = steamId;

            started = false;
        }

        public override void Start()
        {
-            IWriteMessage outMsg = new WriteOnlyMessage();
-            WriteSteamId(outMsg, OwnerSteamID);
-            outMsg.Write((byte)DeliveryMethod.Reliable);
-            outMsg.Write((byte)(PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage));
-
-            byte[] msgToSend = (byte[])outMsg.Buffer.Clone();
-            Array.Resize(ref msgToSend, outMsg.LengthBytes);
-            ChildServerRelay.Write(msgToSend);
+            var headers = new PeerPacketHeaders
+            {
+                DeliveryMethod = DeliveryMethod.Reliable,
+                PacketHeader = PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage,
+                Initialization = null
+            };
+            SendMsgInternal(ownerSteamId, headers, null);

            started = true;
        }

-        public override void Close(string msg = null)
+        public override void Close()
        {
            if (!started) { return; }

-            if (OwnerConnection != null) OwnerConnection.Status = NetworkConnectionStatus.Disconnected;
+            if (OwnerConnection != null) { OwnerConnection.Status = NetworkConnectionStatus.Disconnected; }

            for (int i = pendingClients.Count - 1; i >= 0; i--)
            {
-                RemovePendingClient(pendingClients[i], DisconnectReason.ServerShutdown, msg);
+                RemovePendingClient(pendingClients[i], PeerDisconnectPacket.WithReason(DisconnectReason.ServerShutdown));
            }

            for (int i = connectedClients.Count - 1; i >= 0; i--)
            {
-                Disconnect(connectedClients[i], msg ?? DisconnectReason.ServerShutdown.ToString());
+                Disconnect(connectedClients[i], PeerDisconnectPacket.WithReason(DisconnectReason.ServerShutdown));
            }

            pendingClients.Clear();
@@ -72,27 +63,21 @@ namespace Barotrauma.Networking

            ChildServerRelay.ShutDown();

-            OnShutdown?.Invoke();
+            callbacks.OnShutdown.Invoke();
        }

        public override void Update(float deltaTime)
        {
            if (!started) { return; }

-            if (OnOwnerDetermined != null && OwnerConnection != null)
-            {
-                OnOwnerDetermined?.Invoke(OwnerConnection);
-                OnOwnerDetermined = null;
-            }
-
            //backwards for loop so we can remove elements while iterating
            for (int i = connectedClients.Count - 1; i >= 0; i--)
            {
-                SteamP2PConnection conn = connectedClients[i] as SteamP2PConnection;
+                SteamP2PConnection conn = (SteamP2PConnection)connectedClients[i];
                conn.Decay(deltaTime);
                if (conn.Timeout < 0.0)
                {
-                    Disconnect(conn, "Timed out");
+                    Disconnect(conn, PeerDisconnectPacket.WithReason(DisconnectReason.Timeout));
                }
            }

@@ -109,7 +94,7 @@ namespace Barotrauma.Networking
            catch (Exception e)
            {
                string errorMsg = "Server failed to read an incoming message. {" + e + "}\n" + e.StackTrace.CleanupStackTrace();
-                GameAnalyticsManager.AddErrorEventOnce("SteamP2PServerPeer.Update:ClientReadException" + e.TargetSite.ToString(), GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce($"SteamP2PServerPeer.Update:ClientReadException{e.TargetSite}", GameAnalyticsManager.ErrorSeverity.Error, errorMsg);
 #if DEBUG
                DebugConsole.ThrowError(errorMsg);
 #else
@@ -124,130 +109,132 @@ namespace Barotrauma.Networking
                if (i >= pendingClients.Count || pendingClients[i] != pendingClient) { i--; }
            }
        }
-        
+
        private void HandleDataMessage(IReadMessage inc)
        {
            if (!started) { return; }

-            UInt64 senderSteamId = ReadSteamId(inc);
-            UInt64 ownerSteamId = ReadSteamId(inc);
+            SteamId senderSteamId = ReadSteamId(inc);
+            SteamId sentOwnerSteamId = ReadSteamId(inc);
+
+            var (deliveryMethod, packetHeader, initialization) = INetSerializableStruct.Read<PeerPacketHeaders>(inc);

-            PacketHeader packetHeader = (PacketHeader)inc.ReadByte();
-            
            if (packetHeader.IsServerMessage())
            {
-                DebugConsole.ThrowError("Got server message from" + senderSteamId.ToString());
+                DebugConsole.ThrowError($"Got server message from {senderSteamId}");
                return;
            }

-            if (senderSteamId != OwnerSteamID) //sender is remote, handle disconnects and heartbeats
+            if (senderSteamId != ownerSteamId) //sender is remote, handle disconnects and heartbeats
            {
-                PendingClient pendingClient = pendingClients.Find(c => c.SteamID == senderSteamId);
-                SteamP2PConnection connectedClient = connectedClients.Find(c => c.SteamID == senderSteamId) as SteamP2PConnection;
-                
+                bool connectionMatches(NetworkConnection conn) =>
+                    conn is SteamP2PConnection { Endpoint: SteamP2PEndpoint { SteamId: var steamId } }
+                    && steamId == senderSteamId;
+
+                PendingClient? pendingClient = pendingClients.Find(c => connectionMatches(c.Connection));
+                SteamP2PConnection? connectedClient = connectedClients.Find(connectionMatches) as SteamP2PConnection;
+
                pendingClient?.Heartbeat();
                connectedClient?.Heartbeat();

-                string banReason;
-                if (serverSettings.BanList.IsBanned(senderSteamId, out banReason) ||
-                    serverSettings.BanList.IsBanned(ownerSteamId, out banReason))
+                if (packetHeader.IsConnectionInitializationStep())
+                {
+                    if (!initialization.HasValue) { return; }
+                    ConnectionInitialization initializationStep = initialization.Value;
+
+                    if (pendingClient != null)
+                    {
+                        pendingClient.Connection.SetAccountInfo(new AccountInfo(senderSteamId, sentOwnerSteamId));
+                        ReadConnectionInitializationStep(
+                            pendingClient,
+                            new ReadWriteMessage(inc.Buffer, inc.BitPosition, inc.LengthBits, false),
+                            initializationStep);
+                    }
+                    else if (initializationStep == ConnectionInitialization.ConnectionStarted)
+                    {
+                        pendingClient = new PendingClient(new SteamP2PConnection(senderSteamId));
+                        pendingClient.Connection.SetAccountInfo(new AccountInfo(senderSteamId, sentOwnerSteamId));
+                        pendingClients.Add(pendingClient);
+                    }
+                }
+                else if (serverSettings.BanList.IsBanned(senderSteamId, out string banReason) ||
+                    serverSettings.BanList.IsBanned(sentOwnerSteamId, out banReason))
                {
                    if (pendingClient != null)
                    {
-                        RemovePendingClient(pendingClient, DisconnectReason.Banned, banReason);
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.Banned(banReason));
                    }
                    else if (connectedClient != null)
                    {
-                        Disconnect(connectedClient, DisconnectReason.Banned.ToString() + "/ "+ banReason);
+                        Disconnect(connectedClient, PeerDisconnectPacket.Banned(banReason));
                    }
-                    return;
                }
                else if (packetHeader.IsDisconnectMessage())
                {
                    if (pendingClient != null)
                    {
-                        string disconnectMsg = $"ServerMessage.HasDisconnected~[client]={pendingClient.Name}";
-                        RemovePendingClient(pendingClient, DisconnectReason.Unknown, disconnectMsg);
+                        RemovePendingClient(pendingClient, PeerDisconnectPacket.WithReason(DisconnectReason.Disconnected));
                    }
                    else if (connectedClient != null)
                    {
-                        string disconnectMsg = $"ServerMessage.HasDisconnected~[client]={connectedClient.Name}";
-                        Disconnect(connectedClient, disconnectMsg, false);
+                        Disconnect(connectedClient, PeerDisconnectPacket.WithReason(DisconnectReason.Disconnected));
                    }
-                    return;
                }
                else if (packetHeader.IsHeartbeatMessage())
                {
                    //message exists solely as a heartbeat, ignore its contents
                    return;
                }
-                else if (packetHeader.IsConnectionInitializationStep())
-                {
-
-                    if (pendingClient != null)
-                    {
-                        if (ownerSteamId != 0)
-                        {
-                            pendingClient.Connection.SetOwnerSteamIDIfUnknown(ownerSteamId);
-                        }
-                        ReadConnectionInitializationStep(pendingClient, new ReadOnlyMessage(inc.Buffer, false, inc.BytePosition, inc.LengthBytes - inc.BytePosition, null));
-                    }
-                    else
-                    {
-                        ConnectionInitialization initializationStep = (ConnectionInitialization)inc.ReadByte();
-                        if (initializationStep == ConnectionInitialization.ConnectionStarted)
-                        {
-                            pendingClients.Add(new PendingClient(new SteamP2PConnection("PENDING", senderSteamId)) { SteamID = senderSteamId });
-                        }
-                    }
-                }
                else if (connectedClient != null)
                {
-                    UInt16 length = inc.ReadUInt16();
-                    
-                    IReadMessage msg = new ReadOnlyMessage(inc.Buffer, packetHeader.IsCompressed(), inc.BytePosition, length, connectedClient);
-                    OnMessageReceived?.Invoke(connectedClient, msg);
+                    var packet = INetSerializableStruct.Read<PeerPacketMessage>(inc);
+                    IReadMessage msg = new ReadOnlyMessage(packet.Buffer, packetHeader.IsCompressed(), 0, packet.Length, connectedClient);
+                    callbacks.OnMessageReceived.Invoke(connectedClient, msg);
                }
            }
            else //sender is owner
            {
-                if (OwnerConnection != null) { (OwnerConnection as SteamP2PConnection).Heartbeat(); }
+                (OwnerConnection as SteamP2PConnection)?.Heartbeat();

                if (packetHeader.IsDisconnectMessage())
                {
                    DebugConsole.ThrowError("Received disconnect message from owner");
                    return;
                }
+
                if (packetHeader.IsServerMessage())
                {
                    DebugConsole.ThrowError("Received server message from owner");
                    return;
                }
+
                if (packetHeader.IsConnectionInitializationStep())
                {
-                    if (OwnerConnection == null)
+                    if (OwnerConnection is null)
                    {
-                        string ownerName = inc.ReadString();
-                        OwnerConnection = new SteamP2PConnection(ownerName, OwnerSteamID)
+                        var packet = INetSerializableStruct.Read<SteamP2PInitializationOwnerPacket>(inc);
+                        OwnerConnection = new SteamP2PConnection(ownerSteamId)
                        {
                            Language = GameSettings.CurrentConfig.Language
                        };
-                        OwnerConnection.SetOwnerSteamIDIfUnknown(OwnerSteamID);
+                        OwnerConnection.SetAccountInfo(new AccountInfo(ownerSteamId, ownerSteamId));

-                        OnInitializationComplete?.Invoke(OwnerConnection);
+                        callbacks.OnInitializationComplete.Invoke(OwnerConnection, packet.OwnerName);
+                        callbacks.OnOwnerDetermined.Invoke(OwnerConnection);
                    }
+
                    return;
                }
+
                if (packetHeader.IsHeartbeatMessage())
                {
                    return;
                }
                else
                {
-                    UInt16 length = inc.ReadUInt16();
-
-                    IReadMessage msg = new ReadOnlyMessage(inc.Buffer, packetHeader.IsCompressed(), inc.BytePosition, length, OwnerConnection);
-                    OnMessageReceived?.Invoke(OwnerConnection, msg);
+                    var packet = INetSerializableStruct.Read<PeerPacketMessage>(inc);
+                    IReadMessage msg = new ReadOnlyMessage(packet.Buffer, packetHeader.IsCompressed(), 0, packet.Length, OwnerConnection);
+                    callbacks.OnMessageReceived.Invoke(OwnerConnection!, msg);
                }
            }
        }
@@ -256,90 +243,104 @@ namespace Barotrauma.Networking
        {
            throw new InvalidOperationException("Called InitializeSteamServerCallbacks on SteamP2PServerPeer!");
        }
-        
+
        public override void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod, bool compressPastThreshold = true)
        {
            if (!started) { return; }

-            if (!(conn is SteamP2PConnection steamp2pConn)) return;
-            if (!connectedClients.Contains(steamp2pConn) && conn != OwnerConnection)
+            if (conn is not SteamP2PConnection steamP2PConn) { return; }
+
+            if (!connectedClients.Contains(steamP2PConn) && conn != OwnerConnection)
            {
-                DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + steamp2pConn.SteamID.ToString());
+                DebugConsole.ThrowError($"Tried to send message to unauthenticated connection: {steamP2PConn.AccountInfo.AccountId}");
                return;
            }

-            IWriteMessage msgToSend = new WriteOnlyMessage();
-            byte[] msgData = new byte[16];
-            msg.PrepareForSending(ref msgData, compressPastThreshold, out bool isCompressed, out int length);
-            WriteSteamId(msgToSend, conn.SteamID);
-            msgToSend.Write((byte)deliveryMethod);
-            msgToSend.Write((byte)((isCompressed ? PacketHeader.IsCompressed : PacketHeader.None) | PacketHeader.IsServerMessage));
-            msgToSend.Write((UInt16)length);
-            msgToSend.Write(msgData, 0, length);
+            if (!conn.AccountInfo.AccountId.TryUnwrap(out var connAccountId) || connAccountId is not SteamId) { return; }

-            byte[] bufToSend = (byte[])msgToSend.Buffer.Clone();
-            Array.Resize(ref bufToSend, msgToSend.LengthBytes);
-            ChildServerRelay.Write(bufToSend);
+            byte[] bufAux = msg.PrepareForSending(compressPastThreshold, out bool isCompressed, out _);
+
+            var headers = new PeerPacketHeaders
+            {
+                DeliveryMethod = deliveryMethod,
+                PacketHeader = (isCompressed ? PacketHeader.IsCompressed : PacketHeader.None)
+                               | PacketHeader.IsServerMessage,
+                Initialization = null
+            };
+            var body = new PeerPacketMessage
+            {
+                Buffer = bufAux
+            };
+            SendMsgInternal(steamP2PConn, headers, body);
        }

-        private void SendDisconnectMessage(UInt64 steamId, string msg)
-        {
-            if (!started) { return; }
-            if (string.IsNullOrWhiteSpace(msg)) { return; }
-
-            IWriteMessage msgToSend = new WriteOnlyMessage();
-            WriteSteamId(msgToSend, steamId);
-            msgToSend.Write((byte)DeliveryMethod.Reliable);
-            msgToSend.Write((byte)(PacketHeader.IsDisconnectMessage | PacketHeader.IsServerMessage));
-            msgToSend.Write(msg);
-
-            byte[] bufToSend = (byte[])msgToSend.Buffer.Clone();
-            Array.Resize(ref bufToSend, msgToSend.LengthBytes);
-            ChildServerRelay.Write(bufToSend);
-        }
-
-        private void Disconnect(NetworkConnection conn, string msg, bool sendDisconnectMessage)
+        private void SendDisconnectMessage(SteamId steamId, PeerDisconnectPacket peerDisconnectPacket)
        {
            if (!started) { return; }

-            if (!(conn is SteamP2PConnection steamp2pConn)) { return; }
-            if (sendDisconnectMessage) { SendDisconnectMessage(steamp2pConn.SteamID, msg); }
+            var headers = new PeerPacketHeaders
+            {
+                DeliveryMethod = DeliveryMethod.Reliable,
+                PacketHeader = PacketHeader.IsDisconnectMessage | PacketHeader.IsServerMessage,
+                Initialization = null
+            };
+
+            SendMsgInternal(steamId, headers, peerDisconnectPacket);
+        }
+
+        public override void Disconnect(NetworkConnection conn, PeerDisconnectPacket peerDisconnectPacket)
+        {
+            if (!started) { return; }
+
+            if (conn is not SteamP2PConnection steamp2pConn) { return; }
+
+            if (!conn.AccountInfo.AccountId.TryUnwrap(out var connAccountId) || connAccountId is not SteamId connSteamId) { return; }
+
+            SendDisconnectMessage(connSteamId, peerDisconnectPacket);
+
            if (connectedClients.Contains(steamp2pConn))
            {
                steamp2pConn.Status = NetworkConnectionStatus.Disconnected;
                connectedClients.Remove(steamp2pConn);
-                OnDisconnect?.Invoke(conn, msg);
-                Steam.SteamManager.StopAuthSession(conn.SteamID);
+                callbacks.OnDisconnect.Invoke(conn, peerDisconnectPacket);
+                Steam.SteamManager.StopAuthSession(connSteamId);
            }
            else if (steamp2pConn == OwnerConnection)
            {
-                //TODO: fix?
+                throw new InvalidOperationException("Cannot disconnect owner peer");
            }
        }

-        public override void Disconnect(NetworkConnection conn, string msg = null)
+        protected override void SendMsgInternal(NetworkConnection conn, PeerPacketHeaders headers, INetSerializableStruct? body)
        {
-            Disconnect(conn, msg, true);
-        }
+            var connSteamId = conn is SteamP2PConnection { Endpoint: SteamP2PEndpoint { SteamId: var id } } ? id : null;
+            if (connSteamId is null) { return; }

-        protected override void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg)
+            SendMsgInternal(connSteamId, headers, body);
+        }
+        
+        private void SendMsgInternal(SteamId connSteamId, PeerPacketHeaders headers, INetSerializableStruct? body)
        {
            IWriteMessage msgToSend = new WriteOnlyMessage();
-            WriteSteamId(msgToSend, conn.SteamID);
-            msgToSend.Write((byte)deliveryMethod);
-            msgToSend.Write(msg.Buffer, 0, msg.LengthBytes);
-            byte[] bufToSend = (byte[])msgToSend.Buffer.Clone();
-            Array.Resize(ref bufToSend, msgToSend.LengthBytes);
+            WriteSteamId(msgToSend, connSteamId);
+            msgToSend.WriteNetSerializableStruct(headers);
+            body?.Write(msgToSend);
+
+            ForwardToOwnerProcess(msgToSend);
+        }
+
+        private static void ForwardToOwnerProcess(IWriteMessage msg)
+        {
+            byte[] bufToSend = (byte[])msg.Buffer.Clone();
+            Array.Resize(ref bufToSend, msg.LengthBytes);
            ChildServerRelay.Write(bufToSend);
        }

-        protected override void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket)
+        protected override void ProcessAuthTicket(ClientSteamTicketAndVersionPacket packet, PendingClient pendingClient)
        {
            pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
-
-            pendingClient.Connection.Name = name;
-            pendingClient.Name = name;
+            pendingClient.Name = packet.Name;
            pendingClient.AuthSessionStarted = true;
        }
    }
-}
+}