Beispiel #1
0
        private void Client_BeginReceive(IAsyncResult ar)
        {
            try
            {
                if (_client.EndReceive(ar) > 0)
                {
                    _buffer = new byte[BitConverter.ToInt16(_buffer, 0) - 2];

                    if (_buffer.Length > 10000) //ignore packets that are bigger then 10kb
                    {
                        return;
                    }

                    if (_buffer.Length > 0)
                    {
                        _client.Receive(_buffer, 0, _buffer.Length, SocketFlags.Partial);

                        _buffer = CryptEngine.Crypt(_buffer);

                        //Process the packet.
                        Type pck = ClientPacketProcessor.ProcessPacket(_buffer);
                        if (pck != null)
                        {
                            ReceiveBasePacket rbp = (ReceiveBasePacket)Activator.CreateInstance(pck, this, _buffer);
                            rbp.Run();
                        }

                        Read();
                        return;
                    }
                }
            }
            catch
            {
                if (!_client.Connected)
                {
                    TryToConnect();
                }
            }
        }
Beispiel #2
0
        private void ReadCallbackStatic(IAsyncResult ar)
        {
            try
            {
                if (_socket.EndReceive(ar) > 1)
                {
                    if (_FloodProtector.HandleFlood(_socket.RemoteEndPoint) == false)
                    {
                        Disconnect();
                        return;
                    }

                    //Get length from the buffer, convert to Int16 and read the rest of the packet.
                    _buffer = new byte[BitConverter.ToInt16(_buffer, 0) - 2]; //-2 for the length, we already read that :P

                    if (_buffer.Length > 10000)                               //ignore packets that are bigger then 10kb
                    {
                        return;
                    }

                    if (_buffer.Length > 0)
                    {
                        _socket.Receive(_buffer, _buffer.Length, SocketFlags.Partial);
                        _buffer = CryptEngine.Crypt(_buffer, NetworkKey);
                        Type pck = ClientPacketProcessor.ProcessPacket(_buffer, _socket.RemoteEndPoint.ToString());
                        if (pck != null)
                        {
                            ReceiveBasePacket rbp = (ReceiveBasePacket)Activator.CreateInstance(pck, this, _buffer);
                            rbp.Run();
                            settings.ReceivedPackets++;
                        }
                        else
                        {
                            //unknown packet received
                            Disconnect();
                            return;
                        }

                        Read();
                        return;
                    }
                    else
                    {
                        //Disconnect when no length is given... maybe flood? just disconnect :P
                        Disconnect();
                        return;
                    }
                }
                else
                {
                    Disconnect();
                    return;
                }
            }
            catch
            {
                if (!_socket.Connected)
                {
                    Disconnect();
                }
                return;
            }
        }
Beispiel #3
0
        private void ReadCallbackStatic(IAsyncResult ar)
        {
            try
            {
                if (_socket.EndReceive(ar) > 1)
                {
                    if (_FloodProtector.HandleFlood(_socket.RemoteEndPoint) == false)
                    {
                        //Disconnect();
                        //return;
                    }


                    //Get length from the buffer, convert to Int16 and read the rest of the packet.

                    if (_buffer[0] == 0 && _buffer[1] == 0)
                    {
                        Read();
                        return;
                    }

                    try
                    {
                        _buffer = new byte[BitConverter.ToInt16(_buffer, 0) - 2];
                    }
                    catch
                    {
                        //Sometimes here is a error because the first 2 bytes are '0'
                        //I really don't know how to fix that... so lets ignore it :P
                    }

                    if (_buffer.Length > 0)
                    {
                        settings.ReceivedPackets++;
                        _socket.Receive(_buffer, _buffer.Length, SocketFlags.Partial);
                        _buffer = CryptEngine.Crypt(_buffer, NetworkKey);
                        Type pck = FileClientPacketProcessor.ProcessPacket(_buffer, _socket.RemoteEndPoint.ToString());
                        if (pck != null)
                        {
                            ReceiveBasePacket rbp = (ReceiveBasePacket)Activator.CreateInstance(pck, this, _buffer);
                            rbp.Run();
                        }
                        else
                        {
                            //unknown packet received
                            //Disconnect();
                            Read();
                            return;
                        }

                        Read();
                        return;
                    }
                    else
                    {
                        //Disconnect when no length is given... maybe flood? just disconnect :P
                        //Disconnect();
                        Read();
                        return;
                    }
                }
                else
                {
                    //Disconnect();
                    Read();
                    return;
                }
            }
            catch
            {
                //if(!_socket.Connected)
                //    Disconnect();
                Read();
                return;
            }
        }