Creating A Packet Filter.

[alex21]

Ok i have never before tried networking in my programming, so this is the first time i have tried anything like this. But i am trying to make an application which acts as a medium between a server and client, originally the client would communicate directly to the server, but in this case i am trying to filter the packets and remove the ones i don't want. So i created a packet filtering class, which accepts a connection from the client, and connects to the server, i then tried using two separate threads to send the packets received from the server to the client, and receive the packets from the client to send to the server.

So effectively(i have not tried to filter packets yet) the client and server should be communicating exactly the same, except through my application, however this is not the case, and with my lack of experience in sockets i cannot figure out why.

Some good things, the client connects to my application when i click login, however it then freezes waiting for the return packet from the server which i must never get.

Here is the class:

public static class PacketFilter
    {
        static int BufferSize = 4096;
 
        static Server RedirectToServer;
 
        static bool ConnectingToClient = false;
        static Socket ClientConnection;
        static byte[] RecievedFromClient = new byte[BufferSize];
 
        static bool ConnectingToServer = false;
        static Socket ServerConnection;
        static byte[] RecievedFromServer = new byte[BufferSize];
 
        static Thread ClientConnectionThread = new Thread(new ThreadStart(ClientConnectionThread_Tick));
        static Thread ServerConnectionThread = new Thread(new ThreadStart(ServerConnectionThread_Tick));
 
        public static void Start(Server server)
        {
            RedirectToServer = server;
 
            ClientConnectionThread.Start();
            ServerConnectionThread.Start();
 
            ClientConnect(true);
            ServerConnect(true);
        }
 
        public static void End()
        {
            try
            {
                ClientConnection.Close();
                ServerConnection.Close();
            }
            catch (Exception e)
            {
                MessageBox.Show("Failed to close sockets, " + e.Message);
            }
        }
 
        public static void ClientConnect(bool connect)
        {
            ConnectingToClient = true;
 
            ClientConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep = new IPEndPoint(Dns.GetHostEntry("localhost").AddressList[0], (int)Main.UserInterfaceSettings.ClientPacketListenPort);
            try
            {
                ClientConnection.Bind(ep);
                ClientConnection.Listen(5);
                ClientConnection.BeginAccept(ClientConnect_Complete, ClientConnection);
            }
            catch (Exception) { ConnectingToClient = false; }
        }
 
        public static void ClientConnect_Complete(IAsyncResult sock)
        {
            try
            {
                ClientConnection = ClientConnection.EndAccept(sock);
            }
            catch (Exception) { }
            ConnectingToClient = false;
        }
 
        public static void ServerConnect(bool connect)
        {
            ConnectingToServer = true;
 
            ServerConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep = new IPEndPoint(RedirectToServer.ReturnServerAddress(), (int)RedirectToServer.ReturnPort());
            try
            {
                ServerConnection.BeginConnect(ep, ServerConnect_Complete, ServerConnection);
            }
            catch (Exception) { ConnectingToServer = false; }
        }
 
        public static void ServerConnect_Complete(IAsyncResult sock)
        {
            try { ServerConnection.EndConnect(sock); }
            catch (Exception) {  }
            ConnectingToServer = false;
        }
 
        public static void ClientConnectionThread_Tick()
        {
            while (!Program.EndProgram)
            {
                if (ClientConnection != null)
                {
                    if (ClientConnection.Connected)
                    {
                        try
                        {
                            ClientConnection.BeginSend(RecievedFromServer, 0, RecievedFromServer.Length, SocketFlags.None, ClientConnectionSend, ClientConnection);
                            ClientConnection.BeginReceive(RecievedFromClient, 0, RecievedFromClient.Length, SocketFlags.None, ClientConnectionRecieve, ClientConnection);
                        }
                        catch (Exception) { }
                    }
                    else
                        if (!ConnectingToClient)
                            ClientConnect(true);
                }
                else
                    if (!ConnectingToClient)
                        ClientConnect(true);
 
                Thread.Sleep(1);
            }
        }
 
        public static void ClientConnectionRecieve(IAsyncResult sock)
        {
            try
            {
                ClientConnection.EndReceive(sock);
            }
            catch (Exception) { }
        }
 
        public static void ClientConnectionSend(IAsyncResult sock)
        {
            try
            {
                ClientConnection.EndSend(sock);
                RecievedFromServer = new byte[BufferSize];
            }
            catch (Exception) { }
        }
 
        public static void ServerConnectionThread_Tick()
        {
            while (!Program.EndProgram)
            {
                if (ServerConnection != null)
                {
                    if (ServerConnection.Connected)
                    {
                        try
                        {
                            ServerConnection.BeginSend(RecievedFromClient, 0, RecievedFromClient.Length, SocketFlags.None, ServerConnectionSend, ServerConnection);
                            ServerConnection.BeginReceive(RecievedFromServer, 0, RecievedFromServer.Length, SocketFlags.None, ServerConnectionRecieve, ServerConnection);
                        }
                        catch (Exception) { }
                    }
                    else
                        if (!ConnectingToServer)
                            ServerConnect(true);
                }
                else
                    if (!ConnectingToServer)
                        ServerConnect(true);
 
                Thread.Sleep(10);
            }
        }
 
        public static void ServerConnectionRecieve(IAsyncResult sock)
        {
            try
            {
                ServerConnection.EndReceive(sock);
            }
            catch (Exception) { }
        }
 
        public static void ServerConnectionSend(IAsyncResult sock)
        {
            try
            {
                ServerConnection.EndSend(sock);
                MessageBox.Show(RecievedFromClient.ToString());
                RecievedFromClient = new byte[BufferSize];
            }
            catch (Exception) { }
        }
    }
 

Thank you very much for any help.

[alex21]

I made some changes and now it does a tiny bit of what it is supposed to do.

public static class PacketFilter
    {
        static int BufferSize = 4096;
 
        static Server RedirectToServer;
 
        static bool ConnectingToClient = false;
        static Socket ClientConnection;
        static byte[] RecievedFromClient = new byte[BufferSize];
 
        static bool ConnectingToServer = false;
        static Socket ServerConnection;
        static byte[] RecievedFromServer = new byte[BufferSize];
 
        static int ThreadSyncA = 0;
        static int ThreadSyncB = 0;
        static Thread ClientConnectionThread = new Thread(new ThreadStart(ClientConnectionThread_Tick));
        static Thread ServerConnectionThread = new Thread(new ThreadStart(ServerConnectionThread_Tick));
 
        public static void Start(Server server)
        {
            RedirectToServer = server;
 
            ClientConnectionThread.Start();
            ServerConnectionThread.Start();
 
            ClientConnect(true);
            ServerConnect(true);
        }
 
        public static void End()
        {
            try
            {
                ClientConnection.Close();
                ServerConnection.Close();
            }
            catch (Exception e)
            {
                MessageBox.Show("Failed to close sockets, " + e.Message);
            }
        }
 
        public static void ClientConnect(bool connect)
        {
            ConnectingToClient = true;
 
            ClientConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep = new IPEndPoint(Dns.GetHostEntry("localhost").AddressList[0], (int)Main.UserInterfaceSettings.ClientPacketListenPort);
            try
            {
                ClientConnection.Bind(ep);
                ClientConnection.Listen(5);
                ClientConnection.BeginAccept(ClientConnect_Complete, ClientConnection);
            }
            catch (Exception) { ConnectingToClient = false; }
        }
 
        public static void ClientConnect_Complete(IAsyncResult sock)
        {
            try
            {
                ClientConnection = ClientConnection.EndAccept(sock);
            }
            catch (Exception) { }
            ConnectingToClient = false;
        }
 
        public static void ServerConnect(bool connect)
        {
            ConnectingToServer = true;
 
            ServerConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep = new IPEndPoint(RedirectToServer.ReturnServerAddress(), (int)RedirectToServer.ReturnPort());
            try
            {
                ServerConnection.BeginConnect(ep, ServerConnect_Complete, ServerConnection);
            }
            catch (Exception) { ConnectingToServer = false; }
        }
 
        public static void ServerConnect_Complete(IAsyncResult sock)
        {
            try { ServerConnection.EndConnect(sock); }
            catch (Exception) {  }
            ConnectingToServer = false;
        }
 
        public static void ClientConnectionThread_Tick()
        {
            while (!Program.EndProgram)
            {
                while (ThreadSyncA > ThreadSyncB)
                    Thread.Sleep(1);
                RecievedFromClient = new byte[BufferSize];
 
                if (ClientConnection != null)
                {
                    if (ClientConnection.Connected)
                    {
                        try
                        {
                            ClientConnection.BeginSend(RecievedFromServer, 0, RecievedFromServer.Length, SocketFlags.None, ClientConnectionSend, ClientConnection);
                            //ClientConnection.BeginReceive(RecievedFromClient, 0, RecievedFromClient.Length, SocketFlags.None, ClientConnectionRecieve, ClientConnection);
 
                            //ClientConnection.Send(RecievedFromServer);
                            int test = 0;
                            test = ClientConnection.Receive(RecievedFromClient);
                            if (test != 0)
                                MessageBox.Show(test.ToString() + " client");
                        }
                        catch (Exception) { }
                    }
                    else
                        if (!ConnectingToClient)
                            ClientConnect(true);
                }
                else
                    if (!ConnectingToClient)
                        ClientConnect(true);
 
                ThreadSyncA += 1;
                Thread.Sleep(10);
            }
        }
 
        public static void ClientConnectionRecieve(IAsyncResult sock)
        {
            try
            {
                ClientConnection.EndReceive(sock);
            }
            catch (Exception) { }
        }
 
        public static void ClientConnectionSend(IAsyncResult sock)
        {
            try { ClientConnection.EndSend(sock); }
            catch (Exception) { }
        }
 
        public static void ServerConnectionThread_Tick()
        {
            while (!Program.EndProgram)
            {
                while (ThreadSyncB > ThreadSyncA)
                    Thread.Sleep(1);
                RecievedFromServer = new byte[BufferSize];
 
                if (ServerConnection != null)
                {
                    if (ServerConnection.Connected)
                    {
                        try
                        {
                            ServerConnection.BeginSend(RecievedFromClient, 0, RecievedFromClient.Length, SocketFlags.None, ServerConnectionSend, ServerConnection);
                            //ServerConnection.BeginReceive(RecievedFromServer, 0, RecievedFromServer.Length, SocketFlags.None, ServerConnectionRecieve, ServerConnection);
 
                            //ServerConnection.Send(RecievedFromClient);
                            int test = 0;
                            test = ServerConnection.Receive(RecievedFromServer);
                            if (test != 0)
                                MessageBox.Show(test.ToString() + " server");
                        }
                        catch (Exception) { }
                    }
                    else
                        if (!ConnectingToServer)
                            ServerConnect(true);
                }
                else
                    if (!ConnectingToServer)
                        ServerConnect(true);
 
                ThreadSyncB += 1;
                Thread.Sleep(10);
            }
        }
 
        public static void ServerConnectionRecieve(IAsyncResult sock)
        {
            try
            {
                ServerConnection.EndReceive(sock);
            }
            catch (Exception) { }
        }
 
        public static void ServerConnectionSend(IAsyncResult sock)
        {
            try { ServerConnection.EndSend(sock); }
            catch (Exception) { }
        }
    }

Now when i click login on the client it pop's up with '83 client' then when i click ok it pops up with '46 server' then the break point i have put on this line

ClientConnectio n.BeginSend(Rec ievedFromServer , 0, RecievedFromSer ver.Length, SocketFlags.Non e, ClientConnectio nSend, ClientConnectio n);

is never tripped again, in fact any break point in the Client thread is never tripped again, meaning after the reply from the server is received it freezes somewhere and the thread stops ticking.