コード例 #1
0
        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);
        }
コード例 #2
0
        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 { }
            }
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        public byte[] ReadFixedValue()
        {
            int len = 0;

            if (RemainingLength >= 2)
            {
                len = HabboEncoding.DecodeInt16(ReadBytes(2));
            }
            return(ReadBytes(len));
        }
コード例 #5
0
        public override int PopWiredInt32()
        {
            if (this.GetRemainingLength() < 1)
            {
                return(0);
            }
            byte[] Data = this.ReadBytes(4);

            return(HabboEncoding.DecodeInt32(Data));
        }
コード例 #6
0
        /// <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();
                }
            }
        }
コード例 #7
0
        public int PopInt()
        {
            if (RemainingLength < 4)
            {
                return(0);
            }

            byte[] Data = ReadBytes(4);

            Int32 i = HabboEncoding.DecodeInt32(Data);

            return(i);
        }
コード例 #8
0
        public int PopInt()
        {
            if (RemainingLength < 1)
            {
                return(0);
            }

            var data = PlainReadBytes(4);
            var i    = HabboEncoding.DecodeInt32(data);

            _pointer += 4;
            return(i);
        }
コード例 #9
0
ファイル: ClientMessage.cs プロジェクト: fuding/Coolmemes
        internal Int32 PopWiredInt32()
        {
            if (RemainingLength < 1)
            {
                return(0);
            }

            var Data = PlainReadBytes(4);

            var i = HabboEncoding.DecodeInt32(Data);

            Pointer += 4;

            return(i);
        }
コード例 #10
0
ファイル: ClientPacket.cs プロジェクト: Clawed/ProjectHub
        public int PopInt()
        {
            if (RemainingLength < 1)
            {
                return(0);
            }

            byte[] Data = PlainReadBytes(4);

            Int32 i = HabboEncoding.DecodeInt32(Data);

            Pointer += 4;

            return(i);
        }
コード例 #11
0
        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);
        }
コード例 #12
0
        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();
                }
            }
        }
コード例 #13
0
        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);
        }
コード例 #14
0
        public byte[] ReadFixedValue()
        {
            int len = HabboEncoding.DecodeInt16(this.ReadBytes(2));

            return(this.ReadBytes(len));
        }
コード例 #15
0
ファイル: ClientMessage.cs プロジェクト: TheNaked/Firewind
        internal byte[] ReadFixedValue()
        {
            int len = HabboEncoding.DecodeInt16(ReadBytes(2));

            return(ReadBytes(len));
        }
コード例 #16
0
        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();
                    }
                }
            }
        }
コード例 #17
0
ファイル: GameClient.cs プロジェクト: RootkitR/Essential-5.1
        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);
                }
            }
        }
コード例 #18
0
        internal byte[] ReadFixedValue()
        {
            int bytes = HabboEncoding.DecodeInt16(this.ReadBytes(2));

            return(this.ReadBytes(bytes));
        }
コード例 #19
0
        public byte[] ReadFixedValue()
        {
            var len = HabboEncoding.DecodeInt16(ReadBytes(2));

            return(ReadBytes(len));
        }
コード例 #20
0
        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);
            }
        }
コード例 #21
0
        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);
            }
        }
コード例 #22
0
ファイル: ClientMessage.cs プロジェクト: fuding/Coolmemes
 internal string PopFixedString()
 {
     return(OtanixEnvironment.GetDefaultEncoding().GetString(ReadBytes(HabboEncoding.DecodeInt16(ReadBytes(2)))));
 }
コード例 #23
0
        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);
            }
        }
コード例 #24
0
 public override short ReadInt16()
 {
     return((short)HabboEncoding.DecodeInt16(this.ReadBytes(2)));
 }
コード例 #25
0
        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);
            }
        }
コード例 #26
0
ファイル: ServerPacketParser.cs プロジェクト: dm5wg/Yupi
        /// <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");
                }
            }
        }
コード例 #27
0
 public override int ReadInt32()
 {
     return(HabboEncoding.DecodeInt32(this.ReadBytes(4)));
 }
コード例 #28
0
        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);
            }
        }