public override bool HandlePacket(GameClient session, ref byte[] packet)
{
for (int i = 0; i < packet.Length; i++)
{
if (this.ReadByte(packet[i]))
{
NewCryptoClientMessage message = new NewCryptoClientMessage();
message.Init((uint)HabboEncoding.DecodeInt16(new byte[] { this.Packet[0], this.Packet[1] }), this.Packet);
message.Skip(2);
session.HandlePacket(message);
Array.Clear(this.Packet, 0, this.Packet.Length);
this.Packet = null;
this.Lenght = null;
this.LenghtBytes = null;
this.Pointer = 0;
if (session.Disconnected)
{
return(false); //packet disconnected the user! :D
}
}
}
return(true);
}
public void handlePacketData(byte[] data)
{
int position = 0;
while (position < data.Length)
{
try
{
var MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[position++], data[position++], data[position++], data[position++] });
if (MessageLength < 2 || MessageLength > 4096)
{
continue;
}
var MessageId = HabboEncoding.DecodeInt16(new byte[] { data[position++], data[position++] });
var Content = new byte[MessageLength - 2];
Buffer.BlockCopy(data, position, Content, 0, MessageLength - 2);
position += MessageLength - 2;
if (onNewPacket != null)
{
using (ClientMessage message = ClientMessageFactory.GetClientMessage(MessageId, Content))
{
onNewPacket.Invoke(message);
}
}
}
catch { }
}
}
private ClientMessage TryParseAsNewCrypto(byte[] packet)
{
try
{
int i = 0;
while (i < packet.Length)
{
int lenght = HabboEncoding.DecodeInt32(new byte[] { (byte)packet[i++], (byte)packet[i++], (byte)packet[i++], (byte)packet[i++] });
if (lenght > 0)
{
uint id = (uint)HabboEncoding.DecodeInt16(new byte[] { (byte)packet[i++], (byte)packet[i++] });
if (id > 0)
{
byte[] bytes = new byte[lenght - 2];
for (int j = 0; j < bytes.Length; j++)
{
bytes[j] = packet[i++];
}
NewCryptoClientMessage crypto = new NewCryptoClientMessage();
crypto.Init(id, bytes);
return(crypto);
}
}
}
}
catch
{
return(null);
}
return(null);
}
public byte[] ReadFixedValue()
{
int len = 0;
if (RemainingLength >= 2)
{
len = HabboEncoding.DecodeInt16(ReadBytes(2));
}
return(ReadBytes(len));
}
public override int PopWiredInt32()
{
if (this.GetRemainingLength() < 1)
{
return(0);
}
byte[] Data = this.ReadBytes(4);
return(HabboEncoding.DecodeInt32(Data));
}
/// <summary>
/// Handles the packet data.
/// </summary>
/// <param name="data">The data.</param>
public void HandlePacketData(byte[] data)
{
var i = 0;
if (data.Length == 0)
{
return;
}
while (i < data.Length)
{
if (data.Length - i < 6)
{
return;
}
short messageId = 0;
try
{
var length = HabboEncoding.DecodeInt32(new[]
{
data[i++],
data[i++],
data[i++],
data[i++]
});
if (length < 2 || length > 4096)
{
return;
}
messageId = HabboEncoding.DecodeInt16(new[]
{
data[i++],
data[i++]
});
var packetContent = new byte[length - 2];
var num2 = 0;
while (num2 < packetContent.Length && i < data.Length)
{
packetContent[num2] = data[i++];
num2++;
}
if (OnNewPacket == null)
{
continue;
}
using (var clientMessage = Factorys.GetClientMessage(messageId, packetContent)) OnNewPacket(clientMessage);
}
catch (Exception exception)
{
Logging.HandleException(exception, string.Format("packet handling ----> {0}", messageId));
_con.Dispose();
}
}
}
public int PopInt()
{
if (RemainingLength < 4)
{
return(0);
}
byte[] Data = ReadBytes(4);
Int32 i = HabboEncoding.DecodeInt32(Data);
return(i);
}
public int PopInt()
{
if (RemainingLength < 1)
{
return(0);
}
var data = PlainReadBytes(4);
var i = HabboEncoding.DecodeInt32(data);
_pointer += 4;
return(i);
}
internal Int32 PopWiredInt32()
{
if (RemainingLength < 1)
{
return(0);
}
var Data = PlainReadBytes(4);
var i = HabboEncoding.DecodeInt32(Data);
Pointer += 4;
return(i);
}
public int PopInt()
{
if (RemainingLength < 1)
{
return(0);
}
byte[] Data = PlainReadBytes(4);
Int32 i = HabboEncoding.DecodeInt32(Data);
Pointer += 4;
return(i);
}
internal int PopWiredInt32()
{
if (isMobile)
{
return(int.Parse(MobileBody[Pointer++]));
}
if (this.RemainingLength < 1)
{
return(0);
}
int num = HabboEncoding.DecodeInt32(this.PlainReadBytes(4));
this.Pointer += 4;
return(num);
}
public void handlePacketData(byte[] data)
{
int pos = 0;
while (pos < data.Length)
{
try
{
int MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++], data[pos++] });
if (MessageLength < 2 || MessageLength > 1024)
{
//Logging.WriteLine("bad size packet!");
continue;
}
int MessageId = HabboEncoding.DecodeInt16(new byte[] { data[pos++], data[pos++] });
byte[] Content = new byte[MessageLength - 2];
for (int i = 0; i < Content.Length && pos < data.Length; i++)
{
Content[i] = data[pos++];
}
//Logging.WriteLine("[REQUEST] [" + MessageId + " / len: " + MessageLength + "] => " + Encoding.Default.GetString(Content).Replace(Convert.ToChar(0).ToString(), "{char0}"));
if (onNewPacket != null)
{
using (ClientMessage message = ClientMessageFactory.GetClientMessage(MessageId, Content))
{
onNewPacket.Invoke(message);
}
}
}
catch (Exception e)
{
int MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++], data[pos++] });
int MessageId = HabboEncoding.DecodeInt16(new byte[] { data[pos++], data[pos++] });
Logging.HandleException(e, "packet handling ----> " + MessageId);
con.Dispose();
}
}
}
public bool ReadByte(byte byte_) //returns if packet is fully readed
{
if (this.Lenght != null)
{
if (this.Packet == null)
{
this.Packet = new byte[(int)this.Lenght];
}
this.Packet[this.Pointer++] = byte_;
}
else
{
if (this.LenghtBytes == null)
{
this.LenghtBytes = new byte?[4] {
null, null, null, null
};
}
int i = 0;
for (; i < this.LenghtBytes.Length; i++)
{
if (this.LenghtBytes[i] == null)
{
this.LenghtBytes[i] = byte_;
break;
}
}
if (i == 3)
{
this.Lenght = HabboEncoding.DecodeInt32(new byte[] { (byte)this.LenghtBytes[0], (byte)this.LenghtBytes[1], (byte)this.LenghtBytes[2], (byte)this.LenghtBytes[3] });
}
return(false);
}
return(this.Pointer == this.Packet.Length);
}
public byte[] ReadFixedValue()
{
int len = HabboEncoding.DecodeInt16(this.ReadBytes(2));
return(this.ReadBytes(len));
}
internal byte[] ReadFixedValue()
{
int len = HabboEncoding.DecodeInt16(ReadBytes(2));
return(ReadBytes(len));
}
public void handlePacketData(byte[] data)
{
int i = 0;
if (currentClient != null && currentClient.ARC4 != null)
{
currentClient.ARC4.Decrypt(ref data);
}
checked
{
while (i < data.Length)
{
try
{
int num = HabboEncoding.DecodeInt32(new byte[]
{
data[i++],
data[i++],
data[i++],
data[i++]
});
if (num >= 2 && num <= 1024)
{
int messageId = HabboEncoding.DecodeInt16(new byte[]
{
data[i++],
data[i++]
});
byte[] array = new byte[num - 2];
int num2 = 0;
while (num2 < array.Length && i < data.Length)
{
array[num2] = data[i++];
num2++;
}
if (this.onNewPacket != null)
{
using (ClientMessage clientMessage = ClientMessageFactory.GetClientMessage(messageId, array))
{
this.onNewPacket(clientMessage);
}
}
}
}
catch (Exception pException)
{
HabboEncoding.DecodeInt32(new byte[]
{
data[i++],
data[i++],
data[i++],
data[i++]
});
int num3 = HabboEncoding.DecodeInt16(new byte[]
{
data[i++],
data[i++]
});
Logging.HandleException(pException, "packet handling ----> " + num3);
this.con.Dispose();
}
}
}
}
public void ParsePacket(ref byte[] bytes)
{
//Console.WriteLine(Essential.GetDefaultEncoding().GetString(bytes));
string Packet = Essential.GetDefaultEncoding().GetString(bytes);
if (Essential.GetDefaultEncoding().GetString(bytes) == "<policy-file-request/>" + (char)0)
{
this.Connection.SendMessage(CrossdomainPolicy.GetXmlPolicy());
}
else if (Packet.StartsWith("GET") || Packet.StartsWith("POST"))
{
Essential.GetWebManager().HandleRequest(Packet, this.GetConnection());
}
/*if(Packet.StartsWith("imaphone"))
* {
* //Essential.GetMobileHandler().HandleRequest(Packet, this);
* }*/
int index = 0;
while (index < bytes.Length)
{
try
{
// I tried to make a mobile Version of Habbo, but didn't continue it. If you want I could continue the developing of Essential Mobile
if (!Packet.StartsWith("mobile"))
{
#region "Normal Part"
int MessageLength = HabboEncoding.DecodeInt32(new byte[] { bytes[index++], bytes[index++], bytes[index++], bytes[index++] });
if (MessageLength < 2 || MessageLength > 1024)
{
//Console.WriteLine("bad size packet!");
continue;
}
int MessageId = HabboEncoding.DecodeInt16(new byte[] { bytes[index++], bytes[index++] });
byte[] Content = new byte[MessageLength - 2];
for (int i = 0; i < Content.Length && index < bytes.Length; i++)
{
Content[i] = bytes[index++];
}
if (MessageId == 1615)
{
return;
}
Interface messageInterface;
ClientMessage cMessage = new ClientMessage((uint)MessageId, Content);
if (cMessage != null)
{
if (Essential.GetPacketManager().Handle((uint)MessageId, out messageInterface))
{
try
{
/* Logging.WriteLine(string.Concat(new object[]
* {
* "[INCOMING] ",
* "[",
* messageInterface.GetType().Name.ToString(),
* "] --> [",
* cMessage.Id,
* "] ",
* cMessage.ToString()
* }));*/
messageInterface.Handle(this, cMessage);
}
catch (Exception ex)
{
Logging.LogException("Error: " + ex.ToString());
}
}
}
#endregion
}
else
{
#region "Mobile Part"
if (Packet.Length < 2 || Packet.Length > 1024)
{
continue;
}
this.IsMobileUser = true;
this.GetConnection().IsMobileUser = true;
Interface messageInterface;
uint MessageId = uint.Parse(Packet.Split((char)1)[1]);
ClientMessage cMessage = new ClientMessage((uint)MessageId, null, true, Packet);
if (cMessage != null)
{
if (Essential.GetPacketManager().Handle((uint)MessageId, out messageInterface))
{
try
{
/* Logging.WriteLine(string.Concat(new object[]
* {
* "[INCOMING] ",
* "[",
* messageInterface.GetType().Name.ToString(),
* "] --> [",
* cMessage.Id,
* "] ",
* cMessage.ToString()
* }));*/
messageInterface.Handle(this, cMessage);
break;
}
catch (Exception ex)
{
Logging.LogException("Error: " + ex.ToString());
}
}
}
#endregion
}
}
catch (Exception e)
{
if (e.GetType() == typeof(IndexOutOfRangeException))
{
return;
}
if (e.GetType() == typeof(NullReferenceException))
{
return;
}
Logging.LogException("Error: " + e.ToString());
ServerMessage ServerError = new ServerMessage(Outgoing.ServerError);
ServerError.AppendInt32(1);
ServerError.AppendInt32(1);
ServerError.AppendString(DateTime.Now.ToShortDateString().ToString());
this.SendMessage(ServerError);
}
}
}
internal byte[] ReadFixedValue()
{
int bytes = HabboEncoding.DecodeInt16(this.ReadBytes(2));
return(this.ReadBytes(bytes));
}
public byte[] ReadFixedValue()
{
var len = HabboEncoding.DecodeInt16(ReadBytes(2));
return(ReadBytes(len));
}
public void handlePacketData(byte[] Data, bool deciphered = false)
{
try
{
if (onNewPacket == null)
{
return;
}
if (Data[0] == 71 && Data[1] == 69)
{
PolicyRequest(Data);
return;
}
try
{
Data = EncodeDecode.DecodeMessage(Data);
}
catch
{
return;
}
using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data)))
{
if (Data.Length < 4)
{
return;
}
int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4));
if ((Reader.BaseStream.Length) < MsgLen)
{
return;
}
if (MsgLen < 0 || MsgLen > 5120)
{
return;
}
byte[] Packet = Reader.ReadBytes(MsgLen);
using (BinaryReader R = new BinaryReader(new MemoryStream(Packet)))
{
int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2));
byte[] Content = new byte[Packet.Length - 2];
Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2);
ClientPacket Message = new ClientPacket(Header, Content);
onNewPacket.Invoke(Message);
}
}
}
catch (Exception e)
{
Console.WriteLine("Packet Error! " + e);
}
}
public void HandlePacketData(byte[] data)
{
try
{
if (_client.Rc4Client != null && !_deciphered)
{
_client.Rc4Client.Decrypt(ref data);
_deciphered = true;
}
if (_halfDataRecieved)
{
byte[] fullDataRcv = new byte[_halfData.Length + data.Length];
Buffer.BlockCopy(_halfData, 0, fullDataRcv, 0, _halfData.Length);
Buffer.BlockCopy(data, 0, fullDataRcv, _halfData.Length, data.Length);
_halfDataRecieved = false; // mark done this round
HandlePacketData(fullDataRcv); // repeat now we have the combined array
return;
}
using (BinaryReader reader = new BinaryReader(new MemoryStream(data)))
{
if (data.Length < 4)
{
return;
}
int msgLen = HabboEncoding.DecodeInt32(reader.ReadBytes(4));
if ((reader.BaseStream.Length - 4) < msgLen)
{
_halfData = data;
_halfDataRecieved = true;
return;
}
if (msgLen < 0 || msgLen > 5120)//TODO: Const somewhere.
{
return;
}
byte[] packet = reader.ReadBytes(msgLen);
using (BinaryReader r = new BinaryReader(new MemoryStream(packet)))
{
int header = HabboEncoding.DecodeInt16(r.ReadBytes(2));
byte[] content = new byte[packet.Length - 2];
Buffer.BlockCopy(packet, 2, content, 0, packet.Length - 2);
ClientPacket message = new ClientPacket(header, content);
OnNewPacket.Invoke(message);
_deciphered = false;
}
if (reader.BaseStream.Length - 4 > msgLen)
{
byte[] extra = new byte[reader.BaseStream.Length - reader.BaseStream.Position];
Buffer.BlockCopy(data, (int)reader.BaseStream.Position, extra, 0, (int)(reader.BaseStream.Length - reader.BaseStream.Position));
_deciphered = true;
HandlePacketData(extra);
}
}
}
#pragma warning disable CS0168 // The variable 'e' is declared but never used
catch (Exception e)
#pragma warning restore CS0168 // The variable 'e' is declared but never used
{
//log.Error("Packet Error!", e);
}
}
internal string PopFixedString()
{
return(OtanixEnvironment.GetDefaultEncoding().GetString(ReadBytes(HabboEncoding.DecodeInt16(ReadBytes(2)))));
}
public void handlePacketData(byte[] Data)
{
try
{
if (currentClient.RC4Client != null && !_deciphered)
{
currentClient.RC4Client.Decrypt(ref Data);
_deciphered = true;
}
if (_halfDataRecieved)
{
byte[] FullDataRcv = new byte[_halfData.Length + Data.Length];
Buffer.BlockCopy(_halfData, 0, FullDataRcv, 0, _halfData.Length);
Buffer.BlockCopy(Data, 0, FullDataRcv, _halfData.Length, Data.Length);
_halfDataRecieved = false; // mark done this round
handlePacketData(FullDataRcv); // repeat now we have the combined array
return;
}
using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data)))
{
if (Data.Length < 4)
{
return;
}
int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4));
if ((Reader.BaseStream.Length - 4) < MsgLen)
{
_halfData = Data;
_halfDataRecieved = true;
return;
}
else if (MsgLen < 0 || MsgLen > 5120)//TODO: Const somewhere.
{
return;
}
byte[] Packet = Reader.ReadBytes(MsgLen);
using (BinaryReader R = new BinaryReader(new MemoryStream(Packet)))
{
int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2));
byte[] Content = new byte[Packet.Length - 2];
Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2);
ClientPacket Message = new ClientPacket(Header, Content);
OnNewPacket.Invoke(Message);
_deciphered = false;
}
if (Reader.BaseStream.Length - 4 > MsgLen)
{
byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position];
Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, (int)(Reader.BaseStream.Length - Reader.BaseStream.Position));
_deciphered = true;
handlePacketData(Extra);
}
}
}
catch (Exception e)
{
log.Error("Packet Error!", e);
}
}
public override short ReadInt16()
{
return((short)HabboEncoding.DecodeInt16(this.ReadBytes(2)));
}
public void handlePacketData(byte[] Data, bool deciphered = false)
{
try
{
if (OnNewPacket == null)
{
return;
}
if (Data.Length >= 2)
{
if (Data[0] == 60 && Data[1] == 112)
{
this.currentClient.GetConnection().SendData(Encoding.Default.GetBytes(GetXmlPolicy()));
}
}
if (currentClient != null && !deciphered)
{
//currentClient.RC4Client.Decrypt(ref Data);
}
if (this._halfDataRecieved)
{
byte[] FullDataRcv = new byte[this._halfData.Length + Data.Length];
Buffer.BlockCopy(this._halfData, 0, FullDataRcv, 0, this._halfData.Length);
Buffer.BlockCopy(Data, 0, FullDataRcv, this._halfData.Length, Data.Length);
this._halfDataRecieved = false; // mark done this round
handlePacketData(FullDataRcv); // repeat now we have the combined array
return;
}
using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data)))
{
if (Data.Length < 4)
{
return;
}
int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4));
if (MsgLen <= 0 || MsgLen > (5120 * 2))
{
return;
}
if ((Reader.BaseStream.Length - 4) < MsgLen)
{
this._halfData = Data;
this._halfDataRecieved = true;
return;
}
byte[] Packet = Reader.ReadBytes(MsgLen);
using (BinaryReader R = new BinaryReader(new MemoryStream(Packet)))
{
int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2));
byte[] Content = new byte[Packet.Length - 2];
Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2);
ClientPacket Message = new ClientPacket(Header, Content);
OnNewPacket.Invoke(Message);
}
if (Reader.BaseStream.Length - 4 > MsgLen)
{
byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position];
Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, ((int)Reader.BaseStream.Length - (int)Reader.BaseStream.Position));
handlePacketData(Extra, true);
}
}
}
catch (Exception e)
{
Console.WriteLine("Packet Error! " + e);
}
}
/// <summary>
/// Handles the packet data.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="length">The length.</param>
public void HandlePacketData(byte[] data, int length)
{
if (length > 0 && _currentClient != null)
{
try
{
int pos;
for (pos = 0; pos < length;)
{
if (_currentPacketLength == -1)
{
if (length < IntSize)
{
BufferCopy(data, length);
break;
}
_currentPacketLength = HabboEncoding.DecodeInt32(data, ref pos);
}
if (_currentPacketLength < 2 || _currentPacketLength > 4096)
{
_currentPacketLength = -1;
break;
}
short messageId = 0;
if (_currentPacketLength == length - pos + _bufferPos)
{
if (_bufferPos != 0)
{
BufferCopy(data, length, pos);
pos = 0;
messageId = HabboEncoding.DecodeInt16(_bufferedData, ref pos);
HandleMessage(messageId, _bufferedData, 2, _currentPacketLength);
}
else
{
messageId = HabboEncoding.DecodeInt16(data, ref pos);
HandleMessage(messageId, data, pos, _currentPacketLength);
}
pos = length;
_currentPacketLength = -1;
}
else
{
int remainder = length - pos - (_currentPacketLength - _bufferPos);
if (_bufferPos != 0)
{
int toCopy = remainder - _bufferPos;
BufferCopy(data, toCopy, pos);
int zero = 0;
messageId = HabboEncoding.DecodeInt16(_bufferedData, ref zero);
HandleMessage(messageId, _bufferedData, 2, _currentPacketLength);
}
else
{
messageId = HabboEncoding.DecodeInt16(data, ref pos);
HandleMessage(messageId, data, pos, _currentPacketLength);
// ReSharper disable once RedundantAssignment
pos -= 2;
}
_currentPacketLength = -1;
pos = length - remainder;
}
}
}
catch (Exception exception)
{
ServerLogManager.LogException(exception, "Yupi.Net.Packets.ServerPacketParser.HandlePacketData");
}
}
}
public override int ReadInt32()
{
return(HabboEncoding.DecodeInt32(this.ReadBytes(4)));
}
public void HandlePacketData(byte[] Data)
{
try
{
if (CurrentClient.RC4Client != null && !Deciphered)
{
CurrentClient.RC4Client.Decrypt(ref Data);
Deciphered = true;
}
if (HalfDataRecieved)
{
byte[] FullDataRcv = new byte[HalfData.Length + Data.Length];
Buffer.BlockCopy(HalfData, 0, FullDataRcv, 0, HalfData.Length);
Buffer.BlockCopy(Data, 0, FullDataRcv, HalfData.Length, Data.Length);
HalfDataRecieved = false;
HandlePacketData(FullDataRcv);
return;
}
using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data)))
{
if (Data.Length < 4)
{
return;
}
int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4));
if ((Reader.BaseStream.Length - 4) < MsgLen)
{
HalfData = Data;
HalfDataRecieved = true;
return;
}
else if (MsgLen < 0 || MsgLen > 5120)
{
return;
}
byte[] Packet = Reader.ReadBytes(MsgLen);
using (BinaryReader R = new BinaryReader(new MemoryStream(Packet)))
{
int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2));
byte[] Content = new byte[Packet.Length - 2];
Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2);
ClientPacket Message = new ClientPacket(Header, Content);
OnNewPacket.Invoke(Message);
Deciphered = false;
}
if (Reader.BaseStream.Length - 4 > MsgLen)
{
byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position];
Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, (int)(Reader.BaseStream.Length - Reader.BaseStream.Position));
Deciphered = true;
HandlePacketData(Extra);
}
}
}
catch (Exception e)
{
//log.Error("Packet Error!", e);
}
}
