1. // prout
  2. import java.io.IOException;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. import java.text.DateFormat;
  6. import java.text.SimpleDateFormat;
  7. import java.util.ArrayList;
  8. import java.util.Collections;
  9. import java.util.Date;
 10. import java.util.Iterator;
 11. import java.util.List;
 12. 
 13. public final class Forwarder implements Runnable
 14. {
 15.     private final List clients;
 16.     private final ServerSocket server;
 17.     private final Socket remote;
 18.     private Thread runner;
 19.     
 20.     public Forwarder(String remoteHost, int remotePort, int localPort) throws IOException
 21.     {
 22.         clients = Collections.synchronizedList(new ArrayList());
 23.         System.out.println("[Forwarder] Creating forwarding server...");
 24.         server = new ServerSocket(localPort);
 25.         System.out.println("[Forwarder] Connecting to remote host...");
 26.         remote = new Socket(remoteHost, remotePort);
 27.     }
 28.     
 29.     public void start()
 30.     {
 31.         if (runner == null)
 32.         {
 33.             System.out.println("[Forwarder] Starting forwarding process...");
 34.             runner = new Thread(this, "ForwarderThread");
 35.             runner.start();
 36.             
 37.             System.out.println("[Forwarder] Forwarding data from remote host to clients...");
 38.             try
 39.             {
 40.                 byte b[] = new byte[4096];
 41.                 int c;
 42.                 while ((c = remote.getInputStream().read(b)) != -1)
 43.                 {
 44.                     for (Iterator i = clients.iterator(); i.hasNext();)
 45.                     {
 46.                         ForwarderClient client = (ForwarderClient) i.next();
 47.                         client.getClient().getOutputStream().write(b, 0, c);
 48.                     }
 49.                 }
 50.                 server.close();
 51.                 remote.close();
 52.             }
 53.             catch (IOException e)
 54.             {
 55.                 e.printStackTrace();
 56.             }
 57.         }
 58.     }
 59.     
 60.     public void run()
 61.     {
 62.         while(runner != null && server.isBound() && !server.isClosed())
 63.         {
 64.             try
 65.             {
 66.                 System.out.println("[ForwarderThread] Forwarder is listening for clients to connect...");
 67.                 clients.add(new ForwarderClient(server.accept()));
 68.             }
 69.             catch (IOException e)
 70.             {
 71.                 e.printStackTrace();
 72.             }
 73.         }
 74.     }
 75.     
 76.     private final class ForwarderClient implements Runnable
 77.     {
 78.         private final Socket client;
 79.         
 80.         private ForwarderClient(Socket client)
 81.         {
 82.             this.client = client;
 83.             String name = "ForwarderClientThread (" + client.getInetAddress().getHostName() + ":" + client.getPort() + ")";
 84.             System.out.println("[ForwarderClient] New " + name);
 85.             new Thread(this, name).start();
 86.         }
 87. 
 88.         public void run()
 89.         {
 90.             try
 91.             {
 92.                 byte b[] = new byte[4096];
 93.                 int c;
 94.                 System.out.println("[" + Thread.currentThread().getName() + "] Receiving data from client...");
 95.                 while ((c = client.getInputStream().read(b)) != -1)
 96.                 {
 97.                     remote.getOutputStream().write(b, 0, c);
 98.                 }
 99.             }
100.             catch (IOException e)
101.             {
102.                 System.out.println("[" + Thread.currentThread().getName() + "] Disconnected...");
103.             }
104.             try
105.             {
106.                 client.close();
107.             }
108.             catch (IOException e)
109.             {
110.                 e.printStackTrace();
111.             }
112.             clients.remove(this);
113.         }
114. 
115.         public final Socket getClient()
116.         {
117.             return client;
118.         }
119.     }
120. 
121.     // EXAMPLE OF USE
122.     // 1. Start this program
123.     // 2. Start several Telnet to localhost
124.     public static void main(String[] args) throws IOException
125.     {
126.         // Start a fake a remote iterative server on port 1111. You can connect with telnet localhost 1111 to test what it does
127.         
128.         new Thread(new Runnable() 
129.         {
130.             public void run()
131.             {
132.                 boolean active = true;
133.                 try
134.                 {
135.                     final DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss \r\n");
136.                     final ServerSocket ss = new ServerSocket(1111);
137.                     System.out.println("[FakeServerThread] FAKE SERVER STARTED !");
138.                     final Socket s = ss.accept();
139.                     byte b[]  = new byte[4096];
140.                     while (active)
141.                     {
142.                         int i = s.getInputStream().read(b);
143.                         System.out.println("[FakeServerThread] Received from the forwarder: " + new String(b, 0, i - 1));
144.                         s.getOutputStream().write(df.format(new Date()).getBytes());
145.                         Thread.sleep(1000);
146.                     }
147.                     s.close();
148.                     ss.close();
149.                 }
150.                 catch (IOException e)
151.                 {
152.                     active = false;
153.                 }
154.                 catch (InterruptedException e)
155.                 {
156.                     e.printStackTrace();
157.                 }
158.             }
159.         }, "FakeServerThread").start();
160.         
161.         // Connect to the fake remote server
162.         
163.         new Forwarder("localhost", 1111, 23).start();
164.     }
165. }
166.