Question

I am currently implementing a multithreaded proxy server in java which will accept messages from clients and forward them to another server which will then acknowledge the reception of the message. However, i’m having trouble doing so. Could someone point out what i am doing wrong? Thanks.

ProxyApp:

public class ProxyApp {

    public static ServerSocket server = null;
    public static Socket client = null;


    public static void main(String[] args)
    {
        try
        {
            server = new ServerSocket(6789);
            Socket clientsocket = null;

            while(true)
            { 
                client = server.accept();      

                if(client.isConnected())
                {
                    System.out.println("Proxy is currently listening to client on port 6789");
                }
                Thread t1 = new ProxyHandler(client);
                t1.start();

                clientsocket = new Socket(InetAddress.getLocalHost(), 6780);
                if(clientsocket.isBound())
                {
                    System.out.println("Clientsocket successfully connected on port 6780");
                }

                ProxyHandler t2 = new ProxyHandler(clientsocket);
                t2.start();                                                               
            }
        }
        catch(IOException io)
        {
            System.err.println("IOException: " + io.getMessage());
        }
    }
}

ProxyHandler:

public class ProxyHandler extends Thread {

    private Socket socket;
    private String message;

    public ProxyHandler(Socket socket)
    {
        this.socket = socket;        
    }

    @Override
    public void run()
    {       
        message = "";
        try
        {
            DataInputStream in = new DataInputStream(socket.getInputStream());
            DataOutputStream out = new DataOutputStream(socket.getOutputStream());
            while(true)
            {
                message = in.readUTF();
                out.writeUTF(message);

                System.out.println(message);
            }
        }
        catch(IOException io)
        {
            System.err.println("IOException: " + io.getMessage());
            System.exit(2);
        }
    }
}

ClientClass:

public class ClientClass {

    public static void main(String[] args)
    {
        try
        {
            Socket client = new Socket(InetAddress.getLocalHost(), 6789);

            if(client.isBound())
            {
                System.out.println("Successfully connected on port 6789");
            }

            Scanner scanner = new Scanner(System.in);

            DataInputStream inFromProxy = new DataInputStream(client.getInputStream());
            DataOutputStream outToProxy = new DataOutputStream(client.getOutputStream());

            while(true)
            {
                String message;

                System.out.print("Enter your message: ");
                message = scanner.next();

                outToProxy.writeUTF(message);
                System.out.println(inFromProxy.readUTF());
            }
        }
        catch(IOException io)
        {
            System.err.println("IOException: " + io.getMessage());
            System.exit(2);
        }
    }
}

ServerClass:

public class ServerClass {

    public static void main(String[] args)
    {
        try
        {
            ServerSocket server = new ServerSocket(6780);

            if(server.isBound())
            {
                System.out.println("Server successfully connected on port 6780");
            }

            Socket client = null;
            while(true)
            {
                client = server.accept();

                if(client.isConnected())
                {
                    System.out.println("Proxy is connected");
                }

                DataInputStream inFromProxy = new DataInputStream(client.getInputStream());
                DataOutputStream outToProxy = new DataOutputStream(client.getOutputStream());

                System.out.println(inFromProxy.readUTF());

                outToProxy.writeUTF("Message has been acknowledged!");
            }    
        }
        catch(IOException io)
        {
            System.err.println("IOException: " + io.getMessage());
            System.exit(2);
        }
    }
}

Answer 1

The in and out in the following code represent message from and to the same machine:

DataInputStream in = new DataInputStream(socket.getInputStream());
DataOutputStream out = new DataOutputStream(socket.getOutputStream());

so when you read from in and write to out, all you are doing is creating an echo service.

message = in.readUTF();
out.writeUTF(message);

For a proxy, you want to read from the client and write to the server, and vice versa.

It seems you want something closer to this:

    client = server.accept();      
    clientsocket = new Socket(InetAddress.getLocalHost(), 6780);
    Thread t1 = new ProxyHandler(client, clientsocket );
    t1.start();
    Thread t2 = new ProxyHandler(clientsocket, client);
    t2.start();

where the job of the first thread is to send data from the client to the server and the second’s job is to send from the server to the client.