Protocol Stack Design Pattern
We have already seen that Protocol Layer and Protocol Packet provide a standardized interface between different layers of a protocol. The Protocol Stack design pattern takes advantage of the layer decoupling and provides a mechanism for dynamic insertion and removal of protocol layers from a stack.
Also Known As
- Protocol Layer Manager
- Protocol Layer Collection
Protocol stacks tend to be rigid in design and protocol layers cannot be dynamically added or removed from a protocol stack. This limits the use of protocol stacks in the even changing world of protocol standards. There are several scenarios where the layers in a protocol stack need to be changed on the fly. A few examples are:
- An application detects the failure of the physical layer and decides to use a different medium to transport data. The application decides to change the lower layers of the protocol while keeping the upper layers intact.
- The user has enabled encryption and this requires the sandwiching of the encryption layer between the network layer and the data-link layer.
- The protocol stack designer needs to debug the interactions between the network layer and transport layer. This can be accomplished by sandwiching a pass-through logging layer that stores all the messages that get exchanged between the layers.
The Protocol Stack design pattern addresses this issue and introduces a flexible architecture for dynamic addition and removal of protocol layers.
The Protocol Stack Design pattern can be used to implement any type of layered protocol. 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. This pattern is particularly useful in applications involving dynamic layer manipulation. A few applications are:
- Changing the physical layer when the application detects failure of the physical layer.
- Dynamically adding layers to handle demands from the user session (e.g. enabling encryption)
- Debugging inter-layer interactions by adding a pass-through debug only layer.
- Testing higher layers of a protocol by adding a special loop-back layer to connect the lower layer transmit and receive.
- Emulating a node by configuring a echo-back layer to connect the higher layer transmit and receive.
The Protocol Stack Design Pattern is implemented by the Protocol Stack class. This class maintains a doubly linked list of active layers.
The key actors of this design pattern:
- Protocol Stack: This class maintains a doubly linked list of Protocol layers. It supports dynamic addition and removal of protocol layers.
- 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.
The following diagram shows the relationship and collaboration between various classes needed for the Datalink layer example.
The Protocol Stack design pattern breaks down the rigid protocol layer structure and provides a very flexible solution where layers can be dynamically added and removed from the stack.
The figure below shows the flexibility of the pattern in supporting different layer organizations. The examples in the figure demonstrate:
- A debug pass-through layer that displays the messages being exchanged between the datalink layer and the physical layer.
- A loopback layer that facilitates the testing of the datalink and network layers by just looping back all transmitted messages back for receive.
- An echo-back layer allows the protocol stack to emulate a node by just echoing back all higher layer messages back for transmission.
- An encryption layer sandwiched between the datalink and physical layers. This layers encrypts and decrypts data that is passed between these layers.
The Protocol Stack is implemented as a single class. The class maintains a doubly linked list of Protocol Layers. Important methods of the class are:
- Handle_Transmit: This handler is invoked by the application to transmit messages using the protocol stack.
- Handle_Receive: This handler is invoked by the device to pass received messages to the protocol stack.
- Add_Layer: Add a protocol layer at a specific position in the protocol stack.
- Remove_Layer: Remove a layer from the protocol stack.
Sample Code and Usage
The code for the Protocol Stack class is presented below:
The Protocol Stack design pattern can be used where ever a layered but decoupled organization is required.