# OSI Layer 3 vs Layer 4: Packet Handling and Routing Responsibilities

> Understand OSI Layer 3 vs Layer 4 packet handling. Layer 3 routes across networks via IP, while Layer 4 ensures reliable app delivery using ports. Learn the core differences.

- Repository: [Arie Bregman/devops-exercises](https://github.com/bregman-arie/devops-exercises)
- Tags: deep-dive
- Published: 2026-02-28

---

**The Network layer (Layer 3) determines *where* packets travel across distinct networks using IP addresses and routing protocols, while the Transport layer (Layer 4) manages *how* data delivers reliably to specific applications using port numbers and connection state.**

The distinction between OSI Layer 3 (Network) and Layer 4 (Transport) defines how data moves across the internet versus how it reaches individual applications. According to the bregman-arie/devops-exercises repository, these layers handle fundamentally different **packet handling and routing responsibilities between OSI layers 3 and 4**. While Layer 3 focuses on inter-network navigation and logical addressing, Layer 4 ensures end-to-end process communication and data integrity.

## Layer 3 Network Layer: Inter-Network Routing

The Network layer operates at the packet level to move data across distinct networks. In [`README.md`](https://github.com/bregman-arie/devops-exercises/blob/main/README.md) lines 185-192, the devops-exercises repository defines this layer as responsible for *moving packets across distinct networks* by using logical addresses (IP). It encapsulates payloads in IP datagrams and interacts with routing protocols to forward packets toward their destination networks.

### Core Routing Functions

Layer 3 performs the classic "routing" function by examining **IP headers** to make forwarding decisions. Key responsibilities include:

- **Logical Addressing**: Uses IP addresses to identify hosts across network boundaries
- **Path Determination**: Implements routing protocols such as OSPF and BGP to calculate optimal paths
- **Packet Lifecycle Management**: Handles Time-To-Live (TTL) to prevent infinite loops and performs fragmentation/reassembly when packets exceed Maximum Transmission Unit (MTU) limits
- **Datagram Encapsulation**: Wraps transport-layer segments in IP headers containing source and destination addresses

### Raw IP Implementation (Layer 3)

The following Python code demonstrates direct Layer 3 packet handling by manually constructing an IP header. This bypasses the operating system's transport layer stack, requiring root privileges to send raw packets:

```python
import socket
import struct

# Create a raw socket (requires root privileges)

sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)

# Build a simple IP header (no options)

src_ip = '192.168.1.100'
dst_ip = '192.168.1.1'
ip_header = struct.pack('!BBHHHBBH4s4s',
    0x45,        # Version & IHL

    0,           # Type of Service

    20,          # Total Length

    0,           # Identification

    0,           # Flags/Fragment Offset

    64,          # TTL

    socket.IPPROTO_TCP,  # Protocol (TCP payload)

    0,           # Header checksum (kernel will fill)

    socket.inet_aton(src_ip),
    socket.inet_aton(dst_ip)
)

payload = b''  # No TCP payload for demo

packet = ip_header + payload

# Send the raw IP packet

sock.sendto(packet, (dst_ip, 0))

```

This implementation operates strictly at Layer 3, handling only the IP address and leaving transport-layer details (ports, sequencing, reliability) to be added later if required.

## Layer 4 Transport Layer: End-to-End Delivery

The Transport layer provides services **end-to-end** between source and destination hosts. As documented in [`README.md`](https://github.com/bregman-arie/devops-exercises/blob/main/README.md) lines 190-191, this layer handles segmentation, reliability, flow control, and multiplexing via ports. TCP and UDP take data from applications, split it into segments, and ensure the correct **application process** receives the data—without choosing the network path.

### Port-Based Multiplexing and Reliability

Layer 4 abstracts network complexity into reliable byte streams or connectionless datagrams:

- **Process Addressing**: Uses **port numbers** to identify specific applications (e.g., HTTP on port 80, HTTPS on port 443)
- **Connection Management**: TCP implements the three-way handshake (SYN, SYN-ACK, ACK) to establish stateful connections
- **Flow Control**: Manages data transmission rates to prevent overwhelming receivers using windowing mechanisms
- **Error Recovery**: Handles retransmissions, acknowledgments, and sequencing to ensure complete, ordered delivery

### TCP Socket Implementation (Layer 4)

This example demonstrates how the operating system's TCP stack provides a reliable, ordered byte stream. The programmer works with sockets defined by host address (Layer 3) and **port number** (Layer 4), while the stack automatically handles the three-way handshake, retransmissions, and flow control:

```python
import socket

HOST = 'example.com'      # Destination hostname (will be resolved to an IP)

PORT = 80                 # HTTP service (TCP port)

with socket.create_connection((HOST, PORT)) as s:
    request = b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'
    s.sendall(request)           # Layer 4 (TCP) handles segmentation & reliability

    response = s.recv(4096)
    print(response.decode())

```

The `socket.create_connection` function encapsulates both Layer 3 (DNS resolution to IP) and Layer 4 (TCP connection establishment), but the critical handling of **routing responsibilities** remains separate from the transport-level reliability mechanisms.

## Fundamental Differences in Packet Handling

Understanding the separation of concerns between these layers is critical for network troubleshooting and application design.

**Primary Concern**
- **Layer 3 Network**: Determines *where* to send the packet (routing across networks)
- **Layer 4 Transport**: Determines *how* to deliver data reliably to the right application

**Key Identifiers**
- **Layer 3**: Uses **IP addresses** (logical host addresses) to locate machines across the internet
- **Layer 4**: Uses **port numbers** (application endpoints) to locate specific processes within a host

**Typical Protocols**
- **Layer 3**: IP, ICMP, IGMP, and routing protocols (OSPF, BGP, EIGRP)
- **Layer 4**: TCP, UDP, and SCTP

**Operational Scope**
- **Layer 3**: Routers operate at this layer, examining IP headers to forward packets between autonomous systems
- **Layer 4**: End hosts operate at this layer, with the TCP stack managing connections, retransmissions, and delivering data to the correct process

## Summary

- **Layer 3 (Network)** handles **packet routing responsibilities** across distinct networks using IP addresses, TTL, and routing protocols like OSPF and BGP, as defined in [`README.md`](https://github.com/bregman-arie/devops-exercises/blob/main/README.md) lines 185-192 of the bregman-arie/devops-exercises repository.
- **Layer 4 (Transport)** manages **end-to-end packet handling** between processes using port numbers, providing reliability, flow control, and segmentation via TCP or UDP, documented in lines 190-191.
- **Routers** primarily function at Layer 3, forwarding packets based on destination IP addresses without examining port numbers.
- **Host operating systems** implement Layer 4 to ensure complete data delivery to specific applications, independent of the network path chosen at Layer 3.

## Frequently Asked Questions

### Does the Transport layer ever handle IP addresses?

No. According to the strict OSI model implementation in bregman-arie/devops-exercises, Layer 4 relies on Layer 3 to resolve and handle IP addressing. The Transport layer receives segments from the Application layer and passes them to the Network layer, which encapsulates them with source and destination IP addresses. Layer 4 identifiers are strictly **port numbers**.

### Can Layer 3 guarantee reliable delivery of packets?

No. Layer 3 provides **best-effort delivery** with no guarantee of packet arrival, ordering, or integrity. The IP protocol includes no mechanism for retransmission or acknowledgments. **Reliability** is exclusively a Layer 4 responsibility, implemented by TCP through sequence numbers, acknowledgments, and retransmission timers.

### How do routers use Layer 3 information without examining Layer 4 data?

Routers inspect the **IP header** in each packet to make forwarding decisions based on destination IP addresses and routing table entries. They typically do not examine TCP or UDP headers (Layer 4) unless configured for Network Address Translation (NAT) or quality of service (QoS) filtering. This separation allows routers to forward packets efficiently without maintaining connection state for every flow.

### What happens when a Layer 3 packet exceeds the MTU?

The Network layer handles **fragmentation**, breaking the packet into smaller pieces that fit the MTU of the outgoing interface. Each fragment receives its own IP header with fragment offset values to enable reassembly at the destination. This process occurs entirely at Layer 3 without involving the Transport layer, though Layer 4 may implement Path MTU Discovery to avoid fragmentation overhead.