/// <summary>
/// Interpret a client's handshake, either sending a package
/// of strings or completing the handshake.
///
/// Uncached flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> | <- you are here on server
/// | <----------- Strings |
/// | Dont Need Strings -> | <- you are here on server
/// </code>
///
/// Cached flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Dont Need Strings -> | <- you are here on server
/// </code>
///
/// Verification failure flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> | <- you are here on server
/// | <----------- Strings |
/// + Hash Failed |
/// | Need Strings ------> | <- you are here on server
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// NOTE: Verification failure flow is currently not implemented.
/// </summary>
/// <seealso cref="NetworkInitialize"/>
private void HandleClientHandshake(INetManager net, MsgRobustMappedStringsSerializerClientHandshake msgRobustMappedStringsSerializer)
{
if (net.IsClient)
{
LogSzr.Error("Received client handshake on client.");
return;
}
LogSzr.Debug($"Received handshake from {msgRobustMappedStringsSerializer.MsgChannel.RemoteEndPoint.Address}.");
if (!msgRobustMappedStringsSerializer.NeedsStrings)
{
LogSzr.Debug($"Completing handshake with {msgRobustMappedStringsSerializer.MsgChannel.RemoteEndPoint.Address}.");
_incompleteHandshakes.Remove(msgRobustMappedStringsSerializer.MsgChannel);
return;
}
// TODO: count and limit number of requests to send strings during handshake
var strings = msgRobustMappedStringsSerializer.MsgChannel.NetPeer.CreateNetMessage <MsgRobustMappedStringsSerializerStrings>();
using (var ms = new MemoryStream())
{
WriteStringPackage(ms);
ms.Position = 0;
strings.Package = ms.ToArray();
LogSzr.Debug($"Sending {ms.Length} bytes sized mapped strings package to {msgRobustMappedStringsSerializer.MsgChannel.RemoteEndPoint.Address}.");
}
msgRobustMappedStringsSerializer.MsgChannel.SendMessage(strings);
}
/// <summary>
/// Initializes the string table.
/// </summary>
public void Initialize(INetManager network)
{
_network = network;
_network.RegisterNetMessage <MsgStringTableEntry>(MsgStringTableEntry.NAME, (int)MsgStringTableEntry.ID, message =>
{
if (_network.IsServer) // Server does not receive entries from clients.
{
return;
}
var entry = (MsgStringTableEntry)message;
var id = entry.EntryId;
var str = string.IsNullOrEmpty(entry.EntryString) ? null : entry.EntryString;
if (str == null)
{
_strings.Remove(id);
}
else
{
if (!_strings.ContainsKey(id))
{
_strings.Add(id, str);
}
else
{
_strings[id] = str;
}
}
});
}
/// <summary>
/// Handles the reception, verification of a strings package
/// and subsequent mapping of strings and initiator of
/// receipt response.
///
/// Uncached flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> | <- you are here on client
///
/// Verification failure flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> |
/// | <----------- Strings |
/// + Hash Failed | <- you are here on client
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> | <- you are here on client
/// </code>
///
/// NOTE: Verification failure flow is currently not implemented.
/// </code>
/// </summary>
/// <exception cref="InvalidOperationException">Unable to verify strings package by hash.</exception>
/// <seealso cref="NetworkInitialize"/>
private void HandleStringsMessage(INetManager net, MsgRobustMappedStringsSerializerStrings msgRobustMappedStringsSerializer)
{
if (net.IsServer)
{
LogSzr.Error("Received strings from client.");
return;
}
LockMappedStrings = false;
ClearStrings();
DebugTools.Assert(msgRobustMappedStringsSerializer.Package != null, "msg.Package != null");
LoadStrings(new MemoryStream(msgRobustMappedStringsSerializer.Package !, false));
var checkHash = CalculateHash(msgRobustMappedStringsSerializer.Package !);
if (!checkHash.SequenceEqual(ServerHash))
{
// TODO: retry sending MsgClientHandshake with NeedsStrings = false
throw new InvalidOperationException("Unable to verify strings package by hash." + $"\n{ConvertToBase64Url(checkHash)} vs. {ConvertToBase64Url(ServerHash)}");
}
_stringMapHash = ServerHash;
LockMappedStrings = true;
LogSzr.Debug($"Locked in at {_mappedStrings.Count} mapped strings.");
WriteStringCache();
// ok we're good now
var channel = msgRobustMappedStringsSerializer.MsgChannel;
OnClientCompleteHandshake(net, channel);
}
static int KillAllConnection(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
obj.KillAllConnection();
return(0);
}
// can be overridden for testing
protected void Initialize()
{
Modifiers = new List<NetworkSkinModifier>();
Errors = new NetworkSkinLoadErrors();
PrefabCollection = new GamePrefabCollection();
NetManager = new GameNetManager();
}
static int RemoveAllLuaEventListeners(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 1);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
obj.RemoveAllLuaEventListeners();
return(0);
}
// can be overridden for testing
protected virtual void Initialize()
{
// this must be set here, as the constructor is not called on deserialization
AppliedSkins = NetworkSkinManager.instance.AppliedSkins;
SegmentSkins = NetworkSkinManager.SegmentSkins;
NodeSkins = NetworkSkinManager.NodeSkins;
PrefabCollection = new GamePrefabCollection();
NetManager = new GameNetManager();
}
static int KillConnection(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
int arg0 = (int)LuaScriptMgr.GetNumber(L, 2);
obj.KillConnection(arg0);
return(0);
}
static int DispatchEvent(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
com.gt.events.BaseEvent arg0 = LuaScriptMgr.GetNetObject <com.gt.events.BaseEvent>(L, 2);
obj.DispatchEvent(arg0);
return(0);
}
static int AddMPNetClient(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
com.gt.mpnet.MPNetClient arg0 = LuaScriptMgr.GetNetObject <com.gt.mpnet.MPNetClient>(L, 2);
obj.AddMPNetClient(arg0);
return(0);
}
/// <summary>
/// Initializes the string table.
/// </summary>
public void Initialize(INetManager network, InitCallback callback = null)
{
Debug.Assert(!_initialized);
_callback = callback;
_network = network;
_network.RegisterNetMessage <MsgStringTableEntries>(MsgStringTableEntries.NAME, message =>
{
if (_network.IsServer) // Server does not receive entries from clients.
{
return;
}
var msg = (MsgStringTableEntries)message;
foreach (var entry in msg.Entries)
{
var id = entry.Id;
var str = string.IsNullOrEmpty(entry.String) ? null : entry.String;
if (str == null)
{
_strings.Remove(id);
}
else
{
if (TryFindStringId(str, out int oldId))
{
if (oldId == id)
{
continue;
}
_strings.Remove(oldId);
_strings.Add(id, str);
}
else
{
_strings.Add(id, str);
}
}
}
if (callback == null)
{
return;
}
if (_network.IsClient && !_initialized)
{
_callback?.Invoke();
}
});
Reset();
}
static int DispatchLuaEvent(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 3);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
LuaTable arg1 = LuaScriptMgr.GetLuaTable(L, 3);
obj.DispatchLuaEvent(arg0, arg1);
return(0);
}
static int GetTransmitter(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
com.gt.mpnet.MessageTransmitter o = obj.GetTransmitter(arg0);
LuaScriptMgr.PushObject(L, o);
return(1);
}
static int AddMessageHandler(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 3);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
com.gt.mpnet.MessageHandler arg1 = LuaScriptMgr.GetNetObject <com.gt.mpnet.MessageHandler>(L, 3);
obj.AddMessageHandler(arg0, arg1);
return(0);
}
static int RemoveLuaEventListener(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 3);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
LuaFunction arg1 = LuaScriptMgr.GetLuaFunction(L, 3);
obj.RemoveLuaEventListener(arg0, arg1);
return(0);
}
static int RemoveEventListener(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 3);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
com.gt.events.EventListenerDelegate arg1 = LuaScriptMgr.GetNetObject <com.gt.events.EventListenerDelegate>(L, 3);
obj.RemoveEventListener(arg0, arg1);
return(0);
}
static int RemoveLuaMessageHandler(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 4);
INetManager obj = LuaScriptMgr.GetNetObject <INetManager>(L, 1);
int arg0 = (int)LuaScriptMgr.GetNumber(L, 2);
string arg1 = LuaScriptMgr.GetLuaString(L, 3);
LuaFunction arg2 = LuaScriptMgr.GetLuaFunction(L, 4);
obj.RemoveLuaMessageHandler(arg0, arg1, arg2);
return(0);
}
public GameMainManager()
{
netManager = new NetManager();
websocketMsgManager = new WebSocketMsgManager();
model = new GameModel();
open = new OpenFacebook();
configManager = new ConfigManager();
iap = new IAPManager();
preloader = new PreloaderManager();
EventDispatcher.instance.AddEventListener(EventEnum.REQUEST_ERROR, OnRequestErrorHandle);
}
/// <summary>
/// Inform the server that the client has a complete copy of the
/// mapping, and alert other code that the handshake is over.
/// </summary>
/// <seealso cref="ClientHandshakeComplete"/>
/// <seealso cref="NetworkInitialize"/>
private void OnClientCompleteHandshake(INetManager net, INetChannel channel)
{
LogSzr.Debug("Letting server know we're good to go.");
var handshake = net.CreateNetMessage <MsgMapStrClientHandshake>();
handshake.NeedsStrings = false;
channel.SendMessage(handshake);
if (ClientHandshakeComplete == null)
{
LogSzr.Warning("There's no handler attached to ClientHandshakeComplete.");
}
ClientHandshakeComplete?.Invoke();
}
/// <summary>
/// Performs the setup so that the serializer can perform the string-
/// exchange protocol.
/// </summary>
/// <remarks>
/// The string-exchange protocol is started by the server when the
/// client first connects. The server sends the client a hash of the
/// string mapping; the client checks that hash against any local
/// caches; and if necessary, the client requests a new copy of the
/// mapping from the server.
///
/// Uncached flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// Cached flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Dont Need Strings -> |
/// </code>
///
/// Verification failure flow: <code>
/// Client | Server
/// | <-------------- Hash |
/// | Need Strings ------> |
/// | <----------- Strings |
/// + Hash Failed |
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// NOTE: Verification failure flow is currently not implemented.
/// </remarks>
/// <param name="net">
/// The <see cref="INetManager"/> to perform the protocol steps over.
/// </param>
/// <seealso cref="MsgRobustMappedStringsSerializerServerHandshake"/>
/// <seealso cref="MsgRobustMappedStringsSerializerClientHandshake"/>
/// <seealso cref="MsgRobustMappedStringsSerializerStrings"/>
/// <seealso cref="HandleServerHandshake"/>
/// <seealso cref="HandleClientHandshake"/>
/// <seealso cref="HandleStringsMessage"/>
/// <seealso cref="OnClientCompleteHandshake"/>
public void NetworkInitialize(INetManager net)
{
_net = net;
net.RegisterNetMessage <MsgRobustMappedStringsSerializerServerHandshake>(
nameof(MsgRobustMappedStringsSerializerServerHandshake),
msg => HandleServerHandshake(net, msg));
net.RegisterNetMessage <MsgRobustMappedStringsSerializerClientHandshake>(
nameof(MsgRobustMappedStringsSerializerClientHandshake),
msg => HandleClientHandshake(net, msg));
net.RegisterNetMessage <MsgRobustMappedStringsSerializerStrings>(
nameof(MsgRobustMappedStringsSerializerStrings),
msg => HandleStringsMessage(net, msg));
}
/// <summary>
/// Interpret a server's handshake, either requesting a package
/// of strings or completing the handshake.
///
/// Uncached flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// Cached flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Dont Need Strings -> |
/// </code>
///
/// Verification failure flow: <code>
/// Client | Server
/// | <-------------- Hash | <- you are here on client
/// | Need Strings ------> |
/// | <----------- Strings |
/// + Hash Failed |
/// | Need Strings ------> |
/// | <----------- Strings |
/// | Dont Need Strings -> |
/// </code>
///
/// NOTE: Verification failure flow is currently not implemented.
/// </summary>
/// <exception cref="InvalidOperationException">Mapped strings are locked.</exception>
/// <seealso cref="NetworkInitialize"/>
private void HandleServerHandshake(INetManager net, MsgRobustMappedStringsSerializerServerHandshake msgRobustMappedStringsSerializer)
{
if (net.IsServer)
{
LogSzr.Error("Received server handshake on server.");
return;
}
ServerHash = msgRobustMappedStringsSerializer.Hash;
LockMappedStrings = false;
if (LockMappedStrings)
{
throw new InvalidOperationException("Mapped strings are locked.");
}
ClearStrings();
var hashStr = ConvertToBase64Url(Convert.ToBase64String(msgRobustMappedStringsSerializer.Hash !));
LogSzr.Debug($"Received server handshake with hash {hashStr}.");
var fileName = CacheForHash(hashStr);
if (!File.Exists(fileName))
{
LogSzr.Debug($"No string cache for {hashStr}.");
var handshake = net.CreateNetMessage <MsgRobustMappedStringsSerializerClientHandshake>();
LogSzr.Debug("Asking server to send mapped strings.");
handshake.NeedsStrings = true;
msgRobustMappedStringsSerializer.MsgChannel.SendMessage(handshake);
}
else
{
LogSzr.Debug($"We had a cached string map that matches {hashStr}.");
using var file = File.OpenRead(fileName);
var added = LoadStrings(file);
_stringMapHash = msgRobustMappedStringsSerializer.Hash !;
LogSzr.Debug($"Read {added} strings from cache {hashStr}.");
LockMappedStrings = true;
LogSzr.Debug($"Locked in at {_mappedStrings.Count} mapped strings.");
// ok we're good now
var channel = msgRobustMappedStringsSerializer.MsgChannel;
OnClientCompleteHandshake(net, channel);
}
}
public virtual void Setup(INetManager netManager)
{
if (string.IsNullOrEmpty(PushsocketString))
{
throw new ArgumentNullException(nameof(PushsocketString));
}
if (string.IsNullOrEmpty(PullSocketString))
{
throw new ArgumentNullException(nameof(PullSocketString));
}
if (netManager == null)
{
throw new ArgumentNullException(nameof(netManager));
}
if (!string.IsNullOrEmpty(XPubSocketString) && !string.IsNullOrEmpty(XSubSocketString))
{
var PublisherSocket = new XPublisherSocket(XPubSocketString);
var SubscriberSocket = new XSubscriberSocket(XSubSocketString);
GlobalServerProxy = new Proxy(SubscriberSocket, PublisherSocket);
}
sender = new PushSocket(PushsocketString);
responseSocket = new PullSocket(PullSocketString);
Poller = new NetMQPoller()
{
sender,
responseSocket,
PushQueue
};
NetSend = netManager;
PushQueue.ReceiveReady += (o, args) =>
{
var msg = PushQueue.Dequeue();
sender.SendMultipartMessage(msg);
};
responseSocket.ReceiveReady += ProcessResponse;
IsSetuped = true;
}
/// <summary>
/// Initializes the string table.
/// </summary>
public void Initialize(INetManager network)
{
_network = network;
_network.RegisterNetMessage <MsgStringTableEntry>(MsgStringTableEntry.NAME, (int)MsgStringTableEntry.ID, message =>
{
if (_network.IsServer) // Server does not receive entries from clients.
{
return;
}
var entry = (MsgStringTableEntry)message;
var id = entry.EntryId;
var str = string.IsNullOrEmpty(entry.EntryString) ? null : entry.EntryString;
if (str == null)
{
_strings.Remove(id);
}
else
{
if (TryFindStringId(str, out int oldId))
{
if (oldId == id)
{
return;
}
_strings.Remove(oldId);
_strings.Add(id, str);
}
else
{
_strings.Add(id, str);
}
}
});
// manually register the id on the client so it can bootstrap itself with incoming table entries
if (_network.IsClient && !TryFindStringId(MsgStringTableEntry.NAME, out int msgId))
{
_strings.Add((int)MsgStringTableEntry.ID, MsgStringTableEntry.NAME);
}
}
public virtual void Setup(INetManager netManager)
{
if (string.IsNullOrEmpty(ResponseHostString))
{
throw new ArgumentNullException(nameof(ResponseHostString));
}
_subscriberSocket = new SubscriberSocket(PublisherSocketString);
_subscriberSocket.Subscribe(FrontendID);
Poller = new NetMQPoller()
{
_subscriberSocket,
};
NetSend = netManager;
_subscriberSocket.ReceiveReady += ProcessSubscribe;
IsSetuped = true;
}
static int set_CacheQueueProcess(IntPtr L)
{
object o = LuaScriptMgr.GetLuaObject(L, 1);
INetManager obj = (INetManager)o;
if (obj == null)
{
LuaTypes types = LuaDLL.lua_type(L, 1);
if (types == LuaTypes.LUA_TTABLE)
{
LuaDLL.luaL_error(L, "unknown member name CacheQueueProcess");
}
else
{
LuaDLL.luaL_error(L, "attempt to index CacheQueueProcess on a nil value");
}
}
obj.CacheQueueProcess = LuaScriptMgr.GetBoolean(L, 3);
return(0);
}
/// <summary>
/// Default constructor.
/// </summary>
public StringTable(INetManager network)
{
_network = network;
_strings = new Dictionary <int, string>();
}
