← all systems · see it in The System
Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
The Internet protocol suite, commonly known as TCP/IP, is a framework for organizing the communication protocols used in the Internet and similar computer networks according to functional criteria ... [It] provides end-to-end data communication specifying how data should be packetized, addressed, transmitted, routed, and received. This functionality is organized into four abstraction layers ... The technical standards underlying the Internet protocol suite and its constituent protocols are maintained by the Internet Engineering Task Force (IETF).
Properties published scienceour proposal
Sourced fields, and our own readings.
| aliases | TCP/IP, Internet protocol suite, TCP/IP (the layered end-to-end datagram rule plus the RFC process for adding more) |
| arrives | design 1973, published May 1974; IPv4 installed in ARPANET 1983; DoD standard March 1982 |
| born at | designed summer 1973, published May 1974; first three-network transmission 22 November 1977; ARPANET flag day 1 January 1983 |
| born precision | months (1973-1974 design); a day (flag day) |
| boundary | Inside: the generating rule, which is one common internetwork datagram format and its layering (link, internet, transport, application), the end-to-end split (reliability 'delegated to the hosts'), the robustness rule, and the open rule for adding more (Internet Draft into a numbered RFC; IANA registry values). Also inside: its shell, the closed-to-edit RFC series ('never rescinded or modified') and the IETF tradition of rough consensus and running code that keeps it. Outside: what it unpacks into (the Internet, application protocols), the links and packet switching it rides on, middleboxes on the path, rival suites, and the stored-program machines that run it. |
| nested level | A Seed within stored-program computing ('protocols are to communication what programming languages are to computations'); built on packet switching (Baran early 1960s, Davies 1965) and the ARPANET's RFC practice (1969); above it the Internet, 'a network of networks'. |
| quantum | the protocol specification: a common internetwork datagram format and layering rules, published as RFCs, which any network and any application can copy and implement |
| scale | technological |
| shell | the RFC canon closed to edits: 'Once submitted, accepted, and published, an RFC cannot be changed'; changes need a new RFC with a new serial number; the IETF standards track is the codifier |
Measures (74) published science
| RFC 1 (Host Software, Steve Crocker) | 7 April 1969 date |
| RFC series length (RFC 9280, the RFC Editor Model v3) | numbered past 9,280 by June 2022; not all RFCs are standards |
| IANA protocol registries | over 2,800 registries and subregistries (2015) |
| first port-number registry proposed (Postel, RFC 433) | December 1972 date |
| design of the common internetwork protocol (Kahn and Cerf) | summer 1973; published May 1974 date |
| first specification of the Transmission Control Program (RFC 675) | December 1974 date |
| first three-network internetworked transmission | 22 November 1977 (packet radio, satellite network, ARPANET) date |
| DoD standard for all military networking; ARPANET flag day | March 1982; 1 January 1983 date |
| BSD TCP/IP code placed in the public domain | June 1989 date |
| IPv4 address space (32-bit) | c. 4.3e9 addresses |
| IPv6 address space (128-bit) | c. 3.4e38 addresses |
| IPv6 share of Google's traffic | over 41% (January 2023) percent |
| Internet users (ITU estimate) | 6 billion, 74% of the world's population; 2.2 billion offline (2025) people |
| share of two-way telecommunicated information carried over the Internet | 1% (1993); 51% (2000); more than 97% (2007) percent |
| first observed congestive collapse (NSFNET phase-I backbone) | 32 kbit/s fell to 40 bit/s (three orders of magnitude), October 1986; until end-node congestion control 1987-1988 |
| paths with an intermediary that modifies TCP metadata | a third of paths; 6.5% with harmful ossifying effects fraction of paths |
| IETF meeting attendance | 21 at the first (16 January 1986); maximum 2810 (December 2000, San Diego) attendees |
| TCP/UDP port ranges | registered 1024-49151; dynamic or private 49152-65535 port numbers |
| transport protocols, OSI against TCP/IP | five against two protocols |
| selective acknowledgment throughput gain (Bruyeron, Hemon and Zhang 1998) | up to 45% percent |
| characteristic clock: IETF meetings | three per year since 1991 (quarterly before) meetings per year |
| characteristic clock: TCP sequence-number space wraps | after 2^32 bytes ('Is this sequence number in the first 4 GB or the second?') |
| characteristic clock: retransmission timeout | dynamically determined; initial value smoothed RTT + max(G, 4 x RTT variation) (formula, no number given) seconds |
| characteristic clock: protocol generations at the waist | IPv4 defined 1981 (RFC 791); IPv6 Draft Standard December 1998, Internet Standard 14 July 2017 years |
| split of TCP and IP (version 4) | 1978 date |
| DoD standard for all military computer networking | March 1982 date |
| ARPANET flag day (NCP to TCP/IP) | 1 January 1983 date |
| IPv4 address space | 32-bit; approximately four billion hosts addresses |
| IPv6 standardised | 1998; 128-bit addresses; production implementations about 2006 date |
| last unassigned IPv4 top-level blocks allocated by IANA to the RIRs | February 2011 (blocks of 16 million addresses) date |
| users reaching Google over IPv6 | approximately 50% (June 2026); over 41% of Google's traffic (January 2023) percent |
| significant ossification set in | by 2005 date |
| IANA registries and subregistries | over 2,800 (2015) registries |
| first port-number registry (Postel, RFC 433) | December 1972 date |
| NomCom size | ten randomly chosen volunteers, a non-voting chair and 4 or 5 liaisons people |
| RFC 9293 obsoletes | RFC 793 and RFCs 879, 2873, 6093, 6429, 6528 and 6691 (August 2022) documents |
| transmission speeds the design must allow for | differing by at least 7 orders of magnitude |
| growth over the ARPANET's first 25 years | factors between 1000 (backbone speed) and 1000000 (number of hosts) |
| standards track maturity levels | three in RFC 2026 (Proposed, Draft, Standard); reduced to two by RFC 6410 (2011) levels |
| characteristic clock: minimum time at a standards-track level | at least six months at Proposed Standard; at least four months, or one IETF meeting, at Draft Standard (RFC 2026) |
| characteristic clock: Internet-Draft lifetime | removed after more than six months unchanged without IESG recommendation |
| characteristic clock: TCP initial sequence number generator cycle | approximately every 4.55 hours (clock ticking about every 4 microseconds) |
| minimum IPv4 header | 5 x 32-bit words (20 octets) |
| default send MSS (IPv4) | 536 (576 - 40) octets |
| payload share at the default MSS (per-hand-off efficiency, IP + TCP headers) | 536/576 = 0.93 ratio (usable out / sent in) |
| 1986 congestion collapse throughput (LBL to UC Berkeley) | 32 Kbps to 40 bps (a factor of about 1000) bit/s |
| gateway drop rate in 1988 congestion | 10% of incoming packets fraction |
| dynamic range TCP spanned in 1988 | 800 Mbps (Cray channels) to 1200 bps (packet radio) bit/s |
| reassembly timer (initial setting) | 15 s initial; at most the maximum time to live, about 4.25 minutes |
| characteristic clock: TIME-WAIT (2 x MSL) | 2 x MSL; MSL 'arbitrarily defined to be 2 minutes' |
| fast retransmit threshold | 3 duplicate ACKs |
| congestion response: slow start threshold after loss | ssthresh = max(FlightSize / 2, 2*SMSS) bytes |
| TCP initial window (experiment) | 10 segments (from 2-4) |
| TCP options passing, by port (Honda 2011) | 96% (port 34343), 80% (port 80) fraction of paths |
| paths with layer-4 middlebox interference (Honda 2011) | at least 25% fraction of paths |
| implementations needed to advance a standard | at least two independent and interoperable, from different code bases implementations |
| protocols at the waist | one network protocol (IPv4), two major transports (TCP, UDP) protocols |
| characteristic clock: ack clock (one window per round trip) | packet spacing matches 'the packet time on the slowest link in the path' |
| RIP periodic routing timer (characteristic clock of the routing channel) | 30 s |
| router processing time for one routing message (Xerox PARC measurement) | about 300 (1 ms per route x 300 routes) |
| randomness needed to keep those routers out of step | at least 1 |
| loss rate during synchronized routing-update events (1992 audiocast) | 50 to 85 % |
| TCP throughput under loss (Mathis et al. model) | BW = (MSS/RTT) x C/sqrt(p), C = sqrt(3/2) = 1.22 for periodic loss with every packet acknowledged (1.31 random loss; 0.87 and 0.93 with delayed ACKs) bytes/s |
| QUIC share of Internet traffic (2017) | 7 % |
| QUIC 0-RTT handshake share (desktop) | about 88 % |
| clients unable to use QUIC (2016) | 4.4 (95.3 used it; 0.3 rate-limited) % |
| QUIC default payload size (set by the 1500-byte Ethernet MTU) | 1350 bytes |
| Internet hosts, Jan 1997 to Dec 2000 | 16 million to 100 million (about 60%/year) computers |
| USENET traffic growth since 1984 | about 80 %/year |
| CoDel target sojourn time and interval | TARGET 5 ms; INTERVAL 100 ms |
| TCP handshake share of HTTP transaction latency | up to 25 (3.3 transactions per connection on average) % |
| TCP Fast Open page-load improvement (selected popular sites) | 10 to 40 % |
| IETF meeting frequency | 3 per year |
| IPv6 share of global Internet traffic (2013) | approximately 1 % |
Open contentions (5) open contention
Where sources or readings disagree. Both stay on the map.
- C-277 Which layer is the internet's 'narrow waist' that everything passes through: IP or the web's HTTP?
booked: The map follows the common view that IP is the waist, and keeps the claim that HTTP has become the de facto waist alongside.
the other reading: HTTP (often with TLS over TCP) 'has become a de facto waist for much of today's traffic'; 'This claim is debated' - C-278 Should network software be lenient about what it accepts?
booked: The map follows the classic principle that lenient receiving helps systems work together, and keeps the critique that it hides defects alongside.
the other reading: tolerance hides defects until a strict receiver rejects them, years later (Rose 2001), and leaves room for ossifying deviations - C-413 Where do thoughts come from?
booked: No theory is proven, so the map lists the main ones side by side and doesn't pick one. It shows where thinking is handled in the brain, not where thoughts start.
the other reading: - C-736 When a system first throws away its excess energy and later learns to store it for reuse, is that one process that grew or two separate ones?
booked: The map keeps both readings side by side and rules neither. A few examples fit the 'one process that grew' reading, but it hasn't been tested.
the other reading: - C-1542 Why did TCP/IP win over OSI?
booked: The map lists the sourced reasons (OSI's committee process, TCP/IP being free, running code first) and rules none.
the other reading: (a) OSI's own openness and committee process: 'openness and modularity ... ended up killing OSI' (Russell, a historian); (b) price and availability: TCP/IP 'could be implemented for free' while OSI standards were sold as paper copies (Russell, from a 2012 IBM France interview); (c) running code first: TCP/IP was deployed (flag day 1983, BSD code) while OSI was still being specified (Wikipedia, Protocol Wars); (d) technical: Internet engineers called OSI 'ugly' (Rose 1990, quoted by Russell), a view Russell calls a misreading
Partners and parts published science
Built from / builds (16)
- Internet
- Internet Protocol (role: quanta, the common datagram format)
- Transmission Control Protocol (role: quanta, end-to-end reliability at the hosts)
- End-to-end principle (rule: where functions go)
- Internet standards process (rule: the open rule for adding more)
- The RFC series (shell: the closed-to-edit record)
- Internet Assigned Numbers Authority (shell: the registries)
- Internet Engineering Task Force (shell keeper: the codifier)
- User Datagram Protocol
- Robustness principle (rule: conservative sending, liberal receiving)
- TCP congestion control (the regulation floor)
- The Protocol Wars: TCP/IP against OSI, X.25 and proprietary suites
- Datagrams against virtual circuits ('the battle for access standards')
- Operating system
- The US government's purchases: OSI mandate against TCP/IP (1985-1995)
- Companies' networks: free TCP/IP code against paid, fuller OSI (1980s-mid 1990s)
Sits inside / holds (5)
- Internet Engineering Task Force (shell keeper: the codifier)
- ARPANET (the first carrier network)
- Internet
- Stored-program principle (instructions held in the same memory as data)
- Computer network
Trades with (valence) (21)
- Internet via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Electromagnetic field via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Human (Homo sapiens) via sys:mental-representation · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Cumulative culture (cumulative cultural evolution) via sys:written-record · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Writing (the practice of marking language on a surface, and the script plus rules it works with) via sys:written-record · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Software via sys:computer · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- The RFC series (shell: the closed-to-edit record) via sys:written-record · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Internet Assigned Numbers Authority (shell: the registries) via sys:written-record · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Internet Engineering Task Force (shell keeper: the codifier) via sys:mental-representation · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Application protocols (HTTP, SMTP, FTP, DNS and the rest: what it unpacks into) via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Middleboxes (firewalls, NATs, caches on the path) via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them loss
- The OSI protocol suite (the rival) via sys:mental-representation · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Stored-program principle (instructions held in the same memory as data) via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Packet switching (the older carrier the suite rides on) via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Computer via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Operating system via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Computer security via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them mixed
- Firewall (computing) via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them mixed
- Wireless network via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them mixed
- Computer network via sys:electromagnetic-field · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them gain
- Denial-of-service attack via seed:tcp-ip · Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them mixed
expressed by (29)
- Generation/Synthesis
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Quality Improvement/Refinement
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Amplification/Scale-Up (Manufacture & Distribution)
- Evolvability/Plasticity Engineering (Design for Future Variation)
- Distributed Autonomy/Decentralized Execution (Subsidiarity)
- Internal Coordination/Regulation
- Sensing/Scanning
- Mapping/Modeling
- Navigation/Pathfinding
- Uncertainty Reduction/Learning
- Risk-managed Exploration
- Trail-Marking / Externalized Memory (Stigmergy)
- Social Learning / Public Information Use
- Quick Harm Avoidance
- Reactive Response
- Proactive Defense
- Physical/Virtual Barrier
- Self-Monitoring
- Validation of Effectiveness
- Resilience & Repair
- Redundancy & Diversity
- Quality Control & Error Correction
- Bridging Supply Gaps (Store & Dormancy)
- Scheduled Build-and-Dismantle (On-Demand Structure)
floor filled by (37)
- Internet
- Electromagnetic field
- Human (Homo sapiens)
- Cumulative culture (cumulative cultural evolution)
- Writing (the practice of marking language on a surface, and the script plus rules it works with)
- Software
- Internet Protocol (role: quanta, the common datagram format)
- Transmission Control Protocol (role: quanta, end-to-end reliability at the hosts)
- End-to-end principle (rule: where functions go)
- Internet standards process (rule: the open rule for adding more)
- The RFC series (shell: the closed-to-edit record)
- Internet Assigned Numbers Authority (shell: the registries)
- Internet Engineering Task Force (shell keeper: the codifier)
- Application protocols (HTTP, SMTP, FTP, DNS and the rest: what it unpacks into)
- Stored-program principle (instructions held in the same memory as data)
- nomcom
- rough consensus
- User Datagram Protocol
- Robustness principle (rule: conservative sending, liberal receiving)
- TCP congestion control (the regulation floor)
- QUIC
- Packet switching (the older carrier the suite rides on)
- link layer protocols
- internet draft
- humming
- rfc streams
- rfc editor
- iesg
- router
- ietf working group
- regional internet registry
- Operating system
- Wireless network
- Computer network
- active queue management
- Computer
- Denial-of-service attack
represents (1)
seed within (1)
Kinds (1)
Notes published science
- Routers fall into step like Huygens' pendulum clocks on one wall. Each sends its routing table every 30 seconds, and nothing ties them together, yet past a threshold 'the addition of a single router will convert a completely unsynchronized traffic stream into a completely synchronized one'. The fix is to add noise: at least a second of randomness on each timer. (src:floyd-jacobson-1994)
- In October 2016 Google changed one bit in QUIC's header and broke the Internet for people behind one brand of firewall, which had been blocking QUIC by that bit and now let the first packets through and dropped the rest. QUIC encrypts nearly everything precisely so boxes on the path can't freeze it the way they froze TCP. (src:langley-2017-quic)
- TCP/IP partly won the 'standards wars' on price: its code was free, while companies that wanted OSI's standards 'had to purchase paper copies from the standards group ISO, one copy at a time'. In 1992, when leaders suggested borrowing OSI's protocol to replace IPv4, the engineers in the room 'howled in protest and then sacked their leaders for their heresy'. (src:russell-2013-spectrum)
- In October 1986 a link between two labs 400 yards apart, Lawrence Berkeley Lab and UC Berkeley, slowed from 32 kilobits a second to 40 bits a second, a thousandfold drop. The fix was seven algorithms in the computers at the ends, not in the network, and a version of them still runs in almost every machine online. (src:jacobson-1988)
- TCP keeps time by its own acknowledgments. A sender only puts a new packet in when an old one is acknowledged, so its rhythm locks to the slowest link on the path: 'the sender's packet spacing will exactly match the packet time on the slowest link'. The trouble is starting it, because 'to get data flowing there must be acks ... but to get acks there must be data flowing'. (src:jacobson-1988)
- TCP is still being hemmed in by the boxes on the path. In 2011, at least a quarter of Internet paths had a device that interfered with TCP beyond plain firewalling. Unknown TCP options got through on 96% of paths on an unused port but only 80% on the web's port 80. (src:honda-2011-extend-tcp)
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
mental representation: rough consensus and running code held by the IETF community
- L1: Volunteer engineers: 'There is no membership in the IETF. Anyone can participate by signing up for a working group mailing list or registering for an IETF meeting'; 21 at the first meeting (16 January 1986).
- L2: Sensing the room: humming rather than hand-raising 'allows a group to quickly discern the prevalence of dissent'.
- L3: The shared principles held, not written: 'no architecture, but only a tradition, which was not written down for the first 25 years'; the end-to-end principle 'continuously reinterpreted'; 'The principle of constant change is perhaps the only principle of the Internet that should survive indefinitely.'
- L4: Working groups: decisions 'taken later on the working group mailing list'; the community belief that 'the goal is connectivity, the tool is the Internet Protocol, and the intelligence is end to end'.
- L5: 'Rough consensus is the primary basis for decision making'; support as 'the lack of disagreement ... rather than affirmative agreement'; consensus 'when all issues are addressed, but not necessarily accommodated' (RFC 7282).
- L6: The IESG (area directors and the IETF Chair) 'responsible for the overall operation of the IETF'; a NomCom of 'ten randomly chosen volunteers' appoints and removes the leadership.
- L7: Clark: 'We reject: kings, presidents, and voting. We believe in: rough consensus and running code'; purpose 'Creating voluntary standards to maintain and improve the usability and interoperability of the Internet'.
packet internetwork: the four TCP/IP layers over link signals (parked on EM; see newMediums sys:packet-network)
- L1: Transmission media: the networks are 'linked by electronic, wireless, and optical networking technologies'; the suite 'may be implemented on top of virtually any link-layer technology' (VPNs and tunnels included). Below the link layer, 'All other aspects ... are implicitly assumed to exist and are not explicitly defined in the TCP/IP model'.
- L2: Link layer: device driver, firmware or chipset 'functions, such as framing, to prepare the internet layer packets for transmission'; IP addresses translated to link-layer (MAC) addresses.
- L3: Internet layer, the waist: the IP datagram ('a header and a payload'), source and destination addresses (32-bit IPv4, 128-bit IPv6), a protocol number naming the upper protocol, best-effort delivery; 'a uniform networking interface that hides the actual topology'; ideally 'one, and only one, protocol at the Internet level'.
- L4: Transport layer, at the hosts: TCP's 'reliable, in-order, byte-stream service' (sequence numbers, checksums, retransmission, three-way handshake, ports, passive open) and UDP's connectionless datagrams; state kept only in the endpoints (fate-sharing).
- L5: Flow and congestion control: the receive window; slow start, congestion avoidance, fast retransmit and fast recovery (AIMD, 'a closed-loop control algorithm'); a retransmission timeout set from the smoothed round-trip time; RED and ECN signals from routers; 'an approximately max-min fair allocation between flows'.
- L6: Routing among independent networks: routers forward datagrams hop by hop and do not read what they carry; they 'communicate with one another via specially designed routing protocols'; routing state must be 'self-healing'; IANA delegates address blocks to five regional registries.
- L7: Application layer: 'process-to-process data exchange for applications' (SMTP, FTP, SSH, HTTP); services at well-known ports; the stated goal, RFC 1958: 'the goal is connectivity, the tool is the Internet Protocol, and the intelligence is end to end rather than hidden in the network'.
the boardroom (shared floors)
- L3: IP in every host and router, the narrow waist: header checks, the destination address, time to live, fragmentation; forwarding each datagram on its own
- L4: Transport in the hosts: each TCP connection's state (sequence numbers, windows, timers, the retransmission queue) and congestion control; UDP; ports
- L5: The application layer: the programs' protocols and the support protocols (naming, routing, management) that run over transport
- L6: The RFC series and the standards track: the numbered text every implementer reads; drafts, running code and attack reports land here
- L7: The IETF community: rough consensus and running code; humming instead of voting; the IESG approves; decides what the suite becomes
the protocol suite as network engineers draw it: link signals up to the community that keeps it (reader's view)
- L1: Transmission media: the copper, fibre and radio that link the packet switches; signals carrying frames
- L2: Link layer: each directly connected network's own protocol (Ethernet, Wi-Fi, PPP and the rest) moves a frame to the next hop
- L3: Internet layer (IP, with ICMP): one connectionless datagram format and address space; gateways (routers) forward each datagram independently, keeping no connection state; fragmentation, time to live
- L4: Transport layer, in the hosts: TCP's reliable, ordered byte stream (sequence numbers, acknowledgments, retransmission, flow and congestion control); UDP's bare datagrams; ports name the processes
- L5: Application layer: the protocols people's programs speak (web, mail, file transfer, remote login) and the support protocols (DNS, routing and management)
- L6: The specifications: the numbered RFC series and its standards track, the shared text that lets independent code interoperate
- L7: The community that keeps it: the IETF's working groups, rough consensus (humming, not voting) and running code; the IESG approves; the purpose is a network anyone can join
way in: Arriving datagrams (traffic at a host's or router's interface)
- L1: Signals on the attached link (copper, fibre, radio)
- L2: The interface's link-layer driver takes the frame off the network
way in: Attacks and the reports of them
- L1: An attacker controls some machine connected to the Internet
- L3: Source addresses spoofed; hosts that trust the IP source address are fooled
- L4: TCP sequence numbers predicted; SYN floods fill half-open connection state
- L5: The flaws written up for the community
way in: Congestion (the path's own load)
- L1: Offered traffic exceeds a link; the gateway's buffer overflows
- L3: The datagram is dropped, or (ECN) marked Congestion Experienced in the IP header
way in: Data handed in by local programs
- L1: A process in the host holds the data it wants to send
- L2: The SEND call hands the user's buffer to the connection
way in: Proposals from engineers (the inner channel)
- L1: An engineer's idea, from anyone: 'There is no membership in the IETF. Anyone can participate'
- L2: Written up as an Internet-Draft, with no institution behind it needed
- L3: Posted in the Internet-Drafts directory, which removes it after six months unless it moves on
- L4: Discussed on the working group's list
- L5: Working-group consensus lets it go forward as an RFC
way in: Reports from the path (ICMP errors, Datagram Too Big, redirects)
- L1: A router or host on the path sends a report about a datagram it could not deliver
- L2: Link frame on the directly connected network
- L3: ICMP, carried in IP and read by the IP module
way in: Routing information from neighbouring routers
- L1: A link or neighbouring router changes; signals on the links between routers
- L2: Link frames between neighbouring routers
- L3: Routing messages carried in IP datagrams; routing is the gateways' job, not the hosts'
- L4: Between networks, BGP sessions run over TCP
way in: Running code and operational experience
- L1: Code running in hosts and routers, built and tested before standards are set
- L2: Independent implementations tested against each other
- L4: Problems and fixes found in use, documented piecemeal
- L5: Discussed on a working group's mailing list
way in: Time (timers in the hosts, time to live on every datagram)
- L1: The host's clock ticks
- L3: Every datagram carries a time to live, set by the sender and reduced along the route
way out: Acknowledgments and the advertised window
- L1: Signals on the return path, where they arrive on the sender's datagrams channel
- L3: Carried back in IP datagrams
- L4: The receiver acknowledges the next byte it expects and advertises its window, even when the window is zero
way out: Forwarding (a router passes each datagram on)
- L1: Out on the next link
- L2: Framed for the next network
- L3: Each datagram forwarded on its own, by its destination address
way out: Reporting back (ICMP from routers and hosts)
- L1: Back along the path to the source's icmp channel
- L3: A router that cannot forward a datagram (too big with Don't Fragment set, no route, TTL expired) reports it to the source
way out: Sending (data down the stack onto the link)
- L1: Signals on the link
- L2: Framed for the attached network
- L3: IP addresses each datagram toward its destination
- L4: TCP cuts the stream into segments, numbers them and keeps a copy until acknowledged
- L5: A program hands its data to transport
way out: Standards and running code (the suite changes itself)
- L3: New fields in the IP header (ECN, 2001)
- L4: New algorithms go into the hosts' TCP (4BSD, 1988); defences into ISN generation (RFC 6528)
- L6: An RFC published; later RFCs obsolete earlier ones (RFC 9293 obsoleted RFC 793 and six updates)
- L7: Rough consensus; the IESG approves
way out: Throttling (the sender backs off)
- L1: Less traffic reaches the bottleneck; the queue drains
- L4: The sender cuts its congestion window (ssthresh to half the data in flight)
written record: the RFC series (closed-to-edit specifications plus the rule for adding more)
- L1: RFCs as plain text: typewritten hard copies among ARPA researchers from 1969 (RFC 1, 'Host Software', 7 April 1969); over the ARPANET from December 1969; 'Every RFC is submitted as plain ASCII text'.
- L2: Internet Draft: submitted by experts 'without support from an external institution'; written with a shared requirement vocabulary ('MUST', 'NOT RECOMMENDED'); removed after six months unchanged unless recommended.
- L3: Number bound once: 'The RFC Editor assigns each RFC a serial number. Once assigned a number and published, an RFC is never rescinded or modified'; IANA binds globally unique names and numbers (ports, protocol numbers) once to one meaning.
- L4: The series as a whole: 'a continuous historical record'; later RFCs obsolete earlier ones; STD numbers that keep pointing while the RFCs behind them change; over 2,800 IANA registries (2015); the four-layer structure 'never modified'.
- L5: Status and selection: Informational, Experimental, Best Current Practice, Standards Track, Historic; only the IESG approves standards-track RFCs; Draft Standard needed 'at least two independent and interoperable implementations from different code bases'; cut to two maturity levels (RFC 6410); 'Nothing gets standardised until there are multiple instances of running code.'
- L6: Streams and editing: 'five streams of RFCs: IETF, IRTF, IAB, independent submission, and Editorial'; the RFC Editor (Jon Postel 1969-1998).
- L7: Stated role: the RFCs 'shape the Internet's inner workings and have played a significant role in its success'.