Home > Real-time Mantra > Design Patterns > Protocol Layer Design Pattern
Protocol Layer Design Pattern

Intent

Provide a common framework for implementing different layers of a protocol stack.

Also Known As

• Layer Design Pattern
• ISO/OSI Layer  Design Pattern

Motivation

A typical protocol layer interfaces with an upper layer and a lower layer of the protocol. In most designs there is a lot of dependency between different layers of the protocol. This makes the protocol stack implementation rigid and inflexible. Changes in one layer often percolate to other layers. The Protocol Layer Design Pattern addresses these limitations by decoupling the individual protocol layers.

Applicability

• The Protocol Layer Design Pattern can be used to implement different layers of a protocol stack.
• It can be also used when different operations on an entity need to be performed in a pipeline fashion. Each stage of the pipeline could be modeled as a layer.

Structure

Different layers of the protocol are structured as shown in the figure on the left hand side. Communication between layers takes place using standard interfaces defined by the Protocol Layer base class. All implementations of the protocol layer inherit from this class. The inheriting layer classes should implement the standard interfaces. The standard interfaces are: Transmit is invoked by the upper layer to transfer a packet to the lower layer. Handle Receive is invoked by the lower layer to transfer a packet to the upper layer. The example on the left hand side shows the structure of a three layer protocol stack. The sequence of actions in the Transmit direction are: The application invokes the Network layer's Transmit method. The Network layer performs its actions and invokes the Transmit method for the lower layer. This invokes the Datalink layers transmit method. The Datalink layer performs the layer specific actions and invokes the lower layer's Transmit method. The Physical layer's Transmit method is invoked. This layer programs the appropriate hardware device and transmits the message. The receive processing is similar to the transmit processing described above. Here the Handle Receive method is used to transfer the packet between layers.

Participants

The key actors of this design pattern:

• Protocol Layer: This is the base class for all protocol layers. The individual layers interface with each other via pointers to this class. The actual type of the upper layer and lower layer classes is not known to the implementers of a certain layer.
• Protocol Packet: This class manages addition and removal of headers and trailers for various protocol layers.

Collaboration

The following diagram shows the relationship and collaboration between various classes needed for the Datalink layer example. 

Consequences

Protocol Layer class serves as the foundation for the Protocol Layer design pattern. This class defines the common interface for interactions between different layers of a protocol. This has several advantages:

• The implementation of one layer is completely decoupled from the other layers. The implementers of one layer do not even need to include the header files defining the other layers.
• Layers can be added and removed without needing any changes to the code for individual layers. (e.g. an IPSec layer can be added between the IP and Physical layers, without making any changes to the IP or the Physical Layer code).
• A single layer could interface with multiple upper or lower layer protocols using the same interface. (e.g. an IP layer implementation could interface with an ATM or Ethernet physical layer. No changes would be needed to the code for the IP layer.

Implementation

The following scenarios are supported by the Datalink Layer example of the Protocol Layer design pattern:

A packet is received from the upper layer

1. The upper layer uses its "Lower Layer" pointer to invoke the Transmit method for the lower layer. The "Protocol Packet" to be transmitted is passed to the Transmit method.
2. This invokes the Datalink Layer's Transmit method.
3. The Datalink Layer passes the "Protocol Packet" to the "Transmit Protocol Handler" object.
4. The "Transmit Protocol Handler" processes the "Protocol Packet" and adds the datalink layer header to the packet.
5. The "Transmit Protocol Handler" uses its parent layer to obtain a pointer to the lower layer.
6. The "Protocol Packet" is passed to the lower layer by invoking the Transmit method.

A packet is received from the lower layer

1. The lower layer uses its "Upper Layer" pointer to invoke the "Handle Receive" method for the upper layer. The received "Protocol Packet" is passed to the "Handle Receive" method.
2. This invokes the Datalink Layer's "Handle Receive" method.
3. The Datalink Layer passes the "Protocol Packet" to the "Receive Protocol Handler" object.
4. The "Receive Protocol Handler" object uses the parent layer to obtain a pointer to the upper layer.
5. The "Protocol Packet" is passed to the higher layer by invoking the "Handle Receive" method.

Sample Code and Usage

The code for the Protocol Layer class and the Datalink Layer example is presented below:

00009 #ifndef PROTOCOL_LAYER_H
00010 #define PROTOCOL_LAYER_H
00011 
00012 #include <stdio.h>
00013 class Protocol_Packet;
00014 
00031 
00032 class Protocol_Layer
00033 {
00038     Protocol_Layer *m_p_Lower_Layer;
00039 
00044     Protocol_Layer *m_p_Upper_Layer;
00045 
00046 public:
00052     Protocol_Layer()
00053     {
00054         m_p_Lower_Layer = NULL;
00055         m_p_Upper_Layer = NULL;
00056     }
00057 
00066     virtual void Transmit(Protocol_Packet *p_Packet) = 0;
00067 
00076     virtual void Handle_Receive(Protocol_Packet *p_Packet) = 0;
00077 
00085     void Set_Upper_Layer(Protocol_Layer *p_Layer)
00086     {   m_p_Upper_Layer = p_Layer; }
00087 
00095 
00096     void Set_Lower_Layer(Protocol_Layer *p_Layer)
00097     {   m_p_Lower_Layer = p_Layer; }
00098 
00106 
00107     Protocol_Layer *Get_Upper_Layer() const
00108     {   return m_p_Upper_Layer; }
00109 
00117 
00118     Protocol_Layer *Get_Lower_Layer() const
00119     {   return m_p_Lower_Layer; }
00120 
00121 };
00122 #endif

00010 #ifndef DATALINK_LAYER_H
00011 #define DATALINK_LAYER_H
00012 
00013 #include "Protocol_Layer.h"
00014 #include "Transmit_Protocol_Handler.h"
00015 #include "Receive_Protocol_Handler.h"
00016 
00017 class Protocol_Packet;
00018 
00024 
00025 class Datalink_Layer : public Protocol_Layer
00026 {
00028     Transmit_Protocol_Handler m_transmit_Protocol_Handler;
00029 
00031     Receive_Protocol_Handler m_receive_Protocol_Handler;
00032 
00033 public:
00034 
00035     Datalink_Layer();
00036 
00037    // Process and transmit the packet passed by higher layer.
00038    void Transmit(Protocol_Packet *p_Packet);
00039 
00040    void Handle_Receive(Protocol_Packet *p_Packet);
00041 
00042 };
00043 
00044 #endif

00010 #include "Datalink_Layer.h"
00011 #include "Protocol_Packet.h"
00012 
00018 
00019 Datalink_Layer::Datalink_Layer() : 
00020                     m_transmit_Protocol_Handler(this),
00021                     m_receive_Protocol_Handler(this)
00022 { }
00023 
00030 
00031 void Datalink_Layer::Transmit(Protocol_Packet *p_Packet)
00032 {
00033     m_transmit_Protocol_Handler.Handle_Transmit_Request((Datagram *)p_Packet);
00034 }
00035 
00042 
00043 void Datalink_Layer::Handle_Receive(Protocol_Packet *p_Packet)
00044 {
00045     m_receive_Protocol_Handler.Handle_Received_Packet((Datagram *)p_Packet);
00046 }

Known Uses

• Implementation of ISO-OSI protocol layers.
• Modeling and implementing stages of a pipeline.

Related Patterns/Principles

• Receive Protocol Handler Pattern
• Transmit Protocol Handler Pattern
• Protocol Packet
• Dependency Inversion Principle