NetworkApp.java

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

class NetworkApp {

	public static int payload = 10000000;
	// public static int payload = 1000000;
	// public static int payload = 100000;

	public static int expected_rounds = 10;

	public static int udp_size = 250;

	public static void main(String[] args) {

		if (args.length < 3) {
			System.err.println("Not enough arguments\n" + 
				"tcp s port - TCP server on port\n" + 
				"udp s port - UDP server on port\n" + 
				"tcp c port server - TCP client on server:port\n" +
				"udp c port server - UDP client on server:port\n\n");
			System.exit(-1);
		}

		String server = "localhost";
		String transport_mode = args[0];
		String application_mode = args[1];
		int port = 55555;

		// parse the port from string to number
		try {
			port = Integer.parseInt(args[2]);
		} catch (Exception e) {
			System.err.println("Port is not a number");
			System.exit(-1);
		}

		// remove invalid ports
		if ( port_check(port) == false ) {
			System.err.println("Invalid port number");
			System.exit(-1);
		}

		// set the server/hostname string
		if ( application_mode.equals("c") && args.length == 4 ) {
			server = args[3];
		}

		if ( transport_mode.equals("tcp") && application_mode.equals("s") ) {
			// TCP Server
			tcp_server(port);
		} else if ( transport_mode.equals("tcp") && application_mode.equals("c") ) {
			// TCP Client
			tcp_client(server, port);
		} else if ( transport_mode.equals("udp") && application_mode.equals("s") ) {
			// UDP Server
			udp_server(port);
		} else if ( transport_mode.equals("udp") && application_mode.equals("c") ) {
			// UDP Client
			udp_client(server, port);
		} else {
			System.err.println("app: unknown modes given: " + args[0] + " and " + args[1]);
			System.exit(-1);
		}



	}

	public static boolean port_check(int port) {
		if ( port < 1025 || port > 65535 ) return false;
		return true;
	}

	public static void tcp_client(String server, int port) {

		System.out.println("client: client started, for " + server + " on port = " + port);

		int message = 0;
		Socket socket = null;
		DataOutputStream request = null;
		DataInputStream response = null;


		try {
			socket = new Socket(server, port);
		} catch (Exception x) {
			System.err.println("client: error in socket creation");
			System.err.println("\t" + x.getMessage());
			System.exit(-1);
		}


		try {
			request = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
			response = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
		} catch (Exception x) {
			System.err.println("client: error in IO handling");
			System.exit(-1);
		}

		long initialTime = System.nanoTime();
		try {
			int i = 0;
			for (; i < payload; i++) {
				// writing to the request, to the server
				request.writeByte( i % 10 );
			}
			request.flush();
			System.out.println("client: sent " + i + " bytes");
		} catch (IOException io) {
			System.err.println("client: error in sending data to server");
			System.exit(-1);
		}

		try {
			message = response.readInt();

			if (message == 1) {
				long endTime = System.nanoTime();
				System.out.println("client: server sent SUCCESS-message");
				System.out.println("client: " + (endTime - initialTime) / (int)Math.pow(10, 6) + " milliseconds to transfer");
			} else {
				System.out.println("client: server failed to send SUCCESS-message");
			}

		} catch (IOException io) {
			System.err.println("client: error in sending data");
			System.exit(-1);
		}

		try {
			socket.close();
			System.out.println("client: server connection closed");
		} catch (IOException io) {
			System.err.println("client: error in closing server connection");
			System.exit(-1);
		}

	}


	public static void tcp_server(int port) {

		System.out.println("server: server started on port = " + port);

		String message  = null;
		ServerSocket server  = null;
		DataOutputStream response  = null;
		DataInputStream request  = null;
		Socket client = null;

		try {
			server = new ServerSocket(port);
		} catch (Exception x) {
			System.err.println("server: error in socket creation");
			System.exit(-1);
		}	

		while (true) {

			try {
				System.out.println("server: waiting for client");
				client = server.accept();
			} catch (IOException io) {
				System.err.println("server: error in accepting client connection");
				System.exit(-1);
			}


			System.out.println("server: new clinet found");
			try {
				response = new DataOutputStream(new BufferedOutputStream(client.getOutputStream()));
				request = new DataInputStream(new BufferedInputStream(client.getInputStream()));
			} catch (Exception x) {
				System.err.println("server: error in IO handling");
				System.exit(-1);
			}	

			
			int size = 0;
			try {
				long initialTime = System.nanoTime();
				while (size < payload) {
					byte x = request.readByte();
					size++;
				}
				System.out.println("server: read " + size + " bytes");
				long endTime = System.nanoTime();
				System.out.println("server: " + (endTime - initialTime) / (int)Math.pow(10, 6) + " milliseconds to transfer");
			} catch (IOException io) {
				System.err.println("server: error in sending data to client");
				System.exit(-1);
			}

			try {	
				response.writeInt(1);
				response.flush();
				System.out.println("server: sent SUCCESS-application message to client");				
			} catch (IOException io) {
				System.err.println("server: error in final message to client");
				System.exit(-1);
			}

			try {
				client.close();
				System.out.println("server: client connection closed");
			} catch (IOException io) {
				System.err.println("server: error in closing client connection");
				System.exit(-1);
			}
			

		}
	}

	public static void udp_client(String server, int port) {

		System.out.println("client: client started, for " + server + " on port = " + port);

		int message = 0;
		DatagramSocket socket = null;
		InetAddress address = null;
		DatagramPacket request = null;
		DatagramPacket response = null;

		try {
			socket = new DatagramSocket(port);
			address = InetAddress.getByName(server);
		} catch (Exception x) {
			System.err.println("client: error in socket creation");
			System.err.println("\t" + x.getMessage());
			System.exit(-1);
		}

		// part one
		double time = 0, minimum = Double.MAX_VALUE;
		int exchanges = 0;
		double times[] = new double[expected_rounds];
		while (exchanges < expected_rounds) {
			
			byte[] request_data = new byte[10];
			byte[] response_data = new byte[10];
			for (int k = 0; k < 10; k++) {
				request_data[k] = (byte)exchanges;
			}

			request = new DatagramPacket(request_data, request_data.length, address, port);
			response = new DatagramPacket(response_data, response_data.length);

			long initialTime = System.nanoTime();

			try {
				System.out.println("client: sending packet for exchange #" + (1+exchanges));
				socket.send(request);
				System.out.println("client: received packet for exchange #" + (1+exchanges));
				socket.receive(response);
			} catch (IOException io) {
				System.err.println("client: error in sending or receiving packets");
				System.err.println("\t" + io.getMessage());
				continue; // skip, repeat this step again
			}

			long endTime = System.nanoTime();

			times[exchanges] = ((endTime - initialTime) / (int)Math.pow(10, 6));
			time += times[exchanges];
			if ( times[exchanges] < minimum ) {
				minimum = times[exchanges];
			}
			exchanges++;
		}
		System.out.println("client: total time = " + time + " milliseconds");
		System.out.println("client: minimum time = " + minimum + " milliseconds");
		System.out.println("client: average time = " + (time/exchanges) + " milliseconds");
		double std_dev_time = 0;
		for (int i = 0; i < expected_rounds; i++) {
			double std = Math.pow(times[i] - (time/exchanges), 2);
			std_dev_time += std;
		}
		std_dev_time = Math.sqrt(std_dev_time/expected_rounds);
		System.out.println("client: std. dev. = " + std_dev_time + " milliseconds");

		// part two
		System.out.println("client: sending bulk payload");

		int bytes = 0;
		byte[] single = new byte[udp_size];
		while (bytes < payload) {
			
			single[0] = (byte)0;
			request = new DatagramPacket(single, single.length, address, port);
			
			try {
				socket.send(request);
				bytes += single.length;
			} catch (IOException io) {
				System.err.println("client: error in sending packet");
				// continue anyway
			}
			
		}
		
		System.out.println("client: bulk payload bytes sent = " + bytes);
		System.out.println("client: waiting for server to finish");

		single[0] = (byte)1;
			try {
				int k = 0;
				long start = System.nanoTime();
				while (System.nanoTime()-start < (5 * 1000000000l) ) {
					k = 1 - 1;
				}
				for (int i = 0; i < 100; i++) {
					socket.send(request);
				}
				System.out.println("client: sending termination packet");
			} catch (IOException io) {
				System.err.println("client: error in sending termination packet");
				// it's fine
			}
		System.out.println("client: bulk packets sent");
		



	}

	public static void udp_server(int port) {

		System.out.println("server: server started on port = " + port);

		int message = 0;
		DatagramSocket socket = null;
		InetAddress address = null;
		DatagramPacket request = null;
		DatagramPacket response = null;

		try {
			socket = new DatagramSocket(port);
		} catch (Exception x) {
			System.err.println("server: error in socket creation");
			System.err.println("\t" + x.getMessage());
			System.exit(-1);
		}

		// part one

		byte[] request_data = new byte[10];
		byte[] response_data = new byte[10]; // in the case below, we just send the request back with an alteration
		int exchanges = 0;

		while (exchanges < 10) {
			
			// get packet
			System.out.println("server: waiting for request exchange #" + (1+exchanges));
			request = new DatagramPacket(request_data, request_data.length);
			try {
				socket.receive(request);
				System.out.println("server: receiving");
			} catch (IOException io) {
				System.err.println("server: error in receiving packets");
				continue; // skip this interation, try again
			}

			request_data[request_data.length-1] =+ 1;

			System.out.println("server: sending response exchange #" + (1+exchanges));
			response = new DatagramPacket(request_data, request_data.length, request.getAddress(), request.getPort());
			try {
				socket.send(response);
			} catch (IOException io) {
				System.err.println("server: error in sending packets");
				continue; // try again
			}

			exchanges++;

		}

		System.out.println("server: waiting for bulk payload");
		// part 2 
		boolean trigger = true;
		byte[] single = new byte[2048];
		int count = 0, packets = 0;
		while (trigger || count < payload) {
			request = new DatagramPacket(single, single.length);

			try {
				socket.receive(request);
				count += request.getLength();
				packets++;
			
				String complete = "\r" + count + " / " + payload + " bytes (" + (int)(((double)count/payload)*100) + "%) - " + packets + " packets";
				System.out.print(complete);

			} catch (IOException io) {
				System.out.println("server: error in receiving packet");
				continue;
			}

			System.out.println();

			single = request.getData();
			if ( single[0] == 1 ) {
				trigger = false;
				System.out.println("server: termination packet found");
				break;
			}


		}
		System.out.println("server: bulk payload finished");




	}

}