Hosts chop data into discrete, individually forwarded chunks rather than pouring a stream onto the wire. The header is pure overhead — tens of bytes against payloads of hundreds to thousands — and every sharing, queueing and layering mechanism in the module exists because of this chunking.

Each conversation holds a fixed share for its whole duration, so an admitted call always has its rate — and the eleventh caller on a ten-circuit link is refused even when circuits sit silent. Circuit switching converts sharing into admission control.

With bursty users active a fraction p of the time, a link serves many more users than its circuit count at a small overload probability P(X > k). The gain holds only while the mean load leaves headroom; it collapses once the average alone saturates the link, and it assumes independent activity.

A switch must see the whole packet — to read the header and check integrity — before spending downstream capacity on it. The per-hop transmission toll H × L/R is the floor on which waiting and travel time pile.

Distance is irrelevant: a 1500-byte packet costs 1.2 µs on 10 Gb/s and 1.2 ms on 10 Mb/s. Upgrading a link buys down exactly this component and nothing else.

Set by geography alone — 40 ms across 8000 km of fibre at any rate, any packet size. No upgrade except a shorter path moves it, which is why long links are propagation-dominated and only grow more so as rates rise.

L is bits per packet, a arrivals per second, R bits per second. Below one the link is sustainable on average but still queues, because randomness clusters arrivals; at or above one the backlog grows without bound until arrivals ease or the buffer drops the excess.

Mean time in system follows W = E[S]/(1−ρ), quoted from the queueing topic: delay explodes as ρ → 1, so doubling load from 0.48 to 0.96 multiplies waiting ~26×. Loss is the signal well-behaved senders use to slow down; bigger buffers trade drops for standing delay.

Flow conservation forces R ≤ every link rate, and sending at the minimum achieves it. Upgrading any link except the bottleneck changes nothing; the bottleneck moves to whichever link — or per-flow share — is now smallest. File time is T = F/R in bits.

A sender keeping fewer than BDP bits outstanding leaves capacity idle; more only queues. Throughput obeys min(R, W/RTT), so a 64-KByte window caps a 1 Gb/s continental path at ~6.6 Mb/s — the long-fat-network problem that window scaling answers.

All three are needed: without format bits are ambiguous, without order each end waits for what the other never sends, without the timeout action one lost packet stalls the exchange forever. Each party is modelled as a finite-state machine.

Loss raises no signal, so the timer turns "nothing arrived in time" into a retransmission. Duplicates are the normal price — a timer firing on a delayed reply creates two live copies — so receivers answer idempotently and senders absorb stale replies by state.

No layer parses another: EtherType, the IP protocol field and port numbers each deliver upward exactly once. Applications and link technologies evolve without meeting, at a constant per-layer header cost that small payloads feel (59% on a voice sample) and large ones amortise (~4%).

The waist is deliberately minimal (best-effort delivery, nothing more): everything a layer guarantees, every layer above must wait for. Keeping IP thin keeps every path usable, which is why the Internet kept scope layers and folded presentation and session into the application.

The bytes 12 34 always mean 0x1234 = 4660 regardless of host endianness. The convention is load-bearing, not cosmetic: misreading length bytes little-endian turns a 60-byte datagram into 15360. Single-byte and bit fields need no rule.

IPv4 took the fixed route (total length always bytes 2–3, protocol byte 9) with reserved bits and a small option area; IPv6 moved to chained extension headers. Reserved means zero-on-send plus ignore-on-receive — a contract middleboxes break when they clear or punish unknown bits.

Hop checks observe wire between boxes; transfer correctness spans endpoint memories the hops never see. Hence a best-effort core with intelligence at the hosts. Hop help (wireless retransmission) survives as a performance exception beneath the ends check — never instead of it.

A signal reads as a sum of sinusoids; the medium removes some frequencies and keeps others. The surviving width B in hertz bounds symbols per second (Nyquist) and multiplies capacity (Shannon). Data rate in bits per second is a different quantity in different units.

L_dB = 10 log10(P_in/P_out); end-to-end loss is alpha × d. Quoting per-kilometre loss turns a chain of multiplications into one addition down the budget column.

NRZ guarantees nothing; Manchester puts a transition in every bit at 2x baud; 4B/5B and 8b/10b spend codebook surplus for bounded runs (and disparity control) at 25% overhead. Leftover codewords become control symbols.

A band of width B offers 2B degrees of freedom per second; each symbol choosing among M levels conveys log2 M bits. Density is logarithmic in hardware — each extra bit per symbol doubles the levels and halves neighbour spacing.

Average power is the budget; geometry is the spending plan. Packing more points subdivides the fixed-power plane and shrinks the gap noise must bridge — real links retreat down this ladder as the channel degrades.

An error needs noise alone to bridge half the slicer gap; standardising gives the Gaussian tail. Tails decay faster than exponentially, so equal decibel steps buy accelerating returns near the cliff.

Derived in outline from maximising mutual information with Gaussian input. Worked ceilings: 30.9 kb/s phone, 133.2 Mb/s Wi-Fi, 50.3 Gb/s fibre. Uncoded 64-QAM at 240 Mb/s in the Wi-Fi band overshoots capacity and cannot run error-free.

FDM pays guard bands in hertz, TDM pays idle slots in time; OFDM pays a cyclic-prefix time tax (20%) and separates channels by inner-product geometry. Spacing exactly 1/T is load-bearing.

Sentinel bytes pay stuffing (HDLC escapes every 011111 in the body), length fields pay corruption at the worst place (a bad count resynchronises nothing), and clock encoding pays bandwidth (SONET resynchronises by repetition). Every link layer picks one of these trades; the choices collide again in Ethernet's preamble and VLAN tags.

Worst-case overhead is a fifth of the bit stream — bounded, unlike the byte-stuffed PPP tax, which can double on adversarial data. The receiver applies the same rule in reverse, so one un-escaped 01111110 means flag and anything else is an error.

A code detects up to d−1 errors and corrects up to floor((d−1)/2) — split the budget between the two however you like, since detected-and-uncorrected costs d−1 too. Single parity buys d=2; Hamming codes buy d=3 with the fewest possible check bits (n+1 ≤ 2^(n−k)).

Every error-control scheme is a point on this trade: repetition codes correct anything at rate 1/n, Hamming codes correct one error at rate approaching 1, and the bound n+1 ≤ 2^(n−k) says what single-error correction must cost. A code that saturates the bound is perfect.

Verify by inclusion: summing the segment including the checksum must give all 1s. The carry-around makes the sum byte-order independent — swap the bytes and the swapped sum is the same — which is why it was chosen for IP where hosts disagree on endianness.

HC' = ~(~HC + ~m + m') — subtract the old word, add the new, done in one pass. Routers use it on TTL so the checksum costs the same per hop as the decrement does. The edge case is real: when ~HC + ~m + m' sums to 0xffff the result must stay 0xffff, not fold to 0 — RFC 1141 got that wrong.

Hardware is a shift register and a few XORs; the payoff is a designed guarantee, not a statistical one — a degree-32 CRC detects every burst up to 32 bits and every odd-bit error. Koopman's evaluations show which polynomials actually deliver the promised Hamming distance at each length.

For a linear code the syndrome depends only on the error, not the codeword, so the table maps syndromes to most-likely errors. Hamming (7,4) does it with three equations — the syndrome index is the bit to flip.

Errors are paid per symbol, so a burst hitting b consecutive bits costs at most b/m symbols — the code eats bursts that defeat bit-oriented codes. CDs, DVDs, QR codes and deep-space links all use it; the storage world met it as erasure coding.

Converts one long burst — which any single code cannot correct — into one-symbol errors spread across the depth of the block. Pays delay for burst tolerance with no extra redundancy; the burst length it survives is set by the interleaver depth.

A pure-ALOHA frame is destroyed by any overlap inside a two-frame window, giving S = G·e^(−2G) and an 18.4% ceiling; slotting halves the window for S = G·e^(−G) and 36.8%. Both curves sag after their peak — the protocol is unstable once offered load passes it, which is what backoff exists to fix.

Detection works only while the sender is still talking, so a frame must occupy the wire for 2τ. Classic 10 Mb/s Ethernet fixed 512 bit-times — which set the 64-byte minimum frame on one side and, with the 2.5 km, 4-repeater diameter, the maximum network size on the other.

Each collision is evidence of roughly one more contender, so the range doubles as though the estimate did — exponential response to linear evidence. The cap at n=10 bounds the wait; the capture effect is the price: whoever wins keeps winning while the loser’s range keeps growing.

The OUI half names the vendor; the group bit distinguishes unicast from multicast; the local bit makes room for locally assigned addresses. Flat means no aggregation — a switch cannot summarise where a MAC lives, which is exactly why learning tables and spanning trees are needed.

Backward learning: a frame arriving on port p proves its source lives behind p. Unknown destinations and broadcast still flood — the table is a pruning hint, never a correctness condition, so a stale or missing entry costs extra copies, not wrong delivery.

Ethernet has no TTL, so a looped flood circulates forever; the tree removes loops physically by construction. Classic convergence takes tens of seconds and wastes the blocked links entirely — the two complaints RSTP and TRILL were built to answer.

One physical LAN partitions into per-VLAN broadcast domains; trunk links carry the tags between switches while access ports strip them. 4094 usable VIDs — 0 and 4095 are reserved — and crossing between VLANs still requires a router, which is the point.

Physical sensing reports the sender’s neighbourhood, but the collision happens at the receiver’s. RTS/CTS fixes it with a reservation handshake: every station that overhears either control frame sets a NAV timer and stays silent for the declared duration — virtual carrier sense carried in the frames themselves.

The 802.11 Duration/ID field reserves the medium through the ACK of the current exchange, so even a lone large frame silences its neighbourhood. Collisions move to the short RTS: a lost RTS costs tens of microseconds where a lost data frame cost the whole payload’s airtime.

To DS / From DS bits say which direction the frame travels relative to the wired side; the AP translates between the wireless triple and Ethernet’s pair. A fourth address appears only on AP-to-AP links inside the distribution system — both hop endpoints and both end stations at once.

Replaced the classful A/B/C boundaries that wasted space — a network claims any contiguous power-of-two block. Aggregation lets one route cover many prefixes (192.4.16–31/16 → a single /20), which is what keeps backbone tables measured in hundreds of thousands rather than millions.

The rule is what lets a specific route punch a hole through a covering aggregate. Lookup structures make it fast: binary tries walk bit by bit, path-compressed tries skip one-child runs, multibit tries stride several bits per access, and TCAMs compare all entries at once.

Cache entries time out in minutes, not forever — replug a machine and stale caches recover on their own. The protocol authenticates nothing: any host may answer any query, which is ARP spoofing, and gratuitous replies make it a feature as well as a hole.

RFC 1191’s plateau search; RFC 4821 (PLPMTUD) and RFC 8899 (DPLPMTUD) probe upward without trusting ICMP — the answer to links and tunnels that silently drop or filter the message. The floor is the IPv6 minimum of 1280 bytes.

Replaces ARP’s every-host broadcast: ff02::1:ffXX:XXXX keeps the query off nearly every NIC on the link. Duplicate address detection reuses it — a station asks about its own would-be address first, and an answer means pick another.

Reliable flooding makes every router hold the same map: store if newer, forward except to the sender, reflood a zeroed TTL as a deletion. OSPF signs the 32-bit sequence space from 0x80000001 and ages entries toward MaxAge — the paper trail that lets transient loops exist at all, since two routers briefly run SPF on different maps.

The topology of an area is invisible outside it — internal routers store the area’s map plus summary advertisements, never the outside detail. The price is paid in optimality: a summary-LSA prices a whole range at its worst component’s cost, so a remote router cannot tell the near edge from the far.

Good news travels at link speed, bad news at infinity speed: when a route dies, stale longer routes get re-advertised as real ones and each neighbour believes the other. Finite infinity, split horizon and poisoned reverse patch the easy cases; path vector fixes it by carrying the route itself.

iBGP’s no-readvertisement rule exists because intra-AS routes carry no AS-path loop check; a reflector bends it for clients only, tagging updates with ORIGINATOR_ID and CLUSTER_LIST so a route returning to its origin or cluster is dropped. Path hiding is the price: the reflector advertises its own best, and that may not be the AS’s best.

A path that obeys it climbs provider edges, crosses at most one peer edge, and descends customer edges — never up a second hill. The theorem is what BGP operators actually run: any AS using the usual import rules is inherently safe, no global coordination needed.

Nearest means routing-metric nearest — fine for DNS’s single-shot queries, hazardous for anything stateful, since a topology change can shift a client’s packets to a different site mid-connection. Shared-unicast prefixes carry the same technique without the anycast semantics.

Fortz–Thorup’s objective prices a link at slopes of 1, 3, 10, 70, 500, 5000 across utilisation bands, so the optimiser pays almost anything to keep links below ~85% load. Setting IGP weights to it beats hop-count by 50–110% of carried demand and lands within a few percent of optimal routing.

Routers swap labels, not look up prefixes — the FEC is decided at the edge, so the core forwards on a fixed-format field at hardware speed. Penultimate-hop popping hands the egress a plain IP packet; label stacks are how VPNs and fast reroute ride the same fabric.

Each segment is either an IGP shortest-path step or an explicit hop (End/End.X in SRv6), encoded as MPLS labels or IPv6 addresses in the SRH. The network core keeps no per-flow state — a policy is just a header, which is why it scales where RSVP-TE did not.

OpenFlow standardised the southbound protocol (McKeown 2008); Google’s B4 showed the economics — a WAN carrying Google-internal traffic at near-100% utilisation by computing paths centrally instead of trusting BGP. The hardware stays dumb and fast; policy lives in software that can be changed in hours.

About 90,000 ASes hold the global routing table of over a million prefixes; the policy layer that matters is the business graph — stub, multihomed, and transit ASes connected by customer–provider and peering edges. Inside an AS you optimise with an IGP; between them you negotiate with BGP, and the two views deliberately disagree.

Each speaker prepends its own ASN and rejects any UPDATE containing it, so loops die on arrival. Path length is a cheap, policy-agnostic rank key, but it is also the attack surface: prepending inflates it on purpose, and a rogue ASN that injects itself forwards traffic it was never meant to see.

Each rung exists because the rung above it refused to decide — local-pref is operator policy, path length is a proxy, MED a hint between neighbours, and the last three are just determinism. The ladder makes route selection predictable, which is precisely why Griffin’s stable-paths analysis can treat it as a game.

RIP declares sixteen unreachable, so a vanished subnet can take minutes to die while neighbours relay stale claims — the trace is dozens of advertisements before both sides converge. Split horizon and poisoned reverse cut the common cases but not the three-router triangle, which is why path vector carries the path, not just the count.

Per-packet spraying would reorder segments inside a flow — beyond roughly one serialisation delay the late packet triggers fast retransmit, so routers pin flows instead. The hash divides key space into regions; a link loss reshuffles only that region’s flows, and the residual imbalance is the balls-into-bins bound plus whatever polarisation your hash chain hides.

The header’s port pair is the demux key — the kernel keeps a table of bound endpoints and queues each message behind the matching socket. Well-known numbers (53, 25, 517) pin services; the 16,384 ephemeral ports pin clients, which is why a leaky loop can exhaust TIME_WAIT capacity on a busy proxy.

Zero means not computed, but RFC 8085 effectively mandates it: it is the only thing standing between a bit-flipped address and silent delivery to the wrong endpoint. The pseudo-header folding in IP source and destination is the part people forget — the checksum protects against misdelivery, not just corruption.

With only one outstanding frame, duplicates from a retransmitted frame and a real next frame collide, so one bit alternates. The cost is brutal: a 1.5 Mb/s satellite link drops to roughly 182 kb/s, an eighth of capacity — pipelining exists precisely because stop-and-wait wastes the bandwidth-delay product.

The third segment exists because the responder must learn that its ISN arrived; without it, an old duplicate SYN could open a phantom connection. Each side sends its own ISN — the handshake is two interleaved two-way confirmations, not a courtesy.

Jacobson’s estimator runs SRTT ← (1−g)SRTT + g·R and multiplies the deviation by four, so the timeout tracks the mean without whipsawing on jitter. Karn’s refinement — never re-time a retransmitted segment — stops an ambiguous ACK from corrupting the estimate right when the network is already sick.

Every out-of-order segment makes the receiver repeat its highest in-order ACK number, so a burst of dups means one segment is missing, not the whole flight. SACK narrows the retransmit set to the holes the receiver actually reports — four block pairs in the header, the rest advisory.

The receiver-side fix is to advertise only a real chunk — half the buffer or one MSS; the sender-side fix is to accumulate a full segment before pushing. Between them the zero-window probe (5–60 s backoff) keeps a closed receiver polling without livelock.

Individually both are defensible: Nagle turns keystroke traffic from forty-byte to four-byte efficiency, and delayed ACKs save a packet per two segments. Interleaved, a write-write-read application stalls ~90 ms a round; that is why TCP_NODELAY exists and why SSH feels different on lossy links.

Window arithmetic is invariant bookkeeping: LFS−LAR≤SWS on the send side, LAF−LFR≤RWS on the receive. Under-utilisation is the failure that matters — at W below BDP the link idles between flights, which is why window sizing is a capacity question, not a courtesy.

A single timer on the oldest unacked segment keeps sender state minimal, but one loss retransmits everything after the gap — fine at low loss rates and punishing at high ones. The sequence-space bound W ≤ 2^k − 1 is the ambiguity guard: a full window of lost ACKs must not alias onto the next.

Per-segment timers plus a receive window mean one loss costs exactly one retransmission — the efficiency GBN wastes. The price is a tighter bound, W ≤ 2^(k−1): the send and receive windows may not overlap on sequence numbers, or a replayed old segment is mistaken for new data.

Jacobson’s trace was brutal: 32 Kbps sagging to 40 bps because most packets crossing the bottleneck were copies the receiver already had. The cure was not a bigger queue but self-clocking — ACK-driven pacing, slow start and the RTO estimator — which is why TCP’s congestion machinery is named after the paper that diagnosed it.

The water-filling algorithm saturates the tightest bottleneck first, then repeats on what is left, giving a unique allocation provable via the bottleneck-link property. It is the target TCP only approximates: real senders cannot see the plane, they can only probe it — hence AIMD.

Chiu and Jain showed that from any starting point on the allocation plane, a vector with positive additive and less-than-linear multiplicative terms converges to the fairness line. The sawtooth is the price: steady-state windows oscillate, and the equilibrium rate falls out of the geometry, not a negotiation.

The name is a misdirection: per-RTT doubling is TCP’s most aggressive phase, reaching an IW-to-BDP span in a handful of round trips. Reno adds fast retransmit and fast recovery — keep the pipe half-full after a single loss instead of collapsing to one segment, which is what the later standards actually tune.

Each loss halves the window, so the average window is proportional to 1/√p; a 10 Gb/s flow over a transcontinental path needs loss below 1e-10, which is why math drives protocol design — Padhye's refinement adds timeouts and receiver-window caps that the simple model misses.

Because growth is time-based not ACK-based, CUBIC is RTT-fair — flows at 10 ms and 100 ms climb the same curve. The β=0.7 cut plus fast convergence keeps it polite to itself, and RFC 9438 is just the code spelling out the constants.

Appenzeller et al. showed the single-sawtooth B=RTT·C rule overprovisions wildly: with independent phases the aggregate loss rate smooths out, so a backbone with hundreds of flows needs a few dozen packets of buffering, not gigabytes. The caveat is synchronisation — under attack or on a single big flow, the old rule returns.

AQMs attack it by dropping early: CoDel drops only when queue sojourn exceeds ~5 ms past a 100 ms interval, with a 1/√count control law, and ECN lets a congested router mark instead of drop so TCP's feedback loop reacts without loss. The lesson is queues are a control knob, not a cushion.

Demers–Keshav–Shenker price each packet at max(prev finish, virtual now) + size/weight and serve the smallest finish number; a flow's share survives its own bursts because its packets queue against themselves. DRR cuts the O(log n) heap to O(1) with a quantum-and-deficit scheme at the cost of a bounded unfairness.

The point is decoupling congestion signal from damage: marking capacity gets the sender's attention at queue-buildup time rather than tail-drop time, which is exactly what AQMs like RED and CoDel want. Middleboxes that strip or squash it are the reason deployment took two decades.

Loss-based controls overshoot the knee — BBR periodically probes bandwidth (ProbeBW) and drains to re-measure RTprop (ProbeRTT), locking its inflight limit near one BDP. The v3 draft adds a modest loss response for coexistence; the interesting claim is that throughput and delay are jointly measurable, not a trade-off to guess.

The lease is a soft-state contract: RENEWING unicasts back to the issuer, REBINDING broadcasts to anyone, and at expiry the address is unbound. The relay's giaddr is what makes it routable — without it the server cannot pick the right subnet scope or reply back to the client.

The RA's A-flag gates autonomous addressing; the host runs duplicate-address detection before preferring the tentative address, then watches preferred/valid lifetimes roll it to deprecated and invalid. Stateless means the router only advertises prefixes — it never learns who took them, which is why DHCPv6 still exists for the managed cases.

Sixteen port bits cap a NAPT at ~65k simultaneous flows per inside address, and idle timeouts eat state fast — keepalive arithmetic shows why chat apps poll. The deeper cost is directionality: outbound works, inbound needs a port map, which is the asymmetry ICE and TURN exist to beat.

It works ~80% of the time for UDP because a mapping is created by sending; symmetric NATs break it since the map differs per peer, forcing TURN relays at provider cost. ICE just searches the candidate pairs in priority order — host, server-reflexive, relayed — which is why WebRTC ships all three.

The insight was that a broken v6 path made dual-stack slower than v4-only, so hosts learned to hedge: sort by RFC 6724 preference, start the preferred family, and start the fallback a quarter-second later rather than waiting for failure. That small race is the difference between transition as progress and transition as regression.

A fresh connection pays a handshake RTT plus congestion-window ramp on every object; a 90-object page at 56 ms RTT costs ~12 s serially versus ~1.2 s with parallelism and persistence. Pipelining tried to go further but hit head-of-line blocking — the lesson HTTP/2's framing finally solved properly.

Freshness lifetime is layered: s-maxage beats max-age beats Expires, and absent all three caches guess ~10% of age. The pitfall names matter — no-cache means revalidate, no-store means don't keep, and Vary decides which headers form the key; get them wrong and shared caches leak or starve.

Delegation is administrative fiat — a parent publishes NS for the child and glue A records only when the servers sit below the cut. That one design (names as a tree, authority as a chain) is why DNS scales to billions of names with thirteen logical roots.

Recursive servers do the walking so stubs ask once: a cold lookup of penguins.cs.princeton.edu costs about four queries — root, edu, princeton.edu, cs.princeton.edu — and every referral returned is itself a cacheable fact. The last hop answers authoritatively; everything before it is navigation.

Caching collapses the root's load by six orders of magnitude, which is what makes the whole tree economical. The cost is the bound: a 86400 s TTL means a moved address can stay wrong for a day, so operators drop TTLs before migrations — you pre-pay agility before you need it.

The 9-octet frame header plus stream IDs let one TCP connection carry hundreds of concurrent responses, which fixes HTTP-level HOL blocking — but not transport HOL: one lost TCP segment stalls every stream at probability 1−(1−p)^n versus p per stream before. That residual is exactly what HTTP/3's QUIC datagrams remove.

CRIME proved that compressing attacker-chosen text against secrets leaks length; HPACK's answer is Huffman-coded literals and index references that never mix the two. Repeated headers send a few index bytes instead of hundreds — the 85–88% zlib wins without the side channel.

Treating the wire as fully adversarial is what makes the security goals crisp: confidentiality, integrity, authenticity, forward secrecy each need a distinct mechanism because the attacker in between can exercise all five verbs. Anything weaker just moves the trust boundary somewhere unexamined.

The pair-counting math means a 128-bit digest resists collisions for only ~2^64 work, not 2^128 — the reason SHA-256 exists and why key/IV/nonce sizing questions always halve themselves. It is the same arithmetic that bounds CTR counter space and nonce reuse.

The nonce is the whole game: reuse a counter value and two ciphertexts XOR into the plaintexts' difference, the two-time-pad failure. Its other virtue is parallelism plus no padding — encryption is a map XOR, so decryption never needs the inverse permutation.

The nested two-key construction exists because raw H(key‖message) is forgeable through Merkle-Damgård length extension. Verification is comparison: a tampered tag must be recomputed without the key, which is why truncating to 80 bits is still within the standard.

History says combining a cipher and a MAC yourself goes wrong — padding oracles ate TLS's MAC-then-encrypt, and nonce reuse in GCM hands the attacker the authentication key. AEAD's contract is simpler: the caller supplies a nonce and unencrypted context, the construction does the rest.

Security rests on discrete log being hard while exponentiation is easy; an active MITM breaks it trivially, which is why DH always rides inside an authenticated handshake. Ephemeral DH is what buys forward secrecy — yesterday's key is already gone.

TLS 1.3 lies on the wire deliberately: every record claims type 23, while the real type sits encrypted at the tail with optional padding. The nonce is never transmitted — it is the 64-bit sequence number XORed into a per-direction write_iv, which is how both sides stay synchronised without an explicit IV field.

Everything after ServerHello travels under handshake keys, which is why TLS 1.3 hides the certificate and finishes a round trip faster than 1.2 ever could. The downgrade sentinel and HelloRetryRequest magic exist because the remaining plaintext bits are where the middleboxes live.

Each stage binds the transcript so far plus the previous secret, so a MiTM cannot splice phases: client and server hs_traffic keys diverge by label, and traffic secrets rotate with key updates. The resumption secret hangs off the application secret with the ticket_nonce — a separate tree entirely.

PSK resumption saves signatures, not round trips; 0-RTT saves the trip but weakens two guarantees — it is replayable and non-secret once the early secret leaks. The RFC's answer is a policy: safe methods only, single-use tickets, ClientHello recording — never pretending the cheap flight is the real one.

TCPExposure's measurements showed options stripped on ~14% of :80 paths and sequence numbers rewritten on ~18% — the network now owns your header. RFC 9170's answer is greasing: advertise unused values forever so the middleboxes can never ossify them, the same trick TLS runs on cipher suites.

A lost packet stalls only the streams it carried — the HOL cost TCP pays at the transport is gone. MAX_STREAM_DATA/MAX_DATA form a two-level credit system, MAX_STREAMS bounds concurrency, and RESET_STREAM/STOP_SENDING let either side abandon a stream without abandoning the connection.

Folding TLS 1.3 into the transport means the connection-id, version and crypto arrive together — one RTT to first data, zero on resumption. The server's anti-amplification cap (3× received) and retry tokens police spoofed sources before any state exists.

TCP rebinds on a new source address; QUIC just validates the new path (PATH_CHALLENGE/RESPONSE) and keeps the CID. Rotating CIDs per path prevents an observer linking your packets across networks — privacy bought with unlinkability.

Retransmitted data rides in a brand-new packet number, so an ACK unambiguously names one transmission — the ambiguity that forced Karn's algorithm disappears. Loss is declared by packet threshold or time, and the probe-timeout mechanism replaces TCP's RTO.

HTTP/3 maps requests onto QUIC streams (0,4,8…) and drops HOL-blocking machinery HTTP/2 needed. QPACK's dynamic table updates travel on dedicated uni-streams; a request referencing a not-yet-arrived entry blocks only itself — a bounded stall, not a head-of-line pileup.

Akamai's measurements showed the resolver-to-client distance is the real problem: ECS (RFC 7871) leaks a client prefix through the resolver so the authoritative nameserver can map correctly. Twenty milliseconds of closer placement beats every bandwidth upgrade — the placement decision IS the performance.

BBA-0's insight is that the buffer map is the whole algorithm: a reservoir where you play safe, a cushion where you ramp, and a panic region where you drop to minimum quality. The drain-rate boundary decides stalls, so the 10–20% rebuffer cut came from respecting it, not predicting bandwidth.

5G's TS 23.501 splits control and user planes cleanly: UPFs forward, SMFs assign, AMFs page. The N3 GTP-U tunnel is the seam — your packet is IP inside a UDP/TEID wrapper between the gNB and the UPF, which is how a cell network pretends to be an Ethernet.

An end marker in the GTP stream tells the old gNB's buffer where forwarding ends; the SMF re-points N3 and the UE never sees an address change. QUIC migration and mobile-IP are the same trick viewed from opposite ends: someone updates the binding, the identifier survives.

A SYN flood exhausts the backlog queue with half-opens. Bernstein's trick packs timestamp, counter and a MAC of the 4-tuple into the initial sequence number, so the state rides the wire instead of memory — the queue is proven unnecessary. RFC 4987's honest advice: cookies trade options info for survivability.

The attacker's cost is the query; the victim pays for the answer, which is why UDP services became artillery. Rossow's census showed the abuse surface is protocol-wide, and CISA's advisory forced response-rate limiting and BCP38 source filtering as the only real cures.

Challenge-ACK feedback turns guesswork into a side channel: send probes, count the challenge ACKs, and the exact window position leaks. RST injection kills the stream; data injection can poison a session — the defence is making the guess space intractable, not a firewall.

Below the link, no appliance helps — the pipe is already full. Mitigation lives elsewhere: BGP diversion to scrubbing centres, anycast that spreads the flood across edges, rate limiting and ACLs for protocol attacks, and fair-queue/WAF logic for the application layer.

Statefulness buys correctness — return traffic passes only when a matching outbound flow exists — at the price of a table that itself becomes a flooding target. The boundary between packet filters, stateful inspection and application proxies is what the rules can see, not the box.

Tunnel mode adds ~50–60 bytes per packet (outer IP, ESP/UDP, IV/tag, trailer), shrinking the MTU and forcing MSS clamping — which is why VPN links fragment. The cost buys an untrusted network acting as private wire: GRE and IP-in-IP tunnel without encryption, ESP and WireGuard add AEAD.

Jupiter showed the trick scales to datacenter size: 3-stage folds multiply port count without chassis. The number that matters is bisection bandwidth per server — and ECMP is only as good as the entropy in the 5-tuple spread across those equal paths.

Static ECMP hashes pin an elephant to whatever link its tuple lands on, and a few collisions sink utilization. CONGA measures congestion per path and lets LetFlow rebalance only at flowlet gaps, exploiting the fact that reordering only happens if you move mid-burst.

The collapse is deterministic: synchronized senders overrun one egress queue, tail-drop a full window, and all senders time out together — throughput floors until the barrier passes. Tiny buffers, pacing, and bounded response sizes all attack the same spike.

DCTCP multiplies window by the fraction of marked bytes instead of halving on loss, so the sawtooth flattens and the queue stays near the marking threshold. RFC 8257 standardized it because datacenter RTTs make the 1ms control loop feasible.

Once the serialization term is removed, residual RTT is almost pure queueing — a 27 µs queue on a 47 µs RTT says congestion while loss is still absent. TIMELY's gradient controller adds or cuts based on the slope, which is why it needs hardware timestamps and a homogeneous fabric.

PFC turns Ethernet lossless for RDMA by sending PAUSE frames per priority class; transitively the backpressure tree can cycle and deadlock, so PFC storms and watchdog timers are an operational requirement, not an edge case.

TSO pushes segmentation into the NIC; GRO undoes it on receive, delivering one jumbo skb where the wire carried many frames. The numbers that survive: per-packet CPU dominates at 10G+, so offload wins whenever the flow and MTU line up — and distorts every measurement made above it.

DROP, PASS, TX, REDIRECT — four exits and no lookup stack below them. That's why XDP handles DDoS and L4 load-balancing at line rate: it runs in the driver's RX path and can rewrite or bounce a frame before the kernel allocates anything.

The 2014 paper's bet was that forwarding should be specified per-deployment: parser graphs, typed tables, and primitives compiled into the switch. Today's reality: programmable pipelines exist but the fast ones are still match-action shaped — your protocol lives or dies by whether it fits that silhouette.

The NIC does the transport: queue pairs, memory registration, completion queues, and one-sided READ/WRITE/ATOMIC verbs so a request never enters the peer's software. RoCEv2 wraps that in UDP/IPv4, which is why the fabric has to be lossless — reliability that TCP borrowed from the application got pushed into switch buffers.

RDMA cannot tolerate drops (the fabric is lossless via PFC), so DCQCN marks with ECN, the receiver reflects congestion notification packets, and the sender's rate controller follows the fraction marked — the same loop DCTCP runs at the transport layer, placed at the NIC for queues PFC would otherwise pause.

All-reduce dominates training traffic and every straggler stalls the step, so Meta's RoCE fabric builds a separate backend: dedicated Clos islands, load balancing tuned for elephant flows, and DCQCN parameters set for incast-heavy collectives rather than front-end workloads.

The pair keeps per-packet work flat at 10G+: sender hands one 64 KB write, the NIC emits the frames, the receiving driver rebuilds one skb before the stack sees it. Any middlebox that reorders or rewrites breaks the merge — which is why offloads are measurement hazards, not just accelerators.

The hook's power is its earliness: the program sees the raw frame and can rewrite, drop, hairpin, or redirect to a socket without kernel allocation. Facebook's L4 load balancer and Cloudflare's DDoS edge run there — the price is a verifier that rejects anything unbounded.

The 2014 CCR paper's ask was forwarding described per deployment rather than baked into silicon: parse graphs, typed tables, primitives. Its living descendants (Tofino-class chips, P4Runtime) prove the fast path is still match-action shaped — programs that fit run at line rate; everything else falls to the CPU.

Kubernetes delegates to CNI: a veth pair joins the pod's netns to the host bridge, and the overlay or BGP layer carries pod IPs cluster-wide. Egress looks like NAT, ingress like port-forwarding — containers are just private stacks; the interesting part is who allocates the address.

Maglev's contribution is the table, not the hash: backends fill a lookup table proportionally with almost-disjoint permutations, so one backend's death remaps only its slots — not the hash ring. Connection tracking is local and best-effort; the steering survives server churn because the table, not a negotiated state, holds the mapping.

VXLAN exists because 4096 VLANs are not enough and tenants should not see the physical topology: the frame gets outer Eth/IP/UDP/VXLAN headers (~50 B tax, shrunken effective MTU) and the underlay just routes IP. The multicast-versus-learned-flood question is why every overlay ends up paired with a control plane.

The buffer's depth sets the survival probability: wait one packet-time and any late packet is a dropout; wait three and the codec always has work. Adaptive playout tracks the delay distribution, not its mean — a percentile decision, which is why tail-latency thinking lands in a media lesson.

The protocol pair is small on purpose: sequence numbers and timestamps in RTP, sender/receiver reports and NACKs in RTCP. Every modern mechanism is a consumer of those two numbers — the receiver calculates jitter from timestamp deltas and the sender learns loss from cumulative counts.

The race is quantifiable: repair wins if RTT + jitter slack fits before playout; otherwise redundancy (XOR parity or Reed–Solomon) buys recovery at steady bitrate. Interleaving spreads burst loss across FEC blocks — the same erasure-code trick FEC used at the link layer, aimed at one deadline.

Unlike TCP, the sender can simply emit less — the knob is encoder bitrate, so congestion control becomes estimation: Kalman-filtered one-way delay variation flags queue growth, loss rate caps the ceiling, and AIMD walks the estimate between the two bounds.

RSA signing is exponentiation of the padded hash with d; ECDSA and Ed25519 move to group arithmetic with fresh or deterministic nonces. The fragility is the nonce: a reused or biased k hands over the signing key, which is why Ed25519 derives the nonce from the key plus the message.

The chain is the audit trail of delegation: the leaf attests the site's key, each intermediate vouches for the one below, and verification ends at a root shipped in the trust store. Everything else — SANs, validity windows, key-usage bits — is policy the verifier enforces on that path.

Revocation is the PKI's acknowledged soft underbelly — stapled OCSP is stale by design and CRLs are fetched lazily — so the modern answer shifts to evidence: CT logs require a signed inclusion promise before browsers trust a cert, turning silent misissuance into a visible event.

The capture point is the instrument's bias: GRO merges arrive as one segment, drops upstream never appear, and buffer exhaustion loses more under rate. Filters exist to keep the capture cheap enough to be truthful.

Keshav's observation: dispersion is information. If the bottleneck serves at C bits/s, a pair of length L leaves L/C apart and downstream links preserve it — queueing asymmetry is the error term, which is why estimators average over many pairs rather than trusting one.

Problem: more demand than dedicated capacity. Guarantee: circuits isolate perfectly; packets serve ~3.5× the users here at 0.04% overload. Cost: circuits waste idle slices and block newcomers; packets queue and occasionally drop. Failure case: correlated demand (stadiums, outages) breaks the independence the tail assumes.

Problem: slowness with several candidate causes. Preconditions: packet size, rate, distance and per-box processing known. Guarantee: transmission falls with R, propagation never moves, processing is per-box. Cost: misdiagnosis buys upgrades that change the total by a rounding error (a 10× rate upgrade saving 0.03% on a continental hop). Failure case: confusing bandwidth with latency — a faster link never delivers the first bit earlier.

Problem: a link that looks merely busy but answers slowly. Guarantee: W = E[S]/(1−ρ) quoted from queueing — 60 ms at 0.80, 300 ms at 0.96 here. Cost: averaging hides bursts; provision the pair (ρ plus buffer B), not either alone. Failure case: answering overload with bigger buffers converts drops into standing delay; the cure is sending slower.

Problem: end-to-end rate below what most links could carry. Guarantee: path rate is min_i R_i, per flow the smallest share. Cost: the bottleneck moves after each upgrade (link, then share). Failure case: upgrading the fat core while the thin access still decides every transfer.

Problem: a fast long path delivering a fraction of its rate. Guarantee: one BDP in flight fills the pipe; more only queues. Cost: windows must grow with the links they feed — a 64-KByte window wastes a 1 Gb/s continental path at ~6.6 Mb/s. Failure case: counting packets instead of bits when packet sizes vary.

Problem: headers must parse fast today and extend tomorrow. Guarantee: fixed fields read in constant time; TLV meets unknown types by length. Cost: fixed room runs out; TLV pays a bounds-checked loop per option. Failure case: middleboxes clearing unknown bits spend the extension room the designers saved — the ossification trap.

Problem: where to place a function both hops and ends could perform. Guarantee: correctness is q^H(1−h) — hop effort asymptotes at the ends ceiling. Cost: in-network functions tax every path. Failure case: dropping the endpoint verification because the link retransmits; wireless hop recovery shortens repair but observes nothing about endpoint memory.

Problem: agreement between independently built ends. Guarantee: the machine survives loss (timer), absorbs duplicates (state-gated replies), and disambiguates identical bytes by state. Cost: timeouts manufacture duplicates, so replies must be idempotent. Failure case: pipelining without numbering — one ack no longer identifies which request completed.

Problem: rate ambition without a feasibility bound. Guarantee: no reliable rate above C exists. Cost: approaching C needs long-block coding. Failure case: buying power (logarithmic) where the shortfall is bandwidth (linear) — e.g. pushing uncoded 64-QAM past a 133 Mb/s ceiling.

Problem: many conversations, one band. Guarantee: FDM/TDM isolate by non-contact; OFDM by orthogonality with a cyclic-prefix time tax. Cost: guard hertz, idle slots, or prefix airtime. Failure case: detuned subcarrier spacing, or a prefix shorter than the delay spread.

Problem: more bits per symbol versus more errors. Guarantee: minimum distance at fixed power ranks schemes fairly. Cost: superlinear noise vulnerability with density. Failure case: reading Nyquist density as achievable without checking the error tail.