public void RegisterPacketHandlers() { var types = Assembly.GetAssembly(typeof(TPacketHandler)) .GetTypes() .Where(x => x.IsSubclassOf(typeof(TPacketHandler))); foreach (var type in types) { var attributes = type.GetTypeInfo() .GetCustomAttributes() .OfType <PacketHandlerAttribute>() .ToList(); foreach (var attribute in attributes) { var header = attribute.Header; if (!PacketHandlers.ContainsKey(header)) { PacketHandlers[header] = new List <TPacketHandler>(); } var handler = (TPacketHandler)Activator.CreateInstance(type); PacketHandlers[header].Add(handler); } } }
/// <summary> /// Removes a packet handler /// </summary> /// <param name="handler"></param> public bool UnregisterPacketHandler(IPacketHandler handler) { if (PacketHandlers.ContainsKey(handler.Type)) { return(PacketHandlers[handler.Type].Remove(handler)); } return(false); }
private void HandlePacket(RemoteClient client, IPacket packet) { if (!PacketHandlers.ContainsKey(packet.GetType())) { return; } //throw new InvalidOperationException("No packet handler registered for 0x" + packet.Id.ToString("X2")); PacketHandlers[packet.GetType()](client, this, packet); }
private void HandlePacket(IPacket packet) { var type = packet.GetType(); if (PacketHandlers.ContainsKey(type)) { PacketHandlers[type](this, packet); } //throw new InvalidOperationException("Recieved a packet we can't handle: " + packet.GetType().Name); }
public static bool AddPacketHandler(PacketType packetType, PacketMethod handler) { bool result = false; lock (PacketHandlers) { if (!PacketHandlers.ContainsKey(packetType)) { PacketHandlers.Add(packetType, handler); result = true; } } return(result); }
/// <summary> /// Registers a set of packet handlers to be used by new connections /// </summary> /// <param name="handlers">The handlers to register</param> public void RegisterPacketHandlers(IEnumerable <IPacketHandler> handlers) { foreach (IPacketHandler handler in handlers) { if (!PacketHandlers.ContainsKey(handler.Type)) { PacketHandlers.Add(handler.Type, new List <IPacketHandler>(new[] { handler })); } else { PacketHandlers[handler.Type].Add(handler); } } }
public void SetPacketHandler(ClientPacketId id, NetPacketHandler packetHandler) { if (packetHandler == null) { throw new ArgumentNullException(nameof(packetHandler)); } if (PacketHandlers.ContainsKey(id)) { throw new ArgumentException($"A packet handler is already registered for \"{id}\".", nameof(id)); } PacketHandlers.Add(id, packetHandler); }
private void OnReceivedPacket(object sender, PacketEventArgs args) { var packet = args.Packet; //Console.WriteLine(packet.Type.ToString() + "," + packet.Opcode.ToString()); if (PacketHandlers.ContainsKey(packet.Type)) { if (PacketHandlers[packet.Type].ContainsKey(packet.Opcode)) { if (PacketHandlers[packet.Type][packet.Opcode] != null) { PacketHandlers[packet.Type][packet.Opcode](packet); } } } }
/// <summary> /// The processing system /// </summary> /// <param name="bot">The bot to attach to</param> /// <param name="inPacket">The packet coming in</param> /// <param name="client">The client to attach to</param> public void Process(PalBot bot, Packet inPacket, Client client) { Packet packet; if (!CheckPacket(inPacket, out packet)) { return; } if (PacketHandlers == null || PacketHandlers.Count == 0) { LoadPacketHandlers(bot); } if (!PacketHandlers.ContainsKey(packet.Command.ToUpper())) { bot.On.Trigger("pk", packet); return; } if (packet["COMPRESSION"] == "1") { packet.Payload = packet.DecompressPayload(); } try { bot.Callbacks.Activate(packet); var plug = PacketHandlers[packet.Command.ToUpper()]; var i = (IPacketHandler)Activator.CreateInstance(plug); i.Bot = bot; i.Client = client; i.Process(packet); } catch (Exception ex) { bot.On.Trigger("e", ex); } }
protected virtual async Task ProcessAsync(SocketAsyncEventArgs e) { if (e.SocketError == SocketError.Success && e.BytesTransferred > 0) { bool exception = false; try { if (_cts.IsCancellationRequested) { return; } SocketAsyncEventArgs newArgs = Proxy.ListeningServer.SocketPool.Get(); newArgs.Completed += Operation_Completed; if (ConnectionClient != null && !ConnectionClient.ReceiveAsync(newArgs)) { Operation_Completed(this, newArgs); } await _sem.WaitAsync(_cts.Token); var packets = PacketReader.Read(_processor, e.Buffer, e.Offset, e.BytesTransferred); foreach (Packet packet in packets) { if (_cts.IsCancellationRequested) { return; } if (packet == null) { StarLog.DefaultLogger.Warn("Encountered null packet!"); continue; } try { packet.Direction = Direction; Type pType = packet.GetType(); List <IPacketHandler> pHandlers = null; if (PacketHandlers.ContainsKey(pType)) { pHandlers = PacketHandlers[pType]; var tasks = new List <Task>(); foreach (IPacketHandler beforeHandler in pHandlers) { tasks.Add(beforeHandler.HandleBeforeAsync(packet, this)); } await Task.WhenAll(tasks); } EventHandler <PacketEventArgs> packetArgs = PacketReceived; if (packetArgs != null) { packetArgs(this, new PacketEventArgs(Proxy, packet)); } OtherConnection.FlushPacket(packet); if (pHandlers != null) { var tasks = new List <Task>(); foreach (IPacketHandler sentHandler in pHandlers) { tasks.Add(sentHandler.HandleAfterAsync(packet, this)); } await Task.WhenAll(tasks); } EventHandler <PacketEventArgs> aPacketArgs = AfterPacketReceived; if (aPacketArgs != null) { aPacketArgs(this, new PacketEventArgs(Proxy, packet)); } } catch (Exception ex) { ex.LogError(); } } _sem.Release(); } catch (Exception) { exception = true; } if (exception) { await CloseAsync(); } } else { await CloseAsync(); } }
private void NetworkMessageReceived(IAsyncResult result) { IPEndPoint endPoint = default(IPEndPoint); var payload = NetworkClient.EndReceive(result, ref endPoint); NetworkClient.BeginReceive(NetworkMessageReceived, null); var stream = new BinaryReader(new MemoryStream(payload), Encoding.UTF8); AsymmetricKeyParameter key; RemoteNode node = null; if (endPoint.Address.Equals(IPAddress.Loopback)) { key = CryptoProvider.PublicKey; } else { node = GetNode(endPoint); if (node == null) { return; } key = node.PublicKey; } try { var id = stream.ReadString(); var flags = (MessageFlags)stream.ReadByte(); var transaction = stream.ReadUInt32(); var timestamp = new DateTime(stream.ReadInt64(), DateTimeKind.Utc); if (node != null) { // TODO: Evaluate this margin of error, and this whole system in general that prevents resubmission if (Math.Abs((timestamp - node.PreviousMessageTimestamp).TotalSeconds) > 10) { return; } node.PreviousMessageTimestamp = timestamp; } if (PacketFactories.ContainsKey(id)) { var packet = PacketFactories[id](); packet.Transaction = transaction; packet.Read(stream); int signatureLength = (int)(stream.BaseStream.Length - stream.BaseStream.Position); int messageLength = (int)stream.BaseStream.Position; stream.BaseStream.Seek(0, SeekOrigin.Begin); byte[] message = new byte[messageLength]; byte[] signature = new byte[signatureLength]; stream.BaseStream.Read(message, 0, message.Length); stream.BaseStream.Read(signature, 0, signature.Length); // Verify signature if (!CryptoProvider.VerifySignature(message, signature, key)) { Console.WriteLine("Warning: Received internode network packet with bad signature from {0}", endPoint); } else { if (id == typeof(ConfirmationPacket).Name) { HandleConfirmation(packet); } else if (PacketHandlers.ContainsKey(id)) { PacketHandlers[id](packet, endPoint, this); } else { Console.WriteLine("Warning: Unhandled internode network packet with ID {0}", id); } if ((flags & MessageFlags.PropegateTransaction) > 0 && endPoint.Address == IPAddress.Loopback) { foreach (var target in Network) { if (target != node) { Send(packet, target.EndPoint); } } } if ((flags & MessageFlags.ConfirmationRequired) > 0) { Send(new ConfirmationPacket(transaction), endPoint); // TODO: Don't re-handle duplicate transactions } } } else { Console.WriteLine("Warning: Received unknown internode network packet ID {0}", id); } } catch (Exception e) { Console.WriteLine("Warning: Error parsing internetwork message: {0}", e.GetType().Name); } }