feat: disconnect reason

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -86,6 +86,12 @@ public NetworkPrefabHandler PrefabHandler
         private bool m_ShuttingDown;
         private bool m_StopProcessingMessages;
 
+        // <summary>
+        // When disconnected from the server, the server may send a reason. If a reason was sent, this property will
+        // tell client code what the reason was. It should be queried after the OnClientDisconnectCallback is called
+        // </summary>
+        public string DisconnectReason { get; internal set; }
+
         private class NetworkManagerHooks : INetworkHooks
         {
             private NetworkManager m_NetworkManager;
@@ -443,6 +449,11 @@ public class ConnectionApprovalResponse
             /// If the Approval decision cannot be made immediately, the client code can set Pending to true, keep a reference to the ConnectionApprovalResponse object and write to it later. Client code must exercise care to setting all the members to the value it wants before marking Pending to false, to indicate completion. If the field is set as Pending = true, we'll monitor the object until it gets set to not pending anymore and use the parameters then.
             /// </summary>
             public bool Pending;
+
+            // <summary>
+            // Optional reason. If Approved is false, this reason will be sent to the client so they know why they
+            // were not approved.
+            public string Reason;
         }
 
         /// <summary>
@@ -889,6 +900,7 @@ private void Initialize(bool server)
                 return;
             }
 
+            DisconnectReason = "";
             IsApproved = false;
 
             ComponentFactory.SetDefaults();
@@ -1997,12 +2009,31 @@ internal void HandleIncomingData(ulong clientId, ArraySegment<byte> payload, flo
         /// </summary>
         /// <param name="clientId">The ClientId to disconnect</param>
         public void DisconnectClient(ulong clientId)
+        {
+            DisconnectClient(clientId, null);
+        }
+
+        /// <summary>
+        /// Disconnects the remote client.
+        /// </summary>
+        /// <param name="clientId">The ClientId to disconnect</param>
+        /// <param name="reason">Disconnection reason. If set, client will receive a DisconnectReasonMessage and have the
+        /// reason available in the NetworkManager.DisconnectReason property</param>
+        public void DisconnectClient(ulong clientId, string reason)
         {
             if (!IsServer)
             {
                 throw new NotServerException($"Only server can disconnect remote clients. Please use `{nameof(Shutdown)}()` instead.");
             }
 
+            if (!string.IsNullOrEmpty(reason))
+            {
+                var disconnectReason = new DisconnectReasonMessage();
+                disconnectReason.Reason = reason;
+                SendMessage(ref disconnectReason, NetworkDelivery.Reliable, clientId);
+            }
+            MessagingSystem.ProcessSendQueues();
+
             OnClientDisconnectFromServer(clientId);
             DisconnectRemoteClient(clientId);
         }
@@ -2123,6 +2154,44 @@ private void SyncTime()
 #endif
         }
 
+        internal struct DisconnectReasonMessage : INetworkMessage
+        {
+            public string Reason;
+
+            public void Serialize(FastBufferWriter writer)
+            {
+                if (writer.TryBeginWrite(sizeof(int) + FastBufferWriter.GetWriteSize(Reason)))
+                {
+                    writer.WriteValue(Reason.Length);
+                    writer.WriteValue(Reason);
+                }
+                else
+                {
+                    writer.TryBeginWrite(sizeof(int) + FastBufferWriter.GetWriteSize(""));
+                    writer.WriteValue(0);
+                    writer.WriteValue("");
+                    Debug.LogWarning("Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
+                }
+            }
+
+            public bool Deserialize(FastBufferReader reader, ref NetworkContext context)
+            {
+                int size;
+                reader.TryBeginRead(sizeof(int));
+                reader.ReadValue(out size);
+                Reason = new string(' ', size);
+                reader.TryBeginRead(FastBufferWriter.GetWriteSize(Reason));
+                reader.ReadValue(out Reason);
+
+                return true;
+            }
+
+            public void Handle(ref NetworkContext context)
+            {
+                ((NetworkManager)context.SystemOwner).DisconnectReason = Reason;
+            }
+        };
+
         /// <summary>
         /// Server Side: Handles the approval of a client
         /// </summary>
@@ -2236,6 +2305,15 @@ internal void HandleConnectionApproval(ulong ownerClientId, ConnectionApprovalRe
             }
             else
             {
+                if (!string.IsNullOrEmpty(response.Reason))
+                {
+                    var disconnectReason = new DisconnectReasonMessage();
+                    disconnectReason.Reason = response.Reason;
+                    SendMessage(ref disconnectReason, NetworkDelivery.Reliable, ownerClientId);
+
+                    MessagingSystem.ProcessSendQueues();
+                }
+
                 PendingClients.Remove(ownerClientId);
                 DisconnectRemoteClient(ownerClientId);
             }

com.unity.netcode.gameobjects/Tests/Runtime/DisconnectReasonTests.cs

@@ -0,0 +1,56 @@
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Unity.Netcode.TestHelpers.Runtime;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class DisconnectReasonObject : NetworkBehaviour
+    {
+
+    }
+
+    public class DisconnectReasonTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 2;
+
+        private GameObject m_PrefabToSpawn;
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_PrefabToSpawn = CreateNetworkObjectPrefab("DisconnectReasonObject");
+            m_PrefabToSpawn.AddComponent<DisconnectReasonObject>();
+        }
+
+        private int m_DisconnectCount;
+
+        public void OnClientDisconnectCallback(ulong clientId)
+        {
+            m_DisconnectCount++;
+            Debug.Log($"Disconnected {clientId}");
+        }
+
+        [UnityTest]
+        public IEnumerator DisconnectReasonTest()
+        {
+            float startTime = Time.realtimeSinceStartup;
+
+            // Add a callback for first client, when they get disconnected
+            m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
+            m_ClientNetworkManagers[1].OnClientDisconnectCallback += OnClientDisconnectCallback;
+
+            // Disconnect first client, from the server
+            m_ServerNetworkManager.DisconnectClient(m_ClientNetworkManagers[0].LocalClientId, "Bogus reason 1");
+            m_ServerNetworkManager.DisconnectClient(m_ClientNetworkManagers[1].LocalClientId, "Bogus reason 2");
+
+            while (m_DisconnectCount < 2 && Time.realtimeSinceStartup < startTime + 10.0f)
+            {
+                yield return null;
+            }
+
+            Assert.AreEqual(m_ClientNetworkManagers[0].DisconnectReason, "Bogus reason 1");
+            Assert.AreEqual(m_ClientNetworkManagers[1].DisconnectReason, "Bogus reason 2");
+        }
+    }
+}