Character stuffing program in C

Character stuffing is a technique used in computer programming to control data transmission between different systems or devices. It involves adding special characters or sequences of characters to the data being transmitted to mark the beginning and end of a data frame. This article will explore character stuffing and how it can be implemented in the C programming language.

Character stuffing is commonly used in data communication protocols to ensure the receiving system correctly interprets the transmitted data. It helps frame the data so that the receiver can easily identify the start and end of each data frame. One common use case of character stuffing is serial communication, where data is transmitted one bit at a time over a communication channel.

Implementing character stuffing in C involves adding special characters or sequences of characters to the original data before transmission and removing them at the receiving end to extract the original data. Look at a simple example of a character stuffing program in C.

Example:

#include <stdio.h>
#include <string.h>

void characterStuffing(char* originalData, char* stuffedData, char startChar, char endChar, char escapeChar)
{
    int originalLength = strlen(originalData);
 int stuffedLength = 0;

    for (int i = 0; i < originalLength; i++) {
        if (originalData[i] == startChar || originalData[i] == endChar || originalData[i] == escapeChar) {
            stuffedData[stuffedLength++] = escapeChar;
        }
        stuffedData[stuffedLength++] = originalData[i];
    }

    stuffedData[stuffedLength] = '\0';
}

void characterDestuffing(char* stuffedData, char* originalData, char startChar, char endChar, char escapeChar)
{
    int stuffedLength = strlen(stuffedData);
    int originalLength = 0;

    for (int i = 0; i < stuffedLength; i++) {
        if (stuffedData[i] == escapeChar) {
            i++;
        }
        originalData[originalLength++] = stuffedData[i];
    }

    originalData[originalLength] = '\0';
}

int main()
{
    char originalData[100] = "Hello World!";
    char stuffedData[200];
    char destuffedData[100];

    char startChar = '<';
    char endChar = '>';
    char escapeChar = '\\';

    printf("Original Data: %s\n", originalData);

characterStuffing(originalData, stuffedData, startChar, endChar, escapeChar);
    printf("Stuffed Data: %s\n", stuffedData);

    characterDestuffing(stuffedData, destuffedData, startChar, endChar, escapeChar);
    printf("Destuffed Data: %s\n", destuffedData);

    return 0;
}

Output:

Original Data: Hello World!
Stuffed Data: Hello World!
Destuffed Data: Hello World!

Explanation:

In the above example, we are defining two functions - characterStuffing() and characterDestuffing(). The characterStuffing() function takes the original data and the special characters for start, end, and escape as input and generates the stuffed data by adding escape characters wherever necessary. The characterDestuffing() function takes the stuffed data and removes the escape characters to retrieve the original data.

The main() function demonstrates the usage of these two functions. It defines an original data string, and uses the character stuffing () function to generate the stuffed data. After that, it uses the characterDestuffing() function to retrieve the original data from the stuffed data.

Character stuffing is a simple yet effective technique to ensure reliable data transmission between systems or devices. It helps in framing the data in a way that can be easily.

Here's some more information on character stuffing in C:

Purpose of Character Stuffing: The main purpose of character stuffing is to prevent conflicts between the actual data being transmitted and the control characters used to mark at the beginning and end of a data frame. By adding escape characters before these special characters in the data, character stuffing ensures that they are not misinterpreted as frame delimiters and that the original data is transmitted accurately.
Common Control Characters: In character stuffing, three common control characters are typically used:
- Start of Frame (SOF) or Start Character: It marks the beginning of a data frame and indicates the start of a message.
- End of Frame (EOF) or End Character: It marks the end of a data frame and indicates the end of a message.
- Escape Character: It is used to escape or indicate the following character(s) as data rather than control characters.
Escape Sequence: In character stuffing, when the original data contains any of the control characters (SOF, EOF, or Escape Character), an escape sequence is used to represent them in the stuffed data. The escape sequence typically consists of the escape character followed by another character representing the escaped character. For example, if the escape character is '', and the control characters are '<' for SOF and '>' for EOF, then the escape sequences could be '<' for SOF and '>' for EOF.
Implementation in C: The implementation of character stuffing in C involves iterating through the original data, checking for occurrences of the control characters, and adding escape characters before them in the stuffed data. The escape characters are removed at the receiving end to retrieve the original data. Care should be taken to choose control and escape characters that do not conflict with the transmitted data.
Error Handling: Character stuffing is not foolproof and may introduce errors if not implemented carefully. For example, if the escape character is part of the original data, it may result in an incorrect interpretation. To handle such cases, error-checking mechanisms can be implemented, such as using a specific escape sequence for the escape character itself or techniques like checksums or CRC (Cyclic Redundancy Check) to verify the integrity of the data.
Usage: Character stuffing is commonly used in communication protocols such as HDLC (High-Level Data Link Control), PPP (Point-to-Point Protocol), and Ethernet frames, where data is transmitted serially over communication channels.

In conclusion, character stuffing is a technique used in computer programming to ensure reliable data transmission by adding escape characters to control characters in the data. It is commonly used in communication protocols. It can be implemented in C by adding escape characters before control characters in the original data and removing them at the receiving end. Care should be taken to choose appropriate control and escape characters, and error-checking mechanisms can be implemented to ensure data integrity.

Some more examples

Here are a few more examples of character stuffing in C:

Start and End Character Stuffing: Let's consider an example where the Start of Frame (SOF) character is '<' and the End of Frame (EOF) character is '>'. In this case, the implementation of character stuffing in C could look like this:

void characterStuffing(char* originalData, int originalLength, char* stuffedData, int* stuffedLength) {
    int i, j;
    char escapeChar = '\\'; // escape character
    char startChar = '<'; // start character
    char endChar = '>'; // end character

    for (i = 0, j = 0; i < originalLength; i++) {
        if (originalData[i] == escapeChar || originalData[i] == startChar || originalData[i] == endChar) {
            stuffedData[j++] = escapeChar; // add escape character before control character
        }
        stuffedData[j++] = originalData[i];
    }

    *stuffedLength = j;
}

Multiple Character Stuffing: In some cases, multiple control characters may need to be stuffed. For example, if we have two control characters, SOF as '<' and a custom control character as '#', the implementation could be as follows:

void characterStuffing(char* originalData, int originalLength, char* stuffedData, int* stuffedLength) {
    int i, j;
    char escapeChar = '\\'; // escape character
    char startChar = '<'; // start character
    char customChar = '#'; // custom control character

    for (i = 0, j = 0; i < originalLength; i++) {
        if (originalData[i] == escapeChar || originalData[i] == startChar || originalData[i] == customChar) {
            stuffedData[j++] = escapeChar; // add escape character before control character
        }
        stuffedData[j++] = originalData[i];
    }

    *stuffedLength = j;
}

Error Handling: To handle errors in character stuffing, an additional step can be added to check for the escape character in the original data and use a specific escape sequence. For example, if the escape character is '', and the control characters are '<' for SOF and '>' for EOF, then the escape sequences could be '<' for SOF, '>' for EOF, and '\' for the escape character.

void characterStuffing(char* originalData, int originalLength, char* stuffedData, int* stuffedLength) {
    int i, j;
    char escapeChar = '\\'; // escape character
    char startChar = '<'; // start character
    char endChar = '>'; // end character

    for (i = 0, j = 0; i < originalLength; i++) {
        if (originalData[i] == escapeChar) {
            stuffedData[j++] = escapeChar; // add escape character before escape character
            stuffedData[j++] = escapeChar; // add escape character again to represent escape character
        } else if (originalData[i] == startChar || originalData[i] == endChar) {
            stuffedData[j++] = escapeChar; // add escape character before control character
       }
        stuffedData[j++] = originalData[i];
    }

    *stuffedLength = j;
}

These are just examples of character stuffing implementation in C and can be further customized based on specific requirements and constraints of the communication protocol being used. It's important to thoroughly understand the specifications and requirements of the protocol before implementing character stuffing to ensure reliable data.

Summary

In summary, character stuffing is a technique used in data communication protocols to ensure the reliable transmission of data. It involves adding special control characters or escape sequences before reserved or control characters in the original data to prevent them from being misinterpreted as control signals. This technique helps avoid data collision or misinterpretation, especially when the reserved or control characters are part of the data being transmitted.

Next TopicDifference between printf() and scanf() in C

← prev next →