Protocols and Layered Network Architecture

Why Networks Use Layers

Network communication depends on agreed rules rather than on any one manufacturer or implementation. A network protocol specifies how systems exchange data, including message formats, field meanings, addressing, error handling, timing, and required responses.

Layering divides these responsibilities into manageable groups. Each layer solves a limited class of problems, offers a service to the layer above, and uses the service below. This separation lets higher-level software remain independent of details such as cable type, radio technology, or optical transmission.

A layer boundary is an interface. The interface describes how an upper layer requests a lower-layer service locally, while a protocol describes communication between peer entities at the same layer on different devices.

Takeaway: Protocols define communication rules; services define what a layer offers; interfaces define how neighboring layers interact.

The Five-Layer Internet Model

The commonly taught five-layer Internet model organizes network functions from user-oriented operations down to signal transmission:

1. The application layer provides network functions directly to applications and system services. HTTP, DNS, SMTP, and SSH are examples.

2. The transport layer provides communication between processes running on end hosts.

3. The network layer moves packets between hosts across interconnected networks.

4. The link layer transfers frames across one local or directly connected link.

5. The physical layer transmits encoded bits as electrical, optical, or radio signals.

This five-layer arrangement is a useful teaching model, not a single mandatory standard. The Internet architecture does not exactly match the seven-layer OSI reference model. For example, Internet application functions cover areas that OSI separates into application, presentation, and session layers. The IETF may describe the Internet suite using application, transport, IP or internet, and link layers, with physical behavior often treated as part of the link technology.

Takeaway: The layers provide a conceptual map of responsibilities, while particular standards and implementations may group those responsibilities differently.

Application and Transport Functions

The application layer gives software a way to request network functions. HTTP defines web request and response meaning, DNS queries information about domain names, SMTP transfers email, and SSH supports secure remote administration. These protocols can also support system services that are not directly visible as a user-facing application.

The transport layer connects application processes rather than merely connecting machines. TCP provides a connection-oriented byte stream with reliable, ordered delivery. It uses mechanisms such as sequence numbers, acknowledgments, retransmission, flow control, and congestion control. TCP data is commonly called a segment.

UDP provides a lightweight datagram service and preserves message boundaries. It does not itself guarantee delivery, ordering, or retransmission. UDP data is commonly called a datagram. An application may choose UDP when low protocol overhead or timely delivery matters more than built-in reliability, or it may implement suitable reliability itself.

Port numbers allow the transport layer to deliver received data to the correct application or service. Thus, an application protocol defines the meaning of messages, while the transport protocol provides process-to-process delivery characteristics.

Takeaway: Applications express what data means; transport protocols determine how application processes exchange that data.

Network and Link Delivery

The network layer is responsible for moving packets from one host to another, potentially across many separate networks. IP supplies logical addressing and packet forwarding. A router examines a packet's destination IP address and uses forwarding information to choose a next hop.

IP provides connectionless, best-effort delivery. It does not by itself promise that packets will arrive, arrive only once, arrive in order, or remain undamaged. When an application needs reliability, that function can be supplied by TCP or by the application itself. Different packets belonging to one application flow may follow different paths.

The link layer handles one local link at a time. It creates frames, uses local addresses such as Ethernet MAC addresses, detects transmission errors, and may control access to a shared medium. A frame normally carries an IP packet as its payload.

End-to-end IP addresses generally remain associated with the original source and destination, while link-layer addresses are local to each link and generally change at each router hop. This distinction explains how a packet can cross many different link technologies without changing its overall network-layer destination.

Takeaway: IP provides host-to-host forwarding across networks; link protocols provide neighboring-device delivery on each individual hop.

Signals, Media, and Local Transmission

The physical layer turns link-layer data into signals and reconstructs bits at the receiving end. Its concerns include electrical, optical, or radio signaling; timing and encoding; connectors and pin arrangements; frequencies, wavelengths, and modulation; media requirements; and supported transmission rates and distances.

The physical layer does not interpret application messages or IP addresses. It transmits encoded symbols through media such as copper, fiber, or radio. The receiving link-layer equipment reconstructs those symbols as bits and processes them as a frame.

A single end-to-end exchange can therefore use different physical and link technologies on different hops. Higher layers continue to operate through the common interfaces even when the underlying medium changes.

Takeaway: The physical layer carries signals, while the link layer organizes those signals into local frames.

Encapsulation, Decapsulation, and PDUs

As data moves down the stack, each layer treats the data from the layer above as its payload. Encapsulation adds control information, usually in the form of headers and sometimes trailers. At the destination, Decapsulation removes that information in reverse order.

For a web request sent using TCP over IPv6 and Ethernet, the sequence is:

1. The application creates an HTTP message.

2. TCP adds transport information, producing a TCP segment containing the application data.

3. IPv6 adds a network header, producing an IP packet containing the TCP segment.

4. Ethernet adds a link-layer header and trailer, producing a frame containing the IP packet.

5. The physical layer encodes the frame as bits and signals.

At the destination, the physical layer recovers bits, the link layer checks and removes its frame information, the network layer processes and removes the IP header, and the transport layer uses its header and port information to deliver the data to the correct process.

A protocol data unit (PDU) is the data unit defined at a particular layer. Common PDU names are message or data at the application layer, segment or datagram at the transport layer, packet at the network layer, frame at the link layer, and bits or symbols at the physical layer.

Headers can contain addresses, identifiers, lengths, flags, sequence numbers, checksums, or protocol identifiers. For example, an IPv6 Next Header field identifies what follows the IPv6 header, while an Ethernet type field identifies the protocol carried in a frame.

Takeaway: Encapsulation adds layer-specific information on the way down; decapsulation uses that information and removes it on the way up.

Worked Example: Loading a Web Page

Consider a browser requesting a web resource from a server. The browser creates an HTTP request and passes it to TCP. TCP associates the communicating processes with port numbers and may divide the byte stream into segments. IP places each segment inside a packet containing source and destination addresses.

The sender chooses a first-hop router. On every hop, the incoming link-layer frame is removed, the router examines the IP packet, and the packet is placed into a new outgoing frame addressed to the next local device. The link technology may change from hop to hop, but the transport conversation remains end-to-end between the client and server.

The server reverses the process: it receives signals, reconstructs the frame, extracts the IP packet, processes the transport information, and delivers the HTTP request to the web-server process. The response follows the same layered pattern in the opposite direction.

This example shows why layering is useful. The browser does not need to control Ethernet signals, and a router does not need to interpret the meaning of the HTTP request in order to forward its packet.

Takeaway: Each layer performs its own task while relying on neighboring layers to carry the result onward.

Standards, Benefits, and Limits

Interoperability requires independently produced systems to agree on standards. A standard may specify wire formats, state machines, algorithms, field meanings, timing rules, and required responses to errors.

The IETF develops many Internet standards through specifications published as RFCs, including specifications for IP, TCP, UDP, DNS, and numerous application protocols. The IEEE defines many local-network and physical technologies, including Ethernet through the IEEE 802.3 family. ISO/IEC publishes international standards, including the OSI reference model and other information-technology standards.

Conformance means that an implementation's externally observable behavior is compatible with the protocol requirements. Implementations may still use different internal code, hardware, buffering, or optimizations. Because standards evolve, engineers must consult the applicable current specification and its updates rather than relying only on a protocol name.

Layering provides abstraction, interoperability, replaceability, reuse, and a useful framework for troubleshooting. It also has limits: practical systems may cross layer boundaries for performance, security, quality of service, or hardware acceleration. Such optimizations do not remove the conceptual interfaces or the externally required behavior.

Takeaway: Standards make layered designs interoperable, while implementation techniques may optimize or combine functions without eliminating the architecture's conceptual responsibilities.