Protocol Layer DocumentationDatalink Layer DocumentationIntent
Provide a common framework for implementing different layers of a protocolstack.
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 ofthe protocol. In most designs there is a lot of dependency between differentlayers of the protocol. This makes the protocol stack implementation rigid andinflexible. Changes in one layer often percolate to other layers. The ProtocolLayer Design Pattern addresses these limitations by decoupling the individualprotocol 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 betweenvarious classes needed for the Datalink layer example.
Consequences
Protocol Layer class serves as the foundation for the Protocol Layer designpattern. This class defines the common interface for interactions betweendifferent 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 theProtocol Layer design pattern:
A packet is received from the upper layer
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.
This invokes the Datalink Layer's Transmit method.
The Datalink Layer passes the "Protocol Packet" to the "Transmit Protocol Handler" object.
The "Transmit Protocol Handler" processes the "Protocol Packet" and adds the datalink layer header to the packet.
The "Transmit Protocol Handler" uses its parent layer to obtain a pointer to the lower layer.
The "Protocol Packet" is passed to the lower layer by invoking the Transmit method.
A packet is received from the lower layer
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.
This invokes the Datalink Layer's "Handle Receive" method.
The Datalink Layer passes the "Protocol Packet" to the "Receive Protocol Handler" object.
The "Receive Protocol Handler" object uses the parent layer to obtain a pointer to the upper layer.
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 ispresented below:
Protocol Layer
00009 #ifndef PROTOCOL_LAYER_H 00010 #define PROTOCOL_LAYER_H 00011 00012 #include <stdio.h> 00013 class
Protocol_Packet; 00014 00031 00033 { ; 00039
00044Protocol_Layer *
m_p_Upper_Layer; 00045 00046 public:
00052Protocol_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
00107Protocol_Layer *
Get_Upper_Layer() const 00108 { return
m_p_Upper_Layer; } 00109 00117
00118Protocol_Layer *
Get_Lower_Layer() const 00119 { return
m_p_Lower_Layer; } 00120 00121 }; 00122 #endif
Datalink Layer Header File
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 {
00028Transmit_Protocol_Handlerm_transmit_Protocol_Handler; 00029
00031Receive_Protocol_Handlerm_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
Datalink Layer Source File
00010 #include "
Datalink_Layer.h" 00011 #include "
Protocol_Packet.h" 00012 00018
00019Datalink_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 PatternTransmit Protocol Handler PatternProtocol Packet Dependency Inversion PrincipleExplore More...
Protocol Layer DocumentationDatalink Layer Documentation