/// <summary> /// Send a packet to multiple clients. /// </summary> /// <param name="excepts">clients to exclude</param> public void Send(List <NecClient> clients, NecPacket packet, params NecClient[] excepts) { clients = GetClients(clients, excepts); foreach (NecClient client in clients) { Send(client, packet); } }
/// <summary> /// Send a packet to everyone in the map. /// </summary> public void Send(Map map, NecPacket packet, params NecClient[] excepts) { List <NecClient> clients = GetClients(map.ClientLookup.GetAll(), excepts); foreach (NecClient client in clients) { Send(client, packet); } }
public NecPacket ToPacket() { if (_packet == null) { _packet = new NecPacket(id, ToBuffer(), serverType); } return(_packet); }
public byte[] Write(NecPacket packet, NecClient client) { // TODO update arrowgene service to write uint* byte[] data = packet.Data.GetAllBytes(); IBuffer buffer = BufferProvider.Provide(); ulong dataSize = (ushort)(data.Length + PacketIdSize); PacketLengthType packetLengthType; if (dataSize < byte.MaxValue) { packetLengthType = PacketLengthType.Byte; buffer.WriteByte((byte)packetLengthType); buffer.WriteByte((byte)dataSize); } else if (dataSize < ushort.MaxValue) { packetLengthType = PacketLengthType.UInt16; buffer.WriteByte((byte)packetLengthType); buffer.WriteInt16((ushort)dataSize); } else if (dataSize < uint.MaxValue) { packetLengthType = PacketLengthType.UInt32; buffer.WriteByte((byte)packetLengthType); buffer.WriteInt32((uint)dataSize); } else { _logger.Error($"{dataSize} to big"); return(null); } buffer.WriteInt16(packet.Id); buffer.WriteBytes(data); byte headerSize = CalculateHeaderSize(packetLengthType); packet.Header = buffer.GetBytes(0, headerSize); return(buffer.GetAllBytes()); }
public abstract void Handle(NecClient client, NecPacket packet);
public byte[] Write(NecPacket packet) { byte[] data = packet.Data.GetAllBytes(); IBuffer buffer = BufferProvider.Provide(); PacketType packetType; switch (packet.PacketType) { case PacketType.HeartBeat: packetType = PacketType.HeartBeat; buffer.WriteByte((byte)packetType); buffer.WriteBytes(data); break; case PacketType.Unknown1: packetType = PacketType.Unknown1; buffer.WriteByte((byte)packetType); buffer.WriteBytes(data); break; case PacketType.Disconnect: packetType = PacketType.Disconnect; buffer.WriteByte((byte)packetType); buffer.WriteBytes(data); break; default: ulong dataSize = (ulong)(data.Length + PacketIdSize); if (dataSize < byte.MaxValue) { packetType = PacketType.Byte; buffer.WriteByte((byte)packetType); buffer.WriteByte((byte)dataSize); } else if (dataSize < ushort.MaxValue) { packetType = PacketType.UInt16; buffer.WriteByte((byte)packetType); buffer.WriteUInt16((ushort)dataSize); } else if (dataSize < uint.MaxValue) { packetType = PacketType.UInt32; buffer.WriteByte((byte)packetType); buffer.WriteUInt32((uint)dataSize); } else { Logger.Error($"{dataSize} to big"); return(null); } buffer.WriteUInt16(packet.Id); buffer.WriteBytes(data); break; } byte headerSize = CalculateHeaderSize(packetType); packet.Header = buffer.GetBytes(0, headerSize); return(buffer.GetAllBytes()); }
public List <NecPacket> Read(byte[] data, ServerType serverType) { List <NecPacket> packets = new List <NecPacket>(); if (_buffer == null) { _buffer = BufferProvider.Provide(data); } else { _buffer.SetPositionEnd(); _buffer.WriteBytes(data); } _buffer.Position = _position; bool read = true; while (read) { read = false; if (!_readPacketLengthType && _buffer.Size - _buffer.Position > PacketLengthTypeSize) { byte lengthType = _buffer.ReadByte(); if (!Enum.IsDefined(typeof(PacketType), lengthType)) { Logger.Error($"PacketType: '{lengthType}' not found"); Reset(); return(packets); } _readPacketLengthType = true; _packetType = (PacketType)lengthType; _headerSize = CalculateHeaderSize(_packetType); } if (_readPacketLengthType && !_readHeader && _buffer.Size - _buffer.Position >= _headerSize - PacketLengthTypeSize) { // TODO acquire 1st byte differently in case -1 doesnt work _header = _buffer.GetBytes(_buffer.Position - PacketLengthTypeSize, _headerSize); switch (_packetType) { case PacketType.Byte: { _dataSize = _buffer.ReadByte(); _dataSize -= PacketIdSize; _id = _buffer.ReadUInt16(); _readHeader = true; break; } case PacketType.UInt16: { _dataSize = _buffer.ReadUInt16(); _dataSize -= PacketIdSize; _id = _buffer.ReadUInt16(); _readHeader = true; break; } case PacketType.UInt32: { _dataSize = _buffer.ReadUInt32(); _dataSize -= PacketIdSize; _id = _buffer.ReadUInt16(); _readHeader = true; break; } case PacketType.HeartBeat: { _dataSize = HeartbeatPacketBodySize; _id = (ushort)CustomPacketId.SendHeartbeat; _readHeader = true; break; } case PacketType.Unknown1: { _dataSize = Unknown1PacketBodySize; _id = (ushort)CustomPacketId.SendUnknown1; _readHeader = true; break; } case PacketType.Disconnect: { _dataSize = DisconnectPacketBodySize; _id = (ushort)CustomPacketId.SendDisconnect; _readHeader = true; break; } default: { // TODO update arrowgene buffer to read uint24 && int24 Logger.Error($"PacketType: '{_packetType}' not supported"); Reset(); return(packets); } } } if (_readPacketLengthType && _readHeader && _buffer.Size - _buffer.Position >= _dataSize) { // TODO update arrowgene service to read uint byte[] packetData = _buffer.ReadBytes((int)_dataSize); IBuffer buffer = BufferProvider.Provide(packetData); NecPacket packet = new NecPacket(_id, buffer, serverType); packet.Header = _header; packets.Add(packet); _readPacketLengthType = false; _readHeader = false; read = _buffer.Position != _buffer.Size; } } if (_buffer.Position == _buffer.Size) { Reset(); } else { _position = _buffer.Position; } return(packets); }
/// <summary> /// Send a packet to a client. /// </summary> public void Send(NecClient client, ushort id, IBuffer data) { NecPacket packet = new NecPacket(id, data); Send(client, packet); }
/// <summary> /// Send a packet to a client. /// </summary> public void Send(NecClient client, NecPacket packet) { client.Send(packet); }
public List <NecPacket> Read(byte[] data, NecClient client) { List <NecPacket> packets = new List <NecPacket>(); if (_buffer == null) { _buffer = BufferProvider.Provide(data); } else { _buffer.SetPositionEnd(); _buffer.WriteBytes(data); } _buffer.Position = _position; bool read = true; while (read) { read = false; if (!_readPacketLengthType && _buffer.Size - _buffer.Position > PacketLengthTypeSize) { byte lengthType = _buffer.ReadByte(); if (!Enum.IsDefined(typeof(PacketLengthType), lengthType)) { _logger.Error($"PacketLengthType: '{lengthType}' not found"); byte[] dataDump = _buffer.GetBytes(_buffer.Position - 1, _buffer.Size); _logger.LogErrorPacket(client, dataDump, null); Reset(); return(packets); } _readPacketLengthType = true; _packetLengthType = (PacketLengthType)lengthType; _headerSize = CalculateHeaderSize(_packetLengthType); } if (_readPacketLengthType && !_readHeader && _buffer.Size - _buffer.Position >= _headerSize - PacketLengthTypeSize) { // TODO aquire 1st byte differently incase -1 doesnt work _header = _buffer.GetBytes(_buffer.Position - PacketLengthTypeSize, _headerSize); switch (_packetLengthType) { case PacketLengthType.Byte: { _dataSize = _buffer.ReadByte(); break; } case PacketLengthType.UInt16: { _dataSize = _buffer.ReadUInt16(); break; } case PacketLengthType.UInt32: { _dataSize = _buffer.ReadUInt32(); break; } default: { // TODO update arrowgene service to read uint24 && int24 _logger.Error($"PacketLengthType: '{_packetLengthType}' not supported"); Reset(); return(packets); } } _dataSize -= PacketIdSize; _id = _buffer.ReadUInt16(); _readHeader = true; } if (_readPacketLengthType && _readHeader && _buffer.Size - _buffer.Position >= _dataSize) { // TODO update arrowgene service to read uint byte[] packetData = _buffer.ReadBytes((int)_dataSize); IBuffer buffer = BufferProvider.Provide(packetData); NecPacket packet = new NecPacket(_id, buffer); packet.Header = _header; packets.Add(packet); _readPacketLengthType = false; _readHeader = false; read = _buffer.Position != _buffer.Size; } } if (_buffer.Position == _buffer.Size) { Reset(); } else { _position = _buffer.Position; } return(packets); }
public abstract void Handle(NecConnection client, NecPacket packet);
/// <summary> /// Send a packet to a connection. /// </summary> public void Send(NecConnection connection, ushort id, IBuffer data) { NecPacket packet = new NecPacket(id, data, connection.ServerType); Send(connection, packet); }
/// <summary> /// Send a packet to a client. /// </summary> public void Send(NecClient client, ushort id, IBuffer data, ServerType serverType) { NecPacket packet = new NecPacket(id, data, serverType); Send(client, packet); }
/// <summary> /// Send a packet to a connection. /// </summary> public void Send(NecConnection connection, NecPacket packet) { connection.Send(packet); }
public override void Handle(NecClient client, NecPacket requestPacket) { T request = _deserializer.Deserialize(requestPacket); HandleRequest(client, request); }