Unstable v0.19.1.0

2022-08-19 13:59:08 -03:00
parent 6b55adcdd9
commit 1219615d64
192 changed files with 3875 additions and 2648 deletions
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net;
 using System.Linq;
+using Barotrauma.Steam;
 using Lidgren.Network;

 namespace Barotrauma.Networking
@@ -13,7 +14,7 @@ namespace Barotrauma.Networking

        private readonly List<NetIncomingMessage> incomingLidgrenMessages;

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

@@ -184,7 +185,7 @@ namespace Barotrauma.Networking
                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);
@@ -195,7 +196,7 @@ namespace Barotrauma.Networking

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

@@ -206,7 +207,7 @@ namespace Barotrauma.Networking
        {
            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 == inc.SenderConnection);

            PacketHeader packetHeader = (PacketHeader)inc.ReadByte();

@@ -231,7 +232,9 @@ namespace Barotrauma.Networking
                    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);
                    return;
@@ -264,7 +267,7 @@ namespace Barotrauma.Networking
                        }
                        else
                        {
-                            disconnectMsg = $"ServerMessage.HasDisconnected~[client]={conn.Name}";
+                            disconnectMsg = $"ServerMessage.HasDisconnected~[client]={GameMain.Server.ConnectedClients.First(c => c.Connection == conn).Name}";
                            Disconnect(conn, disconnectMsg);
                        }
                    }
@@ -285,18 +288,18 @@ 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));
+            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 == null)
            {
                if (status != Steamworks.AuthResponse.OK)
                {
-                    LidgrenConnection connection = connectedClients.Find(c => c.SteamID == steamID) as LidgrenConnection;
+                    LidgrenConnection connection = connectedClients.Find(c => c.AccountInfo.AccountId is Some<AccountId> { Value: SteamId id } && id.Value == steamId) as LidgrenConnection;
                    if (connection != null)
                    {
                        Disconnect(connection, DisconnectReason.SteamAuthenticationFailed.ToString() + "/ Steam authentication status changed: " + status.ToString());
@@ -307,7 +310,9 @@ namespace Barotrauma.Networking

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

            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;
            }
@@ -333,7 +338,7 @@ namespace Barotrauma.Networking
            if (!(conn is LidgrenConnection lidgrenConn)) return;
            if (!connectedClients.Contains(lidgrenConn))
            {
-                DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + lidgrenConn.IPString);
+                DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + lidgrenConn.Endpoint.StringRepresentation);
                return;
            }

@@ -368,7 +373,7 @@ namespace Barotrauma.Networking
            NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
            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.StringRepresentation+": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
            }
        }
        
@@ -382,7 +387,7 @@ namespace Barotrauma.Networking
                lidgrenConn.Status = NetworkConnectionStatus.Disconnected;
                connectedClients.Remove(lidgrenConn);
                OnDisconnect?.Invoke(conn, msg);
-                Steam.SteamManager.StopAuthSession(conn.SteamID);
+                if (conn.AccountInfo.AccountId is Some<AccountId> { Value: SteamId steamId }) { Steam.SteamManager.StopAuthSession(steamId); }
            }
            lidgrenConn.NetConnection.Disconnect(msg ?? "Disconnected");
        }
@@ -409,25 +414,25 @@ namespace Barotrauma.Networking
            NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
            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.StringRepresentation + ": " + result.ToString(), 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;
            }
        }

-        protected override void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket)
+        protected override void ProcessAuthTicket(string name, Option<int> ownKey, Option<SteamId> steamId, PendingClient pendingClient, byte[] ticket)
        {
-            if (pendingClient.SteamID == null)
+            if (pendingClient.AccountInfo.AccountId.IsNone())
            {
                bool requireSteamAuth = GameSettings.CurrentConfig.RequireSteamAuthentication;
 #if DEBUG
@@ -436,32 +441,42 @@ namespace Barotrauma.Networking

                //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 || (ticket?.Length ?? 0) == 0)
+                    && !requireSteamAuth)
                {
-                    pendingClient.Connection.Name = name;
                    pendingClient.Name = name;
                    pendingClient.OwnerKey = ownKey;
                    pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
                }
                else
                {
-                    Steamworks.BeginAuthResult authSessionStartState = Steam.SteamManager.StartAuthSession(ticket, steamId);
-                    if (authSessionStartState != Steamworks.BeginAuthResult.OK)
+                    if (!steamId.TryUnwrap(out var id))
                    {
                        if (requireSteamAuth)
                        {
-                            RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "Steam auth session failed to start: " + authSessionStartState.ToString());
+                            RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "Steam auth session failed to start: Steam ID not provided");
                            return;
                        }
-                        else
+                    }
+                    else
+                    {
+                        Steamworks.BeginAuthResult authSessionStartState = Steam.SteamManager.StartAuthSession(ticket, id);
+                        if (authSessionStartState != Steamworks.BeginAuthResult.OK)
                        {
-                            steamId = 0;
-                            pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
+                            if (requireSteamAuth)
+                            {
+                                RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "Steam auth session failed to start: " + authSessionStartState.ToString());
+                                return;
+                            }
+                            else
+                            {
+                                steamId = Option<SteamId>.None();
+                                pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;
+                            }
                        }
                    }
-                    pendingClient.SteamID = steamId;
-                    pendingClient.Connection.Name = name;
+
+                    pendingClient.Connection.SetAccountInfo(new AccountInfo(steamId.Select(uid => (AccountId)uid)));
                    pendingClient.Name = name;
                    pendingClient.OwnerKey = ownKey;
                    pendingClient.AuthSessionStarted = true;
@@ -469,7 +484,7 @@ namespace Barotrauma.Networking
            }
            else
            {
-                if (pendingClient.SteamID != steamId)
+                if (pendingClient.AccountInfo.AccountId != steamId.Select(uid => (AccountId)uid))
                {
                    RemovePendingClient(pendingClient, DisconnectReason.SteamAuthenticationFailed, "SteamID mismatch");
                    return;
@@ -1,8 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
-using System.Text;
+using Barotrauma.Extensions;

 namespace Barotrauma.Networking
 {
@@ -10,7 +9,7 @@ namespace Barotrauma.Networking
    {
        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 InitializationCompleteCallback(NetworkConnection connection, string clientName);
        public delegate void ShutdownCallback();
        public delegate void OwnerDeterminedCallback(NetworkConnection connection);

@@ -20,7 +19,7 @@ namespace Barotrauma.Networking
        public ShutdownCallback OnShutdown;
        public OwnerDeterminedCallback OnOwnerDetermined;

-        protected int? ownerKey;
+        protected Option<int> ownerKey;

        public NetworkConnection OwnerConnection { get; protected set; }

@@ -33,43 +32,23 @@ namespace Barotrauma.Networking
        protected class PendingClient
        {
            public string Name;
-            public int OwnerKey;
+            public Option<int> OwnerKey;
            public 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;
@@ -101,7 +80,10 @@ namespace Barotrauma.Networking
                case ConnectionInitialization.SteamTicketAndVersion:
                    string name = Client.SanitizeName(inc.ReadString());
                    int ownerKey = inc.ReadInt32();
-                    UInt64 steamId = inc.ReadUInt64();
+                    UInt64 steamIdVal = inc.ReadUInt64();
+                    Option<SteamId> steamId = steamIdVal != 0
+                        ? Option<SteamId>.Some(new SteamId(steamIdVal))
+                        : Option<SteamId>.None();
                    UInt16 ticketLength = inc.ReadUInt16();
                    byte[] ticketBytes = inc.ReadBytes(ticketLength);

@@ -136,7 +118,7 @@ namespace Barotrauma.Networking

                    if (!pendingClient.AuthSessionStarted)
                    {
-                        ProcessAuthTicket(name, ownerKey, steamId, pendingClient, ticketBytes);
+                        ProcessAuthTicket(name, ownerKey != 0 ? Option<int>.Some(ownerKey) : Option<int>.None(), steamId, pendingClient, ticketBytes);
                    }
                    break;
                case ConnectionInitialization.Password:
@@ -172,34 +154,37 @@ namespace Barotrauma.Networking
            }
        }

-        protected abstract void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket);
+        protected abstract void ProcessAuthTicket(string name, Option<int> ownKey, Option<SteamId> steamId, PendingClient pendingClient, byte[] ticket);

        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);
-            }
-            else if (pendingClient.Connection is SteamP2PConnection s)
-            {
-                serverSettings.BanList.BanPlayer(pendingClient.Name, s.SteamID, banReason, duration);
-                serverSettings.BanList.BanPlayer(pendingClient.Name, s.OwnerSteamID, banReason, duration);
+                serverSettings.BanList.BanPlayer(pendingClient.Name, accountId, banReason, duration);
            }
+            
+            if (pendingClient.AccountInfo.AccountId.TryUnwrap(out var id)) { banAccountId(id); }
+            pendingClient.AccountInfo.OtherMatchingIds.ForEach(banAccountId);
+            serverSettings.BanList.BanPlayer(pendingClient.Name, pendingClient.Connection.Endpoint, banReason, duration);
        }
-
+        
        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);
+                banReason = default;
+                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);
@@ -225,7 +210,7 @@ namespace Barotrauma.Networking

                CheckOwnership(pendingClient);

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

            pendingClient.TimeOut -= Timing.Step;
@@ -244,8 +229,6 @@ namespace Barotrauma.Networking
            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++)
@@ -286,11 +269,10 @@ namespace Barotrauma.Networking

                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;
                }
            }
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Net;
 using System.Linq;
-using System.Threading;

 namespace Barotrauma.Networking
 {
@@ -10,29 +8,25 @@ namespace Barotrauma.Networking
    {
        private bool started;

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

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

-        public SteamP2PServerPeer(UInt64 steamId, int ownerKey, ServerSettings settings)
+        public SteamP2PServerPeer(SteamId steamId, int ownerKey, ServerSettings settings)
        {
            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;
        }
@@ -40,7 +34,7 @@ namespace Barotrauma.Networking
        public override void Start()
        {
            IWriteMessage outMsg = new WriteOnlyMessage();
-            WriteSteamId(outMsg, OwnerSteamID);
+            WriteSteamId(outMsg, ownerSteamId);
            outMsg.Write((byte)DeliveryMethod.Reliable);
            outMsg.Write((byte)(PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage));

@@ -129,9 +123,9 @@ namespace Barotrauma.Networking
        {
            if (!started) { return; }

-            UInt64 senderSteamId = ReadSteamId(inc);
-            UInt64 ownerSteamId = ReadSteamId(inc);
-
+            SteamId senderSteamId = ReadSteamId(inc);
+            SteamId ownerSteamId = ReadSteamId(inc);
+            
            PacketHeader packetHeader = (PacketHeader)inc.ReadByte();
            
            if (packetHeader.IsServerMessage())
@@ -140,11 +134,14 @@ namespace Barotrauma.Networking
                return;
            }

-            if (senderSteamId != OwnerSteamID) //sender is remote, handle disconnects and heartbeats
+            if (senderSteamId != this.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();

@@ -171,7 +168,7 @@ namespace Barotrauma.Networking
                    }
                    else if (connectedClient != null)
                    {
-                        string disconnectMsg = $"ServerMessage.HasDisconnected~[client]={connectedClient.Name}";
+                        string disconnectMsg = $"ServerMessage.HasDisconnected~[client]={GameMain.Server.ConnectedClients.First(c => c.Connection == connectedClient).Name}";
                        Disconnect(connectedClient, disconnectMsg, false);
                    }
                    return;
@@ -183,13 +180,9 @@ namespace Barotrauma.Networking
                }
                else if (packetHeader.IsConnectionInitializationStep())
                {
-
                    if (pendingClient != null)
                    {
-                        if (ownerSteamId != 0)
-                        {
-                            pendingClient.Connection.SetOwnerSteamIDIfUnknown(ownerSteamId);
-                        }
+                        pendingClient.Connection.SetAccountInfo(new AccountInfo(senderSteamId, ownerSteamId));
                        ReadConnectionInitializationStep(pendingClient, new ReadOnlyMessage(inc.Buffer, false, inc.BytePosition, inc.LengthBytes - inc.BytePosition, null));
                    }
                    else
@@ -197,7 +190,7 @@ namespace Barotrauma.Networking
                        ConnectionInitialization initializationStep = (ConnectionInitialization)inc.ReadByte();
                        if (initializationStep == ConnectionInitialization.ConnectionStarted)
                        {
-                            pendingClients.Add(new PendingClient(new SteamP2PConnection("PENDING", senderSteamId)) { SteamID = senderSteamId });
+                            pendingClients.Add(new PendingClient(new SteamP2PConnection(senderSteamId)));
                        }
                    }
                }
@@ -228,13 +221,13 @@ namespace Barotrauma.Networking
                    if (OwnerConnection == null)
                    {
                        string ownerName = inc.ReadString();
-                        OwnerConnection = new SteamP2PConnection(ownerName, OwnerSteamID)
+                        OwnerConnection = new SteamP2PConnection(this.ownerSteamId)
                        {
                            Language = GameSettings.CurrentConfig.Language
                        };
-                        OwnerConnection.SetOwnerSteamIDIfUnknown(OwnerSteamID);
+                        OwnerConnection.SetAccountInfo(new AccountInfo(this.ownerSteamId, this.ownerSteamId));

-                        OnInitializationComplete?.Invoke(OwnerConnection);
+                        OnInitializationComplete?.Invoke(OwnerConnection, ownerName);
                    }
                    return;
                }
@@ -261,17 +254,19 @@ namespace Barotrauma.Networking
        {
            if (!started) { return; }

-            if (!(conn is SteamP2PConnection steamp2pConn)) return;
+            if (!(conn is 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.ToString());
                return;
            }

+            if (!conn.AccountInfo.AccountId.TryUnwrap(out var connAccountId) || !(connAccountId is SteamId connSteamId)) { 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);
+            WriteSteamId(msgToSend, connSteamId);
            msgToSend.Write((byte)deliveryMethod);
            msgToSend.Write((byte)((isCompressed ? PacketHeader.IsCompressed : PacketHeader.None) | PacketHeader.IsServerMessage));
            msgToSend.Write((UInt16)length);
@@ -282,7 +277,7 @@ namespace Barotrauma.Networking
            ChildServerRelay.Write(bufToSend);
        }

-        private void SendDisconnectMessage(UInt64 steamId, string msg)
+        private void SendDisconnectMessage(SteamId steamId, string msg)
        {
            if (!started) { return; }
            if (string.IsNullOrWhiteSpace(msg)) { return; }
@@ -303,13 +298,16 @@ namespace Barotrauma.Networking
            if (!started) { return; }

            if (!(conn is SteamP2PConnection steamp2pConn)) { return; }
-            if (sendDisconnectMessage) { SendDisconnectMessage(steamp2pConn.SteamID, msg); }
+
+            if (!conn.AccountInfo.AccountId.TryUnwrap(out var connAccountId) || !(connAccountId is SteamId connSteamId)) { return; }
+            
+            if (sendDisconnectMessage) { SendDisconnectMessage(connSteamId, msg); }
            if (connectedClients.Contains(steamp2pConn))
            {
                steamp2pConn.Status = NetworkConnectionStatus.Disconnected;
                connectedClients.Remove(steamp2pConn);
                OnDisconnect?.Invoke(conn, msg);
-                Steam.SteamManager.StopAuthSession(conn.SteamID);
+                Steam.SteamManager.StopAuthSession(connSteamId);
            }
            else if (steamp2pConn == OwnerConnection)
            {
@@ -324,8 +322,12 @@ namespace Barotrauma.Networking

        protected override void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg)
        {
+            var connSteamId = conn is SteamP2PConnection { Endpoint: SteamP2PEndpoint { SteamId: var id } }
+                ? id : null;
+            if (connSteamId is null) { return; }
+            
            IWriteMessage msgToSend = new WriteOnlyMessage();
-            WriteSteamId(msgToSend, conn.SteamID);
+            WriteSteamId(msgToSend, connSteamId);
            msgToSend.Write((byte)deliveryMethod);
            msgToSend.Write(msg.Buffer, 0, msg.LengthBytes);
            byte[] bufToSend = (byte[])msgToSend.Buffer.Clone();
@@ -333,11 +335,10 @@ namespace Barotrauma.Networking
            ChildServerRelay.Write(bufToSend);
        }

-        protected override void ProcessAuthTicket(string name, int ownKey, ulong steamId, PendingClient pendingClient, byte[] ticket)
+        protected override void ProcessAuthTicket(string name, Option<int> ownKey, Option<SteamId> steamId, PendingClient pendingClient, byte[] ticket)
        {
            pendingClient.InitializationStep = serverSettings.HasPassword ? ConnectionInitialization.Password : ConnectionInitialization.ContentPackageOrder;

-            pendingClient.Connection.Name = name;
            pendingClient.Name = name;
            pendingClient.AuthSessionStarted = true;
        }