BitStuffingServer.java---.txt

BitStuffingServer.java---

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

class BitStuffingServer {
    public static void main(String argv[]) throws Exception {
        DatagramSocket serverSocket = new DatagramSocket(6789);
        System.out.println("UDP Bit Stuffing Server is running on port 6789...\n");

        byte[] receiveBuffer = new byte[1024];
        byte[] sendBuffer;
        DatagramPacket sendPacket;

        while (true) {
            // Receive message from client
            DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
            serverSocket.receive(receivePacket);
            InetAddress clientAddress = receivePacket.getAddress();
            int clientPort = receivePacket.getPort();
            
            String data = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received Data: " + data);

            // Perform bit stuffing
            String stuffedData = bitStuff(data);
            System.out.println("Bit-Stuffed Data: " + stuffedData);

            // Perform bit unstuffing
            String unstuffedData = bitUnstuff(stuffedData);
            System.out.println("Bit-Unstuffed Data: " + unstuffedData);

            // Send stuffed data back to client
            sendBuffer = stuffedData.getBytes();
            sendPacket = new DatagramPacket(sendBuffer, sendBuffer.length, clientAddress, clientPort);
            serverSocket.send(sendPacket);
        }
    }

    // Method to perform bit stuffing
    public static String bitStuff(String data) {
        StringBuilder stuffedData = new StringBuilder("01111110"); // Start flag byte
        int count = 0;

        for (int i = 0; i < data.length(); i++) {
            if (data.charAt(i) == '1') {
                count++;
                stuffedData.append("1");
                if (count == 5) {
                    stuffedData.append("0"); // Stuff a '0' after five consecutive '1's
                    count = 0;
                }
            } else {
                stuffedData.append("0");
                count = 0;
            }
        }
        stuffedData.append("01111110"); // End flag byte
        return stuffedData.toString();
    }

    // Method to perform bit unstuffing
    public static String bitUnstuff(String data) {
        StringBuilder unstuffedData = new StringBuilder();
        int count = 0;

        // Remove flag bytes first
        String actualData = data.substring(8, data.length() - 8);

        for (int i = 0; i < actualData.length(); i++) {
            if (actualData.charAt(i) == '1') {
                count++;
                unstuffedData.append("1");
                if (count == 5 && i + 1 < actualData.length() && actualData.charAt(i + 1) == '0') {
                    i++; // Skip the stuffed '0'
                    count = 0;
                }
            } else {
                unstuffedData.append("0");
                count = 0;
            }
        }
        return unstuffedData.toString();
    }
}


BitStuffingClient.java---

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

class BitStuffingClient {
    public static void main(String[] args) throws Exception {
        DatagramSocket clientSocket = new DatagramSocket();
        InetAddress serverAddress = InetAddress.getByName("localhost");
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("Enter binary data: ");
        String data = scanner.nextLine();
        scanner.close();

        // Send data to server
        byte[] sendBuffer = data.getBytes();
        DatagramPacket sendPacket = new DatagramPacket(sendBuffer, sendBuffer.length, serverAddress, 6789);
        clientSocket.send(sendPacket);

        // Receive stuffed data from server
        byte[] receiveBuffer = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
        clientSocket.receive(receivePacket);
        String stuffedData = new String(receivePacket.getData(), 0, receivePacket.getLength());

        System.out.println("Received Bit-Stuffed Data: " + stuffedData);

        clientSocket.close();
    }
}


OUTPUT---
SERVER--

PS C:\Users\Arpita Nath\Desktop\j> javac BitStuffingServer.java BitStuffingClient.java
PS C:\Users\Arpita Nath\Desktop\j> java BitStuffingServer
UDP Bit Stuffing Server is running on port 6789...

Received Data: 01001111110111111
Bit-Stuffed Data: 01111110010011111010111110101111110
Bit-Unstuffed Data: 01001111110111111
PS C:\Users\Arpita Nath\Desktop\j> 

CLIENT---

PS C:\Users\Arpita Nath\Desktop\j>  java BitStuffingClient
Enter binary data: 01001111110111111
Received Bit-Stuffed Data: 01111110010011111010111110101111110
PS C:\Users\Arpita Nath\Desktop\j> 

------------------------------------------------------------------------------------------------------------------------------------------------------------
ParityReceiverServerstop.java---

import java.io.*;
import java.net.*;

public class ParityReceiverServerstop {
    public static void main(String[] args) throws IOException {
        int port = 6789;
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("Server is running on port " + port);

        while (true) { // Keeps the server running
            
            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected...");

            BufferedReader inFromClient = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            DataOutputStream outToClient = new DataOutputStream(clientSocket.getOutputStream());

            int expectedSeq = 0; // Expected sequence number

            String receivedData = inFromClient.readLine();
            if (receivedData == null) continue;
            System.out.println("Received Data: " + receivedData);

            int receivedSeq = receivedData.charAt(0) - '0';  // Extract sequence number
            String data = receivedData.substring(1, receivedData.length() - 1); // Extract actual data
            int receivedParity = receivedData.charAt(receivedData.length() - 1) - '0'; // Extract parity bit

            // Compute parity check
            int count = 0;
            for (char bit : data.toCharArray()) {
                if (bit == '1') count++;
            }
            int computedParity = (count % 2 == 0) ? 0 : 1;

            if (receivedSeq == expectedSeq && computedParity == receivedParity) {
                System.out.println("Data is correct. Sending ACK.");
                outToClient.writeBytes(expectedSeq + "ACK\n");
                expectedSeq = 1 - expectedSeq; // Toggle expected sequence number
            } else {
                System.out.println("Incorrect data! Ignoring frame.");
            }
            
            clientSocket.close(); // Close connection after processing the message
        }
    }
}


ParitySenderClientstop.java---

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ParitySenderClientstop {
    public static void main(String[] args) throws IOException {
        String serverIP = "localhost"; 
        int serverPort = 6789;

        Socket socket = new Socket(serverIP, serverPort);
        System.out.println("Connected to server on port " + serverPort);

        BufferedReader inFromServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        DataOutputStream outToServer = new DataOutputStream(socket.getOutputStream());
        Scanner scanner = new Scanner(System.in);

        int seq = 0; // Sequence number alternates between 0 and 1

        
            System.out.print("Enter binary data: ");
            String data = scanner.nextLine();

            // Compute even parity bit
            int count = 0;
            for (char bit : data.toCharArray()) {
                if (bit == '1') count++;
            }
            String parityBit = (count % 2 == 0) ? "0" : "1";  // Append parity bit

            String dataWithParity = seq + data + parityBit; // Add sequence number and parity
            System.out.println("Sending Data with Parity: " + dataWithParity);

            boolean ackReceived = false;
            
            while (!ackReceived) {
                outToServer.writeBytes(dataWithParity + "\n"); // Send data

                try {
                    socket.setSoTimeout(2000);  // 2 seconds timeout for ACK
                    String response = inFromServer.readLine();
                    
                    if (response != null && response.equals(seq + "ACK")) {
                        System.out.println("ACK received for sequence: " + seq);
                        seq = 1 - seq;  // Toggle sequence number
                        ackReceived = true;
                    }
                } catch (SocketTimeoutException e) {
                    System.out.println("Timeout! Retransmitting...");
                }
            }
        
    }
}


PS C:\Users\Arpita Nath\Desktop\j> javac ParityReceiverServerstop.java ParitySenderClientstop.java
PS C:\Users\Arpita Nath\Desktop\j> java ParityReceiverServerstop
Server is running on port 6789
Client connected...
Received Data: 01010110
Data is correct. Sending ACK.


PS C:\Users\Arpita Nath\Desktop\j> java ParitySenderClientstop
Connected to server on port 6789
Enter binary data: 101011
Sending Data with Parity: 01010110
ACK received for sequence: 0
PS C:\Users\Arpita Nath\Desktop\j>