Since module 2 we have been using addresses like 192.168.10.21 and notations like /24 with the promise that "the detail would come later". That moment has arrived. In this lesson we open up an IPv4 address: what exactly those four numbers are, why the machine sees them as 32 bits, how to convert between decimal and binary (essential for the subnetting in the next lesson), which addresses have special meanings, and why the Meridiano network uses "private" addresses you will never see on the Internet. By the end, you will be able to read the IP configuration of Marta's PC and understand every field, not just recognize it.

1. Anatomy of an IPv4 address: 32 bits in 4 octets
2. Decimal ↔ binary conversion: the weight-table method
3. Network portion and host portion: the role of the mask
4. The historical classes A/B/C (and why they died)
5. Special addresses you must recognize
6. Public and private addresses (RFC 1918)
7. Who hands out public addresses? IANA and the RIRs
8. Meridiano case: a full reading of Marta's configuration

To the computer, an IPv4 address is a 32-bit number: a string of 32 ones and zeros. Since reading 11000000101010000000101000010101 is inhuman, the convention is to split it into 4 groups of 8 bits (each group is called an octet, or byte) and write each octet in decimal, separated by dots. This is the so-called dotted decimal notation:

Two immediate consequences:

• Each octet has 8 bits, so its value ranges from 0 (00000000) to 255 (11111111). That is why you will never see an address like 192.300.1.5: 300 does not fit in 8 bits.
• In total there are 2³² possible addresses: 4,294,967,296 (about 4.3 billion). That seemed infinite in 1981; today it is one of the reasons NAT (lesson 05-03) and IPv6 (lesson 05-04) exist.

The address 192.168.10.21 on Marta's PC and 11000000.10101000.00001010.00010101 are the same number written in two different bases. The router and the switch only ever see the bits; the decimal is for us.

For next lesson's subnetting you need to convert octets fluently. The tool is the weight table: each bit of an octet is "worth" a power of 2, from left to right:

Memorize the row of weights: 128, 64, 32, 16, 8, 4, 2, 1. Each weight is double the one to its right, and they all add up to 255.

Example with the third octet of Marta's PC, 00001010:

Another example, 11000000 (first octet):

And 11111111 (which you will see constantly in masks):

Walk the weight table from left to right asking: does this weight fit into what I have left? If it fits, write a 1 and subtract it; if it doesn't, write a 0 and move on.

Worked example: converting 168 (Marta's second octet):

Second example: converting 21 (Marta's last octet):

With this you can now write Marta's full address in binary:

Practice tip: learn by heart the values that show up in networking again and again: 0, 128, 192, 224, 240, 248, 252, 254, 255. They are the possible octets of a mask (bits set to 1 "filling in from the left") and you will use them non-stop in lesson 05-02.

As we saw when discussing the routing table (module 2), an IP address is not a flat identifier like a MAC: it has structure. Its 32 bits are divided into two fields:

• Network portion: the bits on the left. They identify which network the machine is on. Every machine in the Valencia office shares the same network portion.
• Host portion: the remaining bits. They identify which specific machine within that network.

And who decides where the boundary sits? The subnet mask. The /24 we have been dragging along since module 2 means exactly that: "the first 24 bits are network, the remaining 8 are host". The address on its own does not say where the network ends: 192.168.10.21 could be host 21 of network 192.168.10 (with /24) or host 10.21 of network 192.168 (with /16). That is why an IP configuration always comes as a pair: address + mask.

The idea is analogous to a phone number: country code + national number. The prefix (network portion) tells the worldwide network where to route; the rest (host portion) identifies the final destination within that zone. For this lesson, this introduction is enough; all the mechanics of the mask (bitwise AND, network calculation, subnetting) belong to lesson 05-02.

In the original IPv4 design (the 1980s) there was no explicit mask: the network/host boundary was fixed by the first bits of the address itself. This is classful addressing:

(127 is missing from class A because it is reserved for loopback, as we will see shortly.)

The system was simple but wasted addresses on an industrial scale. A company with 300 machines did not fit in a class C (254 hosts), so it received an entire class B: 65,534 addresses to use 300. Thousands of assignments like that accelerated the exhaustion of the IPv4 space.

The solution, in 1993, was CIDR (Classless Inter-Domain Routing): abolish the classes and make the boundary explicit and flexible through the /n notation you already know. With CIDR, a /23, a /26 or a /29 are just as valid as a /24: the network is sized to fit what is needed. That is the world we work in today and the one we will develop in lesson 05-02.

The classes did, however, leave behind some fossil vocabulary: you will hear "a class C" as informal shorthand for "a /24", and you will see the RFC 1918 private ranges described as "one class A, 16 class Bs and 256 class Cs". Understand the historical reference, but always calculate with CIDR.

Not every address can be assigned to a machine. These will show up in your day-to-day work and you must identify them instantly:

A real operational example at Meridiano: Ana calls because "she has no Internet". She runs ipconfig and reads 169.254.113.7. Nothing more is needed: her machine asked for an IP over DHCP, nobody answered, and Windows self-assigned an APIPA address. The problem is not "the Internet": it is that she cannot reach the router/DHCP server at .10.1.

You may have noticed that the Valencia network (192.168.10.0/24) and the Bilbao one (192.168.20.0/24) start the same way as your home network, the café across the street, and millions of businesses. That is no coincidence: they are private addresses, defined in RFC 1918. Three blocks were reserved for free internal use:

Rules of the game:

• Anyone can use them inside their network without asking anyone's permission. That is why Meridiano freely chose 192.168.10.0/24 and 192.168.20.0/24.
• They are not unique in the world: your neighbor can use exactly the same ones. That is fine, because...
• Internet routers do not route them: a packet with a 192.168.x.x source or destination that reaches a carrier's router gets dropped. Private addresses only make sense inside an organization.

Which raises the obvious question: if Marta's PC has an address the Internet won't accept, how does Marta browse the web? The short answer is NAT: the Valencia router swaps the private address for its own public address on the way out. The full operational how and why, translation tables and consequences included, is lesson 05-03. For now, keep the distinction:

• Private address: RFC 1918, free, repeatable, valid only internally.
• Public address: unique across the entire Internet, formally assigned, the one that is "seen" from outside.

Quick identification trick: if an address starts with 10., with 192.168., or falls between 172.16. and 172.31., it is private. If it is 127.x it is loopback, and if it is 169.254.x it is APIPA. Everything else (except multicast and reserved ranges) is, in principle, public.

Public addresses are not chosen: they are assigned through a hierarchy:

• IANA administers the global space and delegates large blocks to the RIRs (Regional Internet Registries), one per region of the world. Spain falls under RIPE NCC.
• The RIRs assign blocks to carriers (ISPs) and to large organizations.
• The carrier assigns each customer their share. Meridiano, as a typical small business, receives a single public IP per site from its ISP (sometimes not even a fixed one). With NAT, that single address serves all 20 machines in Valencia.

A bit of context: IANA handed out its last free IPv4 block to the RIRs in 2011, and the RIRs ran through their reserves over the following years. Today public IPv4 addresses are rationed, leased and even bought on secondary markets. This exhaustion is the thread connecting the next two lessons: NAT as the patch (05-03) and IPv6 as the solution (05-04).

Let's close by applying everything. Marta runs ipconfig /all on her Valencia PC (on Linux it would be ip addr, which you already used in module 4). Abridged output:

A line-by-line reading with what you have learned:

• IPv4 Address 192.168.10.21: 32 bits, 11000000.10101000.00001010.00010101. Starts with 192.168. → private, RFC 1918: it will never be seen as-is on the Internet.
• Mask 255.255.255.0: in binary, 24 ones followed by 8 zeros → it is the /24. It marks 192.168.10 as the network portion and 21 as the host portion: Marta is machine 21 on the Valencia network.
• Wait: .21 assigned by DHCP when the dynamic range is .100–.199? Correct: Marta's PC has a DHCP reservation (the router always hands the same IP to her MAC 5C-26-0A-4B-91-D3), common practice for machines you want to locate reliably. The file server (.10.10) goes one step further: a static IP configured by hand.
• Default Gateway 192.168.10.1: the router's address, inside the same network (it shares the 192.168.10 portion). It is host 1, the typical convention for the gateway.
• Addresses Marta should not see there: 169.254.x.x (DHCP down), 127.0.0.1 (that is loopback, not a network address) or the addresses 192.168.10.0 / 192.168.10.255 (network and broadcast, not assignable).

And in Bilbao, Jon's PC would tell the same story with different numbers: 192.168.20.7, mask 255.255.255.0, gateway 192.168.20.1. Same structure, different network portion — exactly the reason a router (and the VPN) is needed for Marta and Jon to communicate.

• Treating the address as "four independent numbers". It is ONE 32-bit number; the decimal dotting is just notation. Many subnetting errors are born from working octet by octet without thinking in bits.
• Writing impossible octets (256, 300, −1). Each octet runs from 0 to 255. If a calculation gives you 256, you slipped up in a subtraction or a carry.
• Believing the address alone defines the network. Without a mask, 192.168.10.21 is ambiguous. Always ask for the pair: address + mask.
• Ignoring a 169.254.x.x. It is not "some weird IP": it is the system shouting that DHCP did not respond. Immediate diagnosis: connectivity to the DHCP server.
• Assigning the network address or the broadcast to a machine. .0 and .255 in a /24 are not valid hosts. (With other masks the values change: you will see it in 05-02.)
• Thinking in classes when calculating. Classes are history and vocabulary; modern calculations are CIDR. "It's a 192.168, so class C, so /24" is false reasoning in the CIDR world: a 192.168.10.x can perfectly well carry a /26.
• Tip: practice binary conversions 5 minutes a day for a week. Fluency with 128-64-32-16-8-4-2-1 is the difference between suffering through subnetting and doing it in your head.

Convert to binary, using the successive-subtraction method and showing every step, the four octets of the Meridiano file server's address: 192.168.10.10.

A colleague dictates an address to you in binary: 10101100.00010000.00100000.11001000. a) Convert it to dotted decimal by adding weights. b) Is it public or private? Justify it with the RFC 1918 table.

Three Meridiano machines show these configurations. For each one, state whether it is a normal configuration or the symptom of a problem, and which problem:

• Ana's PC: IPv4 169.254.203.44, mask 255.255.0.0, no default gateway.
• Valencia printer: IPv4 192.168.10.255, mask 255.255.255.0.
• Jon's PC: IPv4 192.168.20.7, mask 255.255.255.0, gateway 192.168.20.1.

Solution 1

Octet 1, 192:

Octet 2, 168:

Octets 3 and 4, 10 (identical to each other):

Result: 192.168.10.10 = 11000000.10101000.00001010.00001010.

Solution 2

a) Sum of weights per octet:

Address: 172.16.32.200.

b) The middle private block of RFC 1918 is 172.16.0.0/12, which spans from 172.16.0.0 to 172.31.255.255. Since 172.16.32.200 has 172 as its first octet and 16 as its second (within the 16–31 range), it is private. It would not be routable on the Internet.

Solution 3

• Ana's PC: 169.254.x.x is APIPA. Her machine asked for an address over DHCP and nobody answered, so it self-assigned a link-local one. With no gateway, it cannot leave its segment. Problem to investigate: reachability of the DHCP server (router 192.168.10.1): cable, switch port, VLAN or the DHCP service itself.
• Printer: 192.168.10.255 with a /24 mask is the broadcast address of the Valencia network, which is not assignable to any machine. It is a botched manual configuration (or software displaying the broadcast where it shouldn't). It needs a valid host address (an unused one between .1 and .254, ideally reserved outside the DHCP range .100–.199).
• Jon's PC: normal configuration for the Bilbao branch: a valid private host address in 192.168.20.0/24, with the gateway at the .20.1 router, inside its own network.

You now know what an IPv4 address really is: a 32-bit number in four octets, convertible between decimal and binary with the 128-64-32-16-8-4-2-1 weight table; divided into a network portion and a host portion by a mask; with special addresses (network, broadcast, loopback, APIPA, 0.0.0.0) you must recognize at a glance; and split into two worlds, the private RFC 1918 one Meridiano uses and the public one rationed by the IANA → RIR → ISP hierarchy. You also know that classes A/B/C died and CIDR replaced them with the flexible /n notation.

But we have left the central piece barely introduced: the mask. How exactly does a machine calculate its network address? How many hosts fit in a /26? How would you carve up 192.168.10.0/24 to separate the corporate VLAN, the guest VLAN and the servers? That — the AND operation, the 5-step method and subnetting with all its arithmetic — is the next lesson: Subnet Masks and Subnetting.