Asm 1: Write a program that has 2 sides: client and server, they communicate to each other
using TCP socket.
A server that:
- can accept connect from client.
- receives integer number n from client.
- calculates the value of square of n.
- and sends back square of n to client.
A client that:
- can connect to server.
- sends an integer number n to server.
- and receives square of n from server.
package Asm1;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class server {
private static final int SERVER_PORT = 65432;
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(SERVER_PORT)) {
System.out.println("Server listening on port " + SERVER_PORT);
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("Connected to client: " +
clientSocket.getInetAddress());
try (
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
OutputStream out = clientSocket.getOutputStream()
) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
int num = Integer.parseInt(inputLine);
int result = num * num;
out.write((result + "\n").getBytes());
}
} catch (Exception e) {
e.printStackTrace();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
package Asm1;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
public class client {
private static final String SERVER_HOST = "127.0.0.1";
private static final int SERVER_PORT = 65432;
public static void main(String[] args) {
try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
OutputStream out = socket.getOutputStream()) {
int num = 5; // Number to calculate the square of
// Send the number to the server
out.write((num + "\n").getBytes());
System.out.println("Sent: " + num);
// Receive the result from the server
String result = in.readLine();
System.out.println("Received: " + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Asm2: Write a program that has 2 sides: client and server, they communicate to each other
using TCP socket.
A server that:
- can accept connect from MULTIPLE clients.
- receives integer number n from client.
- calculates the value of square of n.
- and sends back square of n to client.
A client that:
- can connect to server.
- sends an integer number n to server.
- and receives square of n from server.
package Asm2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
int port = 5555;
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("Server is running and waiting for client
connections...");
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("New client connected: " + clientSocket);
ClientHandler clientHandler = new
ClientHandler(clientSocket);
new Thread(clientHandler).start();
}
} catch (IOException e) {
System.err.println("Error: " + e.getMessage());
}
}
private static class ClientHandler implements Runnable {
private Socket clientSocket;
public ClientHandler(Socket clientSocket) {
this.clientSocket = clientSocket;
}
@Override
public void run() {
try (
BufferedReader reader = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(clientSocket.getOutputStream()))
) {
String inputLine;
while ((inputLine = reader.readLine()) != null) {
try {
int n = Integer.parseInt(inputLine);
int square = n * n;
writer.write("Square of " + n + " is: " + square);
writer.newLine();
writer.flush();
} catch (NumberFormatException e) {
writer.write("Invalid input. Please send an
integer.");
writer.newLine();
writer.flush();
}
}
} catch (IOException e) {
System.err.println("Error handling client: " +
e.getMessage());
} finally {
try {
clientSocket.close();
} catch (IOException e) {
System.err.println("Error closing client socket: " +
e.getMessage());
}
}
}
}
}
package Asm2;
import java.io.*;
import java.net.Socket;
public class Client {
public static void main(String[] args) {
String serverAddress = "localhost";
int serverPort = 5555;
try (Socket socket = new Socket(serverAddress, serverPort);
BufferedReader reader = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
BufferedWriter writer = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
BufferedReader userInput = new BufferedReader(new
InputStreamReader(System.in))
) {
System.out.print("Enter an integer: ");
String input = userInput.readLine();
// Send the integer to the server
writer.write(input);
writer.newLine();
writer.flush();
// Receive the square from the server
String response = reader.readLine();
System.out.println("Server response: " + response);
} catch (IOException e) {
System.err.println("Error: " + e.getMessage());
}
}
}
Asm3:
package Asm3;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.ByteBuffer;
public class UDPServer {
public static void main(String[] args) throws Exception {
int port = 9876;
DatagramSocket serverSocket = new DatagramSocket(port);
System.out.println("Server is running...");
while (true) {
byte[] receiveData = new byte[8];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);
double realNumber = ByteBuffer.wrap(receiveData).getDouble();
double cubedValue = Math.pow(realNumber, 3);
System.out.println("Real number from Client: " + realNumber);
byte[] sendData = new byte[8];
ByteBuffer.wrap(sendData).putDouble(cubedValue);
InetAddress clientAddress = receivePacket.getAddress();
int clientPort = receivePacket.getPort();
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, clientAddress, clientPort);
serverSocket.send(sendPacket);
}
}
}
package Asm3;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.nio.ByteBuffer;
public class UDPClient {
public static void main(String[] args) throws Exception {
BufferedReader inFromUser = new BufferedReader(new
InputStreamReader(System.in));
int port = 9876;
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("localhost");
while (true) {
System.out.print("Please enter a real number: ");
String userInput = inFromUser.readLine();
double realNumber = Double.parseDouble(userInput);
byte[] sendData = new byte[8];
ByteBuffer.wrap(sendData).putDouble(realNumber);
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, IPAddress, port);
clientSocket.send(sendPacket);
byte[] receiveData = new byte[8];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
clientSocket.receive(receivePacket);
double cubedValue = ByteBuffer.wrap(receiveData).getDouble();
System.out.println("Cube of " + realNumber + " received from
server: " + cubedValue);
}
}
}
Mid-term : At server:
1. Server listens to the connection from clients and accepts them.
2. For each client, server has to create a thread that will maintain the connection with that client
(print out a message to screen each time server accepts a connection).
3. After accepting connection from client, server receives the first client’s message that is
[Student_ID]. Server calculates the 4 times of [Student_ID] and sends that value back to client.
(You should use BigInteger
4. Server does the loop:
Server receives the client’s message:
- If that message is a positive integer number, server calculates [number]4 and sends that value
back to client (You should use BigInteger).
- If that message is not a positive integer number, server just sends the client's message back to
client.
At client:
1. Client creates a connection to server.
2. After connecting successfully to server, client sends to server the first message that is
[Student_ID], then reads the 1st reply from server (4x[Student_ID]) and prints it out to the
screen.
3. Client does the following loop:
Client continues to read a message from user keyboard and sends that message to server.
If the message read from keyboard is an integer number, client prepares to receive a message
from server that is [number]4 and prints out to the client's screen
Otherwise, client just receives message from server and prints it out to the screen.
import java.io.*;
import java.net.*;
import java.math.BigInteger;
class ClientHandler extends Thread {
private Socket clientSocket;
public ClientHandler(Socket socket){
this.clientSocket = socket;
}
@Override
public void run() {
try {
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true);
String studentId = in.readLine();
BigInteger studentIdBigInt = new BigInteger(studentId);
BigInteger result =
studentIdBigInt.multiply(BigInteger.valueOf(4));
out.println(result.toString());
while (true) {
String clientMessage = in.readLine();
try {
BigInteger number = new BigInteger(clientMessage);
if (number.signum() <0) {
out.println(clientMessage);
} else {
BigInteger power4 = number.pow(4);
out.println(power4.toString());
}
} catch (NumberFormatException e) {
out.println(clientMessage);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class Server {
public static void main(String[] args) {
int port = 8000;
try {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("System listening on port " + port);
while (true) {
Socket clientSocket = serverSocket.accept();
System.out.println("Accepted connection from client: " +
clientSocket.getInetAddress());
Thread clientThread = new ClientHandler(clientSocket);
clientThread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Client {
public static void main(String[] args) {
String serverAddress = "localhost";
int serverPort = 8000;
String studentId = "2101040159";
try {
Socket socket = new Socket(serverAddress, serverPort);
System.out.println("Connected to server.");
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(),
true);
out.println(studentId);
String response = in.readLine();
System.out.println("Student ID: " + studentId);
System.out.println("Reply from server: " + response);
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("Enter a message: ");
String message = scanner.nextLine();
out.println(message);
response = in.readLine();
System.out.println("Response from server: " + response);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
mid UDP socket:
package UDPsocket;
import java.math.BigInteger;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPServer {
public static void main(String[] args) {
int port = 12345;
try {
DatagramSocket serverSocket = new DatagramSocket(port);
System.out.println("Server listening on port " + port);
byte[] receiveData = new byte[1024];
while (true) {
DatagramPacket receivePacket = new
DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
InetAddress clientAddress = receivePacket.getAddress();
int clientPort = receivePacket.getPort();
String clientMessage = new String(receivePacket.getData(), 0,
receivePacket.getLength());
try {
BigInteger number = new BigInteger(clientMessage);
// If the number is positive, multiply it by 4 and send
it back to the client
if (number.signum() > 0) {
BigInteger multipliedValue =
number.multiply(BigInteger.valueOf(4));
sendData(multipliedValue.toString(), serverSocket,
clientAddress, clientPort);
} else {
// If the number is not positive, send the client's
message back to the client
sendData(clientMessage, serverSocket, clientAddress,
clientPort);
}
} catch (NumberFormatException e) {
// If the message is not a valid integer, send the
client's message back to the client
sendData(clientMessage, serverSocket, clientAddress,
clientPort);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static void sendData(String data, DatagramSocket socket,
InetAddress clientAddress, int clientPort) {
try {
byte[] sendData = data.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, clientAddress, clientPort);
socket.send(sendPacket);
} catch (Exception e) {
e.printStackTrace();
}
}
}
package UDPsocket;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class UDPClient {
public static void main(String[] args) {
String serverAddress = "127.0.0.1";
int serverPort = 12345;
String studentId = "2101040159";
try {
DatagramSocket socket = new DatagramSocket();
InetAddress serverAddressInet =
InetAddress.getByName(serverAddress);
// Step 1: Send Student_ID
sendData(studentId, socket, serverAddressInet, serverPort);
// Step 2: Receive and print the 1st reply from the server
(4x[Student_ID])
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
socket.receive(receivePacket);
String response = new String(receivePacket.getData(), 0,
receivePacket.getLength());
System.out.println("Student ID: " + studentId);
System.out.println("1st reply from server: " + response);
// Step 3: Loop for user messages
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("Enter a message: ");
String message = scanner.nextLine();
sendData(message, socket, serverAddressInet, serverPort);
// Receive and print the response from the server
socket.receive(receivePacket);
response = new String(receivePacket.getData(), 0,
receivePacket.getLength());
System.out.println("Response from server: " + response);
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static void sendData(String data, DatagramSocket socket,
InetAddress serverAddress, int serverPort) {
try {
byte[] sendData = data.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, serverAddress, serverPort);
socket.send(sendPacket);
} catch (Exception e) {
e.printStackTrace();
}
}
}
