public void ProcessReceive(SocketAsyncEventArgs e) { Session.Session session = (Session.Session)e.UserToken; if (session == null) { return; } if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { IPacket packet = PacketSerializer.Deserialize(e.MemoryBuffer.ToArray(), e.BytesTransferred); session.DoAsync(() => { session.OnReceive(packet); }); bool willRaiseEvent = session.Socket.ReceiveAsync(e); if (willRaiseEvent == false) { ProcessReceive(e); } } else { session.DoAsync(() => { SessionManager.Disconnect(session); }); } }
public void Deserialize_Valid_ReturnsValidXml() { PacketSerializer serializer = PacketSerializer.Create("application/xml"); Payment etalon = new Payment { OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017 }; const string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><packet version=\"v1\"><Payment order_id=\"1\" card_number=\"9999000088881111\" expiry_month=\"12\" expiry_year=\"2017\" cvv=\"100\" cardholder_name=\"POVYSHEV NIKOLAY\" amount_kop=\"100\" /></packet>"; Payment payment = null; using (MemoryStream stream = new MemoryStream()) { stream.Write(Encoding.UTF8.GetBytes(xml), 0, xml.Length); stream.Position = 0; payment = serializer.Deserialize <Payment>(stream).Content; } Assert.Equal(etalon.OrderId, payment.OrderId); Assert.Equal(etalon.AmountKop, payment.AmountKop); Assert.Equal(etalon.CardHolderName, payment.CardHolderName); Assert.Equal(etalon.CardNumber, payment.CardNumber); Assert.Equal(etalon.CVV, payment.CVV); Assert.Equal(etalon.ExpiryMonth, payment.ExpiryMonth); Assert.Equal(etalon.ExpiryYear, payment.ExpiryYear); }
private void BeginReceiveCallback(IAsyncResult results) { var state = (AuthenticationState)results.AsyncState; // Timeout, socket has been closed. if (state.client.Client == null) { return; } var packet = (AuthenticationPacket)PacketSerializer.Deserialize(state.buffer)[0]; var auth = state.auth; if (packet.version == auth.version && packet.time == auth.time && !string.IsNullOrEmpty(packet.response) && Guid.Parse(packet.guid) == state.guid) { AuthenticationSuccess?.Invoke(state.client, packet); } else { AuthenticationFailed?.Invoke(state.client); } }
public void SerializeDeserialize() { const int Count = 255; var packets = new List <IPacket>(); var contents = new List <string>(); for (int i = 0; i < Count; i++) { contents.Add("STR: " + i.ToString()); } for (int i = 0; i < Count / 2; i++) { packets.Add(new PingPacket(contents[i])); } for (int i = Count / 2; i < Count; i++) { packets.Add(new AuthenticationPacket(contents[i], contents[i])); } var bytes = PacketSerializer.Serialize(packets.ToArray()); packets = PacketSerializer.Deserialize(bytes).ToList(); for (int i = 0; i < Count / 2; i++) { Assert.AreEqual(contents[i], ((PingPacket)packets[i]).contents); } for (int i = Count / 2; i < Count; i++) { Assert.AreEqual(contents[i], ((AuthenticationPacket)packets[i]).time); } }
protected override PacketObject OnReadPacket() { var packet = (PacketObject)null; do { /* ブロック読み込み */ while ((block_reader_ == null) || (block_reader_.PeekChar() < 0)) { /* ブロックが読み込めなかった場合は終了 */ if (!LoadCompressBlock(reader_main_)) { return(null); } } /* 1パケット読込 */ try { var size = (UInt32)0; size |= (uint)((uint)block_reader_.ReadByte() << 24); size |= (uint)((uint)block_reader_.ReadByte() << 16); size |= (uint)((uint)block_reader_.ReadByte() << 8); size |= (uint)((uint)block_reader_.ReadByte() << 0); packet = PacketSerializer.Deserialize(block_reader_.ReadBytes((int)size)); } catch { /* 読込が失敗した場合は繰り返す */ } } while (packet == null); return(packet); }
static void Main(string[] args) { // memory for the packet MemoryStream memory = new MemoryStream(); // create a packet Packet packet = new Packet(PacketType.Message, Encoding.UTF8.GetBytes("hello, server")); // serialize the packet to the memorystream PacketSerializer serializer = new PacketSerializer(); serializer.Serialize(memory, packet); // save a copy File.WriteAllBytes("TestPacket.bin", memory.ToArray()); // reset the position of the stream memory.Seek(0L, SeekOrigin.Begin); // deserialize the packet Packet deserialized = serializer.Deserialize(memory); // print the packet data Console.WriteLine(Encoding.UTF8.GetString(deserialized.Data, 0, (int)deserialized.Length)); Console.ReadLine(); }
public void Recieve() { DateTime lastPingCheck = DateTime.MinValue; Log.Debug("Starting Listener for client " + ConnectionId); Listening = true; while (Listening) { try { // Check if needs to ping the client to see if its ok DateTime now = DateTime.Now; if (now > lastPingCheck.AddSeconds(PING_CHECK_SECONDS)) { lastPingCheck = now; CheckPing(); } // Read data from socket var socketData = ReadData(); if (socketData == null) { continue; } var packetRead = PacketSerializer.Deserialize(socketData); if (packetRead != null && packetRead is BasePacket) { var packet = (BasePacket)packetRead; packet.ClientId = ConnectionId; if (typeof(PingPacket) == packet.GetType()) { RecievePing((PingPacket)packet); } else { Log.Debug($"Packet {packet.GetType().Name} recieved"); // Put the packet to be processed by the main thread Server.PacketsToProccess.Enqueue(packet); } } } catch (Exception e) { Listening = false; } } ServerEvents.Call(new PlayerQuitEvent() { Client = this, Player = OnlinePlayer, Reason = QuitReason.DISCONNECTED }); Stop(); }
private void Ws_OnMessage(object sender, MessageEventArgs e) { Debug.Log("OnWebSocketMessage : " + e.Data); var packet = PacketSerializer.Deserialize(e.RawData); lock (packetQ) packetQ.Add(packet); }
/// <summary> /// Decodes (i.e. reads) a packet /// </summary> /// <param name="packetId">The id of the packet</param> /// <param name="data">The data that will be fed into the packet to be read</param> /// <returns>The decoded packet</returns> protected virtual Packet Decode(byte packetId, byte[] data) { Packet packet; try { if (_packets.ContainsKey(packetId)) { using (StarReader reader = new StarReader(data)) { packet = PacketSerializer.Deserialize(reader, _packets[packetId]) as Packet; if (reader.DataLeft != 0) { if (packet != null) { StarLog.DefaultLogger.Warn("Packet {0} is incomplete ({1} bytes left)!", packet.GetType().FullName, reader.DataLeft); } else { StarLog.DefaultLogger.Warn("Packet {0} is incomplete ({1} bytes left)!", packetId, reader.DataLeft); } } if (packet == null) { StarLog.DefaultLogger.Warn("Error deserializing packet {0} ({1})", (PacketType)packetId, packetId); packet = new GenericPacket(packetId) { Data = data }; } } } else { packet = new GenericPacket(packetId) { Data = data }; } packet.IsReceive = true; } catch (Exception ex) { StarLog.DefaultLogger.Error("Packet {0} caused an error!", _packets[packetId].FullName); ex.LogError(); return(null); } return(packet); }
public IPacket Unformat(byte id, byte[] data, int index, int count) { if ((id == 0 && data == null) || data.Length == 0) { throw new ArgumentNullException("data", "must contain data"); } #region " Server Packets " switch ((AresId)id) { case AresId.MSG_CHAT_SERVER_LOGIN_ACK: return(serializer.Deserialize <LoginAck>(data, index, count)); case AresId.MSG_CHAT_SERVER_MYFEATURES: return(serializer.Deserialize <Features>(data, index, count)); case AresId.MSG_CHAT_SERVER_TOPIC: return(serializer.Deserialize <Topic>(data, index, count)); case AresId.MSG_CHAT_SERVER_TOPIC_FIRST: return(serializer.Deserialize <TopicFirst>(data, index, count)); case AresId.MSG_CHAT_SERVER_AVATAR: return(serializer.Deserialize <ServerAvatar>(data, index, count)); case AresId.MSG_CHAT_SERVER_PERSONAL_MESSAGE: return(serializer.Deserialize <ServerPersonal>(data, index, count)); case AresId.MSG_CHAT_SERVER_PUBLIC: return(serializer.Deserialize <ServerPublic>(data, index, count)); case AresId.MSG_CHAT_SERVER_EMOTE: return(serializer.Deserialize <ServerEmote>(data, index, count)); case AresId.MSG_CHAT_SERVER_PVT: return(serializer.Deserialize <Private>(data, index, count)); default: { byte[] tmp = new byte[count]; Array.Copy(data, index, tmp, 0, count); return(new Unknown(id, tmp)); } } #endregion }
public object ListenForPacket() { var socketData = ReadData(); if (socketData != null) { return(PacketSerializer.Deserialize(socketData)); } return(null); }
public void Recieve() { DateTime lastPingCheck = DateTime.MinValue; Log.Debug("Starting Listener for client " + ConnectionId); Listening = true; while (Listening) { try { // Check if needs to ping the client to see if its ok DateTime now = DateTime.Now; if (now > lastPingCheck.AddSeconds(PING_CHECK_SECONDS)) { lastPingCheck = now; CheckPing(); } // Read data from socket var socketData = ReadData(); if (socketData == null) { continue; } var packetRead = PacketSerializer.Deserialize(socketData); if (packetRead != null && packetRead is BasePacket) { var packet = (BasePacket)packetRead; packet.ClientId = ConnectionId; if (typeof(PingPacket) == packet.GetType()) { RecievePing((PingPacket)packet); } if (typeof(LoginPacket) != packet.GetType()) { if (!Authenticated) { Log.Error($"Blocked packet {packet.GetType().Name}"); continue; } } Log.Debug($"Packet {packet.GetType().Name} recieved"); // Put the packet to be processed by the main thread Server.PacketsToProccess.Enqueue(packet); } } catch (Exception e) { Listening = false; } } DisconnectClient(); }
public void Deserialize() { var pingPacket = new PingPacket("hello"); var bytes = PacketSerializer.Serialize(pingPacket); var packets = PacketSerializer.Deserialize(bytes); Assert.IsTrue(packets.Length == 1); Assert.AreEqual("hello", ((PingPacket)packets[0]).contents); }
private void ParseIncomingMessage(byte[] payload) { //string message = Encoding.UTF8.GetString(payload).Trim('\0'); IPacket packet = null; using (MemoryStream stream = new MemoryStream(payload)) { packet = serializer.Deserialize(stream); } OnMessageReceived(packet); }
public static Document ReadDocument(StarReader reader) { Document doc = new Document(); doc.Name = reader.ReadString(); reader.ReadByte(); doc.Version = DataConverter.BigEndian.GetInt32(reader.ReadBytes(4), 0); doc.Data = (StarVariant)PacketSerializer.Deserialize(reader, typeof(StarVariant)); return(doc); }
private void OnReceive(IAsyncResult ar) { Debug.Log("RECEIVE!!~~" + ar.CompletedSynchronously); var numberOfByteRead = _networkStream.EndRead(ar); // 패킷처리 var packet = PacketSerializer.Deserialize(_buffer, numberOfByteRead); Debug.Log("[Receive] name: " + packet.GetPacketType()); _waitPacketQueue.Enqueue(packet); // 클리어 // ClearBuffer(); _networkStream.BeginRead(_buffer, 0, 65535, OnReceive, _networkStream); }
protected override void OnMessage(MessageEventArgs e) { object packet = null; /* * if (e.IsText == false) * { * ErrorClose(CloseStatusCode.ProtocolError, "only json data accepted"); * return; * } */ try { packet = PacketSerializer.Deserialize(e.RawData); } catch (Exception ex) { } if (packet == null) { Console.WriteLine($"Parsing Error : {e.Data}"); Console.WriteLine(Encoding.UTF8.GetString(e.RawData)); ErrorClose(CloseStatusCode.InvalidData, "parsing error"); } else if (Handlers.ContainsKey(packet.GetType()) == false) { Console.WriteLine($"Unkown Packet : {e.Data}"); Console.WriteLine(Encoding.UTF8.GetString(e.RawData)); ErrorClose(CloseStatusCode.InvalidData, "unknown packet"); } else { var handler = Handlers[packet.GetType()]; try { handler.Invoke(this, new object[] { packet }); } catch (Exception ex) { Console.WriteLine(ex); ErrorClose(CloseStatusCode.ServerError, "internal server error"); } } }
public void TestLoginPacketSerialization() { LoginPacket loginPacket = new LoginPacket() { Login = "******", Password = "******" }; byte[] serialized = PacketSerializer.Serialize(loginPacket); object deserialized = PacketSerializer.Deserialize(serialized); Assert.That(deserialized is LoginPacket); LoginPacket deserializedLoginPacket = (LoginPacket)deserialized; Assert.AreEqual(deserializedLoginPacket.Login, loginPacket.Login); Assert.AreEqual(deserializedLoginPacket.Password, loginPacket.Password); }
public TResp SendRequest <TReq, TResp>(TReq content) where TReq : IPacketContent where TResp : IPacketContent { HttpWebRequest request = WebRequest.Create(endpoint) as HttpWebRequest; request.Method = "POST"; request.ContentType = contentType; request.Timeout = 3000; PacketSerializer serializer = PacketSerializer.Create(request.ContentType); try { using (MemoryStream stream = new MemoryStream()) { serializer.Serialize(new Packet <TReq>(content) { Version = "v1" }, stream); request.ContentLength = stream.Length; stream.Position = 0; stream.CopyTo(request.GetRequestStream()); } HttpWebResponse response = request.GetResponse() as HttpWebResponse; Stream responseStream = response.GetResponseStream(); Packet <TResp> responsePacket = serializer.Deserialize <TResp>(responseStream); return(responsePacket.Content); } catch (WebException ex) { throw new PacketTransportException("Ошибка соединения с сервером", ex); } }
public bool Deserialize(byte[] bytes, ref int position) { if (!ChannelID.Deserialize(bytes, ref position)) { return(false); } if (!ParentID.Deserialize(bytes, ref position)) { return(false); } if (!Name.Deserialize(bytes, ref position)) { return(false); } if (!PacketSerializer.Deserialize(bytes, ref position, out type)) { return(false); } return(true); }
public void TestSerialize() { var serializer = new PacketSerializer(); var originalPayload = new SentMessagePayload { Id = Guid.NewGuid(), Text = "Hello There hi", ChannelId = Guid.NewGuid(), AuthorId = Guid.NewGuid(), PostedAt = DateTimeOffset.Now, }; var json = serializer.Serialize(originalPayload); var deserializedPayload = (SentMessagePayload)serializer.Deserialize(json); Assert.That(deserializedPayload.Id, Is.EqualTo(originalPayload.Id), "Id was incorrect"); Assert.That(deserializedPayload.Text, Is.EqualTo(originalPayload.Text), "Text was incorrect"); Assert.That(deserializedPayload.ChannelId, Is.EqualTo(originalPayload.ChannelId), "ChannelId was incorrect"); Assert.That(deserializedPayload.AuthorId, Is.EqualTo(originalPayload.AuthorId), "AuthorId was incorrect"); Assert.That(deserializedPayload.PostedAt, Is.EqualTo(originalPayload.PostedAt), "PostedAt was incorrect"); }
public static int Run(string[] args) { try { if (!HandleArguments(ref args)) { return(0); } } catch (OptionException e) { Console.WriteLine(e.Message); return(1); } if (args.Length != 1) { Console.WriteLine("Expected exactly one input file argument."); return(1); } Log.Level = LogLevel.Debug; Log.TimestampFormat = "HH:mm:ss:fff"; var color = Console.ForegroundColor; Log.Loggers.Add(new ConsoleLogger(false, color, color, color, color)); if (!Debugger.IsAttached) { AppDomain.CurrentDomain.UnhandledException += UnhandledException; } var input = args[0]; var output = _output ?? Path.ChangeExtension(input, "txt"); var regexes = _regexes.Select(x => new Regex(x, RegexOptions)) .DefaultIfEmpty(new Regex(".*", RegexOptions)) .ToArray(); _log.Basic("Parsing {0}...", input); var reader = new PacketLogReader(input); var serializer = new PacketSerializer( new OpCodeTable(true, reader.Region), new OpCodeTable(false, reader.Region)); var stats = new PacketStatistics(); using (var result = new StreamWriter(new FileStream(output, FileMode.Create, FileAccess.Write))) { foreach (var entry in reader.EnumerateAll()) { stats.TotalPackets++; var name = serializer.GameMessages.OpCodeToName[entry.OpCode]; if (regexes.Any(r => !r.IsMatch(name))) { stats.IgnoredPackets++; continue; } stats.RelevantPackets++; result.WriteLine("[{0:yyyy-MM-dd HH:mm:ss:fff}] {1} {2}: {3} ({4} bytes)", entry.Timestamp.ToLocalTime(), entry.ServerName, entry.Direction.ToDirectionString(), name, entry.Payload.Count); var parsed = serializer.Create(entry.OpCode); var payload = entry.Payload.ToArray(); if (payload.Length != 0) { if ((_hex == HexDumpMode.Unknown && parsed == null) || _hex == HexDumpMode.All) { result.WriteLine(); result.WriteLine(new RawPacket(name) { Payload = payload }); } if ((_analysis == AnalysisMode.Unknown && parsed == null) || _analysis == AnalysisMode.All) { var arrays = PacketAnalysis.FindArrays(payload); if (arrays.Any()) { result.WriteLine(); result.WriteLine("Potential arrays:"); result.WriteLine(); foreach (var arr in arrays) { stats.PotentialArrays++; result.WriteLine(arr); } } var strings = PacketAnalysis.FindStrings(payload, _whiteSpace, _control, _length); if (strings.Any()) { result.WriteLine(); result.WriteLine("Potential strings:"); result.WriteLine(); foreach (var str in strings) { stats.PotentialStrings++; result.WriteLine(str); } } } } else { stats.EmptyPackets++; } if (parsed != null) { stats.KnownPackets++; if (_parse) { stats.ParsedPackets++; for (var i = 0; i < _roundtrips + 1; i++) { serializer.Deserialize(payload, parsed); var payload2 = serializer.Serialize(parsed); Assert.Check(payload2.Length == payload.Length, "Payload lengths must match after roundtrip."); if (i > 0) { Assert.Check(payload2.SequenceEqual(payload), "Payloads must match after first roundtrip."); } payload = payload2; } result.WriteLine(); result.WriteLine(parsed); } } else { stats.UnknownPackets++; } result.WriteLine(); } } _log.Basic("Parsed packets to {0}", output); if (_stats) { void PrintValue(string name, int value) { _log.Info("{0,17}: {1}", name, value); } void PrintPacketValue(string name, int value) { _log.Info("{0,17}: {1} ({2:P2})", name, value, (double)value / stats.RelevantPackets); } PrintValue("Total packets", stats.TotalPackets); PrintPacketValue("Relevant packets", stats.RelevantPackets); PrintPacketValue("Ignored packets", stats.IgnoredPackets); PrintPacketValue("Empty packets", stats.EmptyPackets); PrintPacketValue("Unknown packets", stats.UnknownPackets); PrintPacketValue("Known packets", stats.KnownPackets); PrintPacketValue("Parsed packets", stats.ParsedPackets); PrintValue("Potential arrays", stats.PotentialArrays); PrintValue("Potential strings", stats.PotentialStrings); } return(0); }
public IMessage DeserializePacket(MessageContainer messageContainer) { return(_package.Deserialize(messageContainer)); }
void HandleEntry(PacketLogReader reader, PacketLogEntry entry, PacketStatistics stats, PacketSerializer serializer, StreamWriter result) { stats.TotalPackets++; var name = serializer.GameMessages.CodeToName[entry.MessageCode]; if (_regexes.All(r => !r.IsMatch(name))) { stats.IgnoredPackets++; return; } result.WriteLine("[{0:yyyy-MM-dd HH:mm:ss:fff}] {1} {2}: {3} ({4} bytes)", entry.Timestamp.ToLocalTime(), reader.Servers[entry.ServerId].Name, entry.Direction.ToDirectionString(), name, entry.Payload.Count); var parsed = serializer.Create(entry.MessageCode); var payload = entry.Payload.ToArray(); if (payload.Length != 0) { if ((_hex == HexDumpMode.Unknown && parsed == null) || _hex == HexDumpMode.All) { result.WriteLine(); result.WriteLine(new RawPacket(name) { Payload = payload, }); } if ((_analysis == AnalysisMode.Unknown && parsed == null) || _analysis == AnalysisMode.All) { var arrays = PacketAnalysis.FindArrays(payload); if (arrays.Any()) { result.WriteLine(); result.WriteLine("Potential arrays:"); result.WriteLine(); foreach (var arr in arrays) { stats.PotentialArrays++; result.WriteLine(arr); } } var strings = PacketAnalysis.FindStrings(payload, _whiteSpace, _control, _length); if (strings.Any()) { result.WriteLine(); result.WriteLine("Potential strings:"); result.WriteLine(); foreach (var str in strings) { stats.PotentialStrings++; result.WriteLine(str); } } } } stats.AddPacket(name, parsed != null, payload.Length); if (parsed != null && _parse) { stats.ParsedPackets++; serializer.Deserialize(payload, parsed); for (var i = 0; i < _roundtrips; i++) { var payload2 = serializer.Serialize(parsed); var len = payload.Length; var len2 = payload2.Length; Assert.Check(len2 == len, $"Payload lengths for {name} don't match ({len2} versus {len})."); if (i > 0) { Assert.Check(payload2.SequenceEqual(payload), $"Payloads for {name} don't match after roundtrip."); } if (i != _roundtrips - 1) { serializer.Deserialize(payload2, parsed); } payload = payload2; } result.WriteLine(); result.WriteLine(parsed); } result.WriteLine(); }
void AcceptNewConnection(IAsyncResult result) { if (listener.IsListening) { listener.BeginGetContext(AcceptNewConnection, null); //Сразу продолжаем прием новых запросов } else { return; } HttpListenerContext context = listener.EndGetContext(result); HttpListenerRequest request = context.Request; HttpListenerResponse response = context.Response; Out.WriteLine("{0} {1} {2}", DateTime.Now.ToString(), request.RemoteEndPoint, request.HttpMethod); try { PacketSerializer serializer = PacketSerializer.Create(request.ContentType); if (serializer == null) { throw new NotSupportedException(); //вместо исключения должен быть корректный ответ об ошибке } //Читаем что нам прислали Packet <IPacketContent> packet = serializer.Deserialize <IPacketContent>(request.InputStream); if (packet == null) { throw new ArgumentException(); } //Подберем обработчик PacketHandler handler = PacketHandler.Create(packet.Version); handler.Out = Out; //Получаем результат Packet <IPacketContent> responsePacket = handler.Handle(packet); //И отправляем обратно using (MemoryStream mstream = new MemoryStream()) { serializer.Serialize(responsePacket, mstream); response.ContentLength64 = mstream.Length; response.StatusCode = 200; mstream.Position = 0; mstream.CopyTo(response.OutputStream); } } catch (Exception ex) { Out.Write("General Exception"); Out.Write(ex.Message); Out.Write(ex.StackTrace); response.StatusCode = 500; } finally { response.OutputStream.Close(); } }
public void WhenTypeIsNotSupported_Deserialization_ThrowsNotSupportedException() { Check.ThatCode(() => _serializer.Deserialize(_serializatedMockPacket)).Throws <NotSupportedException>(); }
public IPacket Unformat(byte id, byte[] data, int index, int count) { #region " Client Packets " switch ((AresId)id) { case AresId.MSG_CHAT_CLIENT_LOGIN: return(serializer.Deserialize <Login>(data, index, count)); case AresId.MSG_CHAT_CLIENT_UPDATE_STATUS: return(serializer.Deserialize <ClientUpdate>(data, index, count)); case AresId.MSG_CHAT_CLIENT_PVT: return(serializer.Deserialize <Private>(data, index, count)); case AresId.MSG_CHAT_CLIENT_PUBLIC: return(serializer.Deserialize <ClientPublic>(data, index, count)); case AresId.MSG_CHAT_CLIENT_EMOTE: return(serializer.Deserialize <ClientEmote>(data, index, count)); case AresId.MSG_CHAT_CLIENT_FASTPING: return(serializer.Deserialize <ClientFastPing>(data, index, count)); case AresId.MSG_CHAT_CLIENT_COMMAND: return(serializer.Deserialize <Command>(data, index, count)); case AresId.MSG_CHAT_CLIENT_AUTHREGISTER: return(serializer.Deserialize <AuthRegister>(data, index, count)); case AresId.MSG_CHAT_CLIENT_AUTHLOGIN: return(serializer.Deserialize <AuthLogin>(data, index, count)); case AresId.MSG_CHAT_CLIENT_AUTOLOGIN: return(serializer.Deserialize <AutoLogin>(data, index, count)); case AresId.MSG_CHAT_CLIENT_AVATAR: return(serializer.Deserialize <ClientAvatar>(data, index, count)); case AresId.MSG_CHAT_CLIENT_PERSONAL_MESSAGE: return(serializer.Deserialize <ClientPersonal>(data, index, count)); case AresId.MSG_CHAT_CLIENT_ADDSHARE: return(serializer.Deserialize <SharedFile>(data, index, count)); case AresId.MSG_CHAT_CLIENT_REMSHARE: break; case AresId.MSG_CHAT_CLIENT_SEARCH: return(serializer.Deserialize <Search>(data, index, count)); case AresId.MSG_CHAT_CLIENT_BROWSE: return(serializer.Deserialize <Browse>(data, index, count)); case AresId.MSG_CHAT_CLIENT_DUMMY: break; case AresId.MSG_CHAT_CLIENT_DIRCHATPUSH: return(serializer.Deserialize <ClientDirectPush>(data, index, count)); case AresId.MSG_CHAT_CLIENT_SEND_SUPERNODES: return(serializer.Deserialize <ClientNodes>(data, index, count)); case AresId.MSG_CHAT_CLIENT_IGNORELIST: return(serializer.Deserialize <Ignored>(data, index, count)); case AresId.MSG_SERVER_TOHUB_LOGINREQ: break; case AresId.MSG_CHAT_CLIENT_CUSTOM_DATA: return(serializer.Deserialize <ClientCustom>(data, index, count)); case AresId.MSG_CHAT_CLIENT_CUSTOM_DATA_ALL: return(serializer.Deserialize <ClientCustomAll>(data, index, count)); default: { byte[] tmp = new byte[count]; Array.Copy(data, index, tmp, 0, count); return(new Unknown(id, tmp)); } } #endregion return(null); }
public IPacket Unformat(byte id, byte[] data, int index, int count) { switch ((AdvancedId)id) { case AdvancedId.MSG_CHAT_CLIENT_CUSTOM_ADD_TAGS: return(serializer.Deserialize <ClientAddTags>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_CUSTOM_REM_TAGS: return(serializer.Deserialize <ClientRemTags>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_CUSTOM_FONT: return(serializer.Deserialize <ClientFont>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_SUPPORTED: return(serializer.Deserialize <ClientVoiceSupport>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_FIRST: return(serializer.Deserialize <ClientVoiceFirst>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_FIRST_TO: return(serializer.Deserialize <ClientVoiceFirstTo>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_CHUNK: return(serializer.Deserialize <ClientVoiceChunk>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_CHUNK_TO: return(serializer.Deserialize <ClientVoiceChunkTo>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_VC_IGNORE: return(serializer.Deserialize <ClientVoiceIgnore>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_SUPPORTS_CUSTOM_EMOTES: return(serializer.Deserialize <ClientEmoteSupport>(data, index, count)); case AdvancedId.MSG_CHAT_SERVER_CUSTOM_EMOTES_ITEM: return(serializer.Deserialize <ClientEmoteItem>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_CUSTOM_EMOTE_DELETE: return(serializer.Deserialize <ClientEmoteDelete>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_ROOM_SCRIBBLE_FIRST: return(serializer.Deserialize <ClientScribbleFirst>(data, index, count)); case AdvancedId.MSG_CHAT_CLIENT_ROOM_SCRIBBLE_CHUNK: return(serializer.Deserialize <ClientScribbleChunk>(data, index, count)); default: { byte[] tmp = new byte[count]; Array.Copy(data, index, tmp, 0, count); return(new Unknown(id, tmp)); } } }
/// <summary> /// Initializes a new instance of the <see cref="PacketReceivedEventArgs"/> class. /// </summary> /// <param name="sender"></param> /// <param name="buffer"></param> /// <param name="length"></param> public PacketReceivedEventArgs(TcpClient sender, byte[] buffer, int length) { this.Sender = sender; Packet = PacketSerializer.Deserialize(buffer); }