Técnica de detección de errores de relleno de bits usando Java

Requisitos previos: 1

. Programación de sockets en Java 

2. Relleno de bits 

3. Encuadre en la capa de enlace de datos 

Los datos se encapsulan en marcos en la capa de enlace de datos y se envían a través de la red. Bit Stuffing es una técnica de detección de errores. 

La idea utilizada es muy simple. Cada cuadro comienza y termina con un patrón de bits especial «01111110», que es el byte indicador. Cada vez que la capa de enlace de datos del remitente encuentra cinco 1 consecutivos en los datos, inserta automáticamente un bit 0 en el flujo de bits saliente. El relleno de bits es análogo al relleno de bytes, en el que un byte de escape se rellena en el flujo de caracteres en curso antes de un byte de bandera en los datos. 

Cuando el receptor ve cinco bits 1 consecutivos, seguidos de un bit 0, tiñe (borra) automáticamente el bit 0. El relleno de bits es completamente transparente para la capa de red tanto en las computadoras emisoras como en las receptoras. 

Con el relleno de bits, el límite entre los dos cuadros se puede reconocer sin ambigüedades por el patrón de bandera. Por lo tanto, si el receptor pierde la pista de dónde está, todo lo que tiene que hacer es escanear la entrada en busca de secuencias de banderas, ya que solo pueden ocurrir en los límites del marco y nunca dentro de los datos.

Illustrative Examples

Sender Side(Client):
User enters a binary data as input.
Enter data: 
0000001
Data is stuffed and sent to the receiver for unstuffing. 
Here server is the receiver.
Data stuffed in client: 01111110000000101111110
Sending to server for unstuffing

Receiver Side(Server):
Receiver receives the stuffed data. 
Stuffed data from client: 01111110000000101111110
Receiver has to unstuff the input data from sender and get the original data which 
was given as input by the user.
Unstuffed data: 
0000001

La implementación del código de la lógica anterior se proporciona a continuación. 

En el lado del remitente (lado del cliente): 

package bitstuffing;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class BitStuffingClient {
    public static void main(String[] args) throws IOException
    {
        // Opens a socket for connection
        Socket socket = new Socket("localhost", 6789);
 
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
 
        // Scanner class object to take input
        Scanner sc = new Scanner(System.in);
 
        // Takes input of unstuffed data from user
        System.out.println("Enter data: ");
        String data = sc.nextLine();
 
        int cnt = 0;
        String s = "";
        for (int i = 0; i < data.length(); i++) {
            char ch = data.charAt(i);
            if (ch == '1') {
 
                // count number of consecutive 1's
                // in user's data
                cnt++;
 
                if (cnt < 5)
                    s += ch;
                else {
 
                    // add one '0' after 5 consecutive 1's
                    s = s + ch + '0';
                    cnt = 0;
                }
            }
            else {
                s += ch;
                cnt = 0;
            }
        }
 
        // add flag byte in the beginning
        // and end of stuffed data
        s = "01111110" + s + "01111110";
 
        System.out.println("Data stuffed in client: " + s);
        System.out.println("Sending to server for unstuffing");
        dos.writeUTF(s);
    }
}

En el lado del receptor (lado del servidor): 

package bitstuffing;
import java.io.*;
import java.net.*;
public class BitStuffingServer {
    public static void main(String[] args) throws IOException
    {
        ServerSocket skt = new ServerSocket(6789);
 
        // Used to block until a client connects to the server
        Socket socket = skt.accept();
 
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
 
        // Receiving the string from the client which
        // needs to be stuffed
        String s = dis.readUTF();
        System.out.println("Stuffed data from client: " + s);
 
        System.out.println("Unstuffed data: ");
        int cnt = 0;
 
        // removal of stuffed bits:
        // start from 9th bit because the first 8
        //  bits are of the special pattern.
        for (int i = 8; i < s.length() - 8; i++) {
            char ch = s.charAt(i);
            if (ch == '1') {
                cnt++;
                System.out.print(ch);
 
                // After 5 consecutive 1's one stuffed bit
                //'0' is added. We need to remove that.
                if (cnt == 5) {
                    i++;
                    cnt = 0;
                }
            }
            else {
 
                // print unstuffed data
                System.out.print(ch);
 
                // we only need to maintain count
                // of consecutive 1's
                cnt = 0;
            }
        }
        System.out.println();
    }
}

La entrada y la salida son como se muestra arriba.