The post TCP/IP Another POST appeared first on Vimal Ghorecha's Personal Utopia.

TCP/IP and OSI Models, OSI Model, TCP/IP Model, TCP/IP Stack

The post Understanding TCP/IP and OSI Models appeared first on Vimal Ghorecha's Personal Utopia.

FileUpload: {
	title: 'Customers File',
	list: false,
	create: true,
	edit: true,
	input: function (data) {
		return '<div id="FileUpload" name="FileUpload"></div>';
	}
}

Step2: We will load AJAX File Upload on div which inserted in first step. When file upload through AJAX, it will return file name, after that we will store that file in one JavaScript variable called UploadedFile.

formCreated: function (event, data){
	data.form.attr('enctype','multipart/form-data');
	$("#FileUpload").uploadFile({
		url:"upload.php",
		fileName:"file",
		onSuccess:function(files,data,xhr){
			UploadedFile = data;
		}
	});
}

Step3: Furthermore, when we submit form for insert record we will set UploadedFile variable in on textbox which will send file name for inserting in database.

formSubmitting: function (event, data) {
	$("#FileUpload").html('<input type="text" id="thumb_img" name="thumb_img" value="' + UploadedFile + '">');
}

All other settings are same. Kindly feel free to talk to me.

Like to Download Source Code of Complete Example.

The post jTable jQuery Plugin File Upload Control appeared first on Vimal Ghorecha's Personal Utopia.

Hamming code is a set of error-correction code s that can be used to detect and correct bit errors that can occur when computer data is moved or stored.

Hamming Code Calculation

Hamming Code Implementation in C

Hamming Code Common Functions

#include<stdio.h>
int power(int n,int m)
{
        int i=0;
        int sum=1;
        for(i=1;i<=m;i++)
                sum *= n;
        return sum;
}
void dec2bin(char bits[], int l, int a)
{
        int i;
        for(i=l-1;i>=0;i--)
        {
                bits[i] = (a & 1) + '0';
                a >>= 1;
        }
}
unsigned char chrpos(int ch,int pos)
{
        return (ch & power(2,pos-1))>>(pos-1);
}
int calcBit(unsigned long c)
{
        int l=0;
        while(c>0)
        {
                l++;
                c>>=1;
        }
        return l;

}
struct checkbit
{
        unsigned int b:1;
};

Hamming Code Sender

//Hamming Code Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#include"hamcom.c"
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch;//Original Character
        char str[]="0000000000000000";//This is not part of Hamming Algorithm just for debug
        unsigned short cw=0,cand; //Codeword and temp code operation variable
        int i,ldata,j=0,lcode,rbit=1; //i,j-> Loop variable, ldata-> size of databits
        // lcode-> size of codeword bits, rbit->size of check bits

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");

        //HAMMING CODE LOGIC STARTS
        printf("Enter Character : ");
        scanf("%c",&ch);

        ldata = calcBit(ch);//Number of bits in original data

        //Logic of finding number of check bits
        while(power(2,rbit)<(ldata+rbit+1))
        {
                rbit++;
        }

        //Length of codeword = length of data + length of check bits
        lcode = ldata + rbit;

        //defining all checkbits
        struct checkbit  r[rbit];
        for(i=0;i<rbit;i++)
        {
                r[i].b = 0;
        }

        //STEP-1 Filling all data bits in codeword
        for(i=3;i<=lcode;i++)
        {
                if(i&(i-1)){ //Condition of Power of 2
                        cand = ch & power(2,j++);
                        cw = cw | (cand<<(i-j));
                }
        }

        //codeword after filling data bits
        dec2bin(str,16,cw);
        printf("%d %s\n",cw,str);

        //STEP-2 calculating all checkbits (parity bits)
        for(i=3;i<=lcode;i++)
        {
                if(i & (i-1)){ //condition for Power of 2
                        for(j=0;j<rbit;j++){
                                if(i & power(2,j)){ //condition for including data bit in parity or not (1,3,5,7,9... include in 1 because all has 1 in last bit)
                                        r[j].b = r[j].b ^ chrpos(cw,i);
                                }
                        }
                }
        }

        //STEP-3 Fill check bits in code word
        for(i=1,j=0;i<=lcode;i++)
        {
                if(!(i&(i-1)))//Conditio nfor only power of 2
                {
                        cw = cw | (r[j++].b << (power(2,j)-1));
                }
        }

        //Final Code word
        dec2bin(str,16,cw);
        printf("\n%d %s\n",cw,str);

        //HAMMING CODE LOGIC ENDS

        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,&cw,sizeof(cw)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

Hamming Code Receiver

//Hamming Code Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#include"hamcom.c" //Common function file for hamming code
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch;//Original Character
        char str[]="0000000000000000";//This is not part of Hamming Algorithm just for debug
        unsigned short cw=0,cand=0; //Codeword and temp code operation variable
        int i,ldata,j=0,lcode,rbit=0;

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,&cw,sizeof(cw)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");

        cw = cw | power(2,9);
        dec2bin(str,16,cw);
        printf("%d %s\n",cw,str);
        //HAMMING CODE LOGIC STARTS

        lcode = calcBit(cw);

        printf("%d\n",lcode);

        for(i=1;i<=lcode;i++)
        {
                if(i & (i-1))
                        continue;
                rbit++;
        }
        struct checkbit r[rbit];

        for(i=0;i<rbit;i++)
        {
                r[i].b = 0;
        }
        for(i=1;i<=lcode;i++)
        {
                for(j=0;j<rbit;j++){
                        if(i & power(2,j)){
                                r[j].b = r[j].b ^ chrpos(cw,i);
                        }
                }
        }

        for(i=0;i<rbit;i++)
        {
                printf(" %d",r[i].b);
                cand = cand | (r[i].b<<i);
        }

        if(cand){
                printf("\nError on %d position",cand);
                printf("\nCorrecting...");
                if(chrpos(cw,cand))
                        cw -= power(2,cand-1);
                else
                        cw += power(2,cand-1);
        }

        printf("\nCORRECT DATA : \n");
        dec2bin(str,16,cw);
        printf("%d %s\n",cw,str);
        cand = 0;
        for(i=1,j=0;i<=lcode;i++){
                if(i & (i-1)){
                        cand = cand | (chrpos(cw,i)<<j++);
                }
        }
        printf("%c\n",cand);

        //HAMMING CODE LOGIC ENDS
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Hamming Code Implementation in C appeared first on Vimal Ghorecha's Personal Utopia.

CRC Implementation in C with efficient algorithm. CRC Implementation with bitwise operators and example.

Best error detection algorithm which used for data transmission.

Modulo-2 binary division

CRC Modulo 2 Division

The modulo-2 division process is defined as follows:

Call the uppermost c+1 bits of the message the remainder

• Beginning with the most significant bit in the original message and for each bit position that follows, look at the c+1 bit remainder:
  • If the most significant bit of the remainder is a one, the divisor is said to divide into it. If that happens (just as in any other long division) it is necessary to indicate a successful division in the appropriate bit position in the quotient and to compute the new remainder. In the case of modulo-2 binary division, we simply:
    • Set the appropriate bit in the quotient to a one, and
    • XOR the remainder with the divisor and store the result back into the remainder
  • Otherwise (if the first bit is not a one):
    • Set the appropriate bit in the quotient to a zero, and
    • XOR the remainder with zero (no effect)
  • Left-shift the remainder, shifting in the next bit of the message. The bit that’s shifted out will always be a zero, so no information is lost.

The final value of the remainder is the CRC of the given message.

CRC Implementation in C

Common file for Both and Reciever

//CRC Common File for Both Sender and Receiver
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message

unsigned short POLYNOMIAL;//Divisor
int spoly=0,sdata=0; //Size of bits in divisor and actual data

struct codeword
{
        unsigned short data;
        unsigned short rem;
};

//Power function for generating power
unsigned long power(unsigned long no,unsigned long len)
{
        unsigned long pow=1,i;
        for(i=1;i<=len;i++)
                pow *= no;
        return pow;
}

//Actual CRC logic which will return remainder
unsigned short crcCalc(unsigned short const message)
{
    unsigned short  remainder,fdigit,bit;

        /* Initially, the dividend is the remainder.  */
        remainder = message;

        //Generating number which will return first bit from left side
        fdigit = power(2,sdata-1);

        //For each bit position in the message....
        for (bit = 0; bit < sdata; bit++)
        {
                //If the uppermost bit is a 1...
                if (remainder & fdigit )
                {
                        //XOR the previous remainder with the divisor.
                        remainder ^= POLYNOMIAL;
                }

                //Shift the next bit of the message into the remainder.
                remainder = (remainder << 1);
        }

        //Return only the relevant bits of the remainder as CRC.
        return (remainder >> (sdata-spoly+1));
}

 CRC Sender Code

//CRC Sender Example
#include "crccom.c" //Common Function of CRC
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Original Message to be sent
        unsigned short tpoly; //temp poly for checking no of bits in poly
        struct codeword ch;

        POLYNOMIAL=19;

        printf("Polynomial (Divisor) : %d",POLYNOMIAL);

        printf("\nEnter Data Character : ");
        scanf("%d",&tpoly);

        ch.data = tpoly;
        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");

        //Calculate number of bits in divisor.
        tpoly = POLYNOMIAL;
        while(tpoly > 0)
        {
                tpoly /= 2;
                spoly++;
        }

        //Total bits for storing data
        sdata = sizeof(ch.data)*8;

        //Move all bits in divisor to the start position
        POLYNOMIAL <<= (sdata-spoly);

        //Calculate acutal CRC
        ch.rem = crcCalc(ch.data);
        printf("Data=> %d, Remainder => %d\n",ch.data,ch.rem);
        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,&ch,sizeof(struct codeword)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

CRC Receiver Code

//CRC Receiver Example
#include "crccom.c" //CRC Common Functions

int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        struct codeword ch;
        unsigned short rem,tpoly;

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,&ch,sizeof(struct codeword)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");

        //CRC Logic Starts

        POLYNOMIAL = 19;
        printf("\nPolynomial (Divisor) : %d\n",POLYNOMIAL);

        tpoly = POLYNOMIAL;
        while(tpoly > 0)
        {
                tpoly /= 2;
                spoly++;
        }
        //Total bits for storing data
        sdata = sizeof(ch.data)*8;

        //Move all bits in divisor to the start position
        POLYNOMIAL <<= (sdata-spoly);
        rem = crcCalc(ch.data);

        if(rem != ch.rem){
                printf("Error in Transmission");
                exit(-5);
        }

        printf("\nSuccessfull Trasmission Original Message : %d",ch.data);

        //CRC Logic Ends

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post CRC Implementation in C appeared first on Vimal Ghorecha's Personal Utopia.

In this error detection method, a block of bits is organized in a table with rows and columns.  Then the parity bit for each column is calculated and a new row of eight bits, which are the parity bits for the whole block, is created.  After that  the new calculated parity bits are attached to the original data and sends to the receiver.

LRC increases the likelihood of detecting burst error.  An LRC of n bits can easily detects a burst error of n bits.

However, if two bits in one data unit are damaged and two bits in exactly the same positions in another data unit are also damaged, the LRC checker will not detect an error.

Notice that although the 5^th bit and the 7^th bit for 1^st and 2 ^nd data unit have been changed but the LRC calculated by receiver is still the same as the LRC received. Thus the receiver checker cannot detect this burst error.

Block Parity Checker LRC Implementation in Unix C

lrcsen.c (Block Parity LRC Sender)

//Block Parity LRC Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch[100],parity=0; //Unsigned character string and parity bit
        int i; // loop variable

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");

        /* LRC LOGIC STARTS */
        printf("Enter Any String : ");
        gets(ch);

        for(i=0;ch[i]!='\0';i++)
        {

                parity ^= ch[i];
        }
        printf("\nOriginal Message => %s",ch);
        printf("\nParity Character => %c %d",parity,parity);

        //Adding Parity Bit (Character) at Last
        ch[i++] = parity;
        ch[i] = '\0';

        printf("\nMessage After LRC => %s\n",ch);

        /* LRC Logic Ends */

        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,ch,sizeof(ch)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

lrcrec.c (Block Parity LRC Receiver)

//Block Parity LRC Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch[100],parity=0,nparity=0; //Here we will take two parity character one which received from sender and one which we will calculate
        int i; //loop variable
        int len; // message length

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,ch,sizeof(ch)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");
        len = strlen(ch)-1;

        /* LRC Logic Stars */
        printf("\nRecieved Message => %s",ch);

        //Received Parity Character
        parity = ch[len]; // last character of string added by sender

        //Now we calculate parity

        for(i=0;i<len;i++)
        {
                nparity ^= ch[i];
        }

        if(parity != nparity){
                printf("\nMessage Currupted...");
                exit(-5);
        }

        ch[len] = '\0'; // replace parity character with null character

        printf("\nOriginal Message => %s\n",ch);

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Block Parity Checker LRC appeared first on Vimal Ghorecha's Personal Utopia.

The simplest and oldest error detection method. A binary digit called parity is used to indicate whether the number of bits with “1” in a given set of bits is even or odd. The parity bit is then appended to original data.
Usually used to detect transmission error . Sender adds the parity bit to existing data bits before transmission.
Receiver checks for the expected parity, If wrong parity found, the received data is discarded and retransmission is requested.

vrcsen.c

//VRC Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch,tch,parity=0; //Unsigned character because we will use first bit as parity bit

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");

        /* VRC LOGIC STARTS */
        printf("Enter Any Valid Character : ");
        scanf("%c",&ch);
        tch=ch;

        while(tch > 0)
        {

                parity ^= tch & 1; //Extract one by one bit and XOR it with parity
                tch >>= 1;
        }
        printf("\nOriginal Character => %c",ch);

        if(parity) //If Parity is 1 means total number of 1's is ODD and we need to set parity 1
                ch += 128; //10000000 will set parity 1

        printf("\nStuffed Character => %c\n",ch);
        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,&ch,sizeof(ch)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

 vrcrec.c

//VRC Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        unsigned char ch,tch,parity=0;

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,&ch,sizeof(ch)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");
        printf("\nRecieved Character => %c",ch);
        tch = ch;

        while(tch > 0)
        {
                parity ^= tch & 1; //Extract last bit and XOR it with Parity
                tch >>= 1; //Remove last bit using right shift
        }

        if(parity){ //If parity is 1 means total no of 1's is ODD
                printf("\nMessage Currupted...");
                exit(-5);
        }

        if(ch > 128) //If ASCII is > 128 then it means we added 128 to make character parity even
                ch-= 128;

        printf("\nOriginal Character => %c\n",ch);

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Single Parity Bit Checker VRC appeared first on Vimal Ghorecha's Personal Utopia.

Byte stuffing is framing technique in which we add special characters (called flag) to distinguish beginning and end of a frame. This technique only works with text data.

In above technique there is problem when flag encounter as data. To overcome this problem we again introduce new special character (called Escape).  The escape characters have a predefined pattern. The receiver removes the escape character and keeps the data part. It cause to another problem, if the text contains escape characters as part of data. To deal with this, an escape character is prefixed with another escape character.

Byte Stuffing Sender Receiver Example

bytestuffsen.c

//Named Piped Byte Stuff Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
#define FLAG '$' //Flag character for starting and ending of frame
#define ESC '#' //Escape character for escaping flag
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Original Message to be sent
        char smsg[MAX]; //Stuffed Message to be stored in this variable
        int i=0,j=0;

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");
        printf("Enter Message : ");
        gets(msg);

        //Byte Stuff Start
        smsg[j++] = FLAG; //Put FLAG in starting of stuff message
        for(i=0;msg[i]!='\0';i++)
        {
                if(msg[i] == FLAG || msg[i] == ESC) //If message character is FLAG or ESC
                {
                        smsg[j++] = ESC;//Escape it
                }
                smsg[j++] = msg[i];
        }
        smsg[j++] = FLAG;//Put Flag in ending of stuff message
        smsg[j] = '\0'; //End ths Stuffed message

        //Byte Stuff End

        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,smsg,sizeof(smsg)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

bytestufrec.c

//Named Piped Byte Stuff Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
#define FLAG '$'
#define ESC '#'
int main()
{
        char *myfifo = "myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Stuffed Message received from Sender
        char dmsg[MAX]; //Original Message after De-Stuff
        int i=0,j=0;

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,msg,sizeof(msg)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");
        printf("\nStuffed Message : %s",msg);

        //Byte De-Stuff Start
        for(i=1;strlen(msg)-1;i++)//We start loop with 1 because want to ignore first FLAG
        {
                if(msg[i] == FLAG || msg[i] == ESC)
                {
                        i++;
                }
                dmsg[j++] = msg[i];
        }
        dmsg[j] = '\0';
        //Byte De-Stuff End
        printf("\nDestuffed Message : %s",dmsg);

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Byte Stuffing Sender Receiver appeared first on Vimal Ghorecha's Personal Utopia.

Framing Technique Bit Stuffing Demonstration

Bit Stuffing Sender Receiver Example

bitstuffsen.c

//Named Piped BitStuffing Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
int main()
{
        char *myfifo = "/tmp/myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Original Message to be sent
        char smsg[MAX]; //Stuffed Message to be sent to Pipe
        int i=0,j=0; //Loop variable for traversal of text
        int cnt=0; //Five Consicutive 1 counter

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");
        printf("Enter Message : ");
        gets(msg);

        /*
        BITSTUFF LOGIC START
        */
        for(i=0;msg[i] != '\0';i++)
        {
                smsg[j++] = msg[i]; //Store every character into Stuffed Message
                if(msg[i] == '1')
                {
                        cnt++;
                }
                else
                        cnt = 0; //If 0 encounter then reset 1's counter
                if(cnt == 5) //If Five consicutive 1's encounter Stuf Extra Bit(0)
                {
                        smsg[j++] = '0';
                        cnt = 0; //Again Set Counter to 0
                }
        }
        smsg[j] = '\0';
        /*
        BITSTUFF LOGIC END
        */

        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,smsg,sizeof(smsg)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

bitstuffrec.c

//Named Piped BitStuffing Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
int main()
{
        char *myfifo = "/tmp/myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Stuffed Message Received From Sender
        char dmsg[MAX]; //Orignal Message After De-Stuff
        int i=0,j=0; //Loop Variable for trafersal of text
        int cnt=0; //Counter variable for Five Consicutive 1

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,msg,sizeof(msg)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");
        printf("\nStuffed Message : ");
        puts(msg);

        /*
        * BIT DE-STUF LOGIC START
        */
        for(i=0;i<strlen(msg);i++)
        {
                if(cnt == 5) //If Five consicutive 1's encounter Remove Bit(0)
                {
                        cnt = 0; //Reset 1's counter
                        continue;
                }
                if(msg[i] == '1')
                        cnt++;
                else
                        cnt=0;//If 0 encounter then reset 1's counter
                dmsg[j++] = msg[i];//Store character into De-Stuffed Message
        }
        dmsg[j] = '\0';
        printf("\nOriginal Message : ");
        puts(dmsg);
        /*
        * BIT DE-STUF LOGIC END
        */

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Bit Stuffing Sender Receiver appeared first on Vimal Ghorecha's Personal Utopia.

A named pipe is really just a special kind of file (a FIFO file) on the local hard drive. Unlike a regular file, a FIFO file does not contain any user information. Instead, it allows two or more processes to communicate with each other by reading/writing to/from this file.

Creating FIFO File
You can create a FIFO with the mkfifo(1) command or the mkfifo(3) function call. From the command line, issue

mkfifo [-m mode] fifoname

int mkfifo(const char *name, mode_t mode)

Using a FIFO File
Since this named pipe looks like a file, you can use all the system calls associated with files to interact with it. In particular, you can use the open, read, write, and close system calls. The following are prototypes for each of these calls as you will need to use them.

• int open(const char *pathname, int flags);
• int read(int fd, void *buf, size_t count);
• int write(int fd, const void *buf, size_t count);
• int close(fd);

Named Pipe FIFO Sender Receiver Example

sender.c

//Named Piped Sender Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
int main()
{
        char *myfifo = "/tmp/myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Original Message to be sent

        printf("Creating Pipe...Waiting for receiver for Process...\n");
        //Creating Named Pipe
        //mkfifo(<filepath>,<permission>)
        if(mkfifo(myfifo,0666) < 0)
        {
                perror("FIFO (Named Pipe) could not be created.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Created...\n");

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_WRONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened.\n");
                exit(-2);
        }
        else
                printf("FIFO (Named Pipe) Opened...\n");
        printf("Enter Message : ");
        gets(msg);

        //Writing to Named Pipe
        //write(<open_pipe_return_value>,<message>,<msgsize>);
        if(write(fp,msg,sizeof(msg)) < 0)
        {
                perror("Error writing to FIFO (Named Pipe)\n");
                exit(-3);
        }
        else printf("Message has been sent to FIFO (Named Pipe)\n");

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\n");
                exit(-4);
        }
        return 0;
}

receiver.c

//Named Piped Receiver Example
#include<stdio.h> //Standard Input Functions
#include<sys/types.h> //Named Pipes (FIFO) Types
#include<sys/stat.h> // Named Pipes (FIFO) Functions
#include<fcntl.h> //File Control Unix Functions
#include<unistd.h> //Unix Standard Functions
#define MAX 100 //Buffer Size for Writing Message
int main()
{
        char *myfifo = "/tmp/myfifo"; //FIFO File Path
        int fp; //Open Pipe Return Value
        char msg[MAX]; //Original Message to be sent

        //Opening Named Pipe
        //open(<filepath>,<openingmode>);
        fp = open(myfifo,O_RDONLY);
        if(fp < 0)
        {
                perror("FIFO (Named Pipe) could not be opened for reading.\n");
                exit(-1);
        }
        else
                printf("FIFO (Named Pipe) Opened... Trying to read from\n");

        //Reading From Named Pipe
        //read(<open_pipe_return_value>,<message>,<msgsize>);
        if(read(fp,msg,sizeof(msg)) < 0)
        {
                perror("Error reading from FIFO (Named Pipe)\n");
                exit(-2);
        }
        else printf("Message Received from FIFO (Named Pipe)\n");
        printf("\nMessage : ");
        puts(msg);

        //Closing Named Pipe
        //close(<open_pipe_return_value>);
        if(close(fp) < 0)
        {
                perror("Error closing FIFO (Named Pipe)\b");
                exit(-3);
        }

        if(unlink(myfifo) < 0)
        {
                perror("Error deleting FIFO (Named Pipe)\b");
                exit(-4);
        }
        return 0;
}

The post Named Pipe FIFO Sender Receiver appeared first on Vimal Ghorecha's Personal Utopia.