Message switching sends the whole message as one unit. Each node on the path stores the complete message and then forwards it to the next node. This is store-and-forward switching.
Computer networks use different methods to move data from one place to another. One of the earliest and conceptually simple methods is message switching. Although modern high-speed networks mostly rely on packet switching, message switching remains an important concept for understanding how store-and-forward communication works.
In several real-world systems—such as email, SMS, enterprise message queues, and delay-tolerant networks—the principles of message switching still play a direct role. This answer explains what message switching is, how it operates, where it is useful, and its advantages and disadvantages, with clear examples and step-by-step explanations.
What is message switching?
Message switching is a store-and-forward method of data communication in which the entire message is treated as a single unit and is transmitted from the source to the destination through one or more intermediate nodes. Each intermediate node receives the whole message, stores it temporarily, and then forwards it to the next node when the communication line is available and routing rules allow.
There is no dedicated end-to-end circuit reserved for the entire duration of the communication, and the network does not break the message into smaller packets at the network layer (as in packet switching). Instead, the message remains intact as one block during transit from node to node.
Key characteristics include:
- Store-and-forward: Every intermediate node must receive and store the entire message before forwarding.
- No dedicated path: The network dynamically chooses the next hop without reserving resources end-to-end.
- Asynchronous communication: The sender and receiver do not need to be active or online at the same time; the network can hold the message until delivery is possible.
- Message-level control: Routing, queuing, priority, and acknowledgment are typically managed at the level of the whole message.
Figure: Message Switching
Historical Context and Modern Relevance
Message switching has roots in telegraph and Telex networks, where offices received messages, recorded them, and forwarded them to the next office in the network. In the 1960s and 1970s, systems like AUTODIN (Automatic Digital Network) used message switching for military and government communications. While the rise of packet switching (e.g., the Internet) shifted mainstream data communication away from pure message switching, the model remains crucial in:
- Email infrastructures (SMTP relays store and forward entire emails until they reach the recipient’s server).
- Short Message Service (SMS), where SMS Centers store and forward messages to mobile devices.
- Enterprise message brokers and queues (e.g., MQ systems) that store messages and deliver them reliably to consumers.
- Delay-tolerant networks (DTNs), such as space communications or remote sensing networks, where continuous connectivity cannot be assumed.
How Message Switching Works: Step-by-Step
Consider nodes A (source), B and C (intermediate switches), and D (destination). The message must travel A → B → C → D. The operational steps are:
- Step 1: Creation – The sender at A creates a message with a header containing the destination address (D), priority, and any other control information.
- Step 2: Transmission to first switch – Node A transmits the entire message to node B. B must have enough buffer space to hold the whole message.
- Step 3: Store – Once B receives the entire message, it stores it on disk or in memory. Only after full receipt does B proceed.
- Step 4: Routing decision – B determines the next hop, which is C in this example, based on routing tables and link availability.
- Step 5: Forwarding – When the link to C is available and any policy conditions are met (e.g., priority scheduling), B forwards the entire message to C.
- Step 6: Repeat – Node C repeats the store-and-forward process and eventually sends the message to D.
- Step 7: Delivery and acknowledgment – Upon delivery, D may send an acknowledgment back to A (end-to-end) or to the previous node (hop-by-hop), depending on the system design.
Message Format and Control Information
A message typically consists of:
- Header: Contains destination address, source address, message ID, priority, time-to-live (TTL) or expiration, routing information, and optional security fields (e.g., signatures).
- Body: The content being delivered (text, data, files, or encoded media).
- Trailer (optional): Checksum or hash for integrity verification.
This design allows intermediate nodes to make routing and scheduling decisions without modifying the payload. Because the entire message must be handled at once, headers also include fields to manage storage requirements and delivery guarantees (e.g., delivery receipts).
Routing and Flow Control in Message Switching
Effective message switching requires clear policies for routing and controlling traffic:
- Routing Strategies:
- Static routing: Predefined paths are used, common in stable, controlled environments.
- Dynamic routing: Routes adapt to link congestion, failures, or policy constraints.
- Policy-based routing: Messages with certain priorities or classifications follow specific paths.
- Queuing and Scheduling:
- FIFO (First-In, First-Out): Simplest policy, fair to arrival order.
- Priority queues: High-priority or time-sensitive messages jump ahead of others.
- Deadline-aware scheduling: Messages with imminent expiry are forwarded first.
- Flow and Congestion Control:
- Admission control: Reject or defer new messages if buffers are low.
- Rate limiting: Limit the rate at which specific sources can inject messages.
- Backpressure: Inform upstream nodes to slow down when buffers fill.
- Reliability and Acknowledgment:
- Hop-by-hop acknowledgment: Each node confirms reception to the previous node before it deletes its copy.
- End-to-end acknowledgment: The destination notifies the source upon final delivery, enabling full delivery guarantees.
Performance Characteristics
Message switching trades off latency for robustness and flexibility. Key performance components include:
- Transmission time: Time to push the bits of the entire message onto a link. If the message length is L bits and link bandwidth is B bits/sec, transmission time per hop is approximately L/B.
- Propagation delay: Time the signal takes to travel over the physical medium between nodes (distance/speed of signal).
- Processing time: Time for a node to verify integrity, read headers, and make routing decisions.
- Queueing delay: Waiting time in the node’s buffer before the link becomes available.
- Total end-to-end delay: Approximately the sum over all hops of (transmission + propagation + processing + queueing). Because the message must be fully received and stored before forwarding, this delay grows with both message size and the number of intermediate nodes.
Advantages of Message Switching
- No need for dedicated circuits:
- Links are shared among many messages, improving utilization compared to circuit switching where a reserved path may sit idle.
- Asynchronous delivery:
- Sender and receiver do not need to be online simultaneously. The network stores the message until the receiver is available, which is ideal for email and SMS.
- Reliability through store-and-forward:
- Intermediate nodes can buffer messages during link failures or congestion and retry later, increasing delivery success.
- Flexible routing and prioritization:
- Messages can be routed dynamically and prioritized, enabling policy control (e.g., emergency messages get higher priority).
- Good for long or variable-size content:
- Because the message is a single unit, systems can apply integrity checks and signatures to the whole message easily.
- Cost-effective for bursty or sporadic traffic:
- Pay-as-you-go link usage without reserving end-to-end resources suits organizations with intermittent communication needs.
- Supports delayed or intermittently connected networks:
- In DTNs, messages can be physically carried by nodes that meet opportunistically (e.g., satellites, drones, or “data mules”).
Disadvantages of Message Switching
- High latency for large messages:
- Each node must receive and store the entire message before forwarding, adding significant delay compared to packet switching.
- Large buffer requirements:
- Intermediate nodes need enough storage for whole messages. A few very large messages can exhaust buffers and block the system.
- Poor suitability for real-time traffic:
- Interactive voice, video, and time-sensitive control systems require low, predictable latency, which message switching cannot guarantee.
- Potential for congestion and blocking:
- If many large messages compete for buffers, nodes may need to drop, defer, or reroute messages, complicating management.
- Processing overhead:
- Each node must process, store, and forward the whole message, increasing per-message overhead.
- Variable and unpredictable delay:
- Queueing and retry behavior create jitter that is unsuitable for applications expecting stable performance.
- Limited parallelism:
- Unlike packet switching, where parts of a message can traverse the network simultaneously, message switching handles the message as one block at a time.
Comparison with Circuit Switching and Packet Switching
It is useful to place message switching in context with the two other classic switching methods.
- Message Switching vs Circuit Switching:
- Path setup: Circuit switching reserves an end-to-end path before data transmission; message switching does not reserve a path.
- Resource usage: Circuit paths may be underutilized; message switching uses links only when transmitting, improving overall efficiency.
- Latency: Circuit switching provides predictable, low per-bit latency once established; message switching has higher and more variable delay.
- Suitability: Circuit switching suits real-time voice/video; message switching suits asynchronous, delay-tolerant data.
- Message Switching vs Packet Switching:
- Granularity: Message switching handles the entire message as one unit; packet switching breaks data into packets, each routed independently.
- Buffering: Message switching requires buffers large enough for whole messages; packet switching needs buffers sized for packets, reducing per-node storage strain.
- Latency: Packet switching can pipeline packets, enabling the destination to start receiving parts of data sooner; message switching incurs store-and-forward delay per hop for the entire message.
- Reliability mechanisms: Message switching often uses hop-by-hop and end-to-end acks for entire messages; packet switching may rely on end-to-end control (e.g., TCP) and per-packet handling.
- Throughput and interactivity: Packet switching generally offers better interactivity and link sharing at fine granularity, which is why it dominates modern Internet design.
Real-World Applications and Examples
- Email (SMTP):
- Mail Transfer Agents accept an entire email, store it, and forward it to the next mail server. If the receiver’s server is down, the message is queued and retried for a period (e.g., 24–72 hours).
- SMS (Short Message Service):
- SMS Centers hold messages when a device is offline or out of coverage and deliver them when the device reconnects.
- Enterprise Messaging (Message Queues/Brokers):
- Systems like message queues store messages from producers and deliver them reliably to consumers, often with priority, retry, and dead-letter handling.
- Military/Aviation Messaging:
- Structured messaging systems (e.g., older X.400-based or aviation AMHS) rely on store-and-forward for reliability and auditing.
- Delay-Tolerant Networks (DTN):
- Spacecraft communication or remote sensor networks use store-and-forward “bundles” to cope with intermittent connectivity and long delays.
- Electronic Data Interchange (EDI):
- Business documents (invoices, orders) are transmitted as complete messages stored and forwarded through gateways until delivery.
Design Considerations and Best Practices
When designing or evaluating a message-switched system, engineers address these factors:
- Message size limits:
- Impose maximum message sizes to prevent buffer exhaustion. Large objects can be chunked at the application level if necessary.
- Buffer management:
- Dimension storage to expected peak loads; implement backpressure and rate limiting. Use persistent storage to survive node failures.
- Prioritization and QoS:
- Define priorities, deadlines, and service classes. Ensure high-priority traffic can preempt lower-priority queues.
- Reliability policies:
- Choose hop-by-hop or end-to-end acknowledgments; set retry intervals and maximum retries; maintain delivery receipts and logs.
- Routing and policy control:
- Plan static routes for predictability or dynamic routes for resilience; implement routing metrics (link cost, queue occupancy, delay).
- Security:
- Use encryption for confidentiality; digital signatures for authenticity and non-repudiation; access control to prevent unauthorized injection.
- Integrity and validation:
- Checksums or hashes to detect corruption; schema validation for structured messages to prevent malformed content from propagating.
- Expiration and TTL:
- Assign time-to-live to prevent undeliverable messages from circulating indefinitely; route to dead-letter queues for operator review.
- Monitoring and observability:
- Track queue lengths, latency percentiles, drop rates, and error types. Alert on anomalies to prevent congestion collapses.
- Interoperability:
- Adopt standard formats and addressing schemes; document message schemas; ensure compatibility between different domains or organizations.
Conclusion
Message switching is a foundational store-and-forward technique where the entire message is received, stored, and then forwarded at each intermediate node without reserving an end-to-end circuit. Its defining strengths are asynchronous operation, robust delivery through buffering and retries, and flexible routing with prioritization. These qualities make it ideal for email, SMS, enterprise queues, and delay-tolerant networks—contexts where guaranteed or eventual delivery is more important than low, predictable latency.
Compare it with packet switching.