Networks Framing

Introduction

When data travels across a network, it doesn't simply move as a continuous stream of bits. Instead, it's organized into manageable chunks called frames. Framing is a critical function of the Data Link Layer (Layer 2) in the OSI model, responsible for packaging data for transmission and ensuring it can be reliably recognized by receiving devices.

Think of frames as digital envelopes that package your data with important addressing and error-checking information. Without proper framing, network devices wouldn't know where one piece of data ends and another begins, making reliable communication impossible.

What is Framing?

Framing is the process of dividing the data received from the Network Layer into smaller units called frames and adding header and trailer information necessary for transmission. This process creates a clear boundary around each data unit, allowing receiving devices to:

1. Identify the beginning and end of each frame
2. Extract the original data
3. Detect transmission errors
4. Manage the flow of data between devices

Types of Framing Methods

1. Character-Oriented Framing

In character-oriented framing, data is transmitted as a sequence of characters, with special characters marking the beginning and end of frames.

How it works:

• Flag Characters: Special characters (typically ASCII) mark frame boundaries
• Byte Stuffing: A technique used to ensure flag characters in the data don't confuse receivers

Here's a simple example of character-oriented framing:

FLAG | HEADER | DATA | FLAG

Byte Stuffing Example

When the data contains the flag character, we need to use byte stuffing:

Original data: Hello FLAG World
Transmitted: Hello ESC FLAG World

Where:
- FLAG is the special boundary character
- ESC is an escape character

Code Example: Byte Stuffing in Python

python

def byte_stuff(data, flag_byte, escape_byte):
    stuffed_data = []
    
    for byte in data:
        if byte == flag_byte or byte == escape_byte:
            stuffed_data.append(escape_byte)
        stuffed_data.append(byte)
            
    return stuffed_data

# Example usage
data = [0x41, 0x42, 0x7E, 0x43, 0x7D, 0x44]  # Where 0x7E is FLAG and 0x7D is ESC
flag_byte = 0x7E
escape_byte = 0x7D

stuffed = byte_stuff(data, flag_byte, escape_byte)
print(f"Original: {data}")
print(f"Stuffed: {stuffed}")

# Output:
# Original: [65, 66, 126, 67, 125, 68]
# Stuffed: [65, 66, 125, 126, 67, 125, 125, 68]

2. Bit-Oriented Framing

Bit-oriented framing works at the bit level rather than the character level, making it more efficient for synchronous transmission.

How it works:

• Uses a specific bit pattern (01111110) called a flag to mark frame boundaries
• Employs bit stuffing to ensure the flag pattern doesn't appear in the data

01111110 | ADDRESS | CONTROL | DATA | CRC | 01111110
   ^                                          ^
   |                                          |
 Start                                       End
 Flag                                        Flag

Bit Stuffing Example

When five consecutive 1s appear in the data, a 0 is inserted to prevent confusion with the flag pattern:

Original data: 01101111110110
Bit-stuffed:   011011111010110
                      ^
                  Stuffed bit

Code Example: Bit Stuffing in Python

python

def bit_stuff(data):
    result = []
    consecutive_ones = 0
    
    for bit in data:
        result.append(bit)
        if bit == 1:
            consecutive_ones += 1
            if consecutive_ones == 5:
                result.append(0)  # Insert a 0 after five consecutive 1s
                consecutive_ones = 0
        else:
            consecutive_ones = 0
            
    return result

# Example usage
data = [0,1,1,0,1,1,1,1,1,0,1,1,0]
stuffed = bit_stuff(data)

print(f"Original: {data}")
print(f"Stuffed:  {stuffed}")

# Output:
# Original: [0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0]
# Stuffed:  [0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0]

3. Length-Based Framing

Length-based framing uses a length field in the header to indicate the frame's size.

How it works:

• The header contains a count field specifying the frame's length
• No special characters or bit patterns needed for boundaries
• Receiver counts bytes to determine where the frame ends

LENGTH | HEADER | DATA

Code Example: Length-Based Framing in Python

python

def create_length_frame(data):
    # Calculate the length of data
    length = len(data)
    
    # Create the frame (length + data)
    frame = [length] + data
    
    return frame

def extract_from_length_frame(frame):
    # Extract the length from the first byte
    length = frame[0]
    
    # Extract the data portion
    data = frame[1:length+1]
    
    return data

# Example usage
original_data = [0x48, 0x65, 0x6C, 0x6C, 0x6F]  # "Hello" in ASCII
frame = create_length_frame(original_data)
extracted = extract_from_length_frame(frame)

print(f"Original data: {original_data}")
print(f"Frame: {frame}")
print(f"Extracted data: {extracted}")

# Output:
# Original data: [72, 101, 108, 108, 111]  
# Frame: [5, 72, 101, 108, 108, 111]
# Extracted data: [72, 101, 108, 108, 111]

Frame Structure

While frame structures vary between protocols, most contain these common components:

Frame Components

1. Start/End Delimiters: Mark frame boundaries
2. Address Fields: Source and destination addresses
3. Control Field: Contains sequence numbers, frame type
4. Data/Payload: The actual data being transmitted
5. Error Check: Usually a CRC (Cyclic Redundancy Check) for error detection

Real-World Framing Protocols

Ethernet Framing

Ethernet is the most common LAN technology, using a specific frame format:

Preamble (7 bytes) | SFD (1 byte) | Destination MAC (6 bytes) | Source MAC (6 bytes) | Type/Length (2 bytes) | Data (46-1500 bytes) | FCS (4 bytes)

• Preamble: Pattern of alternating 1s and 0s for synchronization
• SFD (Start Frame Delimiter): Marks the start of the frame (10101011)
• MAC Addresses: Hardware addresses identifying source and destination
• Type/Length: Indicates the protocol type or frame length
• Data: The actual payload
• FCS (Frame Check Sequence): For error detection

Point-to-Point Protocol (PPP) Framing

PPP is commonly used for establishing direct connections between two nodes:

Flag (1 byte) | Address (1 byte) | Control (1 byte) | Protocol (2 bytes) | Data (Variable) | FCS (2 or 4 bytes) | Flag (1 byte)

Frame Synchronization

Frame synchronization is the process of aligning the receiver with the sender's frame boundaries. Methods include:

1. Pattern-Based Synchronization: Uses unique bit patterns
2. Violation-Based Synchronization: Uses code violations
3. Time-Based Synchronization: Uses timing to separate frames

Framing Challenges and Solutions

1. Error Detection and Correction

Frames may get corrupted during transmission. Solutions include:

• Parity Checking: Simple but limited error detection
• Checksums: More effective than parity, used in TCP/IP
• CRC (Cyclic Redundancy Check): Powerful polynomial-based error detection
• Forward Error Correction: Allows receivers to correct errors without retransmission

2. Frame Size Considerations

• Small frames: High overhead, inefficient for large data transfers
• Large frames: Better efficiency but higher risk of transmission errors
• Optimal frame size: Balances efficiency and error probability

Practical Application: Analyzing Network Frames

Let's examine a simple example of capturing and analyzing Ethernet frames using Python and the scapy library:

python

from scapy.all import sniff, Ether

def analyze_frame(packet):
    # Extract Ethernet frame information
    src_mac = packet[Ether].src
    dst_mac = packet[Ether].dst
    frame_type = packet[Ether].type
    
    print(f"Source MAC: {src_mac}")
    print(f"Destination MAC: {dst_mac}")
    print(f"EtherType: {hex(frame_type)}")
    print(f"Frame Length: {len(packet)} bytes")
    print("-" * 50)

# Capture 5 frames
sniff(prn=analyze_frame, count=5)

# Example Output:
# Source MAC: 00:1a:2b:3c:4d:5e
# Destination MAC: ff:ff:ff:ff:ff:ff
# EtherType: 0x800
# Frame Length: 74 bytes
# --------------------------------------------------

Summary

Framing is a fundamental networking concept that enables reliable data communication by clearly delimiting data units. In this guide, we've explored:

• The purpose and importance of framing in the Data Link Layer
• Different framing methods (character-oriented, bit-oriented, length-based)
• Common frame structures and components
• Real-world framing protocols like Ethernet and PPP
• Challenges in framing and their solutions

Understanding framing provides essential insight into how networks manage data transmission and ensures reliable communication between devices. This knowledge forms the foundation for more advanced networking concepts.

Exercises

1. Implement a simple character-oriented framing system in your preferred programming language.
2. Write a program that performs bit stuffing and unstuffing on a given bit sequence.
3. Analyze network traffic on your computer using Wireshark and identify different frame types.
4. Compare the efficiency of different frame sizes by calculating the overhead percentage for each.
5. Design a custom framing protocol for a specific application scenario.

Additional Resources

• RFC 1662: PPP in HDLC-like Framing
• IEEE 802.3: Ethernet Standards
• Computer Networks (5th Edition) by Andrew S. Tanenbaum
• Data Communications and Networking by Behrouz A. Forouzan