Post

The Life of a UDP Packet

Posted
By Ofek Almog
6 min read
The Life of a UDP Packet

Ever wondered what happens when you send a message over the internet? Let’s dive into the story of a UDP packet - from birth to death.

Table of Contents

What’s UDP?

UDP stands for User Datagram Protocol. Think of it as the postal service of the internet - you write a message, put it in an envelope with an address, and send it off. Unlike its more careful cousin TCP, UDP doesn’t wait for confirmation that your message arrived. It’s fast, simple, and sometimes a bit reckless.

graph TD
    A[Your Application] -->|"Hey, send this data!"| B[UDP]
    B -->|"Sure, here's your packet"| C[Network]
    C -->|"Packet delivered... maybe?"| D[Destination]
    
    style B fill:#ff9999
    style A fill:#99ccff
    style D fill:#99ff99

Birth: Creating the Packet

Let’s say you’re playing an online game and your character shoots a fireball. Your game needs to tell the server “Player fired fireball at coordinates (100, 200)”.

Here’s what happens when the UDP packet is born:

sequenceDiagram
    participant App as Game Application
    participant Socket as UDP Socket
    participant OS as Operating System
    
    App->>Socket: send("fireball at 100,200")
    Socket->>OS: Create UDP packet
    Note over OS: Adds UDP header:<br/>Source Port: 5000<br/>Dest Port: 8080<br/>Length: 24 bytes<br/>Checksum: 0x1A2B
    OS->>Socket: Packet ready!
    Socket->>App: Data sent (hopefully)

Basically: your game asks to send data, the system wraps it in a UDP envelope with addressing info, and sends it off into the network.

Leaving Home: The Network Stack

Our little packet now needs to travel through the network stack. It’s like getting dressed for a journey - each layer adds its own wrapper:

graph TD
    A[Application Layer<br/>'fireball at 100,200'] --> B[UDP Layer<br/>Adds UDP Header]
    B --> C[IP Layer<br/>Adds IP Header]
    C --> D[Ethernet Layer<br/>Adds Ethernet Header]
    D --> E[Physical Layer<br/>Converts to electrical signals]
    
    style A fill:#ff9999
    style B fill:#ffcc99
    style C fill:#99ccff
    style D fill:#cc99ff
    style E fill:#99ff99

At each layer, our packet gets wrapped like a Russian doll: (Babushka ;))

graph LR
    subgraph "Final Packet"
        A[Ethernet Header] --> B[IP Header] --> C[UDP Header] --> D[Your Data]
    end
    
    style A fill:#cc99ff
    style B fill:#99ccff
    style C fill:#ffcc99
    style D fill:#ff9999

First Steps: Local Network

Now our packet is ready to leave your computer. First stop: the local network! (LAN)

graph TD
    A[Your Computer<br/>192.168.1.100] -->|Ethernet Cable/WiFi| B[Switch/Router<br/>192.168.1.1]
    B --> C{Is destination<br/>on local network?}
    C -->|Yes| D[Deliver Locally]
    C -->|No| E[Send to Gateway]
    E --> F[Internet Gateway<br/>Your ISP]
    
    style A fill:#99ccff
    style B fill:#ffcc99
    style F fill:#ff9999

Your router looks at the packet and thinks: “Hmm, this packet wants to go to 203.0.113.42. That’s not on my local network (192.168.1.x), so I’ll send it to my gateway.”

The Big Journey: Internet Routing

This is where the real adventure begins! Our packet enters the vast internet and starts hopping from router to router:

graph TD
    A[Your ISP Router] --> B[Regional ISP Hub]
    B --> C[Internet Backbone Router]
    C --> D[Another Backbone Router]
    D --> E[Destination ISP]
    E --> F[Destination Router]
    F --> G[Target Server]
    
    subgraph "The Internet Cloud"
        B
        C
        D
    end
    
    style A fill:#99ccff
    style G fill:#99ff99

At each router, the same process happens:

sequenceDiagram
    participant P as Incoming Packet
    participant R as Router
    participant T as Routing Table
    participant N as Next Router
    
    P->>R: "I need to reach 203.0.113.42"
    R->>T: "Where should I send this?"
    T->>R: "Send it to 10.0.1.1"
    R->>N: Forward packet
    Note over R: TTL decreased by 1<br/>New Ethernet headers added

Each router:

  1. Looks at the destination IP (203.0.113.42)
  2. Checks its routing table (“How do I get there?”)
  3. Forwards the packet to the next best router
  4. Decreases TTL by 1 (Time To Live - prevents infinite loops)

Arrival: Reaching the Destination

Finally! Our packet reaches the destination server:

sequenceDiagram
    participant Net as Network Interface
    participant OS as Operating System
    participant App as Game Server
    
    Net->>OS: Packet arrived!
    Note over OS: Strips Ethernet header<br/>Strips IP header<br/>Checks UDP header
    OS->>OS: "This is for port 8080"
    OS->>App: "You have mail! 'fireball at 100,200'"
    App->>App: Process fireball attack
    Note over App: Updates game state<br/>Player takes damage!

The destination server unwraps our packet like opening a present: 🎁

graph RL
    A[Final Data<br/>'fireball at 100,200'] --> B[Remove UDP Header] 
    B --> C[Remove IP Header]
    C --> D[Remove Ethernet Header]
    D --> E[Original Packet]
    
    style A fill:#99ff99
    style E fill:#ff9999

What Could Go Wrong?

UDP is called “unreliable” for a reason. Here are some things that might happen to our poor packet:

graph TD
    A[Packet Sent] --> B{Router Congested?}
    B -->|Yes| C[DROPPED! 💀]
    B -->|No| D{Network Cable OK?}
    D -->|Damaged| E[CORRUPTED! 🤕]
    D -->|Good| F{TTL Expired?}
    F -->|Yes| G[TIMEOUT! ⏰]
    F -->|No| H[Delivered! 🎉]
    
    style C fill:#ff6666
    style E fill:#ffaa66
    style G fill:#ffff66
    style H fill:#66ff66

Common Packet Disasters:

  1. Dropped: Router gets overwhelmed and tosses our packet in the digital trash
  2. Lost: Takes a wrong turn and ends up in the internet equivalent of Bermuda Triangle
  3. Corrupted: Gets mangled by electrical interference
  4. Delayed: Stuck in traffic (network congestion)

UDP vs TCP: Why Choose UDP?

You might wonder, “Why use UDP if it’s unreliable?” Here’s the comparison:

graph LR
    subgraph "UDP: The Speed Demon"
        A1[Send packet] --> A2[Done!]
    end
    
    subgraph "TCP: The Perfectionist"
        B1[Send packet] --> B2[Wait for ACK]
        B2 --> B3{ACK received?}
        B3 -->|No| B4[Resend packet]
        B4 --> B2
        B3 -->|Yes| B5[Done!]
    end
    
    style A1 fill:#99ff99
    style A2 fill:#99ff99
    style B1 fill:#99ccff
    style B5 fill:#99ccff

UDP is perfect for:

  • Gaming: Fast reactions matter more than perfect data
  • Video streaming: A few dropped frames won’t kill you
  • DNS lookups: Just ask again if it fails
  • Real-time communication: Speed over perfection

TCP is better for:

  • File downloads: You want every single byte
  • Web browsing: Missing parts of a webpage is annoying
  • Email: You definitely want your messages to arrive

The Journey Ends

And that’s the life of our UDP packet! From a simple game action to electrical signals racing through fiber optic cables at the speed of light, crossing continents in milliseconds.

Our packet lived fast and free - no guarantees, no confirmations, just pure speed. It might have made it to the server where the fireball hit its target, or it might be lost forever in the digital void. That’s the UDP way: “Send it and forget it!”

Next time you’re gaming online or watching a video, remember the billions of little UDP packets making their perilous journey across the internet, living their brief but exciting lives in the name of keeping your digital world running smoothly.

networks
This post is licensed under CC BY 4.0 by the author.