IPv4 Addressing: Classful and Classless

At the network layer, logical addressing is the foundation of global routing, ensuring that every connected host or router interface is uniquely identifiable. This guide details the mathematics, architectural transitions, and subnetting operations of the Internet Protocol version 4 (IPv4) addressing system.

1. Structure and Notation of IPv4 Addresses

An IPv4 address is a 32-bit binary identifier that uniquely and universally defines the connection of a host or router interface to the global Internet. The total number of unique addresses possible—known as the address space—is defined by:

$N = 2^{32} = 4,294,967,296 \text{ addresses}$

To make these 32-bit addresses human-readable, three standard notation systems are used:

Binary Notation: The address is displayed as 32 bits, divided into four 8-bit groups (octets) separated by spaces or dots.
Dotted-Decimal Notation: Each octet is converted into its decimal equivalent (ranging from $0$ to $255$ ) and separated by a period.
Hexadecimal Notation: Each octet is represented by its equivalent two-digit hexadecimal value, often prefixed with 0x.

text

Dotted-Decimal:       129.       11.       11.      239
                       │         │         │         │
Binary:             10000001  00001011  00001011  11101111
                       │         │         │         │
Hexadecimal:          0x81  .   0x0B  .   0x0B  .   0xEF

Syntax Validation Rules

A valid dotted-decimal IPv4 address must adhere to the following constraints:

It must consist of exactly four octets separated by three dots.
No octet can contain leading zeros (e.g., 111.56.045.78 is invalid).
The decimal value of any octet must be within the closed interval $[0, 255]$ .
It cannot mix notations within a single expression.

2. Bitwise Mathematical Operations

Network devices extract address boundaries, subnet configurations, and target networks using bitwise calculations. The three fundamental logical operations are NOT, AND, and OR.

Bitwise NOT (Complement)

Inverts every individual bit of an address or mask. $\neg 1 = 0 \quad \text{and} \quad \neg 0 = 1$

Bitwise AND

Outputs a $1$ if and only if both input bits are $1$ . $A \land B = 1 \iff A=1 \text{ and } B=1$

Bitwise OR

Outputs a $1$ if at least one of the input bits is $1$ . $A \lor B = 1 \iff A=1 \text{ or } B=1 \text{ (or both)}$

text

AND Operation (Used to find Network Address):
Address: 11000000 10101000 00001010 01010101  (192.168.10.85)
Mask:    11111111 11111111 11111111 00000000  (255.255.255.0)
────────────────────────────────────────────
Result:  11000000 10101000 00001010 00000000  (192.168.10.0)

3. Classful Addressing Architecture

Introduced during the early development of the Internet, classful addressing divided the entire 32-bit address space into five distinct classes: A, B, C, D, and E.

Class Identification

The class of an address is determined by analyzing the first few bits of the first octet (the most significant bits):

text

Class-checking Tree (Continuous Verification):
[MSB Bit]
  ├── 0 ──────────────────────────────────────────────────────────► Class A (0.0.0.0 to 127.255.255.255)
  └── 1 ── [2nd Bit]
             ├── 0 ───────────────────────────────────────────────► Class B (128.0.0.0 to 191.255.255.255)
             └── 1 ── [3rd Bit]
                        ├── 0 ────────────────────────────────────► Class C (192.0.0.0 to 223.255.255.255)
                        └── 1 ── [4th Bit]
                                   ├── 0 ─────────────────────────► Class D (224.0.0.0 to 239.255.255.255)
                                   └── 1 ─────────────────────────► Class E (240.0.0.0 to 255.255.255.255)

Netid and Hostid Split

In classes A, B, and C, the address is split into two logical parts: the network identifier (netid) and the host identifier (hostid).

Class A: Uses 1 octet for the netid (with the first bit fixed as 0) and 3 octets for the hostid. Designed for massive organizations.
Class B: Uses 2 octets for the netid (first two bits fixed as 10) and 2 octets for the hostid. Designed for mid-sized networks.
Class C: Uses 3 octets for the netid (first three bits fixed as 110) and 1 octet for the hostid. Designed for small organizations.
Class D: Used entirely for multicasting groups. There is no netid/hostid split.
Class E: Reserved for future experimental purposes.

text

Class A:  │0│   netid (7 bits)   │              hostid (24 bits)              │
Class B:  │10│   netid (14 bits)     │          hostid (16 bits)          │
Class C:  │110│     netid (21 bits)       │      hostid (8 bits)      │

Space Allocation and Wastage Metrics

The static splitting of classes led to massive address exhaustion:

| Class | Prefix | Default Mask | Total Blocks | Addresses per Block | Primary Use | | :--- | :--- | :--- | :--- | :--- | :--- | | A | /8 | 255.0.0.0 | $128$ | $16,777,216$ | Large Networks (Huge wastage) | | B | /16 | 255.255.0.0 | $16,384$ | $65,536$ | Mid-sized Entities | | | | | | | Small Networks (Often too small) | | | N/A | N/A | | | Multicast Group Delivery | | | N/A | N/A | | | Experimental Reservation |

4. Subnetting and Supernetting in Classful Networks

Subnetting (Three-Level Addressing)

To split a large allocated classful block into smaller physical networks, organizations introduced subnetting. This adds a intermediate level of hierarchy, dividing the hostid into a subnetid and a local hostid:

text

Standard Two-Level:     │     netid (n bits)     │        hostid (32-n bits)         │
                         ▼                        ▼                                   ▼
Subnetted Three-Level:  │     netid (n bits)     │  subnetid (s bits)  │ hostid (h)  │

To implement subnetting, a custom subnetwork mask (or subnet mask) is used. The subnet mask has $1$ s covering the netid and subnetid, and $0$ s covering the hostid.

Subnet Mask Calculation

If a Class B network with default prefix /16 ( $n = 16$ ) is divided into $K = 4$ subnets, the number of borrowed bits $s$ is:

$s = \log_2(K) = \log_2(4) = 2 \text{ bits}$

The new subnet prefix length ( $n_{\text{subnet}}$ ) is:

$n_{\text{subnet}} = n + s = 16 + 2 = 18 \text{ bits}$

This yields a subnet mask with eighteen $1$ s: 11111111.11111111.11000000.00000000, which translates to 255.255.192.0.

Supernetting

Conversely, supernetting combines several adjacent class C blocks into a single larger block. This shrinks the prefix length to reduce size and overhead in global routing tables.

5. Classless Addressing (CIDR)

With the rapid growth of the Internet in the mid-1990s, classful boundaries were abandoned in favor of Classless Inter-Domain Routing (CIDR).

Variable-Length Blocks

Classless addressing allows arbitrary boundaries instead of fixed 8, 16, or 24-bit blocks. The network is defined by a variable-length prefix and the remaining bits serve as the suffix:

text

Classless Format:       │◄───────── prefix (n bits) ────────►│◄────── suffix (32-n bits) ─────►│

The prefix identifies the organization's unique network.
The suffix identifies the specific node connection.

Slash Notation

CIDR uses slash notation (also known as CIDR notation) to specify the prefix length $n$ :

$\text{IPv4\_Address / } n$

Mathematical Address Extraction Formulas

Given any arbitrary address $A$ and its classless prefix length $n$ , we can calculate the properties of the entire block using three primary equations:

1. Number of Addresses ( $N$ )

$N = 2^{32-n}$

2. First Address in the Block ( $A_{\text{first}}$ )

To find the first address (often called the network address), perform a bitwise AND between the address and the network mask $M$ : $A_{\text{first}} = A \land M$ (Alternatively: Set the rightmost $32-n$ suffix bits of the address to all $0$ s).

3. Last Address in the Block ( $A_{\text{last}}$ )

To find the last address (the directed broadcast address), perform a bitwise OR between the address and the bitwise complement (NOT) of the network mask: $A_{\text{last}} = A \lor (\neg M)$ (Alternatively: Set the rightmost $32-n$ suffix bits of the address to all $1$ s).

Step-by-Step Mathematical Walkthrough

Suppose an interface address is configured as 110.23.120.14/20.

Step 1: Extract the Network Mask ( $M$ )

A prefix of $n = 20$ means the mask has twenty $1$ s followed by twelve $0$ s: $\text{Binary Mask: } \underbrace{11111111.11111111.1111}_{20 \text{ bits of 1s}}0000.00000000$ Converting to dotted-decimal yields .

Step 2: Calculate the Total Number of Addresses ( $N$ )

Using our first formula: $N = 2^{32-20} = 2^{12} = 4,096 \text{ addresses}$

Step 3: Compute the First Address ( $A_{\text{first}}$ )

Convert the third octet of the IP address ( $120$ ) to binary to perform the bitwise operations: $\text{Octet 3 Value: } 120 = 01111000_2$ $\text{Octet 3 Mask: } 240 = 11110000_2$

Perform the bitwise AND: $01111000_2 \land 11110000_2 = 01110000_2 = 112_{10}$

Since the first two octets of the mask are all $1$ s, they remain unchanged. Since the final octet of the mask is all $0$ s, it becomes $0$ . $A_{\text{first}} = \mathbf{110.23.112.0/20}$

Step 4: Compute the Last Address ( $A_{\text{last}}$ )

Invert the mask: $\neg M = 0.0.15.255$

Perform the bitwise OR with $A_{\text{first}}$ (or the original address): $\text{Octet 3 Value: } 112 = 01110000_2$ $\text{Octet 3 Inverted Mask: } 15 = 00001111_2$

Thus, the last address is: $A_{\text{last}} = \mathbf{110.23.127.255/20}$

6. Subnetting in Classless Addressing

When an organization is allocated a block of classless addresses, it can divide those addresses into smaller subnets using Variable Length Subnet Masking (VLSM).

Core Allocation Constraints

To ensure a subnetted block routes correctly, two criteria must be met:

Power of 2: The number of addresses allocated to each subblock must be a power of $2$ ( $2, 4, 8, 16, 32, \dots$ ).
Boundary Alignment: The starting address of any subblock must be evenly divisible by the size of that subblock.

VLSM Subnet Design Walkthrough

An organization is granted the block 14.24.74.0/24 ( $256$ total addresses) and must support three subnets:

Subnet 1: Needs 120 host addresses.
Subnet 2: Needs 60 host addresses.
Subnet 3: Needs 10 host addresses.

text

Visual Layout of Variable-Length Address Blocks:
Address Space [0 to 255]
┌──────────────────────────────────────┬───────────────────┬─────────┬─────────────┐
│       Subnet 1 (128 Addr)            │ Subnet 2 (64 Addr)│Subnet 3 │ Reserved    │
│       14.24.74.0 /25                 │ 14.24.74.128 /26  │(16 Addr)│ (48 Addr)   │
│                                      │                   │/28      │             │
└──────────────────────────────────────┴───────────────────┴─────────┴─────────────┘
0                                     127 128             191 192   207 208       255

Step 1: Allocate Subnet 1

Requested: $120$ hosts.
Power of 2 allocation: We must allocate $128$ addresses (since $2^7 = 128$ ).
New Prefix Length: $32 - \log_2(128) = 25$ .

Step 2: Allocate Subnet 2

Requested: $60$ hosts.
Power of 2 allocation: We allocate $64$ addresses (since $2^6 = 64$ ).
New Prefix Length: $32 - \log_2(64) = 26$ .

Step 3: Allocate Subnet 3

Requested: $10$ hosts.
Power of 2 allocation: We allocate $16$ addresses (since $2^4 = 16$ ).
New Prefix Length: $32 - \log_2(16) = 28$ .

This leaves 48 addresses unused (14.24.74.208 to 14.24.74.255) for future growth.

7. Special-Purpose IPv4 Addresses

Specific blocks in the IPv4 address space are reserved for special system behaviors and cannot be assigned to public internet hosts:

This-Host Address (0.0.0.0/32): Used by a device during its bootstrap process before it has been assigned a valid IP address. It is only valid as a source address.
Loopback Address (127.0.0.0/8): Packets sent to this range never leave the local machine. They are routed directly back up the local protocol stack for testing and local services (e.g., 127.0.0.1).
Limited Broadcast Address (255.255.255.255): Used to send a packet to every active host on the local physical network. Routers block these packets to prevent broadcast storms from spreading across the wider internet.
Directed Broadcast Address: Formed by setting the hostid suffix bits to all $1$ s within a target subnet block. Routers can forward this packet across the internet to reach all hosts in that target destination network.

8. Network Address Translation (NAT)

As the public IPv4 pool depleted, Network Address Translation (NAT) was introduced to slow down address exhaustion. NAT allows an entire private network to share a single public IPv4 address to access the internet.

Private Address Ranges (RFC 1918)

The Internet Assigned Numbers Authority (IANA) reserved three IP address blocks for private internal networks. These addresses are not routed on the public internet:

10.0.0.0 /8 (Single Class A block)
172.16.0.0 /12 (16 contiguous Class B blocks)
192.168.0.0 /16 (256 contiguous Class C blocks)

Translation Mechanics (NAPT / PAT)

Simple IP-only translation requires a unique public IP for each concurrent session, which still limits capacity. Modern NAT networks use Network Address Port Translation (NAPT), mapping both IP addresses and transport-layer port numbers (TCP/UDP) to multiplex many internal devices over a single public IP.

text

Private LAN                               Boundary NAT Router                      Public Internet
[ Host A: 172.18.3.1:5000 ]                                                      
            │                                                                    
            ▼ (Outbound Packet)                                                  
      Src: 172.18.3.1:5000   ───────────► [ NAT Translation Table ] ────────────► [ Web Server: 8.8.8.8:80 ]
      Dst: 8.8.8.8:80                      Internal: 172.18.3.1:5000               Src: 200.24.5.8:10001
                                           External: 200.24.5.8:10001              Dst: 8.8.8.8:80
                                                    ▲                            
[ Host B: 172.18.3.2:5000 ]                         │                            
            │                                       │                            
            ▼ (Outbound Packet)                     │                            
      Src: 172.18.3.2:5000   ───────────────────────┘                            
      Dst: 8.8.8.8:80

When a packet leaves the private network, the NAT router rewrites the private source IP and port to its public IP and a unique temporary port. The router maintains this state in its translation table to map incoming response packets back to the correct internal host.

9. Programmatic IPv4 Calculations

Below is a complete, production-ready Python implementation using standard bitwise operations to compute the first address, last address, and total number of addresses in a classless CIDR block without external libraries.

python

def calculate_cidr_bounds(ip_str: str, prefix_len: int):
    # Convert dotted-decimal string to 32-bit unsigned integer
    octets = list(map(int, ip_str.split('.')))
    ip_int = (octets[0] << 24) | (octets[1] << 16) | (octets[2] << 8) | octets[3]
    
    # Generate the subnet mask based on the prefix length
    mask = ((1 << 32) - 1) ^ ((1 << (32 - prefix_len)) - 1) if prefix_len >

Summary

IPv4 Architecture: Built on a 32-bit address space yielding $2^{32}$ ( $4,294,967,296$ ) unique addresses, represented in dotted-decimal format.
Classful vs Classless: Classful addressing used rigid, fixed-size boundaries (Classes A, B, C) that wasted millions of addresses. Modern Classless addressing (CIDR) uses custom prefix lengths ( $/n$ ) to allocate addresses efficiently based on need.
Subnetting Mathematics: Allows organizations to divide large network blocks into smaller, isolated networks. Subblocks must match a power of two ( $2^{32-n}$ ) and align on boundaries divisible by their size.

Assessed progress

IPv4 Addressing: Classful and Classless

Key Concepts

IPv4 Address Structure

Classful Addressing

Classless Inter-Domain Routing (CIDR)

Logical Subnetting

Network Address Translation (NAT)

Quick Check

Computer Networks

Computer Networks