Example #1
0
 /// <summary>
 /// Wendet alle Filter der Reihe nach an
 /// </summary>
 /// <param name="packet"></param>
 private void applyFilters(L2BasePacket packet)
 {
     foreach (IPacketFilter f in filter)
     {
         f.FilterPacket(packet);
     }
 }
Example #2
0
 public void FilterPacket(L2BasePacket packet)
 {
     if (packet.FromServer)
     {
         this.serverPacket(packet);
     }
     else
     {
         this.clientPacket(packet);
     }
 }
Example #3
0
        /// <summary>
        /// Liefert das nächste L2Basepacket aus der ReadQueue zurück und entfernt es aus der Readqueue.
        /// Ist kein L2BasePacket vorhanden wird null zurückgeliefert!
        /// </summary>
        /// <returns>Das L2BasePacket oder null</returns>
        public L2BasePacket GetPacket()
        {
            L2BasePacket p = null;

            if (this.readQueue.Count > 0)
            {
                // syncronize
                lock (this.readQueue)
                {
                    p = this.readQueue.Dequeue();
                }
            }
            return(p);
        }
Example #4
0
        private void clientPacket(L2BasePacket packet)
        {
            int opcode = packet.GetOpcode();

            switch (opcode)
            {
                case 0x0e: // Protcolversion
                    packet.Data.SetIndex(2);
                    packet.Data.ReadByte(); //Opcode
                    packet.Data.WriteUInt32(828); // Protocolversion
                    break;
                default:
                    break;
            }
        }
Example #5
0
        public void Send(L2BasePacket packet)
        {
            byte[] size = BitConverter.GetBytes((uint)packet.Data.Length());
            packet.Data[0] = size[0];
            packet.Data[1] = size[1];

            // encrypt the packet
            this.cryptor.Encrypt(packet.Data.GetData(), 2, packet.Data.Length());

            // syncronize
            lock (this.sendQueue)
            {
                this.sendQueue.Enqueue(packet);
            }
            // Wake up the SendThread
            //this.sendThread.Interrupt();
        }
Example #6
0
        public void Send(L2BasePacket packet)
        {
            byte[] size = BitConverter.GetBytes((uint)packet.Data.Length());
            packet.Data[0] = size[0];
            packet.Data[1] = size[1];

            // encrypt the packet
            this.cryptor.Encrypt(packet.Data.GetData(), 2, packet.Data.Length());

            // syncronize
            lock (this.sendQueue)
            {
                this.sendQueue.Enqueue(packet);
            }
            // Wake up the SendThread
            //this.sendThread.Interrupt();
        }
Example #7
0
        private void serverPacket(L2BasePacket packet)
        {
            int opcode = packet.GetOpcode();

            switch (opcode)
            {
                case 0x2e: //keypacket
                    packet.Data.SetIndex(3);
                    packet.Data.ReadByte();
                    packet.Data.ReadBytes(8);
                    packet.Data.WriteInt32(0x01);
                    packet.Data.WriteInt32(0x01);
                    packet.Data.WriteByte(0x00);
                    packet.Data.WriteInt32(0x00);
                    break;
                default:
                    break;
            }
        }
Example #8
0
 public void FilterPacket(L2BasePacket packet)
 {
     // Do Nothing
 }
Example #9
0
 public void FilterPacket(L2BasePacket packet)
 {
 }
Example #10
0
 /// <summary>
 /// Sendet ein selbst erstelltes Packet zum Server
 /// </summary>
 /// <param name="packet"></param>
 public void SendPacketToServer(L2BasePacket packet)
 {
     this.gameServerCon.Send(packet);
 }
Example #11
0
 /// <summary>
 /// Wendet alle Filter der Reihe nach an
 /// </summary>
 /// <param name="packet"></param>
 private void applyFilters(L2BasePacket packet)
 {
     foreach (IPacketFilter f in filter)
     {
         f.FilterPacket(packet);
     }
 }
Example #12
0
 /// <summary>
 /// Sendet ein selbst erstelltes Packet zum Server
 /// </summary>
 /// <param name="packet"></param>
 public void SendPacketToServer(L2BasePacket packet)
 {
     this.gameServerCon.Send(packet);
 }
Example #13
0
 /// <summary>
 /// Sendet ein selbst erstelltes Packet zum Clienten
 /// </summary>
 /// <param name="packet"></param>
 public void SendPacketToClient(L2BasePacket packet)
 {
     this.gameClientCon.Send(packet);
 }
Example #14
0
        private void loginProxyWorker()
        {
            TcpListener clientListener = new TcpListener(this.loginListeningEndPoint);

            Console.Out.WriteLine("Warte auf Verbindung...");
            clientListener.Start();
            try
            {
                TcpClient client = clientListener.AcceptTcpClient();
                this.loginClientCon = new Connection(client, this.loginCryptClient);
                Console.Out.WriteLine("Client auf Login verbunden.");

                TcpClient serverClient = new TcpClient(this.loginDestinationEndPoint.Address.ToString()
                                                       , this.loginDestinationEndPoint.Port);
                Console.Out.WriteLine("Zu Loginserver verbunden.");
                this.loginServerCon = new Connection(serverClient, this.loginCryptServer);

                // Start to work! ^^

                while (this.loginRunning)
                {
                    // send ClientReadQueue to ServerSendQueue
                    L2BasePacket fromClient = this.loginClientCon.GetPacket();
                    if (fromClient != null)
                    {
                        // Handle Packets here
                        switch (fromClient.GetOpcode())
                        {
                        case 0x02:     // RequestServerLogin, Start gameProxyWorker!
                            Console.Out.WriteLine("ClientPacket::RequestServerLogin, starting gameProxy");
                            this.OnRequestServerLogin(fromClient.Data);
                            break;
                        }
                        this.loginServerCon.Send(fromClient);
                    }

                    // send ServerReadQueue to ClientSendQueue
                    L2BasePacket fromServer = this.loginServerCon.GetPacket();
                    if (fromServer != null)
                    {
                        // Handle Packets here
                        switch (fromServer.GetOpcode())
                        {
                        case 0x00:     // Init
                            Console.Out.WriteLine("LoginServerpacket::Init");
                            this.handleInit(fromServer.Data);
                            break;

                        case 0x04:     // Serverlist
                            Console.Out.WriteLine("LoginServerpacket::Serverlist");
                            // Modify the Serverlist
                            this.modifyServerlist(fromServer.Data);
                            break;
                        }
                        this.loginClientCon.Send(fromServer);
                    }

                    // Sleep
                    Thread.Sleep(1);
                }
                Console.Out.WriteLine("LoginProxyThread Beendet");
                client.Close();
                serverClient.Close();
            }
            catch (Exception e)
            {
                Console.Out.WriteLine(e.ToString());
            }
        }
Example #15
0
 /// <summary>
 /// Sendet ein selbst erstelltes Packet zum Clienten
 /// </summary>
 /// <param name="packet"></param>
 public void SendPacketToClient(L2BasePacket packet)
 {
     this.gameClientCon.Send(packet);
 }
Example #16
0
 public void FilterPacket(L2BasePacket packet)
 {
 }
Example #17
0
        private void gameProxyWorker()
        {
            TcpListener clientListener = new TcpListener(this.gameClientEp);

            Console.Out.WriteLine("\nWarte auf Verbindung vom GameClient");
            clientListener.Start();
            try
            {
                TcpClient client = clientListener.AcceptTcpClient();

                //this.gameClientCon = new Connection(client, this.gameCryptClient);
                this.gameClientCon = new Connection(client, new NullCrypt());

                Console.Out.WriteLine("Client auf Game verbunden.");

                TcpClient serverClient = new TcpClient(this.gameServerEp.Address.ToString()
                                                       , this.gameServerEp.Port);
                Console.Out.WriteLine("Zu Gameserver verbunden.");

                //this.gameServerCon = new Connection(serverClient, this.gameCryptServer);
                this.gameServerCon = new Connection(serverClient, new NullCrypt());

                // Work here
                while (this.gameRunning)
                {
                    L2BasePacket fromClient = this.gameClientCon.GetPacket();
                    if (fromClient != null)
                    {
                        fromClient.FromServer = false;
                        this.applyFilters(fromClient);

                        // Handle Packets here
                        switch (fromClient.GetOpcode())
                        {
                        case 0x00:
                            break;
                        }
                        this.gameServerCon.Send(fromClient);
                    }

                    // send ServerReadQueue to ClientSendQueue
                    L2BasePacket fromServer = this.gameServerCon.GetPacket();
                    if (fromServer != null)
                    {
                        fromServer.FromServer = true;
                        this.applyFilters(fromServer);

                        // Handle Packets here
                        switch (fromServer.GetOpcode())
                        {
                        case 0x2e:
                            this.onKeyPacket(fromServer.Data);
                            // We should now stop the loginProxyThread
                            this.StopLogin();
                            break;
                        }
                        this.gameClientCon.Send(fromServer);
                    }

                    // Sleep
                    Thread.Sleep(1);
                }
                Console.Out.WriteLine("GameProxyThread Beendet");
                client.Close();
                serverClient.Close();
            }
            catch (Exception e)
            {
                Console.Out.WriteLine(e.ToString());
            }
        }