com.unity.netcode.gameobjects/com.unity.netcode.gameobjects/Runtime/Messaging/NetworkManagerHooks.cs at 68288b7fdf36f2653874b864a06c810760c23017 · Unity-Technologies/com.unity.netcode.gameobjects · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
using System;
using Unity.Netcode.Transports.UTP;

namespace Unity.Netcode
{
    internal class NetworkManagerHooks : INetworkHooks
    {
        private NetworkManager m_NetworkManager;

        internal NetworkManagerHooks(NetworkManager manager)
        {
            m_NetworkManager = manager;
        }

        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
        {
        }

        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
        {
        }

        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
        {
        }

        public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
        {
        }

        public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
        {
        }

        public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
        {
        }

        public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
        {
        }

        public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
        {
        }

        public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
        {
            return !m_NetworkManager.MessageManager.StopProcessing;
        }

        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
        {
            if (m_NetworkManager.IsServer)
            {
                if (messageType == typeof(ConnectionApprovedMessage))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. {transportErrorMsg}");
                    }

                    return false;
                }

                if (m_NetworkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client) && (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted.");
                    }

                    return false;
                }

                if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. {transportErrorMsg}");
                    }

                    return false;
                }
            }
            else
            {
                if (messageType == typeof(ConnectionRequestMessage))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. {transportErrorMsg}");
                    }

                    return false;
                }

                if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage) &&
                    !(m_NetworkManager.CMBServiceConnection && m_NetworkManager.LocalClient.IsSessionOwner && m_NetworkManager.NetworkConfig.EnableSceneManagement))
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. {transportErrorMsg}");
                    }

                    return false;
                }
            }

            return !m_NetworkManager.MessageManager.StopProcessing;
        }

        private static string GetTransportErrorMessage(FastBufferReader messageContent, NetworkManager networkManager)
        {
            if (networkManager.NetworkConfig.NetworkTransport is not UnityTransport)
            {
                return $"NetworkTransport: {networkManager.NetworkConfig.NetworkTransport.GetType()}. Please report this to the maintainer of transport layer.";
            }

            var transportVersion = GetTransportVersion(networkManager);
            return $"{transportVersion}. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}";
        }

        private static string GetTransportVersion(NetworkManager networkManager)
        {
            var transportVersion = "NetworkTransport: " + networkManager.NetworkConfig.NetworkTransport.GetType();
            if (networkManager.NetworkConfig.NetworkTransport is UnityTransport unityTransport)
            {
                transportVersion += " UnityTransportProtocol: " + unityTransport.Protocol;
            }

            return transportVersion;
        }

        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
        {
        }

        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
        {
        }
    }
}