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();
}
}
}