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