void Workmanager_HostMessageReceived(NetworkMessage w, NetworkMessageHandler <NetworkMessage> msgHandler)
{
switch (w.MessageType)
{
case NetworkMessageType.ConfigUpdate:
Logger.Log("Host configuration received!");
var config = ((IDictionary <object, object>)w.Data).Deserialize <WorkerConfiguration>();
// override config in worker manager (this also disconnects it from local configuration)
workermanager.WorkerConfig = config;
break;
case NetworkMessageType.StatusCheck:
var msg = JsonConvert.SerializeObject(new
{
IsHost = true,
IsActive = workermanager.IsListening,
IsBusy = workmanager.ConsecutiveInvalidWorks > 10
});
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.StatusCheck, msg));
break;
}
}
public void RemoveMessageHandler(ushort command, NetworkMessageHandler handler)
{
if (_messageHandles.ContainsKey(command))
{
_messageHandles [command] -= handler;
}
}
public void UnregisterMessageHandler(int messageId, NetworkMessageHandler handler)
{
if (handlerDic.TryGetValue(messageId, out var list) && list.Contains(handler))
{
list.Remove(handler);
}
}
public void SendAndHandle(NetworkMessage message)
{
// sharing before handling
// so that if handle generates more commands, correct order is kept
SendOnly(message);
NetworkMessageHandler.Handle(message);
}
private static void StoreHandlers()
{
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_SEED_ACK, MiscHandlers.NC_MISC_SEED_ACK);
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_S2SCONNECTION_RDY, MiscHandlers.NC_MISC_S2SCONNECTION_RDY);
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_S2SCONNECTION_ACK, MiscHandlers.NC_MISC_S2SCONNECTION_ACK);
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_GAMETIME_REQ, MiscHandlers.NC_MISC_GAMETIME_REQ);
}
public ServerDefault(ServiceConfiguration configuration)
{
this.configuration = configuration;
msgHandler = new NetworkMessageHandler();
server = new NetworkServer();
server.serverDelegate = this;
SetupMessageHandlers();
}
//MARK: Manage Message Handlers
public void AddMessageHandler(ushort command, NetworkMessageHandler handler)
{
if (!_messageHandles.ContainsKey(command))
{
_messageHandles.Add(command, handler);
}
else
{
_messageHandles [command] += handler;
}
}
public void Detach(Type type, NetworkMessageHandler handler)
{
try
{
_eventHandler[type] -= handler;
}
catch
{
//Logger.Error("Can't detach to delegate");
}
}
public void RegisterMessageHandler(int messageId, NetworkMessageHandler handler)
{
if (!handlerDic.TryGetValue(messageId, out var list))
{
list = new List <NetworkMessageHandler>();
handlerDic.Add(messageId, list);
}
if (!list.Contains(handler))
{
list.Add(handler);
}
}
public override void Init(NetworkModule[] loadedDependencies)
{
if (m_NetworkMessageHandler == null)
{
m_NetworkMessageHandler = loadedDependencies[0] as NetworkMessageHandler;
networkLogMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_LOG", HandleNetworkLog, NetworkMessageHandler.NetworkMessageReceiver.Both);
networkToggleLogMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_TOGGLE_LOG", HandleNetworkToggleLog, NetworkMessageHandler.NetworkMessageReceiver.Both);
}
Application.logMessageReceived += OnLog;
if (networkManager.enableLogging)
{
Debug.LogWarning("If Network Manager logging is enabled, be careful that this may cause an infinite loop across the network of logging if both the server and client are sending logs to eachother.");
}
}
private static void StoreHandlers()
{
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_SEED_ACK, MiscHandlers.NC_MISC_SEED_ACK);
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_S2SCONNECTION_RDY, MiscHandlers.NC_MISC_S2SCONNECTION_RDY);
NetworkMessageHandler.Store(NetworkCommand.NC_MISC_S2SCONNECTION_REQ, MiscHandlers.NC_MISC_S2SCONNECTION_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_CLIENT_VERSION_CHECK_REQ, UserHandlers.NC_USER_CLIENT_VERSION_CHECK_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_US_LOGIN_REQ, UserHandlers.NC_USER_US_LOGIN_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_XTRAP_REQ, UserHandlers.NC_USER_XTRAP_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_WORLD_STATUS_REQ, UserHandlers.NC_USER_WORLD_STATUS_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_WORLDSELECT_REQ, UserHandlers.NC_USER_WORLDSELECT_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_NORMALLOGOUT_CMD, UserHandlers.NC_USER_NORMALLOGOUT_CMD);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_LOGIN_WITH_OTP_REQ, UserHandlers.NC_USER_LOGIN_WITH_OTP_REQ);
NetworkMessageHandler.Store(NetworkCommand.NC_USER_WILLLOGIN_ACK, UserHandlers.NC_USER_WILLLOGIN_ACK);
}
void SendStatusMessage(NetworkMessageHandler <NetworkMessage> msgHandler)
{
if (workmanager.ConnectedToHost == false || msgHandler == null)
{
return;
}
var msg = JsonConvert.SerializeObject(new
{
IsHost = false,
IsActive = crawler.IsActive,
IsBusy = workmanager.ConsecutiveInvalidWorks > 10
});
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.StatusCheck, msg));
}
private void LoadRequiredModules()
{
//Network Message Handler
m_MessageHandler = SafeLoadModule <NetworkMessageHandler>();
//Network Behaviour Manager
SafeLoadModule <NetworkBehaviourManager>();
//Scene Manager
SafeLoadModule <NetworkSceneManager>();
if (Debug.isDebugBuild)
{
//Network Log Module
//SafeLoadModule<NetworkLogModule>();
}
}
void Workmanager_HostMessageReceived(NetworkMessage w,
NetworkMessageHandler <NetworkMessage> msgHandler)
{
switch (w.MessageType)
{
case NetworkMessageType.StatusCheck:
// send more detailed status information you can only send from here...
SendStatusMessage(msgHandler);
break;
case NetworkMessageType.ConfigUpdate:
Logger.Log("Host configuration receieved!");
var config = ((IDictionary <object, object>)w.Data).Deserialize <WorkerConfiguration>();
// override config in crawler (this also disconnects it from local configuration)
crawler.Config = config;
break;
}
}
public void Attach(Type type, NetworkMessageHandler handler)
{
try
{
NetworkMessageHandler handlers;
_eventHandler.TryGetValue(type, out handlers);
if (handlers == null)
{
_eventHandler[type] = handler;
}
else
{
_eventHandler[type] = _eventHandler[type] + handler;
}
}
catch
{
//Logger.Error("Can't attach to delegate: " + exception.Message);
}
}
public override void Init(NetworkModule[] loadedDependencies)
{
if (m_NetworkMessageHandler == null)
{
m_NetworkMessageHandler = loadedDependencies[0] as NetworkMessageHandler;
spawnMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_SPAWN_OBJECT", HandleSpawnMessage, NetworkMessageHandler.NetworkMessageReceiver.Client);
unspawnMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_UNSPAWN_OBJECT", HandleUnspawnMessage, NetworkMessageHandler.NetworkMessageReceiver.Client);
objectSuccessMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_OBJECT_SUCCESS", HandleObjectSuccessMessage, NetworkMessageHandler.NetworkMessageReceiver.Server);
clientRPCMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_CLIENT_RPC", HandleClientRPCMessage, NetworkMessageHandler.NetworkMessageReceiver.Client);
serverRPCMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_SERVER_RPC", HandleServerRPCMessage, NetworkMessageHandler.NetworkMessageReceiver.Server);
ownerChangeMessageType = m_NetworkMessageHandler.RegisterMessageType("NETWORK_OWNER_CHANGE", HandleOwnerChangeMessage, NetworkMessageHandler.NetworkMessageReceiver.Both);
}
m_NetworkIDCounter = 0;
m_NetworkBehaviours.Clear();
m_NetworkBehaviourDictionary.Clear();
m_ReleasedNetworkIDs.Clear();
m_LocalPendingBehaviours.Clear();
m_RemotePendingBehaviours.Clear();
m_RemotePendingBehavioursHashes.Clear();
m_LocalPendingBehavioursList.Clear();
m_HashedStrings.Clear();
SceneManager.sceneLoaded += OnSceneLoad;
}
public override void Init(NetworkModule[] loadedDependencies)
{
sceneHashes.Clear();
for (int i = 0; i < GetAllSceneNames().Length; i++)
{
sceneHashes.Add(GetAllSceneNames()[i].GetStableHash(networkManager.config.rpcHashSize), GetAllSceneNames()[i]);
}
if (m_MessageHandler == null)
{
for (int i = 0; i < loadedDependencies.Length; i++)
{
if (loadedDependencies[i] is NetworkMessageHandler)
{
m_MessageHandler = loadedDependencies[i] as NetworkMessageHandler;
}
}
sceneChangeMessageType = m_MessageHandler.RegisterMessageType("SCENE_CHANGE", HandleSceneChangeMessage, NetworkMessageHandler.NetworkMessageReceiver.Both);
}
SceneManager.sceneLoaded += OnSceneLoad;
SceneManager.sceneUnloaded += OnSceneUnload;
}
public void Receive(NetworkMessage message)
{
NetworkMessageHandler.Handle(message);
}
public void SSLWithMessageHandler()
{
string clMessage = "Ping!";
string srMessage = "Pong!";
string clReceived = "";
string srReceived = "";
string clMessage2 = "Ping Ping!";
string srMessage2 = "Pong Pong!";
string clReceived2 = "";
string srReceived2 = "";
int port = 0;
var t1 = Task.Run(() =>
{
var listener = new TcpListener(IPAddress.Any, 0);
listener.Start();
port = ((IPEndPoint)listener.LocalEndpoint).Port;
try
{
listener.Start();
var cert = SecurityUtils.BuildSelfSignedCertificate("crycrawler");
var cl = listener.AcceptTcpClient();
var str = cl.GetStream();
var ssl = SecurityUtils.ServerEstablishSSL(str, cert);
// create message handler
var msgHandler = new NetworkMessageHandler <NetworkMessage>(ssl);
msgHandler.ExceptionThrown += (a, b) =>
{
};
var response = msgHandler.WaitForResponse(5000).Result;
srReceived = response.Data as string;
Task.Delay(3000).Wait();
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.Join, srMessage));
response = msgHandler.WaitForResponse(5000).Result;
srReceived2 = response.Data as string;
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.Join, srMessage2));
Task.Delay(1000).Wait();
ssl.Close();
str.Close();
}
finally
{
listener.Stop();
}
});
Task.Delay(1000).Wait();
var t2 = Task.Run(() =>
{
var cl = new TcpClient();
cl.Connect(IPAddress.Loopback, port);
var str = cl.GetStream();
var ssl = SecurityUtils.ClientEstablishSSL(str);
// create message handler
var msgHandler = new NetworkMessageHandler <NetworkMessage>(ssl);
msgHandler.ExceptionThrown += (a, b) =>
{
};
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.Join, clMessage));
var response = msgHandler.WaitForResponse(5000).Result;
clReceived = response.Data as string;
msgHandler.SendMessage(new NetworkMessage(NetworkMessageType.Join, clMessage2));
response = msgHandler.WaitForResponse(5000).Result;
clReceived2 = response.Data as string;
Task.Delay(1000).Wait();
ssl.Close();
str.Close();
});
Task.WhenAll(t1, t2).Wait();
Assert.Equal(clMessage, srReceived);
Assert.Equal(srMessage, clReceived);
Assert.Equal(clMessage2, srReceived2);
Assert.Equal(srMessage2, clReceived2);
}
byte[] INetworkMessageSerializationHandler.Serialize(NetworkMessageHandler message) // cast message object to chat message => onSerialize(message as ChatMessage);
/// <summary>
/// Do handshake between client and server. Password is validated and client id is exchanged.
/// </summary>
/// <returns>Client ID that was exchanged</returns>
public static string DoHandshake(NetworkMessageHandler <NetworkMessage> messageHandler, string passwordHash, bool asClient,
string existingClientId = null, Predicate <string> clientIdExists = null, Predicate <string> clientIdValid = null)
{
if (asClient)
{
// send JOIN request
messageHandler.SendMessage(new NetworkMessage(NetworkMessageType.Join, new[] { passwordHash, existingClientId }));
// wait for response
var response = messageHandler.WaitForResponse().Result;
if (response.MessageType != NetworkMessageType.Accept)
{
throw new InvalidOperationException($"Rejected join! Got '{response.MessageType}', expected '{NetworkMessageType.Accept}'");
}
// read client Id
var id = response.Data as string;
if (string.IsNullOrEmpty(id))
{
throw new InvalidOperationException("Server did not reply with valid client ID!");
}
// send OK
messageHandler.SendMessage(new NetworkMessage(NetworkMessageType.OK));
return(id);
}
else
{
// wait for JOIN request
var response = messageHandler.WaitForResponse().Result;
if (response.MessageType != NetworkMessageType.Join)
{
throw new InvalidOperationException($"Invalid client response! Got '{response.MessageType}', expected '{NetworkMessageType.Join}'");
}
var array = response.Data as object[];
if (string.IsNullOrEmpty(passwordHash) == false)
{
// check password
var password = array[0] as string;
if (passwordHash != password)
{
throw new IncorrectPasswordException("Invalid password!");
}
}
// check client id
var clientId = array == null ? null : array[1] as string;
// if client id invalid, generate new one
if (string.IsNullOrEmpty(clientId) || clientIdValid?.Invoke(clientId) != true)
{
do
{
clientId = Extensions.GenerateRandomPathSafeString(20);
} while (clientIdExists?.Invoke(clientId) != false);
}
// send ACCEPT
messageHandler.SendMessage(new NetworkMessage(NetworkMessageType.Accept, clientId));
// wait for OK
response = messageHandler.WaitForResponse().Result;
if (response.MessageType != NetworkMessageType.OK)
{
throw new InvalidOperationException($"Invalid client response! Got '{response.MessageType}', expected '{NetworkMessageType.OK}'");
}
return(clientId);
}
}
public NetworkMessageHandler GetDefaultHandler(NetworkMessageHandler handler)
{
return(_defaultHandler);
}
public void SetDefaultHandler(NetworkMessageHandler handler)
{
_defaultHandler = handler;
}
/// <summary> /// Handles socket client message. /// </summary> Task IClientHandler.OnMessageAsync(SocketClient client, NetworkMessageHandler message) // SocketClient is actually ChatClient so it can be casted to our own type => processChatMessageAsync(client as ChatClient, message as ChatMessage);
/// <summary> /// Handles socket client message. /// </summary> void IClientHandler.ConnectionMessage(SocketClient client, NetworkMessageHandler message) // SocketClient is actually ChatMember so it can be casted to our own type => onConnectionMessage(client as ChatMember, message as ChatMessage);
