1.

Develop a program for error detecting code using CRC-CCITT

(16- bits).

import java.util.Scanner;

import java.io.*;

public class CRC1

public static void main(String args[])

Scanner sc = new Scanner(System.in);

//Input Data Stream

System.out.print("Enter message bits: ");

String message = sc.nextLine();

System.out.print("Enter generator: ");

String generator = sc.nextLine();

int data[] = new int[message.length() + generator.length() - 1];

int divisor[] = new int[generator.length()];

for(int i=0;i<message.length();i++)

data[i] = Integer.parseInt(message.charAt(i)+"");

for(int i=0;i<generator.length();i++)

divisor[i] = Integer.parseInt(generator.charAt(i)+"");

//Calculation of CRC

for(int i=0;i<message.length();i++)

if(data[i]==1) for(int j=0;j<divisor.length;j++)

data[i+j] ^= divisor[j];

//Display CRC

System.out.print("The checksum code is: ");

for(int i=0;i<message.length();i++) data[i] =

Integer.parseInt(message.charAt(i)+"");
for(int i=0;i<data.length;i++)

System.out.print(data[i]);

System.out.println();

//Check for input CRC code

System.out.print("Enter checksum code: ");

message = sc.nextLine();

System.out.print("Enter generator: ");

generator = sc.nextLine(); data = new int[message.length() +

generator.length() - 1];

divisor = new int[generator.length()];

for(int i=0;i<message.length();i++)

data[i] = Integer.parseInt(message.charAt(i)+"");

for(int i=0;i<generator.length();i++)

divisor[i] = Integer.parseInt(generator.charAt(i)+"");

//Calculation of remainder

for(int i=0;i<message.length();i++)

if(data[i]==1)

for(int j=0;j<divisor.length;j++)

data[i+j] ^= divisor[j];

//Display validity of data

boolean valid = true;

for(int i=0;i<data.length;i++)

if(data[i]==1)

valid = false; break;

if(valid==true)
System.out.println("Data stream is valid");

else

System.out.println("Data stream is invalid. CRC error occurred.");

2. Develop a program for congestion control using leaky bucket

algorithm.

import java.util.Scanner;

import java.lang.*;

public class leaky {

public static void main(String[] args) {

int i; // Declaring a variable 'i' for loop control.

int a[] = new int[20];

int buck_rem = 0;

int buck_cap = 4;

int rate = 3;

int sent, recv;

Scanner in = new Scanner(System.in);

System.out.println("Enter the number of packets"); int n = in.nextInt();

System.out.println("Enter the packets");

for (i = 1; i <= n; i++) a[i] = in.nextInt();

System.out.println("Clock \t packet size \t accept \t sent \t remaining");

for (i = 1; i <= n; i++) {

if (a[i] != 0) {

if (buck_rem + a[i] > buck_cap) recv = -1

else { recv = a[i];

buck_rem += a[i];

}}
else { recv = 0;

if (buck_rem != 0)

if (buck_rem < rate) {

sent = buck_rem;

buck_rem = 0;

} else {

sent = rate; buck_rem = buck_rem - rate;

}}

else { sent = 0}

(recv == -1)

if (recv == -1)

System.out.println(i + "\t\t" + a[i] + "\t dropped \t" + sent + "\t" +

buck_rem); else // Otherwise, print the accepted, sent, and remaining
values. System.out.println(i + "\t\t" + a[i] + "\t\t" + recv + "\t" + sent + "\
t" + buck_rem); } } }

3. Develop a program for simple RSA algorithm to encrypt and

decrypt the data.

import java.io.DataInputStream;

import java.io.IOException;

import java.math.BigInteger;

import java.util.Random;

public class RSA {

private BigInteger p,q,N,phi,e,d;

private int bitlength=1024;

private Random r;

public RSA()

r=new Random();
p=BigInteger.probablePrime(bitlength,r);

q=BigInteger.probablePrime(bitlength,r);

System.out.println("Prime number p is"+p);

System.out.println("prime number q is"+q);

N=p.multiply(q);

phi=p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
e=BigInteger.probablePrime(bitlength/2,r);
while(phi.gcd(e).compareTo(BigInteger.ONE)>0&&e.compareTo(phi)<0)

e.add(BigInteger.ONE);

System.out.println("Public key is"+e); d=e.modInverse(phi);

System.out.println("Private key is"+d);

public RSA(BigInteger e,BigInteger d,BigInteger N)

this.e=e;

this.d=d;

this.N=N;

public static void main(String[] args)throws IOException

RSA rsa=new RSA();

DataInputStream in=new DataInputStream(System.in);

String testString; System.out.println("Enter the plain text:");

testString=in.readLine();

System.out.println("Encrypting string:"+testString);

System.out.println("string in
bytes:"+bytesToString(testString.getBytes()));

byte[] encrypted=rsa.encrypt(testString.getBytes());
byte[] decrypted=rsa.decrypt(encrypted);

System.out.println("Dcrypting Bytes:"+bytesToString(decrypted));

System.out.println("Dcrypted string:"+new String(decrypted));

private static String bytesToString(byte[] encrypted)

String test=" "; for(byte b:encrypted)

test+=Byte.toString(b);

return test;

public byte[]encrypt(byte[]message)

return(new BigInteger(message)).modPow(e,N).toByteArray();

public byte[]decrypt(byte[]message)

return(new BigInteger(message)).modPow(d,N).toByteArray();

4.Using TCP/IP sockets, write a client – server program to make

the client send the file name and to make the server send back
the contents of the requested file if present.

// TCP Server :

import java.net.*;

import java.io.*;
public class TCPS

public static void main(String[] args) throws Exception

ServerSocket sersock=new ServerSocket(4000);

System.out.println("Server ready for connection");

Socket sock=sersock.accept();

System.out.println("Connection Is successful and waiting for chatting");

InputStream istream=sock.getInputStream();

BufferedReader fileRead=new BufferedReader(new

InputStreamReader(istream));

String fname=fileRead.readLine();

BufferedReader ContentRead=new BufferedReader(new

FileReader(fname));

OutputStream ostream=sock.getOutputStream();

PrintWriter pwrite=new PrintWriter(ostream,true);

String str;

while((str=ContentRead.readLine())!=null)

pwrite.println(str);

sock.close();

sersock.close();

pwrite.close();

fileRead.close();

ContentRead.close();

}
TCP Client:

import java.net.*;

import java.io.*;

public class TCPC

public static void main(String[] args) throws Exception

Socket sock=new Socket("127.0.01",4000);

System.out.println("Enter the filename");

BufferedReader keyRead=new BufferedReader(new

InputStreamReader(System.in));

String fname=keyRead.readLine();

OutputStream ostream=sock.getOutputStream();

PrintWriter pwrite=new PrintWriter(ostream,true);

pwrite.println(fname);

InputStream istream=sock.getInputStream();

BufferedReader socketRead=new BufferedReader(new

InputStreamReader(istream));

String str;

while((str=socketRead.readLine())!=null)

System.out.println(str);

pwrite.close();

socketRead.close();

keyRead.close();

}
5. Develop a program on datagram socket for client/server to
display the messages on client side, typed at the server side.

//UDP Sever:

import java.net.*;

import java.net.InetAddress;

class UDPServer

public static void main(String args[])throws Exception

DatagramSocket serverSocket = new DatagramSocket(9876);

byte[] receiveData=new byte[1024];

byte[] sendData=new byte[1024];

while(true)

System.out.println("Server is Up");

DatagramPacket receivePacket=new
DatagramPacket(receiveData,receiveData.length);
serverSocket.receive(receivePacket);

String sentence=new String(receivePacket.getData());

System.out.println("RECEIVED:"+sentence);

InetAddress IPAddress=receivePacket.getAddress();

int port=receivePacket.getPort();

String capitalizedSentence=sentence.toUpperCase();

sendData=capitalizedSentence.getBytes();

DatagramPacket sendPacket=new
DatagramPacket(sendData,sendData.length,IPAddress,port);
serverSocket.send(sendPacket);

}
//UDP Client :

import java.io.*;

import java.net.*;

import java.net.InetAddress;

class UDPClient

public static void main(String[] args)throws Exception

BufferedReader inFromUser=new BufferedReader(new

InputStreamReader(System.in)); DatagramSocket clientSocket=new
DatagramSocket();

InetAddress IPAddress=InetAddress.getByName("localhost");

byte[] sendData=new byte[1024];

byte[] receiveData=new byte[1024];

System.out.println("Enter the sting to be converted in to Upper case");

String sentence=inFromUser.readLine(); sendData=sentence.getBytes();

DatagramPacket sendPacket=new
DatagramPacket(sendData,sendData.length,IPAddress,9876);
clientSocket.send(sendPacket);

DatagramPacket receivePacket=new
DatagramPacket(receiveData,receiveData.length);
clientSocket.receive(receivePacket);

String modifiedSentence=new String(receivePacket.getData());

System.out.println("FROM SERVER:"+modifiedSentence);

clientSocket.close();

6. Develop a program to find the shortest path between vertices

using the Bellman-Ford and path vector routing algorithm.
import java.util.Arrays;

class Graph {

class Edge {

int source, destination, weight;

Edge(int source, int destination, int weight) {

this.source = source; this.destination = destination;

this.weight = weight; } }

int vertices, edges;

Edge[] edgeList;

Graph(int vertices, int edges) {

this.vertices = vertices;

this.edges = edges;

edgeList = new Edge[edges];

void addEdge(int edgeIndex, int source, int destination, int weight)

{ edgeList[edgeIndex] = new Edge(source, destination, weight);

void bellmanFord(int startVertex) {

int[] distances = new int[vertices];

Arrays.fill(distances, Integer.MAX_VALUE);

distances[startVertex] = 0;

for (int i = 1; i < vertices; i++) {

for (int j = 0; j < edges; j++) {

int u = edgeList[j].source; int v = edgeList[j].destination;

int weight = edgeList[j].weight;

if (distances[u] != Integer.MAX_VALUE && distances[u] + weight <

distances[v]) { distances[v] = distances[u] + weight; } } } // Check for
negative-weight cycles for (int j = 0; j < edges; j++) {

int u = edgeList[j].source; int v = edgeList[j].destination;

int weight = edgeList[j].weight;

if (distances[u] != Integer.MAX_VALUE && distances[u] + weight <
distances[v]) { System.out.println("Graph contains a negative-weight
cycle"); return; } } printSolution(distances, startVertex); }

void printSolution(int[] distances, int startVertex) {

System.out.println("Vertex distances from source vertex " + startVertex +

":");

for (int i = 0; i < vertices; i++) {

System.out.println("To Vertex " + i + " is " + distances[i]); } }

void distanceVectorRouting(int[][] graph, int startVertex) {

int[] distances = new int[vertices];

Arrays.fill(distances, Integer.MAX_VALUE);

distances[startVertex] = 0; boolean updated;

do { updated = false;

for (int u = 0; u < vertices; u++) {

for (int v = 0; v < vertices; v++) {

if (graph[u][v] != Integer.MAX_VALUE && distances[u] !=

Integer.MAX_VALUE && distances[u] + graph[u][v] < distances[v]) {

distances[v] = distances[u] + graph[u][v]; updated = true; } } } }

while (updated); printSolution(distances, startVertex); }

public static void main(String[] args) {

int vertices = 5;

int edges = 8;

Graph graph = new Graph(vertices, edges); // Adding edges to the graph

graph.addEdge(0, 0, 1, -1);

graph.addEdge(1, 0, 2, 4);

graph.addEdge(2, 1, 2, 3);

graph.addEdge(3, 1, 3, 2);

graph.addEdge(4, 1, 4, 2);

graph.addEdge(5, 3, 2, 5);

graph.addEdge(6, 3, 1, 1);
graph.addEdge(7, 4, 3, -3); // Running Bellman-Ford Algorithm
System.out.println("Bellman-Ford Algorithm:"); graph.bellmanFord(0); //
Distance Vector Routing System.out.println("\nDistance Vector Routing
Algorithm:");

int[][] routingGraph = { {0, -1, 4, Integer.MAX_VALUE,

Integer.MAX_VALUE}, {Integer.MAX_VALUE, 0, 3, 2, 2},
{Integer.MAX_VALUE, Integer.MAX_VALUE, 0, Integer.MAX_VALUE,
Integer.MAX_VALUE}, {Integer.MAX_VALUE, 1, 5, 0, Integer.MAX_VALUE},
{Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, -3, 0}, };
graph.distanceVectorRouting(routingGraph, 0); } }

7. Develop a program to implement a sliding window protocol in

the data link layer.

import java.util.Arrays;

import java.util.Random;

class GoBackNProtocol {

private final int WINDOW_SIZE; // Window size

private final int TOTAL_FRAMES; // Total number of frames

private int nextFrameToSend = 0; // Index of the next frame to send

private int frameExpectedByReceiver = 0; // The frame that the

receiver expects

public GoBackNProtocol(int totalFrames, int windowSize) {

this.TOTAL_FRAMES = totalFrames;

this.WINDOW_SIZE = windowSize;

public void sendFrames() {

Random random = new Random();

while (nextFrameToSend < TOTAL_FRAMES) {

// Simulate sending frames in the current window

for (int i = 0; i < WINDOW_SIZE && nextFrameToSend <

TOTAL_FRAMES; i++) {
 System.out.println("Sender: Sending frame " +
nextFrameToSend);

nextFrameToSend++;

// Simulate receiving an ACK with some random loss

if (random.nextBoolean()) {

frameExpectedByReceiver += WINDOW_SIZE;

System.out.println("Receiver: ACK received for frames up to " +

frameExpectedByReceiver);

} else {

System.out.println("Receiver: ACK lost, resending frames from "

+ (frameExpectedByReceiver));

nextFrameToSend = frameExpectedByReceiver; // Go back to

the unacknowledged frame

System.out.println("All frames sent and acknowledged

successfully.");

public static void main(String[] args) {

int totalFrames = 10; // Total number of frames to send

int windowSize = 4; // Window size

GoBackNProtocol protocol = new GoBackNProtocol(totalFrames,

windowSize);

protocol.sendFrames();

}}