/************************************
*						*
*	Flexible Client Program		*
*						*
*	BY: Simeon Bassett		*
*						*
*	simeon_b@hotmail.com		*
*						*
*	This comment must remain.	*
*						*******************************************
*													*
* 	More information about the program and the 					*
* 	source code can be found within the readme.txt file (if there is one) 	*
*													*
*	You may freely ditribute this as you wish, however you may not alter it	*
*	in any way without my permission.							*
*													*
*	If you do alter it please leave my comments in.					*
*	You MUST leave in this comment.							*
*													*
*******************************************************************************/

import java.io.*;
import sun.net.*;

class rawclient extends Thread
{

	//Globals
	static NetworkClient net;		//used to create the client object and then input and print streams from that
	static BufferedReader net_input;
	static PrintStream net_output;
	static BufferedReader input;
	static String range = "port must be a whole number in the range of 0 - 65536";

	//Here is the string for the help command
	static String help = "More information is in the readme.txt file  \n\n to send information to the server, simply type in the string and hit enter, to get information, hit enter on a blank line   \n\nCommands:  \n help - Displays this message  \n quit - quits the program  \n restart - restarts the program without quitting  \n repeat - repeats a certain message  \n delay repeat - not implemented yet  \n port scan - checks for open ports on a computer  \n port fondle - repeatedly connects to a server  \n view repeat - view the message send in repeat  \n send - send a message to the server, used for sending a piece of information that is already a command such as quit or help \n";

	static boolean noCommand = true;
	static String header = "Raw Client   By: Simeon Bassett    simeon_b@hotmail.com \n";
	static boolean firstCycle = true;
	static String server;
	static int port; 
	static String repeatBuffer = "";		//for the repeat command
	static int delay = 200;

	public static void main(String arg[])
	{
		if (firstCycle) 			//do these only when the program starts
		{
			System.out.println(header);
		
			input = new BufferedReader(new InputStreamReader(System.in));
			
			firstCycle = false;
		}

		try
		{
			System.out.print("server:");
			server = input.readLine();
			if(server.equals(""))
			{
				server = "cjnetworks.com";
				System.out.println(server);
			}
			System.out.print("port:");
			String tempPort = input.readLine();
			if(tempPort.equals(""))
			{
				port = 25;
			}
			else
			{
				port = (new Integer(tempPort)).intValue();
			}

			System.out.println("port has been read (" + port + ")"  );			//debugging info

			if( (check_server(server) && check_port(port)) )
			{
				System.out.println("Creating client object");
				net = new NetworkClient(server, port);
				System.out.println("Client object Created");
			}
			else
			{
				System.out.println("There was an error in the client specification");
				main(null);
				return;
			}

		}
		catch(IOException e)
		{
			System.out.println("connection not possible");
		}
		catch(NumberFormatException e)
		{
			System.out.println(range);
		}
		catch(NullPointerException e)
		{
			System.out.println("There was an error in the client specification");
		}

		if(!net.serverIsOpen())
		{
			System.out.println("server is not open");
			main(null);
			return;
		}

		net_input = new BufferedReader(new InputStreamReader(net.serverInput));
		net_output = net.serverOutput;

		program(input, net_input, net_output);

		return;

	}

/**************************************
*	   Program Core			  *
**************************************/

/*  I didn't name the variables in the program() 
function the same as the globals because 
of scope problems that I didn't want to work around 
with the scope resolution operator. I guess that will teach me to use
global variables.  */

	static void program(BufferedReader program_input, BufferedReader program_net_input, PrintStream program_net_output)
	{	
		String command = "";

		System.out.print("%");
		try { command = program_input.readLine(); } catch(IOException e) { System.out.println(e); return;  }


		/********************
		*	Features	  *
		********************/
		if (command.equalsIgnoreCase("help"))
		{
			System.out.println(help); 
			noCommand = false;
		}
		if (command.equalsIgnoreCase("quit"))
		{
			cleanUp();
			noCommand = false;
			return;
		}
		if (command.equalsIgnoreCase("restart"))
		{
			main(null);
			return;
		}
		if (command.equalsIgnoreCase("repeat"))
		{
			int countMax = 0;
			int count = 0;
			String sync = "0";
			repeatBuffer = "";			

			System.out.print("message: ");
			while(!(repeatBuffer.endsWith("*\n")))
			{
				try { repeatBuffer += program_input.readLine() + "\n"; } catch(IOException e) { }
			}
			
			repeatBuffer = repeatBuffer.substring( 0 , repeatBuffer.length() - 2 ); //shave the ending command off

			System.out.print("Times to repeat: ");
			try
			{
				countMax = (new Integer(program_input.readLine())).intValue();
			}
			catch(IOException e)
			{
				System.out.println("IO error  " + e);
			}
			
			System.out.print("Sync to input from server: ");
			try { sync = program_input.readLine(); } catch(IOException e) { }
			if(sync.equals(""))
			{
				while(count < countMax)
				{
					program_net_output.println(repeatBuffer);
					count++;
				}				
			}
			else
			{
				String netInput = "";
				boolean breakLoop = false;
				
				System.out.println(repeatBuffer);

				while(count < countMax)
				{
					program_net_output.println(repeatBuffer);

					while(true) 	//wait until sync message is encountered before moving on
					{ 	
						try
						{
							if(net_input.ready())
								netInput = net_input.readLine();

							System.out.println(netInput); 

							if ( netInput.lastIndexOf(sync) != -1 )
							{
								breakLoop = true;
							}

							sleep(delay);
						}
						catch(IOException e)
						{  
						}
						catch(InterruptedException e)
						{
						}

						if(breakLoop)
							break;

					} 
 
					count++;
					try { sleep(delay); } catch(InterruptedException e) {  }
				}
			}

			command = "";
		}
		if (command.equalsIgnoreCase("delay repeat"))
		{
			
		}
		if (command.equalsIgnoreCase("port scan"))
		{
			//Create the variables
			String portScanServer = "";			
			int portsFound = 0;
			int startAt = 0;	
			int endAt = 65536;
			int threads = 1;
			int timeout = 1000;
			int split;
			int portPoint;
			int extraPorts = 0;
			int totalScanningPorts;
			
			//Reset portScan's static variables
			portScan.totalPortsFound = 0;
			portScan.finishedThreads = 0;
			portScan.portsChecked = 0;

			//Get user Input
			try 
			{
				//lots of user input for this one
				System.out.print("Server: ");
				portScanServer = program_input.readLine(); 

				System.out.print("Start at: ");
				startAt = (new Integer(program_input.readLine())).intValue();

				System.out.print("End at: ");
				endAt = (new Integer(program_input.readLine())).intValue();

				System.out.print("Threads: ");
				threads = (new Integer(program_input.readLine())).intValue();

				/* System.out.print("timeout: ");
				timeout = (new Integer(program_input.readLine())).intValue();  */

				System.out.print("Open ports found at: ");
			} 
			catch(IOException e) 
			{  
			}
			
			//Variable Arithmetic to set up for port scan
			totalScanningPorts = endAt - startAt;

			//if there are more thread than ports just go with one thread to each port
			if (totalScanningPorts < threads)
				threads = totalScanningPorts;

			extraPorts = totalScanningPorts % threads;
			split = (totalScanningPorts - extraPorts)/threads;
			portPoint = startAt + split + extraPorts;
			
			portScan[] scanner = new portScan[threads];

			scanner[0] = new portScan(portScanServer , startAt , portPoint , timeout );
			scanner[0].start();

			portPoint++;

			int count = 1;
			while (count < threads)
			{
				scanner[count] = new portScan(portScanServer , portPoint , portPoint + split , timeout);
				scanner[count].start();
				portPoint += split + 1;
				count++;
			}	
			
			while(portScan.finishedThreads < threads)	//check to make sure that all of the threads have finished and wait until they do
			{	
				try
				{
					sleep(1000);
				}
				catch(InterruptedException e)
				{
				}
			}
			
			System.out.print("\n");
			System.out.println(portScan.portsChecked + " ports were checked");

			if(portScan.totalPortsFound == 0)
				System.out.print("there were no open ports found, how dissappointing!");
			else
				System.out.print("there were " + portScan.totalPortsFound + " open ports found ");

			System.out.print("\n");
			noCommand = false;
		}
		if (command.equalsIgnoreCase("port fondle"))
		{
			String server;
			int port;
			int cycles;
			int countInner = 0;
			int countOuter = 0;
			int connectDelay = 0;

			try
			{	
				//the input
				System.out.print("Server: ");
				server = program_input.readLine();

				System.out.print("port: ");
				port = (new Integer(program_input.readLine())).intValue();

				System.out.print("cycles: ");
				cycles = (new Integer(program_input.readLine())).intValue();

				System.out.print("delay: ");
				connectDelay = (new Integer(program_input.readLine())).intValue();
				
				//The meat
				while(countOuter < cycles)
				{
					while ( countInner < 65536 ) 
					{
						try
						{
							new java.net.Socket(server , port);
							sleep(connectDelay);
							countInner++;
						}
						catch(IOException e)
						{
						}
						catch(InterruptedException e)
						{
						}
					}

					countOuter++;
					System.out.print(".");
				}

				System.out.println("All cycles complete");
			}
			catch(IOException e)
			{
				System.out.print(e);
			}

			noCommand = false;
		}
		if (command.equalsIgnoreCase("view repeat"))
		{
			System.out.println(repeatBuffer);
			noCommand = false;
		}
		if (command.equalsIgnoreCase("send"))
		{
			System.out.print("-->");
			try { command = program_input.readLine(); } catch(IOException e) { }
		}
		if (noCommand)
		{
			if(!(command.equals("")))
				program_net_output.println(command);
			else
				printNet();
			
		}
		/******************
		*   End Features	*
		******************/

		program(program_input, program_net_input, program_net_output);
		
		return;
	}


/**************************************
*	        Functions			  *
**************************************/

	static void cleanUp()
	{
		printNet();

		//Clean up time
		try
		{	
			//close the global client object
			net.closeServer();

			//close the global IO streams
			net_input.close();
			net_output.close();
		}
		catch(Exception e)
		{
			System.out.println(e);
		}

	}

	static void printNet()
	{
		String netInput = "";
		
		try 
		{ 
			while(net_input.ready()) 
			{ 
				netInput = net_input.readLine();
				System.out.println(netInput); 
			}  
		} 
		catch(IOException e) 
		{   
			System.out.println("could not get input from server");
		}
		
		return;
	}

	static boolean check_server(String server)
	{
		if(server.equals(""))
		{
			System.out.println("server not valid");
			return false;
		}
		return true;
	}

	static boolean check_port(int port)
	{

		if(port > 65536)
		{
			System.out.println(range + " (more than 65536)");
			return false;
		}

		if(port < 0)
		{
			System.out.println(range + " (less than 0)");
			return false;
		}

		return true;
	}

}


/******************************
*	Classes			*
******************************/

class portScan extends Thread
{	

	java.net.Socket server;
	String serverName;	
	int startingPort;
	int endingPort;
	int count;
	int timeOut;

	static final int portMin = 0;
	static final int portMax = 65536;

	public static int totalPortsFound = 0;
	public static int finishedThreads = 0;
	public static int portsChecked = 0;

	public portScan(String serverAddress, int startPort, int endPort , int timeout)
	{
			serverName = serverAddress;
			count = startingPort = startPort;
			endingPort = endPort;
			timeOut = timeout;
	}

	public void run()
	{
		while(count <= endingPort)
		{	
			try
			{
				server = new java.net.Socket(serverName , count);
				System.out.print(" " + count + " ");
				portScan.totalPortsFound++;
			}
			catch(IOException e)
			{
				System.out.print(".");
				portsChecked++;
			}
			count++;
		}
		
		finishedThreads++;
		return;
	}

}