/*
Client ID must be reset sometime or it will run out of bound!
*/
import java.net.*;
import java.io.*;

public class EchoServer {
// Just some initializations.. Don't fuck! ;P
	ServerSocket m_ServerSocket;
	int openscans = 0;
	int closedscans = 0;

// What port to bind to?
	int srvport = 12111;

	public EchoServer() {
		try {
// Create the server socket.
			m_ServerSocket = new ServerSocket();
			m_ServerSocket.setReuseAddress(true);
			m_ServerSocket.bind(new InetSocketAddress("10.0.0.6", srvport), 200);
		} catch(IOException ioe) {
			System.out.println("Could not create server socket at port " + srvport + ". Quitting.");
			System.exit(-1);
		}

		System.out.println("Listening for clients on port " + srvport + "...");

// Successfully created Server Socket. Now wait for connections.
		int id = 0;
		while(true) {
			try {

// Accept incoming connections.
				Socket clientSocket = m_ServerSocket.accept();

// accept() will block until a client connects to the server.
// If execution reaches this point, then it means that a client
// socket has been accepted.

// For each client, we will start a service thread to
// service the client requests. This is to demonstrate a
// multithreaded server, although not required for such a
// trivial application. Starting a thread also lets our
// EchoServer accept multiple connections simultaneously.

// Start a service thread
				ClientServiceThread cliThread = new ClientServiceThread(clientSocket, id++);
				cliThread.start();
			} catch(IOException ioe) {
				System.out.println("Exception encountered on accept. Ignoring. Stack Trace :");
				ioe.printStackTrace();
			}
		}
	}

	public static void main (String[] args) {
		new EchoServer();
	}

	class ClientServiceThread extends Thread {
		Socket m_clientSocket;
		int m_clientID = -1;
		boolean m_bRunThread = true;

		ClientServiceThread(Socket s, int clientID) {
			m_clientSocket = s;
			m_clientID = clientID;
		}

		public void run() {
// Obtain the input stream and the output stream for the socket                    
// A good practice is to encapsulate them with a BufferedReader                    
// and a PrintWriter as shown below.                                               

			BufferedReader in = null;
			PrintWriter out = null;

// Print out details of this connection
			System.out.println("Accepted Client : ID - " + m_clientID + " : Address - " +
				m_clientSocket.getInetAddress().getHostName());

			try {
				in = new BufferedReader(new InputStreamReader(m_clientSocket.getInputStream()));
				out = new PrintWriter(new OutputStreamWriter(m_clientSocket.getOutputStream()));

// At this point, we can read for input and reply with appropriate output.      
// Run in a loop until m_bRunThread is set to false
				while(m_bRunThread) {

// read incoming stream
					String clientCommand = in.readLine();
//					System.out.println("Client Says: " + clientCommand);                        

// Split the string
// String structure: <pass>:<ip>:<port>
					String [] inputvars = null;
					inputvars = clientCommand.split(":");

					String ip = inputvars[2];
					String pxrt = inputvars[3];
					int port = Integer.parseInt(pxrt);

					if(ip.length() >= 7 && port > 0) {
						try {
// Open a socket without any parameters. It hasn't been binded or connected
							Socket sock = new Socket();

// Bind to a local ephemeral port
							sock.bind(null);

// Connect to ip specified port 80 with a timeout of 3500 milliseconds
							sock.connect(new InetSocketAddress(ip,port), 3500);
							out.println("OPEN");
							openscans++;
							sock.close();
						} catch (IOException ex) {
// The remote host is not listening on this port
							out.println("CLOSED");
							closedscans++;
						}
					} else if(ip.length() == 5) {
						out.println("--- Statistics ---\n Clients: "+ m_clientID + "\n Open: " + openscans + "\n Closed: " + closedscans);
					} else {
						out.println("UNAUTHORIZED");
					}
					out.flush();
// Special command. Quit this thread
					m_bRunThread = false;
					System.out.print("                                                   OK - Stopping client thread for client : " + m_clientID);
				}
			} catch(Exception e) {
				e.printStackTrace();
			} finally {
// Clean up
				try {
					in.close();
					out.close();
					m_clientSocket.close();
//					clientSocket.close();
					System.out.println("...Stopped");
				} catch(IOException ioe) {
					ioe.printStackTrace();
				}
			}
		}
	}
}