IP Addressing and Subnetting

An octet is a group of eight bits. Each bit holds either 0 or 1. An IPv4 address has four octets, making 32 bits in all. Start with one octet; the same method works on each of the four parts.

Give each bit its value

Read the positions from left to right:

Each position is worth twice the one to its right. Add a position's value only when its bit is 1. For 10101100, the active positions are 128, 32, 8 and 4:

The zero in the 64 position contributes nothing. In 01100100, the 1s select 64, 32 and 4, giving 100. The leftmost bit carries the greatest value; 10000000 is 128, while 00000001 is 1.

Build binary from decimal

To convert 200, work through the same values in order. At each position, ask whether its value fits into the amount left.

1. 128 fits: write 1 and leave 72.
2. 64 fits: write 1 and leave 8.
3. 32 and 16 do not fit: write 0 in both positions.
4. 8 fits: write 1 and leave 0.
5. The 4, 2 and 1 positions are all 0.

The result is 11001000. Check it by adding the selected values: 128 + 64 + 8 = 200. Once the remainder reaches zero, keep writing zeros until all eight positions are filled.

Write decimal 10 as 00001010 when it is an octet. The shorter binary number 1010 has the same value, but eight positions let you line up an address with its subnet mask. Do not treat a binary string as a decimal number: binary 00000100 means four, not one hundred.

Recognize mask patterns

Subnet masks repeatedly use octets whose 1s fill from the left. These patterns are useful enough to learn:

Each row adds another place value. For instance, 224 is 128 + 64 + 32. An octet of all zeros is 0; all ones sum to 255.

Count combinations

With one bit there are two possible patterns. With two bits there are four: 00, 01, 10 and 11. Each added bit doubles the possibilities, so $n$ bits give $2^n$ values. Eight bits give 256 values, numbered 0 through 255. This distinction between the number of values and the largest value matters when you count addresses.

An IPv4 address is a 32-bit number used to identify a network interface. Its familiar form, dotted decimal, converts each of four octets to decimal and separates them with dots. The dots mark boundaries between octets; they are not decimal points.

Read four octets

The address 192.168.10.77 is:

11000000.10101000.00001010.01001101

The first octet is 128 + 64 = 192. The second is 128 + 32 + 8 = 168. The third is 8 + 2 = 10, and the fourth is 64 + 8 + 4 + 1 = 77. Each octet must be between 0 and 255. An address such as 192.168.1.256 is invalid because its final number needs more than eight bits.

The full space contains $2^{32}$ addresses: 4,294,967,296. Some are reserved for specific purposes, so this is not the number available for ordinary internet hosts.

An address belongs to an interface, the connection through which a device joins a network. A router connecting three IP networks needs addressing on all three interfaces. A laptop using Wi-Fi and Ethernet can have a different IPv4 address on each. This is why troubleshooting starts with the interface in use.

Find the boundary with a mask

Every address has a network portion and a host portion. The network portion identifies its subnet; the host portion selects an interface within that subnet. These are portions of the same 32 bits, not extra numbers added to the address.

The address alone does not show the split. With /16, 172.16.45.200 belongs to 172.16.0.0/16. With /21, it belongs to 172.16.40.0/21. The longer prefix keeps more bits in the network portion and leaves fewer for hosts. Always carry the prefix with an address when calculating its subnet.

Understand the old classes

Before CIDR, address classes supplied fixed default boundaries:

The first bits are 0, 10, 110, 1110 and 1111, respectively. First octets 0 and 127 have special uses even though their leading bit is 0. For example, 150.20.0.9 falls in the historical class B range; 230.0.0.5 is a multicast group address.

Fixed classes wasted space. A network needing 300 host addresses would exceed a class C block's 254 usable addresses but use only a small part of a class B block's 65,534. Classless Inter-Domain Routing (CIDR) replaced fixed boundaries in 1993. A prefix can now be any length from 0 to 32. 10.1.2.0/24 is a valid classless block: the old class A label does not force it to use /8.

A subnet mask marks which bits belong to the network. It has 32 bits: a continuous run of 1s from the left, followed by 0s. A 1 keeps the corresponding address bit in the network portion. A 0 marks a host position.

Count network bits

Prefix notation writes the number of mask 1s after a slash. /24 means 24 network bits and eight host bits. Its mask is 11111111.11111111.11111111.00000000, or 255.255.255.0.

For /21, split 21 into 8 + 8 + 5. The first two octets are 255. The next contains five 1s, 11111000, worth 248. The final octet is zero. The mask is 255.255.248.0.

To go the other way, count the 1s in each octet. 255.255.255.192 contains 8 + 8 + 8 + 2 = 26, so it is /26. The partly filled octet is often the only part you need to convert.

Check that a mask is valid

A mask octet can be 0, 128, 192, 224, 240, 248, 252, 254 or 255. However, valid octets alone are not enough: the entire mask must keep the continuous run of 1s. After an octet below 255, every later octet must be zero. 255.255.0.255 fails because its 1s restart. 255.255.255.100 fails because binary 100 is 01100100, which breaks the pattern within one octet.

Count addresses and find the increment

If the prefix is $p$, the host-bit count is $h=32-p$. There are $2^h$ addresses. In an ordinary broadcast subnet, reserve the all-zero host pattern for the network and the all-one pattern for broadcast, leaving $2^h-2$ usable addresses. /31 and /32 have special uses and are handled separately.

The block size, or increment, is 256 minus the mask value in the octet where the mask stops being 255. With /26, that octet is the fourth: 256 − 192 = 64. Networks start at .0, .64, .128 and .192. With /21, the increment is 256 − 248 = 8 in the third octet; the fourth octet is still part of the host portion.

A larger prefix number means fewer addresses: /26 is smaller than /25. Each added network bit halves the possible host patterns.

Recognize the ends of the prefix scale

A /0 has no fixed network bits and mask 0.0.0.0; it covers the entire IPv4 space. A /32 fixes all 32 bits and has mask 255.255.255.255; it identifies one exact address. These endpoints help you read a default route or host prefix without trying to assign an ordinary usable-host count to it.

Read settings in different forms

Windows ipconfig displays a dotted-decimal mask. Linux ip addr attaches the prefix to the address. macOS ifconfig may display a hexadecimal mask such as 0xffffff00, equivalent to 255.255.255.0. These are different ways to show the same boundary.

The network address has every host bit set to 0. The broadcast address has every host bit set to 1. In an ordinary IPv4 subnet, the addresses between those endpoints are available for interfaces.

Apply the mask bit by bit

A bitwise AND keeps a 1 only when both input bits are 1. All other pairs give 0. ANDing an address with its mask preserves the network bits and clears the host bits.

For 192.168.10.77/26, the first 24 bits are fully masked. Work on the final octet:

Address: 01001101   (77)
Mask:    11000000   (192)
AND:     01000000   (64)

The network is 192.168.10.64. Six host bits remain. Set them all to 1: 01111111 is 127, making the broadcast 192.168.10.127. The usable range runs from 192.168.10.65 through 192.168.10.126, containing $2^6-2=62$ addresses.

The broadcast is one less than the next network address. Adding the whole block size to .64 produces .128, the next subnet, not this subnet's broadcast.

Use the block-size shortcut

For 172.16.45.200/21, convert /21 to 255.255.248.0. The boundary is in octet three, with increment 8. Multiples around 45 are 40 and 48, so 45 lies in the block starting at 40.

• Network: 172.16.40.0.
• Next network: 172.16.48.0.
• Broadcast: 172.16.47.255.
• First and last usable: 172.16.40.1 and 172.16.47.254.

The full fourth octet is host space, so clear it to 0 for the network and fill it with 255 for the broadcast. The block has 11 host bits, giving $2^{11}-2=2,046$ usable addresses.

An address ending in .0 or .255 can still be a host address in a larger subnet. Both 172.16.41.0 and 172.16.44.255 lie between these endpoints. Their complete host portions are neither all zeros nor all ones. Judge all host bits, not only the last decimal number.

The increment describes movement in one octet, not always the number of addresses in the whole block. In the /21 example, eight third-octet values each contain 256 final-octet values, giving 2,048 total addresses. Subtracting the two reserved endpoints gives the same 2,046 usable addresses as the host-bit formula. Keep these two meanings of “block size” separate when the boundary is before octet four.

Handle /31 and /32 correctly

A /31 contains two addresses. On a supported point-to-point router link, both are usable under RFC 3021; no broadcast reservation is needed. For example, 10.0.0.8/31 can number its two endpoints as 10.0.0.8 and 10.0.0.9.

A /32 identifies one exact address, such as a router's logical loopback interface. It does not supply a range of hosts. Do not apply the ordinary subtract-two formula to either special case.

Check an endpoint calculation

Verify that the network begins on the increment, the original address falls within the block, and the next network begins immediately after the broadcast. For ordinary broadcast subnets, first usable is network + 1 and last usable is broadcast − 1. If the prefix cuts the third octet, a calculation that changes only the fourth octet has missed the boundary.

A host uses its own address and mask to decide whether a destination is local. If both addresses produce the same network address under that mask, it sends directly on the local network. Otherwise, it sends to its default gateway, a router interface in its own subnet.

Compare networks, not the first three numbers

192.168.1.100/25 belongs to 192.168.1.0/25. The address 192.168.1.130/25 belongs to 192.168.1.128/25. Their first three octets match, but the /25 boundary divides the last octet in half. They are in different subnets.

The prefix also changes whether an address is assignable. 192.168.10.64 is a usable address in 192.168.10.0/25, whose hosts run from .1 to .126. In 192.168.10.64/26, the same .64 is the network address. You need both address and mask to judge it.

Check a gateway

Suppose a PC has 192.168.10.70/26 with gateway 192.168.10.1. The PC's subnet is 192.168.10.64/26, with hosts .65 through .126. The gateway .1 is outside that range, so it is not a valid directly connected gateway for these settings.

Check the address plan before changing anything. If the PC belongs in this subnet, use the address of the router interface serving it, such as .65 if that is the configured router address. If the PC belongs elsewhere, correct its address or mask to match that plan. A plausible unused address is not enough: the gateway entry must identify the actual router interface.

Notice mismatched masks

Host A is 192.168.1.10/24; host B is 192.168.1.200/25. A treats B as local. B places itself in 192.168.1.128/25 and treats A as remote. They disagree because their masks define different boundaries. Communication may fail or depend on routing behavior. Interfaces intended to share one subnet must use its planned prefix consistently.

A duplicate address causes a different problem: two interfaces claim the same address on the same network. Traffic may reach the wrong interface or fail intermittently. The fact that private addresses are reusable across separate organizations does not permit duplicates within one connected subnet.

Read the relevant settings

On Windows, run ipconfig or ipconfig /all. On Linux, ip addr shows addresses and prefixes; ip route shows a gateway after default via. On macOS, use network settings or ifconfig for the address and mask.

Ask whether the address is usable under its prefix, whether the actual gateway is in the subnet, and whether the prefix matches the plan. Also check uniqueness when symptoms are intermittent.

On Cisco IOS, an interface-mode command such as ip address 192.168.10.65 255.255.255.192 sets an IPv4 address. show ip interface brief lists interface addresses and status; it does not replace checking the configured mask. Separate routed interfaces normally need non-overlapping subnets, and IOS commonly rejects overlaps.

Public IPv4 addresses are globally unique addresses eligible for routing across the internet. Most organizations obtain them from an ISP. IANA allocates space through five Regional Internet Registries: AFRINIC, APNIC, ARIN, LACNIC and RIPE NCC. Being public does not guarantee that a device will accept connections; routes and security settings still matter.

Learn the three private blocks

RFC 1918 reserves address space that organizations can reuse internally:

These addresses are not routed on the public internet. Two separate organizations may both use 10.1.0.0/24 internally. Within either connected subnet, each interface still needs its own address.

Pay particular attention to 172. Only second octets 16 through 31 are private. 172.20.10.2 lies inside the block, while 172.15.0.1 and 172.32.0.1 lie outside it. The mask 255.240.0.0 keeps the first four bits of the second octet fixed, spanning 16 possible second-octet values.

Connect private hosts to public networks

An edge router or firewall can perform network address translation (NAT). For an outgoing connection, it replaces a private source address with a public address and maintains the information needed to translate the reply.

Port address translation (PAT) lets several internal hosts share one public address. Port numbers help distinguish their connections. This reduces the public addresses an organization needs. NAT and PAT describe translation behavior; they are not extra private address ranges.

IPv4 has about 4.3 billion possible addresses, with substantial space reserved for special uses. IANA distributed its last general free pool blocks in February 2011. Private addressing with translation allows reuse; IPv6 supplies a much larger address space.

Recognize an ISP's shared space

100.64.0.0/10 spans 100.64.0.0 through 100.127.255.255. RFC 6598 reserves it for provider networks using carrier-grade NAT (CGNAT). It is neither public space nor one of the three RFC 1918 private blocks.

If a home router's outside interface shows 100.72.5.9, that address lies in the ISP's shared range. The provider may translate it again before traffic reaches the public internet. Calling every nonpublic address “RFC 1918” would hide this difference.

Choose space that can connect later

A large organization may divide the private 10.0.0.0/8 block into site and department networks. Small routers often default to 192.168.0.0/24 or 192.168.1.0/24. Before connecting two sites through a VPN, compare their plans. If both use the same subnet, an address such as 192.168.1.20 cannot uniquely identify which site's host is intended. Choose non-overlapping space for networks that will meet.

Special-purpose addresses carry information about how a packet or interface is being used. Check the whole reserved range before treating an unfamiliar address as an ordinary public host.

Tests that stay on the host

127.0.0.0/8 is loopback space. 127.0.0.1 is the usual loopback address, but 127.0.0.53 is also inside the block. A loopback packet stays on the host. A successful ping 127.0.0.1 checks local IP software; the packet never tests the network cable or remote router.

Addresses limited to one link

IPv4 link-local space is 169.254.0.0/16. On Windows it is associated with Automatic Private IP Addressing (APIPA). A host that cannot obtain a DHCP address may select a local address from 169.254.1.0 through 169.254.254.255, using a /16 mask. The first and last /24 blocks are reserved for this selection process.

Such an address supports communication on the local link, not routed internet access. If a DHCP-configured workstation unexpectedly shows 169.254.37.12, check its link, switch port or VLAN and the path to DHCP. The address suggests failed automatic assignment; by itself it does not identify which component failed. A manually entered link-local address can look the same.

Separate the zero and broadcast meanings

0.0.0.0 can be a source meaning that the host has no address yet. In a server's listening settings, it means all local IPv4 addresses. With /0, 0.0.0.0/0 names every IPv4 destination and is used for a default route. The prefix changes the meaning.

255.255.255.255 is the limited broadcast, kept on the local network. A subnet's own broadcast, such as 192.168.10.127 for 192.168.10.64/26, is a directed broadcast. Routers normally disable forwarding of directed broadcasts by default.

Know the other ranges

A multicast address identifies a group destination, not a host's own unicast address. The smaller block 224.0.0.0/24 is reserved for local-link control traffic. Examples include 224.0.0.5 for OSPF routers and 224.0.0.251 for multicast DNS.

Documentation blocks let instructions show realistic address calculations without naming a live public host. Benchmark space serves controlled performance tests. Neither category becomes an ordinary internet host range simply because it is outside RFC 1918. IANA's special-purpose registry is the reference for less familiar blocks.

Subnetting divides an address block by moving bits from the host portion into the network portion. All resulting blocks are smaller and have longer prefixes. When they all use the same prefix, the plan is called fixed-length subnet masking (FLSM).

Choose enough subnet bits

Borrowing $s$ bits creates $2^s$ equal subnets. Add $s$ to the starting prefix. From 192.168.10.0/24, suppose you need six subnets. Two extra bits give four subnets, which is too few. Three give eight, so use /27.

A /27 leaves five host bits, giving $2^5-2=30$ usable addresses in each subnet. Its mask is 255.255.255.224, and its increment is 32 in the last octet.

The first and last subnets are valid. Subtract two for network and broadcast addresses inside an ordinary subnet, not from the number of subnets. The old rule that avoided “subnet zero” and the all-ones subnet does not apply to modern classless planning.

Choose enough host bits

If the requirement gives host count, choose the smallest host-bit count $h$ satisfying $2^h-2$ at least equal to that count. Then calculate the prefix as $32-h$.

For 500 usable addresses, eight host bits give 254, which is too few. Nine give 510, so use /23. For 30 usable addresses, /27 fits exactly; 31 requires /26.

Count every interface that needs an address. Thirty computers plus a router gateway need 31 usable addresses, even before printers, servers or switch management. If a stated host count already includes the gateway, do not add it a second time.

A prefix change can also carry the list across an octet boundary. Dividing 10.30.8.0/22 into /25s borrows three bits and gives eight blocks. Their starts are 10.30.8.0, 10.30.8.128, 10.30.9.0, 10.30.9.128, continuing through 10.30.11.128. After the final-octet .128 block, the next start increments octet three and resets octet four. Every block still contains 128 total addresses.

Test both limits

A plan can pass the host test and fail the subnet test. Five LANs needing 40 usable addresses each require five /26 blocks. A /24 holds only four of those blocks. The five blocks require 320 total addresses, so they cannot fit into 256. A /23 has room for eight /26 blocks.

Conversely, making many very small blocks can satisfy the subnet count while leaving too few host addresses in each. Start with the supplied parent block, calculate the candidate prefix, and check both requirements before listing networks.

FLSM keeps the plan simple, but all networks receive the same size. Giving a two-interface router link a /27 leaves 28 usable addresses unused. When needs differ substantially, different prefix lengths can use the parent space more efficiently.

Variable-length subnet masking (VLSM) gives each subnet its own prefix length. A large LAN can receive a /25, a smaller LAN a /27, and a two-interface router link a /30, all inside one parent block.

Size the requirements first

Plan 192.168.50.0/24 for three LANs needing 100, 50 and 20 usable addresses, plus two router links. Here the LAN counts already include their gateways.

• 100 needs seven host bits: 126 usable, so /25.
• 50 needs six: 62 usable, so /26.
• 20 needs five: 30 usable, so /27.
• Each link uses /30: two usable addresses.

Reserve expected growth before making these choices. A current count of 50 may fit a /26, but a requirement of 70 after growth does not.

Allocate largest to smallest

Large blocks have fewer possible starting positions. In a /24, a /25 starts at .0 or .128. Allocating small blocks first can split free space across both halves and leave no whole /25.

All abbreviated addresses in the table begin with 192.168.50. The masks are 255.255.255.128, .192, .224 and .252, respectively.

After placing a block, move to the next free address that is aligned for the next block's size. A /26 must start on a multiple of 64 in the last octet. 192.168.50.100/26 is a host address within the .64 block, not a new network beginning at .100.

Account for the free space

The plan uses 128 + 64 + 32 + 4 + 4 = 232 total addresses. Addresses .232 through .255 remain free: 24 addresses, expressible as 192.168.50.232/29 and 192.168.50.240/28.

A fourth LAN needing 20 usable addresses requires a whole /27, or 32 total addresses. It cannot fit in those 24 remaining addresses. Even when a free total is large enough, its alignment and continuity must also suit the requested block. Starting from a /23 would provide more room to preserve larger growth blocks.

On a supported point-to-point link, a /31 uses both of its two addresses and consumes half the space of a /30. Choose the link convention before completing the plan; its endpoints must support it.

A growth allowance can change a prefix at a sharp threshold. A LAN needing 14 usable addresses fits /28, but adding one more required interface raises the need to 15 and forces /27. Its allocation doubles from 16 total addresses to 32. Add expected devices to the usable requirement before rounding to a power-of-two block; adding a few spare addresses after choosing /28 cannot enlarge that block beyond its boundary.

Audit the plan

Record each network, prefix, dotted mask, usable range and broadcast. Check that every subnet fits its requirement, starts on its own boundary, stays inside the parent block and does not overlap another allocation.

A usable plan needs distinct, correctly aligned blocks. Summarization, also called aggregation or supernetting, then names suitable groups of blocks with one shorter prefix. The checks for overlap and summary both depend on address boundaries.

Check alignment and overlap

A network address must have all host bits zero. For /26, the last-octet increment is 64. 192.168.1.32/26 is therefore not a network beginning at .32; it lies inside 192.168.1.0/26.

Two correctly aligned CIDR blocks either stay separate or one contains the other. 10.0.0.0/23 covers 10.0.0.0 through 10.0.1.255. A proposed 10.0.1.0/24 lies completely inside it. They overlap even though their written network addresses differ.

To test this efficiently, apply the shorter prefix to both network addresses. If the results match, the more specific block lies inside the less specific one. You can also compare the complete first-to-last ranges. Separate allocations in one address plan must not claim any of the same addresses.

Find an exact summary

Consider four networks: 172.16.0.0/24, 172.16.1.0/24, 172.16.2.0/24 and 172.16.3.0/24. They are contiguous and contain 1,024 addresses in all.

The first two octets share 16 bits. In the third octet, 0 is 00000000 and 3 is 00000011; they share the first six bits. Keeping 22 bits gives 172.16.0.0/22, covering exactly 172.16.0.0 through 172.16.3.255.

For an exact single-block summary, the combined coverage must be continuous, contain a power-of-two number of addresses, and start on the matching boundary. With equal-sized input blocks, their count must also be a power of two. Different-sized blocks can combine: 192.168.10.0/25, 192.168.10.128/26 and 192.168.10.192/26 fill one complete /24.

Distinguish covering from exact

Four /24 blocks from 172.16.1.0/24 through 172.16.4.0/24 also contain 1,024 addresses, but they start at the wrong boundary for /22. The smallest single block containing them is 172.16.0.0/21. It includes additional /24 blocks outside the requested group.

Use the first address of the first block and the last address of the last block to check a covering prefix. Looking only at network addresses can miss the size of the final block. For example, 10.20.0.0/24 plus 10.20.1.0/23 cannot be treated as two valid adjacent allocations: the second label is misaligned and actually falls within 10.20.0.0/23.

An address plan that gives each site a contiguous aligned parent block is easier to summarize and extend. For example, separate site blocks 10.1.0.0/16 and 10.2.0.0/16 let each site's smaller subnets retain a clear common prefix.

IPv6 uses 128-bit addresses, compared with IPv4's 32 bits. Its space contains about $3.4\times {10}^{38}$ addresses. The larger space supports globally unique addressing at a scale IPv4 cannot provide.

Read hexadecimal groups

Hexadecimal uses 0–9 and a–f; a means 10 and f means 15. Each digit represents four bits, a nibble. Hex 4b represents 0100 1011, or decimal 75. Four hex digits form a 16-bit group, often called a hextet.

A full IPv6 address has eight groups, separated by colons:

2001:0db8:0000:0000:0008:0800:200c:417a

Count eight groups of 16 bits to account for all 128 bits. Hex letters are case-insensitive, but the recommended text form uses lowercase.

Shorten without changing values

First remove leading zeros inside each group. 0db8 becomes db8, 0008 becomes 8, and 0000 becomes 0. Keep internal and trailing zeros: 0800 becomes 800, not 8.

Next, replace one continuous run of all-zero groups with ::. Use it only once. Two double colons would leave the division of missing groups ambiguous. The full example becomes 2001:db8::8:800:200c:417a.

RFC 5952 recommends compressing the longest run. If runs tie, compress the first. Leave a single zero group as 0:

The last address has only one zero group, so recommended form keeps it visible. A valid IPv6 spelling and the recommended spelling are different questions: some valid forms are longer or use uppercase.

Expand a short address

For 2001:db8:acad:12::100, five groups are visible. Eight minus five leaves three zero groups represented by ::. Insert them, then pad each group to four digits:

2001:0db8:acad:0012:0000:0000:0000:0100

This expansion also shows why 2001:db8::1 and 2001:db8::1:0 differ. Their final 16 bits differ; removing a trailing zero group changes the address.

In a URL, square brackets separate an IPv6 literal from a port: http://[2001:db8::10]:8080/. Here the brackets are part of URL syntax, while the colons inside identify the address.

Recognize coexistence approaches

IPv4 and IPv6 use different packet formats and do not communicate directly. Dual stack runs both protocols, allowing each connection to use the appropriate one. Tunneling carries packets of one protocol inside packets of the other across an intervening network. NAT64, commonly paired with DNS64, translates between IPv6-only clients and IPv4-only servers. These are different jobs: adding an IPv6 address to a dual-stack host does not translate an IPv4 packet.

An IPv6 prefix keeps the first stated number of bits. 2001:db8:acad:12::25/64 has a 64-bit network prefix and a 64-bit interface ID. IPv6 uses slash prefixes, not dotted-decimal subnet masks.

Keep a /64 for LANs

The standard LAN subnet is /64. It supports the 64-bit interface IDs used by SLAAC and modified EUI-64. One /64 contains $2^{64}$ addresses, about $1.8\times {10}^{19}$, so LAN planning does not shrink blocks to match a few dozen hosts.

For a /64, keep the first four full groups and clear the other four. The address 2001:db8:acad:12:a::1/64 belongs to 2001:db8:acad:12::/64. That prefix remains a complete IPv6 address: omitting the :: would leave only four written groups with no notation for the missing ones.

Separate site, subnet and interface

A typical site plan contains a global routing prefix, a subnet ID and the interface ID. If the site receives a /48, its first three groups are fixed. Group four provides 16 subnet bits before the /64 interface boundary.

The subnet count is $2^{64-48}=65,536$. Count through the fourth group from 0 to ffff:

• 2001:db8:acad::/64.
• 2001:db8:acad:1::/64.
• 2001:db8:acad:2::/64.
• Continue through 2001:db8:acad:ffff::/64.

A /56 leaves eight subnet bits, giving $2^{64-56}=256$ LAN subnets. For 2001:db8:acad:4b00::/56, the first two hex digits of group four, 4b, remain fixed. The /64 subnet group can run from 4b00 through 4bff.

Read boundaries inside groups

Each hex digit holds four bits. Prefix lengths divisible by four fall on nibble boundaries, which are easy to see. For /56, keep 14 hex digits. Applying it to 2001:db8:acad:4b7f::25 produces 2001:db8:acad:4b00::/56: the final two digits of group four become zero.

Subnet IDs are hexadecimal. An ID written 10 represents decimal 16, not ten. A plan can label VLAN 10 with subnet text 10, but that is a naming choice, not decimal arithmetic.

The subnet-count rule also works away from nibble boundaries. A /55 site leaves nine bits before /64, so it holds 512 LANs. For 2001:db8:acad:4a00::/55, the LAN group runs from 4a00 through 4bff: one bit of the second hex digit in that group can vary. A /56 beginning at 4a00 instead stops at 4aff. Use bit counts when a prefix cuts through a hex digit; visually keeping whole digits would lose that extra subnet bit.

Router-to-router links can use /64 or a /127; the latter holds exactly two addresses under RFC 6164. This point-to-point choice does not change the standard /64 layout for LANs.

Configure and verify an interface

In Cisco IOS interface configuration mode, ipv6 address 2001:db8:acad:1::1/64 assigns an address. Appending eui-64 to a /64 prefix command asks the router to build the ID from its MAC address. show ipv6 interface brief lists addresses, including link-local ones. Windows ipconfig and Linux ip -6 addr also show IPv6 settings. Verify the prefix as well as the address: a correct-looking host ID cannot fix a wrong subnet prefix.

A unicast address identifies one interface. An IPv6 interface normally has a link-local address and may also have global or unique local addresses. Several addresses on one interface are expected, so inspect each address's role before deciding which one to use.

Global unicast addresses

The currently allocated global unicast space is 2000::/3, beginning with hex 2 or 3. These addresses are intended for globally unique, internet-routable unicast communication. The range also contains special-purpose reservations: 2001:db8::/32 and 3fff::/20 are documentation space, for example. A leading 2 or 3 is a first classification clue, not permission to assign an arbitrary address from that space.

As with public IPv4, global scope does not guarantee that a service is reachable. The network must route the prefix, and security policy may block traffic.

Link-local addresses

The reserved link-local prefix is fe80::/10. Its address format uses zero bits through the /64 boundary, followed by a 64-bit interface ID, so normal addresses appear as fe80::....

Link-local addresses serve communication on one link. Routers never forward packets with a link-local source or destination onto another link. IPv6 neighbor discovery and router advertisements use this local reach; a host's default gateway is often a router's link-local address.

Because fe80::1 can exist on several separate links, a host may need a zone index to select the interface. fe80::1%eth0 identifies the Linux interface named eth0. Windows may show an interface number, such as %12. The zone is local information, not another part of the 128 address bits.

Unique local addresses

Unique local addresses (ULAs) occupy fc00::/7. Locally assigned ULAs begin with fd, from fd00::/8. A site prefix combines that beginning with a 40-bit randomly chosen Global ID, producing a /48. Next come a 16-bit subnet ID and a 64-bit interface ID.

For example, fd3c:9a21:7b04::/48 provides site-local addressing without depending on an ISP's global prefix. The random Global ID makes accidental overlap between independently planned sites unlikely. ULAs are not routed on the public internet, but they work within a routed organization without requiring NAT.

A host can use a ULA for an internal service and a global address for an internet service. Its source-address selection chooses an appropriate address for the connection. The older fec0::/10 site-local category was deprecated and replaced by the ULA approach.

A ULA and a link-local address therefore serve different needs: an organization can route a ULA between its internal subnets, while a link-local address stays on its originating link.

IPv6 has no broadcast addresses. It uses multicast groups for many tasks that need delivery to multiple interested interfaces. Other special addresses identify local tests, unconfigured sources or compatibility with IPv4.

Read multicast groups and scopes

Multicast addresses begin with ff, the ff00::/8 range. The next four bits are flags and the following four specify scope, the area in which the group is valid. Scope 1 is interface-local, 2 link-local, 5 site-local, 8 organization-local and e global. A multicast address is a destination, never a packet's source.

A solicited-node multicast address combines ff02::1:ff00:0/104 with the last 24 bits of a unicast address. For 2001:db8:acad:1::7:3a, expand the ending to 0007:003a. The last 24 bits are 07:003a, giving ff02::1:ff07:3a. Neighbor discovery can send a request to this smaller group instead of all nodes. Different unicast addresses can share the same last 24 bits, so the group need not identify just one interface.

Distinguish anycast from multicast

Anycast configures the same unicast address on several interfaces. Routing delivers a packet to one selected destination, according to routing metrics and policy. It need not be the geographically closest server or the one with the lowest measured delay. Public DNS services use this approach in IPv4 as well as IPv6.

Multicast delivers to group members; anycast selects one destination. An anycast address has no special visible prefix: the configuration and routing make it anycast.

Recognize special single addresses

::1/128 is loopback, the single IPv6 address for traffic that stays on the host. ::/128, normally written ::, is the unspecified address, used as a source before an address is available. With /0, ::/0 instead describes all IPv6 destinations and denotes a default route.

Documentation prefixes are 2001:db8::/32 and 3fff::/20. They support examples without naming live global hosts.

Recognize IPv4 embedded in IPv6 text

IPv4-mapped addresses use ::ffff:0:0/96 on dual-stack hosts. ::ffff:192.0.2.10 is equivalent to ::ffff:c000:20a; the last 32 bits hold the IPv4 value.

You can check the embedded value one byte at a time. Decimal 192 becomes hex c0, 0 becomes 00, 2 becomes 02 and 10 becomes 0a. Grouping the bytes as c000:020a preserves all 32 bits; shortening removes only the leading zero from 020a. This is why a dotted-decimal ending and a hexadecimal ending can name the same mapped value.

The NAT64 well-known prefix is 64:ff9b::/96, so 64:ff9b::192.0.2.10 is 64:ff9b::c000:20a. Although both forms embed IPv4 bits, they serve different purposes. A mapped address represents an IPv4 endpoint within a host's IPv6 programming interface; the NAT64 prefix identifies addresses used by a translator.

In a /64 subnet, the interface ID is the final 64 bits of the address. It can be set manually, assigned by DHCPv6, or created by the host through SLAAC. Host-created IDs may be random or follow modified EUI-64.

Turn a MAC address into an ID

A MAC address has 48 bits. Modified EUI-64 expands it to 64 bits and changes one bit. Use MAC 00:1a:2b:3c:4d:5e:

1. Split it into two 24-bit halves: 001a2b and 3c4d5e.
2. Insert fffe between them: 001a2bfffe3c4d5e.
3. Regroup into four hextets: 001a:2bff:fe3c:4d5e.
4. Flip the universal/local bit in the first byte. Its value is 2, the seventh bit from the left. Binary 00000000 becomes 00000010, so 00 becomes 02.

The ID is 021a:2bff:fe3c:4d5e. Combined with 2001:db8:acad:1::/64, it gives 2001:db8:acad:1:21a:2bff:fe3c:4d5e. The leading zero of 021a disappears in recommended IPv6 text. A link-local address using this ID is fe80::21a:2bff:fe3c:4d5e.

Flip the bit in either direction

“Flip” means change 0 to 1 or 1 to 0. It does not always mean add 2. A first byte of 02 changes to 00. For MAC 3c:22:fb:12:34:56, first byte 3c is 00111100. Flipping its bit worth 2 gives 00111110, or 3e. The final ID is 3e22:fbff:fe12:3456.

Insert fffe between the original halves before grouping into hextets. It appears across the middle hextet boundary, in the pattern xxxx:xxff:fexx:xxxx. Appending it at the end produces a different ID.

Read an ID carefully

The middle ff:fe pattern suggests modified EUI-64, but a manually chosen or random ID can contain the same bits. Recover a MAC only when you know this method was used: remove the inserted fffe, then flip the bit worth 2 again. The operation reverses itself.

For a reverse calculation, suppose 0a64:22ff:fe12:ab34 is known to be modified EUI-64. Remove the middle fffe to recover 0a:64:22:12:ab:34. Flip the first byte’s bit worth 2: 0a becomes 08. The original MAC is 08:64:22:12:ab:34. Removing the marker alone would leave the wrong first byte; undo both construction steps.

A MAC-derived ID can let observers link a device's activity across networks. Modern desktop and mobile systems commonly use stable per-network IDs and temporary IDs for outgoing connections, reducing that exposure. A random-looking ID is normal; SLAAC does not require a MAC-derived value.

Check uniqueness before use

A host performs duplicate address detection (DAD) for a new unicast address. It sends a neighbor solicitation from the unspecified source :: to the address's solicited-node multicast group. If a conflict is detected, the host cannot use that address. Otherwise, it can move from tentative to usable after the check completes. A 64-bit interface ID and a correct prefix establish the address's shape; DAD checks whether it is already in use on the link.