Chapter 5: CIDR Notation and Prefix Length

The Slash Notation

Addresses like 192.168.0.15/24, 10.0.0.0/8, and 172.16.0.0/16 use slash notation (also called CIDR notation): an IP address, a slash, and a decimal number. That number is the prefix length — the count of consecutive leading 1 bits in the subnet mask.

An IPv4 address is 32 bits. The prefix length says how many of those bits belong to the network portion; the rest are the host portion. So /24 means the first 24 bits are network and the last 8 are host:

/24  →  11111111.11111111.11111111.00000000  →  255.255.255.0

Count the 1s in 255.255.255.0 and you get exactly 24 — which is why it is written /24.

Figure 5.1: Prefix length as the bit boundary between network and host portions

Analogy — a phone number and its area code. The prefix length draws a line: everything to the left is the "area code" (which network you belong to), everything to the right is your personal "line number." A /24 draws that line after 24 binary digits; a /16 draws it earlier. Everyone on the same side of the line shares the same network.

At the packet level, a router applies the mask using a bitwise AND, which zeroes out the host bits and leaves the network address behind. That extracted network address is what the router matches against its routing table.

Figure 5.2: How a router extracts the network address with a bitwise AND

/8, /16, /24, and everything in between

The old classful system allowed only three sizes, all landing on tidy octet boundaries: /8 (Class A), /16 (Class B), and /24 (Class C). CIDR's power is that the prefix is not restricted to multiples of 8 — it can be any value from /0 to /32. A /23, /26, or /30 is perfectly valid. This freedom to place the boundary at any bit position is the mathematical heart of variable-length subnet masking (VLSM).

CIDR vs. classful

Under classful rules the class was implied by the address's first bits and the mask was assumed. Under CIDR nothing is assumed — the prefix length is stated explicitly every time, which is exactly why the notation is so useful.

CIDR and Address Allocation

CIDR was introduced by the IETF in 1993 (RFC 1518 and RFC 1519, later updated by RFC 4632 in 2006) to solve two urgent problems classful addressing created: the rapid exhaustion of the IPv4 address space, and the runaway growth of internet routing tables.

The purpose: ending the waste of classful allocation

The classful system forced every network into one of a few sizes: Class A (/8) ≈ 16.7 million addresses, Class B (/16) = 65,536, Class C (/24) = 256. An organization needing 500 addresses could not fit in a single Class C (254 usable), so it was bumped to a Class B of over 65,000 — using fewer than 1% and leaving ~99% idle.

CIDR fixes this with right-sized (classless) allocation. Because the prefix can fall on any bit boundary, that 500-host organization gets a /23 (510 usable hosts) — a near-perfect fit instead of a wasteful /16. This directly slows depletion of the IPv4 pool.

Analogy — renting the right amount of storage. Classful allocation rented only three unit sizes: closet, garage, or warehouse. If your belongings didn't fit the closet, your only option was the warehouse — and you paid for all that empty space. CIDR builds a unit to whatever size you actually need.

Provider address blocks

Regional registries hand large blocks to ISPs, and ISPs subdivide them classlessly for customers. An ISP holding a /16 might carve it into hundreds of /24s, /26s, or /29s, each sized to a customer's need. The address block — a contiguous range described by one CIDR prefix — becomes the fundamental unit of allocation.

Figure 5.3: Provider address-block allocation hierarchy

Reducing routing table size through supernetting

Every distinct network needs an entry in core routers' routing tables. Under classful routing each network required its own entry, and as the internet grew these tables ballooned toward sizes that threatened router memory and performance.

CIDR's answer is route aggregation, also called supernetting. Multiple contiguous blocks that share the same leading bits collapse into a single entry with a shorter prefix — a supernet. Suppose an ISP controls sixteen contiguous /24s that all share their first 20 bits:

203.0.0.0/24
203.0.1.0/24
203.0.2.0/24
   ...
203.0.15.0/24     (16 networks in total)

Because all sixteen share their first 20 bits, they can be advertised as a single supernet:

203.0.0.0/20     (one routing entry replaces sixteen)

Figure 5.4: Supernetting collapses sixteen contiguous /24s into one /20 route

Multiply that savings across the whole internet and the effect is dramatic: smaller routing tables, faster routing decisions, less router memory. Supernetting is the mirror image of subnetting — subnetting makes a prefix longer to split a block, while supernetting makes it shorter to combine blocks. None of this was possible under classful rules, which is why classless addressing is now the universal standard.

Prefix-to-Mask Conversion

Every IPv4 prefix from /0 to /32 maps to exactly one subnet mask. Total addresses in a block = 2^(32 − prefix); usable hosts is normally 2^(32 − prefix) − 2, subtracting one address for the network identifier and one for the broadcast address.

Two rows deserve special attention. A /31 (RFC 3021) is used for point-to-point links, where both addresses are usable and no network or broadcast address is reserved — 2 usable out of 2. A /32 describes a single host: exactly one address, used for host routes and loopback interfaces.

Fast mental conversion

You do not need all 33 rows. Memorize just the eight possible values of a partial octet — the octet only partly filled with 1 bits:

These come straight from binary: one leading 1 is 10000000 = 128; two are 11000000 = 192; each added bit adds the next power of two until all eight give 11111111 = 255. Each value is the previous one plus a halving step (128, +64, +32, +16, …).

With that table in hand, converting any prefix to a mask is a three-step recipe:

1. Fill whole octets. Each group of 8 prefix bits becomes a 255. A /26 has three full octets (24 bits), so the mask starts 255.255.255.
2. Handle the leftover bits. Subtract the full octets from the prefix: 26 − 24 = 2 leftover bits. Look up 2 bits → 192. Mask is now 255.255.255.192.
3. Pad with zeros. Any octet after the partial one is 0.

Figure 5.5: The three-step prefix-to-mask conversion recipe

Worked example — convert /20: 20 = 16 + 4, so two full octets → 255.255; 4 leftover bits → 240; remaining octet 0 → 255.255.240.0.

Worked example — mask to prefix: given 255.255.255.192, two full 255s = 16 bits, a third 255 = 24, and 192 = 2 bits → 24 + 2 = /26.

Worked example — host counts: for /26, total = 2^6 = 64, usable = 62. For /30, total = 2^2 = 4, usable = 2 — exactly why /30 is the classic router-to-router link.

Common exam prefixes

Notice the pattern past /24: the final octet marches through the partial-octet values — 128, 192, 224, 240 — while the host count halves at each step. Seeing that pattern rather than memorizing isolated facts is what makes conversion feel automatic.