How Computers Talk: Packets, Frames, and Addresses

Write a birthday card and you face three addressing jobs. The card names your friend. The envelope names the street address the mail carrier needs. The courier's pouch names only the depot it goes to first — the courier never reads your card at all.

Every message your computer sends does the same triple-wrapping. The inner message names the faraway computer. A middle wrapper names the final destination for every network along the way. An outer wrapper names only the next device down the wire — rewritten at every stop, like the courier's pouch.

Get one wrapper wrong and the message goes to the wrong place, or nowhere. Most "the internet is broken" mysteries are just a wrong address on the wrong wrapper.

Here's the puzzle.

Scenario. Your friend Priya's video calls work fine, but her roommate's laptop can't see the shared folder on Priya's laptop. You're staring at a short list of captured messages from Priya's laptop, trying to learn which address does what — because the fix depends on knowing which wrapper is wrong.

Given artifacts. Four captured messages. Key: aa:aa:… = Priya's laptop · bb:bb:… = roommate's laptop · cc:cc:… = the home box that forwards messages between the apartment and the internet.

# | Time  | Source hardware   | Dest hardware     | Source IP    | Dest IP      | Src port | Dst port | Info
1 | 0.000 | aa:aa:aa:aa:aa:aa | bb:bb:bb:bb:bb:bb | 192.168.1.10 | 192.168.1.20 | 52341    | 445      | File-share request
2 | 0.004 | bb:bb:bb:bb:bb:bb | aa:aa:aa:aa:aa:aa | 192.168.1.20 | 192.168.1.10 | 445      | 52341    | File-share reply
3 | 1.102 | aa:aa:aa:aa:aa:aa | cc:cc:cc:cc:cc:cc | 192.168.1.10 | 203.0.113.45 | 61200    | 443      | Video-call data
4 | 1.150 | cc:cc:cc:cc:cc:cc | aa:aa:aa:aa:aa:aa | 203.0.113.45 | 192.168.1.10 | 443      | 61200    | Video-call data

Your task: using only packet #3, answer three questions with the exact values from its row — (a) which machine on this wire should receive it (the destination hardware address), (b) which machine across the world is the true destination (the destination IP address), (c) which program on the far machine should get it (the destination port).

Workspace: analyze-and-answer — three text fields labeled (a), (b), (c). Copy the values exactly as they appear; nothing is graded.

Commitment ritual: below the workspace sits a checkbox — "I've attempted this challenge and thought it through." Checking it (with or without typing an answer) reveals the worked answer in S7. Nothing is graded; the checkbox is a promise to yourself that you struggled first. (Honor system for now — real progress tracking arrives with accounts.)

Messages travel in small, addressed pieces

The smallest piece of information is a bit (a single 1 or 0 — eight of them make a byte, and everything you've ever seen on a screen is bits in bulk). Networks don't send your whole video call as one giant blob; they chop every message into small chunks called packets (a small piece of a larger message, carrying addresses so the network knows where it's going).

Why chop? Sharing. A wire is like a single-lane road: if one giant truck (your video call) blocked it end to end, everyone else's mail would wait. Small packets interleave — a slice of your call, a slice of your roommate's file transfer, a slice of someone's web page — so hundreds of conversations share the same wires fairly. Your devices quietly reassemble the slices at the far end.

Why this matters for the challenge: each row in the capture is one packet — one slice, with its addresses printed on the outside. Reading the row means reading the addresses.

Wrappers inside wrappers: encapsulation

Every packet wears layers, and the layering has a name: encapsulation (wrapping data in successive layers, each layer adding its own addressing — the card, the envelope, and the courier's pouch from the hook). The order matters and never changes:

1. Your program hands down its message with the worldwide addresses attached — this is the packet, addressed from the true sender to the true receiver.
2. Then the local wire addresses are attached outside it — now it's a frame (a packet plus its outermost wrapper, the envelope used for one trip along one wire).

Inner wrapper: who in the world. Outer wrapper: who's next on this wire. At every stop along the way, the outer wrapper is peeled off and replaced with a fresh one naming the next device — while the inner addresses ride through untouched, all the way to the far end.

Why this matters for the challenge: packet #3 wears both wrappers. The puzzle is noticing that its two destination addresses name two different machines — and realizing that's exactly how the system is designed.

Three addresses, three jobs

Every connected device juggles three kinds of address, each answering one question:

A useful memory hook: the hardware address is the courier's depot, the IP address is the street address, and the port is the name on the mailbox. Miss the depot and the pouch never leaves town; miss the street and it crosses the world to the wrong house; miss the name and it arrives at the right house but nobody claims it.

Why this matters for the challenge: questions (a), (b), and (c) map one-to-one onto these three rows. You'll apply the mapping to packet #3 in the worked answer.

How to read one line of a capture

A capture is just a list of packets, one per row, in the order they flew past. The columns are always the same story: # (the packet's number in the list), Time (seconds since the capture started), Source → Destination (who sent it, who should receive it), Protocol (what kind of message), Length (how big), and Info (a one-line human summary).

Two reading habits that pay off forever. First, read source and destination as a pair — packets 1 and 2 in the challenge are mirror images, the request and its reply. Second, when two addresses on one row disagree, ask which wrapper each belongs to — the challenge's packet #3 disagrees with itself on purpose, and the disagreement is the lesson.

In the challenge excerpt we laid every address out flat so you can compare them side by side. Real tools nest them — hardware addresses inside the frame section, IP addresses inside the packet section, ports inside the program section — and Section 5 walks you through that real view.

Why this matters for the challenge: (a), (b), and (c) are all visible in packet #3's row right now. The theory gave you the map; the row is the territory.

• Big messages are split into small addressed packets so many conversations can share the same wires fairly.
• Encapsulation wraps twice: worldwide addresses make it a packet, local wire addresses make it a frame — always in that order.
• Three addresses, three jobs: hardware names the next device on this wire, IP names the device anywhere in the world, port names the program on the device.
• For internet traffic the destination hardware address is your forwarding box, not the far server — the outer wrapper is rewritten at every stop while the IP addresses ride through unchanged.
• Read a capture line by matching each address to its job: wire, world, or program — and read source/destination as mirror-image pairs.

Next: IP Addresses and Subnets Without Tears — you can now read the addresses on a packet; next you'll learn to read the addresses themselves: what the four numbers mean, and how to tell whether two devices are neighbors or strangers.