Every device (e.g., router, computer, smartphone, smart coffee machine) in order to send or receive data on any network (e.g., local network at your home, or global network like the internet), must have an address called the IP (Internet Protocol) address. The commonly used type is IP version 4 (IPv4), 32 bits used to express an address (e.g., 10.26.60.138). A newer version of IP addresses started to be deployed named as IP version 6 (IPv6). IPv6 uses 128 binary bits to express an address (e.g., 2001:cdba:0000:0000:0000:0000:3257:9652). IP is the logical address of a device, however, there are number of applications and programs (e.g., WhatsApp, Skype, Chrome) running on that device and need to access the network to send and receive data. Thus, besides IP address, we need addresses to identify the different applications and programs running we are calling these addresses Port address. Thus, for the packets to be routed correctly from an application on device A to an application on device B, each packet should hold:

the address of the sender (IPv4 of device A) + an integer identifier (Port number) for the application on device A that initiated the communication (e.g., Skype may use port 443)

the address of the receiver (IPv4 of device B) + an integer identifier (Port number) for the application on device B that is expected to receive the delivered packet.

Socket programming refers to using a set of tools to build connection-oriented and connectionless channels for two-way communication between applications running on different devices. In this lab, we will use Java socket programming to implement the client-server model we discussed in Unit1. A process (or application) running on the client device creates single connection-oriented session and communicates with a process (or application) running on server device. Java (through import java.net.*;) provides a collection of classes and functionalities to create and handle low-level communication details. We will also need to build input and output streams for data during the communication sessions (through import java.io.*;). Usually the client and server applications reside on two different devices (e.g., two computers, smartphone and computer). But, to keep this lab simple, you can run both client and server applications on the same computer.

Server-side application structure: The first step is to create a server socket and bound this socket to certain port number of your selection (use port number >=1024). ServerSocket mySocket = new ServerSocket(6666); The server now needs to listen to any connection requests from clients to this port. This is done through the accept(). Socket connectedClient = mySocket.accept(); Accept() blocks the server application waiting until a client makes a connection request using the server IP address and the port number of this application (6666 in this case). If everything goes well, the server accepts the connection. The accepted connection from this new client is represented by the returned socket object. With the new socket object, the server can get data from the client side and also respond with data, through input and output streams to receive messages and write messages from and to the client endlessly until the socket is closed along with these data streams. BufferedReader br = new BufferedReader(new InputStreamReader(connectedClient.getInputStream())); // Read data from the client PrintStream ps = new PrintStream(connectedClient.getOutputStream()); // Send data to the client

Client-side application structure: The client, in order to initiate a connection with the server, must know the IP of the device that hosts the server application along with the port number that the server application is listening to. The first step is to create a connection request using the server IP and the port address Socket mySocket = new Socket("192.168.0.8", 6666); Where the 192.168.0.8 -as an example- is the IP of the server device. If you run both client and server on the same device, you can use 127.0.0.1 instead, to refer to your own computer. Socket mySocket = new Socket("127.0.0.1", 6666); This constructor creates a new socket only when the server accepts the connection, otherwise, it will throw an exception. With the new created socket object, the client can send data to the server and get data back, through input and output streams to receive messages and write messages from and to the server endlessly until the socket is closed along with these data streams. DataOutputStream outStream = new DataOutputStream(mySocket.getOutputStream()); // to send data to the server BufferedReader inStream = new BufferedReader(new InputStreamReader(mySocket.getInputStream())); //to read data coming from the server In the assignment folder, you will find client.java and server.java files. Use the Java IDE you find appropriate (e.g., Eclipse, NetBeans), create two java terminal projects one to run client.java and one to run server.java. Carefully read the code of the two projects along with the comments placed per command. Run the server project first, then run client project. These projects simply create a chat between the client and server. Through the terminal window of the client you can start writing some statements, and on clicking enter you should find these statements on the terminal of the server side along with responses back from the server displayed at the client side. This chat will keep on until the client sends exist as a command and clicks enter, this will terminate the connection established as well as the read and write streams on the two sides.

Task description:

In this part, you will update both client and server projects created in task1 with an interactive communication scenario, where a user at the client side can enter a command through the terminal then waits for a response back from the server to be able to send another command. The server handles the received commands and return appropriate results. The following table holds the different supported commands that a user can initiate, along with the proper handle from the server side and the expected response per command. The server keeps a list (Dynamic-size ArrayList or Static-size Array) of integers (initially empty or filled with zeros) and named inputValues to handle (add/remove) commands. If you use ArrayList option you can use the different APIs to add/remove elements. If you use array option, so to add an element, you can replace the first zero with the new element. If you use array option, so to remove an element, replace it with zero. The client initially prints a list of the supported commands for the user to write correct formatted command. If a user sends any other command or a supported command but in a different format, the server should ignore the command and respond with unsupported command without exiting either the client or the server

JAVA CODE:

class Client { public static void main(String args[]) { try { // Create client socket to connect to certain server (Server IP, Port address) // we use either "localhost" or "127.0.0.1" if the server runs on the same device as the client Socket mySocket = new Socket("127.0.0.1", 6666); // to interact (send data / read incoming data) with the server, we need to create the following: //DataOutputStream object to send data through the socket DataOutputStream outStream = new DataOutputStream(mySocket.getOutputStream()); // BufferReader object to read data coming from the server through the socket BufferedReader inStream = new BufferedReader(new InputStreamReader(mySocket.getInputStream())); String statement = ""; Scanner in = new Scanner(System.in); while(!statement.equals("exit")) { statement = in.nextLine(); // read user input from the terminal data to the server outStream.writeBytes(statement+" "); // send such input data to the server String str = inStream.readLine(); // receive response from server System.out.println(str); // print this response } System.out.println("Closing the connection and the sockets"); // close connection. outStream.close(); inStream.close(); mySocket.close(); } catch (Exception exc) { System.out.println("Error is : " + exc.toString()); } } }

class Server { public static void main(String args[]) { try { // Create server Socket that listens/bonds to port/endpoint address 6666 (any port id of your choice, should be >=1024, as other port addresses are reserved for system use) // The default maximum number of queued incoming connections is 50 (the maximum number of clients to connect to this server) // There is another constructor that can be used to specify the maximum number of connections ServerSocket mySocket = new ServerSocket(6666); System.out.println("Startup the server side over port 6666 ...."); // use the created ServerSocket and accept() to start listening for incoming client requests targeting this server and this port // accept() blocks the current thread (server application) waiting until a connection is requested by a client. // the created connection with a client is represented by the returned Socket object. Socket connectedClient = mySocket.accept(); // reaching this point means that a client established a connection with your server and this particular port. System.out.println("Connection established"); // to interact (read incoming data / send data) with the connected client, we need to create the following: // BufferReader object to read data coming from the client BufferedReader br = new BufferedReader(new InputStreamReader(connectedClient.getInputStream())); // PrintStream object to send data to the connected client PrintStream ps = new PrintStream(connectedClient.getOutputStream()); // Let's keep reading data from the client, as long as the client does't send "exit". String inputData; while (!(inputData = br.readLine()).equals("exit")) { System.out.println("received a message from client: " + inputData); //print the incoming data from the client ps.println("Here is an acknowledgement from the server"); //respond back to the client } System.out.println("Closing the connection and the sockets"); // close the input/output streams and the created client/server sockets ps.close(); br.close(); mySocket.close(); connectedClient.close(); } catch (Exception exc) { System.out.println("Error :" + exc.toString()); } } }

PLEASE ANSWER THIS AS SOON AS POSSIBLE.

Client Supported Commands Add: x where x can be any integer value (e.g., Add: 74) Remove: x where x can be any integer value (e.g., Remove: 2) Get_Summation Server Reaction and response 1- Add x to the inputValues list 2- Respond with added successfully" 1- Remove all occurrences x from the inputValues list 2- Respond with removed successfully" 1- Calculate the summation of values in the inputValues list 2- Respond with The summation is x where x is the summation of all values in the list. If empty list or all elements are zeros, x in the message equals null 1- Search for the minimum number in the input Values list 2- Respond with The minimum is x Get_Minimum where x is the minimum value in the list. If empty list or all elements are zeros, x in the message equals null 1- Search for the maximum number in the inputValues list 2- Respond with "The maximum is r" Get_Maximum where x is the maximum value in the list. If empty list or all elements are zeros, x in the message equals null No action or response required. Exit This is the only command that terminates the interactive communication. Client Supported Commands Add: x where x can be any integer value (e.g., Add: 74) Remove: x where x can be any integer value (e.g., Remove: 2) Get_Summation Server Reaction and response 1- Add x to the inputValues list 2- Respond with added successfully" 1- Remove all occurrences x from the inputValues list 2- Respond with removed successfully" 1- Calculate the summation of values in the inputValues list 2- Respond with The summation is x where x is the summation of all values in the list. If empty list or all elements are zeros, x in the message equals null 1- Search for the minimum number in the input Values list 2- Respond with The minimum is x Get_Minimum where x is the minimum value in the list. If empty list or all elements are zeros, x in the message equals null 1- Search for the maximum number in the inputValues list 2- Respond with "The maximum is r" Get_Maximum where x is the maximum value in the list. If empty list or all elements are zeros, x in the message equals null No action or response required. Exit This is the only command that terminates the interactive communication