/// <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>(); }