Layered Architecture in Computer Networks

We've explored why networks are layered, how layers are designed as modules, what interfaces exist between them, and how peer communication works. Now it's time to answer the fundamental question: What does each layer actually do?

Each layer in the network stack has specific responsibilities—functions it performs that no other layer handles. Understanding these functions is essential for network design, troubleshooting, and knowing which protocols operate where. This page provides a comprehensive overview of layer functions, setting the stage for deep dives into each layer in subsequent chapters.

The Physical Layer (Layer 1) is responsible for the actual transmission of raw bits over a physical medium. It deals with the hardware, electrical, optical, and mechanical aspects of network interfaces.

Primary functions:

The Data Link Layer (Layer 2) transforms the raw bit stream into a reliable link between adjacent network nodes. It handles framing, addressing within a network segment, and error detection.

Primary functions:

The two sublayers:

The Data Link Layer is often divided into two sublayers:

LLC (Logical Link Control):

• Provides uniform interface to network layer
• Handles multiplexing (different network protocols over same link)
• Defined by IEEE 802.2

MAC (Media Access Control):

• Handles access to the shared medium
• Addresses specific to physical network type
• Different for Ethernet, WiFi, Token Ring, etc.

Switching at Layer 2:

Switches operate at Layer 2, learning MAC addresses and forwarding frames only to the relevant port. This creates collision domains per port (improving performance) and enables efficient local network operation.

The Network Layer (Layer 3) enables communication across different networks—the inter-networking that gives us the 'Internet.' It handles logical addressing, routing, and packet forwarding.

Primary functions:

Key insight: Best-effort delivery

IP provides best-effort delivery—packets are forwarded toward their destination with no guarantee of:

• Delivery (packets may be dropped)
• Ordering (packets may arrive out of sequence)
• Timing (packets may be delayed)
• Integrity (packets may be corrupted—though checksums help)

This simplicity is deliberate. By keeping IP simple, routers can be fast. Reliability is pushed to higher layers (TCP) where end hosts can handle it without burdening the network core.

The narrow waist:

IP is the 'narrow waist' of the Internet architecture:

• Everything below speaks IP (Ethernet, WiFi, fiber, satellite)
• Everything above uses IP services (TCP, UDP, their applications)

This universality is why the Internet scales—any device speaking IP can communicate with any other device speaking IP, regardless of physical network technology.

The Transport Layer (Layer 4) provides end-to-end communication services for applications. It transforms the network's best-effort delivery into the reliable (or unreliable, for UDP) byte stream that applications expect.

Primary functions:

The end-to-end principle in action:

Transport layer exemplifies the end-to-end principle:

• Reliability is at the endpoints, not in routers
• Flow control is between sender and receiver hosts
• Congestion control responds to network conditions
• Encryption (TLS over TCP) is at endpoints

This keeps routers simple and fast while enabling sophisticated features where they can be done correctly—at the communicating ends.

Emerging transports:

QUIC (Quick UDP Internet Connections) is a new transport protocol running over UDP that provides:

• Connection establishment in 0-RTT (for repeat connections)
• Integrated TLS encryption
• Multiplexed streams without head-of-line blocking
• Connection migration (survives IP address changes)

QUIC is used by HTTP/3 and represents the evolution of transport layer thinking.

The Session Layer (Layer 5 in OSI model) manages dialog control and synchronization between applications. In the TCP/IP model, these functions are typically absorbed by the application layer, but they remain conceptually important.

Primary functions (conceptual):

Where session functions appear in TCP/IP:

Though TCP/IP doesn't have a distinct session layer, session concepts appear in:

Examples:

• HTTP sessions: Cookies track user sessions across stateless HTTP requests
• RPC frameworks: gRPC manages bidirectional streaming sessions
• SSH: Maintains encrypted session with channel multiplexing
• Database connections: Connection pooling and session management

The Presentation Layer (Layer 6 in OSI model) handles data representation—ensuring that data sent by one application can be understood by another, regardless of internal formats.

Primary functions (conceptual):

Modern manifestations:

TLS (Transport Layer Security): Despite its name suggesting transport layer, TLS provides presentation-layer functions:

• Encryption (data confidentiality)
• Authentication (verify peer identity)
• Integrity (detect tampering)

Content negotiation (HTTP):

• Accept: application/json — Request JSON data format
• Accept-Encoding: gzip, br — Request compressed response
• Accept-Language: en-US — Request English content
• Content-Type: text/html; charset=utf-8 — Indicate encoding and format

Serialization formats: JSON, Protocol Buffers, and other serialization formats handle the 'presentation' of structured data—converting between in-memory objects and byte streams for transmission.

Why presentation matters:

Without proper presentation handling:

• Text appears as gibberish (wrong character encoding)
• Numbers are corrupt (byte order mismatch)
• Data can't be parsed (format mismatch)
• Security is compromised (encryption failures)

The Application Layer (Layer 7) provides network services directly to end-user applications. It's where network capabilities become useful functionality—web browsing, email, file transfer, and countless other services.

Primary functions:

Application layer is where users live:

Every user interaction with a network ultimately manifests at the application layer:

• Typing google.com → DNS query + HTTP request
• Clicking 'Send' on email → SMTP commands to mail server
• Streaming video → HTTP requests for media segments
• Opening remote terminal → SSH authentication and command exchange

The API to applications:

Application protocols define how software communicates over networks. When you use:

• curl https://api.example.com/data — You're using HTTP at application layer
• fetch() in JavaScript — Same HTTP, different interface
• Database client connecting to server — Database-specific application protocol

Modern trends:

• RESTful APIs: HTTP-based services dominate modern application communication
• gRPC: Protocol Buffers + HTTP/2 for efficient service-to-service calls
• GraphQL: Query language layered over HTTP
• WebSocket: Full-duplex application communication over HTTP upgrade

We've completed our exploration of layered architecture by examining what each layer actually does. Let's consolidate the key insights:

Module Complete:

Congratulations! You've completed Module 1: Layered Architecture. You now understand:

• Why networks use layered architecture (complexity management, evolution)
• How layers are designed as modules (encapsulation, interfaces, dependencies)
• What service interfaces connect layers (SAPs, primitives, connection types)
• How peers communicate (virtual communication, headers, state machines)
• What each layer actually does (physical to application functions)

This foundation prepares you for the remaining modules on network models: OSI Model, TCP/IP Model, and their comparison.