In the last two articles, we talked about IPv4 basics (Part IV) (Part V). We introduced the concept of folding a sheet of paper to understand subnetting. Each fold of the paper is a bit borrowed from the host address field. We illustrated net IP, valid IP addresses and Local Broadcast Address (LBA). The net IP and the Local Broadcast Address cannot be assigned to nodes. These are like cookies, and the valid IP addresses are like the filling.

I do not know why, but in business settings, some folks frown on assigning Class C address space. Just mentioning it in case you encounter it. I’m sure the bits don’t care.

Let’s assume you have been asked to create 500 subnets in a Class B network space. You go to your notes and look up the Class B addresses available for private use. You write down that you can use the range from 172.16.0.0 to 172.31.255.255 (Table 7). You also write down that the default subnet mask is 255.255.0.0. And just to jog your memory, you write down that the network you are using is then 172.16.0.0/16, because /16 is the CIDR notation for the default Class B subnet mask.

Next, you start mentally folding the paper that is the 172.16.0.0/16 network. You need 500 subnets. To get there, you fold once, making two subnets. Fold again to get 4. Fold a third time and you have 8. Fold a fourth time to get 16. A fifth fold gets you 32, and a sixth gets you 64. A seventh fold means you have 128 subnets. An eighth fold gives you 256. And finally, a ninth fold gets you to 512, enough to cover the 500 subnets your boss asked for.

We folded the paper nine times. Therefore, we need to borrow nine bits from the host address space to create the 500 subnets. In binary, the subnet mask you started with was 11111111.11111111.00000000.00000000.

We need to borrow nine bits in the host space. This means changing nine zeros in the subnet mask to ones, giving us 11111111.11111111.11111111.10000000.

This makes the fourth octet the critical octet, because it is where the transition between network and host address space occurs.

Of course, we want to write this in decimal, since we are human and frankly, it is simpler to remember. The new subnet mask is 255.255.255.128, because the first bit in the fourth octet has a decimal weight of 128.

Next, we need to know the increment for our subnetting exercise. We look again at Table 11 and discover that for a subnet mask value of 128, the decimal weight is 128, so the increment is 128.

The first address in the network is 172.16.0.0. We write that down as the first net IP. We then write down 172.16.0.128 as the second net IP, because 128 is the increment. The Local Broadcast Address for the first subnet is then one less than the second net IP, or 172.16.0.127. We write that down in the first space for the LBA. The valid IP addresses for this first subnet start at one greater than the net IP and end at one less than the LBA for the subnet. We write down the range of valid IP addresses, the filling for the cookies, as 172.16.0.1–126.

The next step is to write down the net IPs for the remaining subnets, then the Local Broadcast Addresses for each subnet. Of course, there is a pattern to this because of the increment. After the net IP of 172.16.0.128, we add 128 to the address. To wit, 128 plus 128 is 256. Since 172.16.0.256 is not a valid address, we change the 256 to 0 and increment the octet to its left. This gives us 172.16.1.0 for the next net IP. We can fill in the rest of the net IPs by following the same pattern with alternating 0 and 128 in the fourth octet, and incrementing the third octet.

The LBA for the second subnet must be one less than the third net IP. Subtracting 1 from 172.16.1.0 leaves 172.16.0.255. With the pattern established, the rest can be filled in easily.

In the interest of space, I will not show all 500 subnets, since you can see the pattern.

In the next article, we’ll take up subnetting for hosts per subnet.

Tom Norman, CPBE is project engineer for Diversified.

[Want more information like this? Subscribe to our newsletter and get it delivered right to your inbox.]

The last edition of this column talked about subnets and introduced folding paper as an illustration of how subnets can be understood. This will be very useful as we proceed. 

MORE IPv4 SUBNETTING BASICS

Consider an analog clock. Start the second hand at 12:00 and follow it clockwise around the dial. At 12:00, 60 seconds have passed. Zero seconds and 60 seconds are the same place on the dial. When the second hand gets to 60, the minute hand has moved one minute. Since we keep track of time in minutes and seconds, we usually think of seconds from zero to 59, then at 60 seconds we re-set our seconds count to zero and add a minute. It’s like counting from nine to 10, where we increment the tens column when we pass nine. 

It’s like that looking at IP and subnet octets. We can go from zero to 255 in each octet, but 256 means the octet is filled. We don’t have room for 256, because 255 is the limit, i.e. all binary bits are set to 1. When we hit 256, the octet changes to zero and we increment the octet to the left by one. 

At home, your computer might have an IP address like 192.168.1.10. For this address, your subnet mask is probably 255.255.255.0. You decide you want two networks. Doing the mental math, you say “Two networks from one means one fold of the paper.” Each fold of the paper is a bit borrowed from the host address field. Here, you borrow one bit. That means you need to change your subnet mask. Here’s how that works: 

You started off with 255.255.255.0. In binary, that’s all ones in the first three octets. To borrow, you need the first bit in the fourth octet. Here’s how it works: 

11111111.11111111.11111111.00000000 is 255.255.255.0. This is where you start. You borrow the first bit in the fourth octet. The new subnet mask is 11111111.11111111.11111111.10000000. 

Borrowing Table 9 from an earlier article and revising it to show the borrowing, here’s the new fourth octet:

The first bit in the fourth octet has a decimal weight of 128, so the final octet of the new subnet mask changes to 128 in decimal notation. The new subnet mask is 255.255.255.128. The way the computer sees it, this is 11111111.1111111.1111111.10000000. Since the fourth octet is where the edge of the subnet is defined, it is the critical octet here. 

Hint: It is valuable to know the correlation of decimal weights (DW) of eight bit binary numbers with subnet masks (SM) values. To do this, let’s look at another table.

This is a good table to memorize, or to be able to regenerate at will. The SM row shows the succession of subnet mask numbers as each bit is turned on. In subnetting, we’ll be using this table a lot.

Now that we have two subnets, we have to know where each subnet starts and ends. The increment dividing one subnet from the other is the Decimal Weight from Table 11 associated with the subnet mask. In this case, note that with the subnet mask (SM) being 128, the Decimal Weight (DW) is also 128. This is also the increment between the subnets. 

We know the first address in the first subnet is 192.168.1.0. This is the network IP for the first subnet. Let’s write that down as the first “Net IP.” Adding the increment, we get 192.168.1.128, the starting address of the second subnet. Next, we need the “Local Broadcast Address” for the 192.168.1.0 network. The largest number we can use without stepping on the 192.168.1.128 space is 192.168.1.127. This is the Local Broadcast Address, or LBA. For the 192.168.1.128 network, the LBA will be the largest number we can use without stepping outside the original network space. We’ll write down 192.168.1.255, meaning all bits in the fourth octet are full. 

Now, we can do the math to find the available addresses in each subnet. These range from one higher than the Net IP to one less than the LBA, so we write them down in the middle column. Think of the Net IP and the LBA as the cookies and the Valid IP Addresses as the filling.

The valid IP addresses may be assigned to nodes in the network.

The last editionof this column discussed subnet masks and the nature of IP addressing. In this and the following column, we will begin discussing what subnetting means and how to do it. First, though, we need to discuss some other basic stuff.

SUBNET

A network may be sub-divided into smaller units called “subnets.” As we will discuss, a subnet may be sub-divided into smaller subnets. There are specific rules for how to create subnets. 

NETWORKS, GATEWAYS & BROADCASTS

Each network and each subnet must have a network address and a broadcast address. These are always the smallest address in a network and the largest address in a network, respectively. Consider an array of IP addresses of 192.168.1.0 through 192.168.1.255, using the subnet mask 255.255.255.0. With the smallest address in the array being 192.168.1.0, this is the network address. The largest address in the array is 192.168.1.255, this is the broadcast address. The network address and the broadcast address may not be assigned to Hosts. Therefore, for any subnet, the number of available host addresses is equal to the number of addresses in the subnet, minus two. Gateways must be assigned among the remaining available addresses. It is common, but not required, for gateways to occupy the address adjacent to the network address. In this example, that would be 192.168.1.1. 

WHAT IS A DEFAULT GATEWAY? 

Imagine you are living in a large apartment building with several floors and many apartments on each floor. Apartments on the first floor might have numbers beginning with one, apartments on the second floor may have numbers beginning with two, and so on. Regardless, the apartment building has a street address that all the apartments share. For mail to get to your apartment, it first has to come to the street address; in an IP sense, the street address is the “gateway” to your apartment. A message from another apartment in the building can get to you without going outdoors. For a message from outside your building to get to you, it has to come through the building’s door. This is a bit like how a “default gateway” works—it’s the passageway in and out of your subnet. 

So let’s say the IP address of your computer is 10.24.24.120, with a subnet mask of 255.255.255.0. This means the first three octets of the IP address are the network. Your PC can only talk directly with other PCs in its network, so the default gateway needs to be in that network. Maybe the network admin has set it to be 10.24.24.1. This means that when you talk to computers outside your network, you are sending your communications first to 10.24.24.1, which then forwards them. 

IPv4 SUBNETTING BASICS

Before talking IPv4 subnetting, let me mention that there are two IP addressing schemes. IPv4 uses the dotted decimal notations we have been talking about, while IPv6 uses an entirely different system with enough address space (so I have heard) to count all the stars in the known universe with room left over. In these articles, we are talking only of IPv4. It is also worth mentioning that IPv6 will become more and more a part of everything as time goes by, because the public address space in IPv4 has been used up entirely. However, the private IPv4 address space is virtually infinite because these addresses cannot be used on the public internet. Therefore, they can be re-used over and over in any number of locations. 

Subnetting gives you the power to create (sub) network spaces. I like to use the analogy of a sheet of paper. Think of the surface of a sheet of paper as the addresses in a network. If you fold it in half, then unfold it, there will be a crease dividing the paper into two smaller parts. Now you have two sub-networks, with the original number of available addresses split between them. Take another sheet of paper and fold it twice. When you unfold it, you will have two creases that divide the paper’s surface into four parts. If you had made a third fold, you would have eight parts, and so on. Each fold doubles the number of parts, with the individual parts becoming smaller with each fold. If the paper is the network, each part is a subnet. Each fold reduces the number of addresses available for each subnet, but doubles the number of subnets. 

Suppose you have a request for seven subnets. If you fold the paper once, you have two subnets. If you fold twice, you have four. If you fold a third time, you have eight. Thus, three folds give you seven subnets with one left over. 

Next article, we’ll get a bit more into the meat of IPv4 basics. 

Tom Norman, CPBE is project engineer for Diversified.

For more background, read Parts I, II & III

For more background, read Parts I and II.

COLLISIONS AND BROADCASTS

If computers in an open network talk freely with one another and two computers start talking at the same time, you have a “data collision.” Collisions may be arbitrated via Carrier Sense Multiple Access/Collision Detection (CSMA/CD), which tells the computers on the network to stop talking and try again at random, usually avoiding a successive collision. With Ethernet switches, these collision domains are broken up because switches provide dedicated paths between hosts. Thus, other computers don’t see that traffic. An Ethernet switch breaks up collision domains. 

Nevertheless, each computer needs to announce itself to the network from time to time. It does this by broadcasting to all computers in the network. Ethernet switches do not block broadcasts. However, routers will not pass broadcasts from local hosts. Routers break up broadcast domains.

SUBNET MASKS

The subnet mask identifies which bits in an IP address belong to the network and which belong to the host. A subnet mask consists of a contiguous series of ones (1) followed by a contiguous series of zeros (0). It contains exactly 32 bits, broken up into four successive groups of eight bits (octets), in dotted decimal notation. It defines the network portion (designated by the contiguous string of ones), and the host portion (designated by the contiguous string of zeros) of the IP address. The default subnet masks for Class A, B and C IP addresses are: 

Table 8

Click on the Image to Enlarge

Examining an IP address of 192.168.2.10 with the default Class C subnet mask applied, the network address is 192.168.2, and the host address is 10. Let’s discuss how this works: 

Consider the IP address 192.168.2.10 and a Class C Subnet masks. Looking at one above the other, we get:

IP Address 11000000.10101000.00000010.00001010

Subnet Mask 11111111.11111111.11111111.00000000

The result is 11000000.10101000.00000010.00000000

This is the network address portion of the IP address. A subnet mask separates the network and host portions of an IP address.

CLASSFUL ADDRESSING

Before 1993, subnet masks were not used. The address class determined the size of the network and the subnet mask was implied but not used. The classes of addresses allowed for some networks to have a great many hosts, while others were smaller. This is called “classful addressing.” Though it still exists, you may never have to deal with classful addressing. Classful addressing means the subnet is fixed by the address class and cannot be altered.

CLASSLESS ADDRESSING

In 1993, Classless Inter-Domain Routing (CIDR) was introduced. IP address classes are ignored by assigning subnet masks. You might use Class A address space (10.x.x.x) and use the Class C subnet mask (255.255.255.0) to manage those addresses. This could create multiple networks in the Class A space, each with a limit of 255 addresses. Or suppose your IT department assigned you address space of 10.34.134.0/23. The /23 is an example of CIDR notation. The /23 says the subnet mask has 23 contiguous ones (1). That means the 23 contiguous ones (network) are followed by nine contiguous zeros (host). So what does this mean? First, let’s see what the subnet mask looks like in binary: 

11111111.11111111.11111110.00000000 shows a string of 23 ones. The first two octets each are 255. The third octet’s last bit is zero (0), so is value is 255 – 1 = 254. The subnet mask is 255.255.254.0. 

The third octet of the IP address is 134. We can figure out what this is in binary using a table: 

Table 9

First, we ask if 134 is bigger than 128. It is, so we set a 1 beneath the 128. 

Next, we subtract 128 from 134. The result is 6. The next number to the right not larger than 6 is 4. We set a 1 beneath the 4. 

Now, subtract that 4 from the 6 we had before, and we get 2. The next number to the right that is not larger than 2 is (surprise) 2. We set a 1 beneath the 2, and we have identified the binary ones (1) for the octet value 134. Set the remaining bits to zero (0) and we’re mapped to binary. 10000110 = 134. 

In this example, the subnet mask uses the first seven digits of the octet. The last digit is part of the host address space. With 9 bits available for the host address space, you have 512 host addresses including the network and broadcast addresses (more on this later). Your total address space includes the addresses from 10.34.134.0 through 10.34.135.255. 

Tom Norman, CPBE, is Project Engineer for Diversified.

Broadcast and video production systems are moving rapidly into the IP realm. Therefore, understanding IP basics is now part of the engineer’s toolkit. To understand how IP works, we need to start with some background material. 

OSI REFERENCE MODEL AND TCP/IP SUITE

The OSI Reference Model was developed as a framework for moving data through a system, each layer interoperating with its adjacent layers while remaining agnostic to other layers. Its seven layers are listed below with information about their functions.

The TCP/IP Suite’s functional equivalents are shown in the far right column. Even though the TCP/IP Suite is more commonly used in practice, when you hear someone talking about Layer 2, Layer 3, etc., they are talking about the OSI Model.

To remember the layers from the bottom up, remember Please Do Not Throw Sausage Pizza Away. Top down, remember Angry People Seem To Never Dance Properly, necessarily incorporating the split infinitive.

BINARY NUMBERS

Computers think in binary. To understand IP addressing and subnetting, you need to understand binary. For IPv4 addressing, we use 8 bit binary numbers. 

We all understand how to count to nine. After nine, we need another digit. We call this decimal, or the base 10 numbering system. If we raise 10 to a power, zeros following the one are equal in number to the power. Consider 102 = 100, or 103 = 1000. Any number to the zero power is equal to one. 

Making a table, we see:

In binary, there are two possible values for any digit, zero (0) or one (1). When we count in binary, we want to translate to decimal because we think in decimal. To make this work, we give a Decimal Weight (DW) to each digit in a binary number. 

The weight of each binary bit is twice the value of its neighbor to the right. This is based on the number two raised to the power of one less than the decimal weight’s position, going from right to left. In Table 3 below, DW is Decimal Weight and DWP is Decimal Weight Position.

To calculate the decimal value of a binary number, you just add up the decimal weights of the bits whose values are one. Here are some examples.

If the binary value is one, we add the DW to the total value. Example 1 is 64 + 32 + 16 + 8 + 4 + 2 = 126. 

Can you see there are 256 possible values in an 8-bit binary number? They range from 0 – 255. Since there’s no 256, we carry, incrementing the number to the left by one and setting the value 256 back to zero. Let’s increase the IP address 192.168.2.255 by one. After carrying, you get 192.168.3.0. In binary, using only the last two octets, we have: 

2.255 = 00000010.11111111, adding one results in

3.0 = 00000011.00000000

As you can see, there are exactly 10 kinds of people in the world. There are those who understand binary, and those who don’t.