Skip to content

Commit

Permalink
refactor: moving message handling out of networkplayer (#818)
Browse files Browse the repository at this point in the history
Making NetworkPlayer do less things, Server or client should handle message instead of player.

Makes registering message simpler, no need to wait for player to Connect to register message.

BREAKING CHANGE: RegisterHandler functions now exist on MessageHandler On Server and Client
BREAKING CHANGE: NetworkAuthenticator now use Setup methods that should be used to register messages
  • Loading branch information
James-Frowen committed Jul 15, 2021
1 parent 056dc48 commit b2e9d96
Show file tree
Hide file tree
Showing 45 changed files with 597 additions and 374 deletions.
24 changes: 17 additions & 7 deletions Assets/Mirage/Authenticators/BasicAuthenticator.cs
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ public class BasicAuthenticator : NetworkAuthenticator
/// </para>
/// <para>
/// You might want to use an accessToken or passwords. Be aware that the normal connection
/// in mirror is not encrypted so sending secure information directly is not adviced
/// in Mirage is not encrypted so sending secure information directly is not adviced
/// </para>
/// </summary>

Expand All @@ -53,13 +53,17 @@ struct AuthResponseMessage

#region Server Authenticate

/*
This region should is need to validate the client connection and auth messages sent by the client
*/
public override void ServerSetup(NetworkServer server)
{
// register messsage for Auth when server starts
// this will ensure the handlers are ready when client connects (even in host mode)

server.MessageHandler.RegisterHandler<AuthRequestMessage>(OnAuthRequestMessage);
}

public override void ServerAuthenticate(INetworkPlayer player)
{
// wait for AuthRequestMessage from client
player.RegisterHandler<AuthRequestMessage>(OnAuthRequestMessage);
}


Expand Down Expand Up @@ -107,10 +111,16 @@ IEnumerator DelayedDisconnect(INetworkPlayer player, float waitTime)

#region Client Authenticate

public override void ClientAuthenticate(INetworkPlayer player)
public override void ClientSetup(NetworkClient client)
{
player.RegisterHandler<AuthResponseMessage>(OnAuthResponseMessage);
// register messsage for Auth when client starts
// this will ensure the handlers are ready when client connects (even in host mode)

client.MessageHandler.RegisterHandler<AuthResponseMessage>(OnAuthResponseMessage);
}

public override void ClientAuthenticate(INetworkPlayer player)
{
// The serverCode should be set on the client before connection to the server.
// When the client connects it sends the code and the server checks that it is correct
player.Send(new AuthRequestMessage
Expand Down
20 changes: 15 additions & 5 deletions Assets/Mirage/Authenticators/TimeoutAuthenticator.cs
Original file line number Diff line number Diff line change
Expand Up @@ -40,6 +40,14 @@ private void HandleClientAuthenticated(INetworkPlayer player)
ClientAccept(player);
}

public override void ServerAuthenticate(INetworkPlayer player)
{
pendingAuthentication.Add(player);
Authenticator.ServerAuthenticate(player);
if (Timeout > 0)
StartCoroutine(BeginAuthentication(player, ServerReject));
}

public override void ClientAuthenticate(INetworkPlayer player)
{
pendingAuthentication.Add(player);
Expand All @@ -49,12 +57,14 @@ public override void ClientAuthenticate(INetworkPlayer player)
StartCoroutine(BeginAuthentication(player, ClientReject));
}

public override void ServerAuthenticate(INetworkPlayer player)
public override void ServerSetup(NetworkServer server)
{
pendingAuthentication.Add(player);
Authenticator.ServerAuthenticate(player);
if (Timeout > 0)
StartCoroutine(BeginAuthentication(player, ServerReject));
Authenticator.ServerSetup(server);
}

public override void ClientSetup(NetworkClient client)
{
Authenticator.ClientSetup(client);
}

IEnumerator BeginAuthentication(INetworkPlayer player, Action<INetworkPlayer> reject)
Expand Down
9 changes: 4 additions & 5 deletions Assets/Mirage/Runtime/CharacterSpawner.cs
Original file line number Diff line number Diff line change
Expand Up @@ -61,7 +61,7 @@ public virtual void Awake()
}
if (Server != null)
{
Server.Authenticated.AddListener(OnServerAuthenticated);
Server.Started.AddListener(OnServerStarted);
if (ServerObjectManager == null)
{
throw new InvalidOperationException("Assign a ServerObjectManager");
Expand All @@ -78,14 +78,13 @@ void OnDestroy()
}
if (Server != null)
{
Server.Authenticated.RemoveListener(OnServerAuthenticated);
Server.Started.RemoveListener(OnServerStarted);
}
}

private void OnServerAuthenticated(INetworkPlayer player)
private void OnServerStarted()
{
// wait for client to send us an AddPlayerMessage
player.RegisterHandler<AddCharacterMessage>(OnServerAddPlayerInternal);
Server.MessageHandler.RegisterHandler<AddCharacterMessage>(OnServerAddPlayerInternal);
}

/// <summary>
Expand Down
20 changes: 10 additions & 10 deletions Assets/Mirage/Runtime/ClientObjectManager.cs
Original file line number Diff line number Diff line change
Expand Up @@ -90,20 +90,20 @@ void OnClientSceneChanged(string scenePath, SceneOperation sceneOperation)

internal void RegisterHostHandlers()
{
Client.Player.RegisterHandler<ObjectDestroyMessage>(msg => { });
Client.Player.RegisterHandler<ObjectHideMessage>(msg => { });
Client.Player.RegisterHandler<SpawnMessage>(OnHostClientSpawn);
Client.Player.RegisterHandler<ServerRpcReply>(msg => { });
Client.Player.RegisterHandler<RpcMessage>(msg => { });
Client.MessageHandler.RegisterHandler<ObjectDestroyMessage>(msg => { });
Client.MessageHandler.RegisterHandler<ObjectHideMessage>(msg => { });
Client.MessageHandler.RegisterHandler<SpawnMessage>(OnHostClientSpawn);
Client.MessageHandler.RegisterHandler<ServerRpcReply>(msg => { });
Client.MessageHandler.RegisterHandler<RpcMessage>(msg => { });
}

internal void RegisterMessageHandlers()
{
Client.Player.RegisterHandler<ObjectDestroyMessage>(OnObjectDestroy);
Client.Player.RegisterHandler<ObjectHideMessage>(OnObjectHide);
Client.Player.RegisterHandler<SpawnMessage>(OnSpawn);
Client.Player.RegisterHandler<ServerRpcReply>(OnServerRpcReply);
Client.Player.RegisterHandler<RpcMessage>(OnRpcMessage);
Client.MessageHandler.RegisterHandler<ObjectDestroyMessage>(OnObjectDestroy);
Client.MessageHandler.RegisterHandler<ObjectHideMessage>(OnObjectHide);
Client.MessageHandler.RegisterHandler<SpawnMessage>(OnSpawn);
Client.MessageHandler.RegisterHandler<ServerRpcReply>(OnServerRpcReply);
Client.MessageHandler.RegisterHandler<RpcMessage>(OnRpcMessage);
}

bool ConsiderForSpawning(NetworkIdentity identity)
Expand Down
18 changes: 8 additions & 10 deletions Assets/Mirage/Runtime/INetworkPlayer.cs
Original file line number Diff line number Diff line change
Expand Up @@ -12,26 +12,24 @@ public interface IMessageSender
void Send(ArraySegment<byte> segment, int channelId = Channel.Reliable);
}

// delegates to give names to variables in handles
public delegate void MessageDelegate<in T>(T message);
public delegate void MessageDelegateWithPlayer<in T>(INetworkPlayer player, T message);

/// <summary>
/// An object that can receive messages
/// </summary>
public interface IMessageReceiver
{
void RegisterHandler<T>(Action<INetworkPlayer, T> handler);
void RegisterHandler<T>(MessageDelegateWithPlayer<T> handler);

void RegisterHandler<T>(Action<T> handler);
void RegisterHandler<T>(MessageDelegate<T> handler);

void UnregisterHandler<T>();

void ClearHandlers();
}

/// <summary>
/// An object that can send and receive messages and notify messages
/// </summary>
public interface IMessageHandler : IMessageSender, IMessageReceiver
{
void HandleMessage(ArraySegment<byte> packet);
void HandleMessage(INetworkPlayer player, ArraySegment<byte> packet);
}

/// <summary>
Expand Down Expand Up @@ -60,7 +58,7 @@ public interface IObjectOwner
/// An object owned by a player that can: send/receive messages, have network visibility, be an object owner, authenticated permissions, and load scenes.
/// May be from the server to client or from client to server
/// </summary>
public interface INetworkPlayer : IMessageHandler, IVisibilityTracker, IObjectOwner, IAuthenticatedObject, ISceneLoader
public interface INetworkPlayer : IMessageSender, IVisibilityTracker, IObjectOwner, IAuthenticatedObject, ISceneLoader
{
SocketLayer.IConnection Connection { get; }
void Disconnect();
Expand Down
143 changes: 143 additions & 0 deletions Assets/Mirage/Runtime/MessageHandler.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,143 @@
using System;
using System.Collections.Generic;
using System.IO;
using Mirage.Logging;
using Mirage.Serialization;
using UnityEngine;

namespace Mirage
{
public class MessageHandler : IMessageReceiver
{
static readonly ILogger logger = LogFactory.GetLogger(typeof(MessageHandler));

readonly bool disconnectOnException;

// Handles network messages on client and server
internal delegate void NetworkMessageDelegate(INetworkPlayer player, NetworkReader reader);

// message handlers for this connection
internal readonly Dictionary<int, NetworkMessageDelegate> messageHandlers = new Dictionary<int, NetworkMessageDelegate>();

public MessageHandler(bool disconnectOnException)
{
this.disconnectOnException = disconnectOnException;
}

private static NetworkMessageDelegate MessageWrapper<T>(MessageDelegateWithPlayer<T> handler)
{
void AdapterFunction(INetworkPlayer player, NetworkReader reader)
{
T message = NetworkDiagnostics.ReadWithDiagnostics<T>(reader);

handler.Invoke(player, message);
}
return AdapterFunction;
}

/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public void RegisterHandler<T>(MessageDelegateWithPlayer<T> handler)
{
int msgType = MessagePacker.GetId<T>();
if (logger.filterLogType == LogType.Log && messageHandlers.ContainsKey(msgType))
{
logger.Log("RegisterHandler replacing " + msgType);
}
messageHandlers[msgType] = MessageWrapper(handler);
}

/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public void RegisterHandler<T>(MessageDelegate<T> handler)
{
RegisterHandler<T>((_, value) => { handler(value); });
}

/// <summary>
/// Unregister a handler for a particular message type.
/// <para>Note: Messages dont need to be unregister when server or client stops as MessageHandler will be re-created next time server or client starts</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
public void UnregisterHandler<T>()
{
int msgType = MessagePacker.GetId<T>();
messageHandlers.Remove(msgType);
}

/// <summary>
/// Clear all registered callback handlers.
/// </summary>
public void ClearHandlers()
{
messageHandlers.Clear();
}


internal void InvokeHandler(INetworkPlayer player, int msgType, NetworkReader reader)
{
if (messageHandlers.TryGetValue(msgType, out NetworkMessageDelegate msgDelegate))
{
msgDelegate.Invoke(player, reader);
}
else
{
try
{
Type type = MessagePacker.GetMessageType(msgType);
throw new InvalidDataException($"Unexpected message {type} received in {this}. Did you register a handler for it?");
}
catch (KeyNotFoundException)
{
throw new InvalidDataException($"Unexpected message ID {msgType} received in {this}. May be due to no existing RegisterHandler for this message.");
}
}
}

public void HandleMessage(INetworkPlayer player, ArraySegment<byte> packet)
{
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(packet))
{
// protect against attackers trying to send invalid data packets
// exception could be throw if:
// - invalid headers
// - invalid message ids
// - invalid data causing exceptions
// - negative ReadBytesAndSize prefixes
// - invalid utf8 strings
// - etc.
//
// if exception is caught, disconnect the attacker to stop any further attacks

try
{
int msgType = MessagePacker.UnpackId(networkReader);
InvokeHandler(player, msgType, networkReader);
}
catch (InvalidDataException ex)
{
logger.Log(ex.ToString());
}
catch (Exception e)
{
string disconnectMessage = disconnectOnException ? ", Closed connection: {this}" : "";
logger.LogError($"{e.GetType()} in Message handler (see stack below){disconnectMessage}\n{e}");
if (disconnectOnException)
{
player.Disconnect();
}
}
}
}
}
}
11 changes: 11 additions & 0 deletions Assets/Mirage/Runtime/MessageHandler.cs.meta

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

12 changes: 12 additions & 0 deletions Assets/Mirage/Runtime/NetworkAuthenticator.cs
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,12 @@ protected void ServerReject(INetworkPlayer player)
player.Disconnect();
}

/// <summary>
/// Used to set up authenticator on server
/// <para>Can be used to register message handlers before any players connect</para>
/// </summary>
public abstract void ServerSetup(NetworkServer server);

/// <summary>
/// Authenticate the player on the Server.
/// <para>Called by the server when new client connects</para>
Expand Down Expand Up @@ -67,6 +73,12 @@ protected void ClientReject(INetworkPlayer player)
player.Disconnect();
}

/// <summary>
/// Used to set up authenticator on client
/// <para>Can be used to register message handlers before any player connects</para>
/// </summary>
public abstract void ClientSetup(NetworkClient client);

/// <summary>
/// Authenticate the player on the Client.
/// <para>Called by the client after connected to the server</para>
Expand Down

0 comments on commit b2e9d96

Please sign in to comment.