Offensive Security Researcher & Quantum Cryptography Analyst

Packet Switching in Computer Networks

Abdul Wahab Junaid
Packet Switching In Computer Networks

Every time you load a web page, send a WhatsApp message, or stream a video, your data is being broken into small pieces, sent across a vast web of routers and links, and reassembled at the other end — all within milliseconds. This entire process relies on a technique called packet switching, one of the foundational ideas that makes the modern Internet possible.

In this article, we’ll build an understanding of packet switching from the ground up: what it is, how it works, why it was invented, and how it compares to older switching techniques. We’ll also look at practical, hands-on examples using Linux, Cisco, and Python.

1. What Is Packet Switching?

Packet switching is a method of transmitting data across a network by breaking it into small, manageable units called packets. Each packet is sent independently through the network, potentially via different paths, and reassembled into the original message at the destination.

Each packet typically contains:

Why Break Data Into Packets?

Imagine trying to send an entire 2GB video file as one giant, uninterrupted stream over a shared network link. If any part of that transmission failed, you’d have to resend the whole thing. Also, one large transmission would monopolize the link, preventing anyone else from using it during that time.

By breaking data into small packets:

2. A Brief History

Packet switching was independently conceived in the early 1960s by Paul Baran (at RAND Corporation, for resilient military communication) and Donald Davies (at the UK’s National Physical Laboratory, who coined the term “packet”). This concept later became the foundation of ARPANET, the precursor to today’s Internet, developed in the late 1960s. This was a revolutionary departure from the telephone network’s circuit-switching model, which reserved a dedicated path for each call.

3. How Packet Switching Works — Step by Step

Let’s walk through what happens when you send data across a packet-switched network:

  1. Segmentation: The sending device breaks the message/data into smaller packets.
  2. Header Addition: Each packet gets a header containing the destination address, source address, and a sequence number.
  3. Transmission: Packets are sent onto the network, one after another, often interleaved with other users’ packets on shared links.
  4. Routing: Each intermediate router examines the destination address in the packet header and forwards it toward the next hop, based on its routing table.
  5. Queuing: If a router’s outgoing link is busy, packets wait in a queue (buffer) until the link is free.
  6. Reassembly: At the destination, packets are reordered (using sequence numbers) and reassembled into the original message.
  7. Error Handling: If a packet is missing or corrupted, depending on the protocol (e.g., TCP), a retransmission request may be triggered.

Mermaid Diagram: The Journey of a Packet

flowchart LR
    A[Application Data] --> B[Segmentation into Packets]
    B --> C[Packet 1]
    B --> D[Packet 2]
    B --> E[Packet 3]
    C --> F[Router 1]
    D --> G[Router 2]
    E --> F
    F --> H[Router 3]
    G --> H
    H --> I[Destination: Reassembly]

4. Store-and-Forward Mechanism

Packet-switched networks typically operate using a store-and-forward approach at each router:

  1. The router receives the entire packet and stores it temporarily in a buffer.
  2. It checks the packet for errors (using checksums).
  3. It looks up the destination address in its routing table.
  4. It forwards the packet out the appropriate interface toward the next hop.

This is different from cut-through switching (used by some high-performance Ethernet switches), where forwarding begins as soon as the destination address is read, without waiting for the entire frame to arrive — trading some error-checking robustness for lower latency.

5. Types of Packet Switching

As discussed in more detail in a companion article on datagram vs. virtual circuit switching, packet switching itself has two major approaches:

5.1 Datagram Packet Switching (Connectionless)

5.2 Virtual Circuit Packet Switching (Connection-Oriented)

FeatureDatagramVirtual Circuit
Setup phaseNoYes
Path consistencyMay varyFixed
Packet orderNot guaranteedPreserved
Overhead per packetFull address in every packetSmall VC identifier
Failure resilienceHighLower (path re-establishment needed)

6. Packet Switching vs. Circuit Switching

Since packet switching is often first understood by contrasting it with circuit switching, here is a direct comparison:

FeaturePacket SwitchingCircuit Switching
PathDynamic, per-packet or per-sessionFixed, dedicated for entire call/session
Resource usageShared, efficientDedicated, can be wasteful if idle
Setup delayLittle to none (datagram) or moderate (VC)High (dial-up/connection setup)
Failure handlingAutomatic rerouting possibleCall drops if path fails
ExamplesInternet (IP), MPLSTraditional telephone network (PSTN)
Bandwidth efficiencyHigh (statistical multiplexing)Lower (reserved even when idle)
Best suited forBursty data trafficContinuous, real-time voice traffic (historically)

7. Advantages of Packet Switching

  1. Efficient use of bandwidth: Multiple communications can share the same physical link through statistical multiplexing.
  2. Resilience: Since packets can take different paths, the network can route around failed links or congested nodes.
  3. Scalability: New devices can join the network without requiring dedicated circuits to be built.
  4. Cost-effective: Shared infrastructure reduces the cost per user compared to dedicated circuits.
  5. Supports diverse traffic types: Data, voice (VoIP), and video can all be packetized and sent over the same network.

8. Disadvantages of Packet Switching

  1. Variable delay (jitter): Since packets can take different paths and queue at routers, delivery time isn’t constant — problematic for real-time applications like voice/video without additional protocols (e.g., RTP, QoS).
  2. Out-of-order delivery: Especially in datagram switching, packets may need reordering at the destination.
  3. Overhead: Each packet requires header information, which adds overhead compared to a raw, continuous circuit-switched stream.
  4. Potential for congestion: Shared links can become congested, leading to delays or packet loss during peak usage.

9. Linux Example: Observing Packet Switching in Action

You can observe how your own data gets broken into packets when it leaves your machine using packet capture tools.

# Capture packets on interface eth0 while downloading a file
sudo tcpdump -i eth0 -n -c 20 host 93.184.216.34

Sample output:

14:02:01.111 IP 192.168.1.5.51000 > 93.184.216.34.80: Flags [S], seq 123456
14:02:01.145 IP 93.184.216.34.80 > 192.168.1.5.51000: Flags [S.], seq 987654, ack 123457
14:02:01.146 IP 192.168.1.5.51000 > 93.184.216.34.80: Flags [.], ack 987655
14:02:01.147 IP 192.168.1.5.51000 > 93.184.216.34.80: Flags [P.], seq 1:518, ack 1
14:02:01.190 IP 93.184.216.34.80 > 192.168.1.5.51000: Flags [.], seq 1:1461, ack 518

Each line represents a separate packet, showing how even a simple HTTP request/response involves multiple discrete packets flowing back and forth — the essence of packet switching.

You can also check the Maximum Transmission Unit (MTU), which determines the largest packet size that can be sent without fragmentation:

ip link show eth0 | grep mtu
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP

10. Cisco Example: Observing Router Packet Forwarding Behavior

On a Cisco router, packet switching happens continuously as it forwards IP packets based on its routing table. You can observe forwarding statistics and per-interface packet counts:

Router# show interfaces GigabitEthernet0/0

GigabitEthernet0/0 is up, line protocol is up
  5 minute input rate 2000 bits/sec, 3 packets/sec
  5 minute output rate 1500 bits/sec, 2 packets/sec
     102345 packets input, 98234123 bytes
     87651 packets output, 76234123 bytes

You can also trace how a router makes a per-packet forwarding decision using Cisco Express Forwarding (CEF), which is Cisco’s optimized packet-switching mechanism:

Router# show ip cef 192.168.20.0
192.168.20.0/24
  nexthop 10.0.0.2 GigabitEthernet0/1

This shows that packets destined for the 192.168.20.0/24 network are switched (forwarded) via GigabitEthernet0/1 toward next-hop 10.0.0.2 — a lookup performed independently for packets matching this destination, which is the essence of datagram-style packet switching at the IP layer.

To simulate and observe basic packet switching path behavior:

Router# traceroute 192.168.20.5

Type escape sequence to abort.
Tracing the route to 192.168.20.5

  1 10.0.0.2 4 msec 4 msec 4 msec
  2 192.168.20.5 8 msec 8 msec 4 msec

11. Python Example: Building a Simple Packet Switching Simulator

Here’s an educational simulation that models how packets get queued, routed, and forwarded through simple router nodes — helpful to visualize the mechanics of packet switching.

import queue
import time
import random

class Router:
    def __init__(self, name):
        self.name = name
        self.buffer = queue.Queue()

    def receive_packet(self, packet):
        print(f"[{self.name}] Received packet {packet['id']} destined for {packet['dest']}")
        self.buffer.put(packet)

    def forward_packets(self, next_hop):
        while not self.buffer.empty():
            packet = self.buffer.get()
            # Simulate variable network delay (jitter)
            delay = random.uniform(0.01, 0.1)
            time.sleep(delay)
            print(f"[{self.name}] Forwarding packet {packet['id']} to {next_hop.name} "
                  f"(delay: {delay:.3f}s)")
            next_hop.receive_packet(packet)

# Create a simple 3-router topology: R1 -> R2 -> R3 (Destination)
r1 = Router("R1")
r2 = Router("R2")
r3 = Router("R3")

# Simulate breaking a message into 5 packets
message = "This is a large message being split into packets"
words = message.split()
packets = [{"id": i, "dest": "HostB", "data": word} for i, word in enumerate(words)]

# Send all packets into R1's buffer
for pkt in packets:
    r1.receive_packet(pkt)

# Forward from R1 -> R2 -> R3
r1.forward_packets(r2)
r2.forward_packets(r3)

print("\nAll packets delivered to final router:", r3.name)

This simulation demonstrates key packet-switching concepts: independent packet handling, queuing/buffering at each hop, and variable per-packet delay (jitter) — all core characteristics of real packet-switched networks.

12. Real-World Applications of Packet Switching

ApplicationHow Packet Switching Is Used
Web Browsing (HTTP/HTTPS)Web pages are broken into TCP segments/IP packets and reassembled by the browser
VoIP (Voice over IP)Voice is digitized and packetized (RTP over UDP), with jitter buffers compensating for variable delay
Video Streaming (Netflix, YouTube)Video is chunked and sent as a sequence of packets, often adaptively based on network conditions
Online GamingSmall, frequent packets carry game state updates, often over UDP for low latency
Cloud Computing / APIsREST/HTTP API calls are packetized and routed across data center networks
IoT DevicesSensor readings are sent as small packets, often over lightweight protocols like MQTT/CoAP over IP

13. Best Practices

  1. Tune MTU appropriately to avoid fragmentation, which adds overhead and processing delay. Use tools like ping -M do -s <size> on Linux to discover path MTU.
  2. Use QoS (Quality of Service) mechanisms on routers/switches to prioritize latency-sensitive packet-switched traffic (e.g., VoIP) over bulk data transfers.
  3. Monitor for congestion and packet loss using tools like show interfaces on Cisco devices or ss -s on Linux, since packet switching’s shared nature makes congestion a real risk.
  4. Design applications to tolerate jitter and reordering, especially over UDP, since packet switching does not guarantee consistent delay or order.
  5. Leverage buffering strategies (like jitter buffers in VoIP) to smooth out the natural variability introduced by packet switching.

14. Troubleshooting Common Issues

Issue: High Latency/Jitter During Video Calls

Symptom: Choppy audio/video, frequent freezing.

Cause: Packet switching introduces variable delay as packets queue at congested routers; without QoS, real-time packets can be delayed behind bulk data transfers.

Fix: Implement QoS policies on network devices to prioritize RTP/UDP traffic:

Router(config)# class-map match-all VOICE
Router(config-cmap)# match protocol rtp
Router(config)# policy-map QOS-POLICY
Router(config-pmap)# class VOICE
Router(config-pmap-c)# priority percent 20

Issue: Fragmented Packets Causing Performance Degradation

Symptom: tcpdump shows many fragmented IP packets; slow transfer speeds.

Cause: Packet size exceeds the MTU of some link along the path, forcing fragmentation.

Fix: Discover the path MTU and adjust accordingly:

ping -M do -s 1472 8.8.8.8

If this fails with “Message too long,” reduce packet size or enable Path MTU Discovery (PMTUD).

Issue: Packet Loss on a Specific Link

Symptom: show interfaces on Cisco shows increasing “output drops” or “input errors” counters.

Cause: Congestion, buffer overflow, or a faulty physical link causing dropped packets.

Fix: Check interface error counters and consider increasing buffer/queue sizes or upgrading link capacity:

Router# show interfaces GigabitEthernet0/0 | include drops
  Total output drops: 245

15. Conclusion

Packet switching is the fundamental technique that allows the modern Internet to move enormous amounts of diverse data — web pages, voice calls, video streams, IoT sensor readings — efficiently and resiliently across shared infrastructure. By breaking data into small, independently routable packets, networks achieve far greater efficiency and fault tolerance than the older circuit-switching model. Understanding the mechanics of packet switching — from store-and-forward processing to datagram vs. virtual circuit approaches — is essential groundwork for anyone working with computer networks, whether configuring Cisco routers, analyzing traffic with Linux tools, or building networked applications in Python.

Further Reading

Exit mobile version