2. The server program will start first and keep listening to the specified port. Your client will connect tothe port that your server is listening to, and a socket between your client and server is constructed.3. Your client program will first prompt a welcome message that asks the user to enter a username usingthe keyboard. This username will then be sent to the server. Then, your server, after receiving theusername from your client, will send an acknowledgment message to the client.4. Your client, after receiving the acknowledgment message from your server, will prompt a messagethat asks the user to enter the corresponding password. This password will then be sent to the server.Then, your server, after receiving the password from your client, will verify the received pair ofusername and password against the list of legitimate pairs. If the result is positive, the server willsend a success message along with the current market value of the stock to the client. If the result isnegative, the server will send a failure message to the client.5. Your client, after receiving the result message, will print out the result and close the socket. Yourserver will close the socket following the client, and keep listening for the next client request.6. Your server will close the socket after waiting for the username or the password for 30 seconds.3Programming NotesI suggest you to start modifying the TCP server program (echoserver.c) provided. Your server programneeds to handle FILE I/O for authentication. When the server is up and running, you can start modifying theTCP client program (echoclinet.c). Both echoserver.c and echocleint.c are provided in netProgramming.tarfile (check course website-¿materials tab).This project will help you to understand the basic client-server interaction using TCP sockets.You can use azuread jupyterhub server for this project. You can run server program in oneterminal window and a client program in another terminal window. 2 Project SpecificationIn this project, you are required to do socket programming in C language (Linux environment) to implementa pair of client and server that can achieve simple password verification to indicate the current market valueof the stock. Your client will send a pair of username and password to your server and your server willverify whether the pair of username and password is legitimate or not for retrieving the stock value. Assumethe only legitimate pairs of usernames and passwords that will be accepted by your server are as follows.Username Password Stock Valuewelpa23eghqwo31alcidmrvlsnapcl1broCVStyjli14drjwqe83fgnmds28zrhkt187c13.9341.2310.2185.0956.4391.34Table 1: Content of StockFile.txtSpecifically, your client and server programs entail to achieve the following requirements:1. Your client program needs to take two arguments that specify the name of server and the port that itis trying to connect to. Your program for server needs to take an argument that specifies the port thatit is listening to. You can use (5000+last 4 digits of your student-id number) as a port number.1

The answer provided below has been developed in a clear step by step manner.1) #include "unp.h" int main(int argc, char **argv) { int sockfd; struct sockaddr_in servaddr; if (argc != 2) err_quit("usage: tcpcli <IPaddress>"); sockfd = Socket(AF_INET, SOCK_STREAM, 0); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(SERV_PORT); Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); str_cli(stdin, sockfd); /* do it all */ exit(0); } The above code does the following: Create socket, fill in Internet socket address structure A TCP socket is created and an Internet socket address structure is filled in with the server's IP address and port number. The server's IP address is taken from the command-line argument and the server's well-known port (SERV_PORT) is from our unp.h header. Connect to server connect establishes the connection with the server. The function str_cli handles the rest of the client processing. 2) Our TCP client and server follow the flow of functions that we diagrammed in Figure 4.1. The below code is the concurrent server program: tcpcliserv/tcpserv01.c #include "unp.h" int main(int argc, char **argv) { int listenfd, connfd; pid_t childpid; socklen_t clilen; struct sockaddr_in cliaddr, servaddr; listenfd = Socket(AF_INET, SOCK_STREAM, 0); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(SERV_PORT); Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); Listen(listenfd, LISTENQ); for ( ; ; ) { clilen = sizeof(cliaddr); connfd = Accept(listenfd, (SA *) &cliaddr, &clilen); if ( (childpid = Fork()) == 0) { /* child process */ Close(listenfd); /* close listening socket */ str_echo(connfd); /* process the request */ exit(0); } Close(connfd); /* parent closes connected socket */ } } The above code does the following: Create socket, bind server's well-known port A TCP socket is created. An Internet socket address structure is filled in with the wildcard address (INADDR_ANY) and the server's well-known port (SERV_PORT, which is defined as 9877 in our unp.h header). Binding the wildcard address tells the system that we will accept a connection destined for any local interface, in case the system is multihomed. Our choice of the TCP port number is based on Figure 2.10 in Section 2.9. It should be greater than 1023 (we do not need a reserved port), greater than 5000 (to avoid conflict with the ephemeral ports allocated by many Berkeley-derived implementations), less than 49152 (to avoid conflict with the "correct" range of ephemeral ports), and it should not conflict with any registered port. [p122] The socket is converted into a listening socket by listen. Wait for client connection to complete The server blocks in the call to accept, waiting for a client connection to complete. Concurrent server For each client, fork spawns a child, and the child handles the new client. The child closes the listening socket and the parent closes the connected socket 3) The following code allows for a server to wait for a client to connect to a (already binded) socket. It terminates either when a client connects to the socket, or when "server_run" takes the value 0: this allows other part of the code to shutdown the server when suitable to do so. static inline int wait_for_client_to_connect(int sockfd, int* server_run){ int client_found = 0; int clientfd = 0; struct sockaddr_in client_addr; int addrlen=sizeof(client_addr); if ( listen(sockfd,1) != 0 ) return -1; while ( client_found==0 && *server_run==1 ) { clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &addrlen); if ( clientfd < 0 ) { clientfd = 0; if (errno==EAGAIN || errno==EWOULDBLOCK) usleep(10); // nobody connected, wait for request else return -1; // something wrong, send error } else { // client found, configuring socket and exit client_found=1; int nodelay_flag = 1; setsockopt(clientfd, IPPROTO_TCP, TCP_NODELAY, (void*) &nodelay_flag, sizeof(int)); // disable nagle algorithm } } return clientfd; } 4) public class Server { public static void main(String[] args) { Server server = new Server(); server.start(5006); } private void start(int port) { try(ServerSocket serverSocket = new ServerSocket(port); Socket clientSocket = serverSocket.accept(); BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream(), "UTF-8"));) { String line; while (true) { while((line = bufferedReader.readLine())!=null){ System.out.println("line = " + line); } } } catch (IOException e) { throw new RuntimeException(e); } } The client looks like this: public class Client { public static void main(String[] args) { Client client = new Client(); client.start("localhost", 5006); } private void start(String localhost, int port) { Random random = new Random(); try (Socket socket = new Socket(localhost, port); BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF-8"))) { while (true) { int i = random.nextInt(); bufferedWriter.write(String.valueOf(i)); bufferedWriter.newLine(); System.out.println("i = " + i); //sleep(bufferedWriter); } } catch (Exception e) { e.printStackTrace(); } } private void sleep(BufferedWriter bufferedWriter) throws Exception{ //bufferedWriter.flush(); //Has to enabled if the wait below is to work TimeUnit.SECONDS.sleep(3); } Context: As is evident from the code, the server is single threaded. It accepts a connection from the client and goes into a busy loop processing data from the client socket. The server is intentionally handicapped. Running one instance of the client program works as intended. The client ends random integers and the same are printed on the server's console. 5) import socket def server_program(): # get the hostname host = socket.gethostname() port = 5000 # initiate port no above 1024 server_socket = socket.socket() # get instance # look closely. The bind() function takes tuple as argument server_socket.bind((host, port)) # bind host address and port together # configure how many client the server can listen simultaneously server_socket.listen(2) conn, address = server_socket.accept() # accept new connection print("Connection from: " + str(address)) while True: # receive data stream. it won't accept data packet greater than 1024 bytes data = conn.recv(1024).decode() if not data: # if data is not received break break print("from connected user: " + str(data)) data = input(' -> ') conn.send(data.encode()) # send data to the client conn.close() # close the connection if __name__ == '__main__': server_program() So our python socket server is running on port 5000 and it will wait for client request. If you want server to not quit when client connection is closed, just remove the if condition and break statement. Python while loop is used to run the server program indefinitely and keep waiting for client request. Python Socket Client We will save python socket client program as socket_client.py. This program is similar to the server program, except binding. The main difference between server and client program is, in server program, it needs to bind host address and port address together. See the below python socket client example code, the comment will help you to understand the code. import socket def client_program(): host = socket.gethostname() # as both code is running on same pc port = 5000 # socket server port number client_socket = socket.socket() # instantiate client_socket.connect((host, port)) # connect to the server message = input(" -> ") # take input while message.lower().strip() != 'bye': client_socket.send(message.encode()) # send message data = client_socket.recv(1024).decode() # receive response print('Received from server: ' + data) # show in terminal message = input(" -> ") # again take input client_socket.close() # close the connection if __name__ == '__main__': client_program() 6)