# Subnetting – Folding the Paper

## Subnetting – Folding the Paper

My goal is to create folders. Now you might think this is a non-networker topic since folder creation might be better suited to a disk and file management venue. However, when I say I am creating folders, I am referring to you – the reader. I want **you** to become an expert folder…of networks. How does someone fold a network? Well follow along and by the time we are done, you will be well on your way to becoming a subnetting guru.

For this method to make sense, it is assumed that you have a prerequisite knowledge of IPv4 addressing, classes of addresses, and the use of subnet masks. It also is assumed that you understand the binary numbering system and how a decimal mask looks when converted to binary. If you are not there yet, you might want to brush up on that before continuing. Are you still here? Okay, let’s become folders!

I like to call this subnetting method ‘folding the paper.’ The cool thing about this way of doing subnetting (and there are many methods out there) is that there are no exceptions. This way works for Class A networks, Class B networks, and Class C networks. You won’t get started learning this and a few steps into the process are told that you should ‘always do it this way always, EXCEPT….’ It can be confusing to think I have learned how to do a task only to be told to ‘do it this way, unless bla bla bla.’ So let’s dispense with the bla bla bla and discuss what I think is the easiest way to learn subnetting if you’ve never done it before, and if you already know it, you might add this little tidbit to your networking knowledge repertoire.

How does it work? Imagine that you have a literal piece of paper in your hands. This one piece of paper represents one network. Class A, Class B, Class C – it does not matter, it is still just one network. The area of the piece of paper represents the available address space for that network. If you need two networks, just fold it in half. This is a straightforward idea that is just common sense. If there are two children and one piece of cake, you cut the cake into two pieces. We are doing the same thing here. Once you fold and crease the paper, unfold it to a flat piece of paper again. Now you have a line that divides the paper into two equal pieces. How many times did you have to fold it to get two pieces (or two networks, since our paper represents networks)? It took just one fold, right? Of course, the area of each piece of the paper, and the available address space of each newly created network, has become smaller, but there’s nothing confusing about that.

If we use, as an example, a common Class C network ID of 192.168.1.0 with a mask of 255.255.255.0, we see first off that this information represents just ONE network. A Class C network with the default Class C mask represents a network that has not been divided. The same is true if you are presented with a Class B network with the default Class B mask, or a Class A address with the default Class A mask – it is still just one network. There will come a time when you will be asked to subnet a subnet, or further divide a network that has already been divided before we got to it, but that time is not now.

Let us apply the folding concept to our given example. The subnet mask that was given is a /24 (slash 24), which means there are 24 ones, or 24 network bits in the mask before we did anything to it. It would look like this: 11111111.11111111.11111111.00000000 The zeros are the host bits in our network. The task in subnetting is to identify how many of the host bits we need to borrow to accomplish our stated objective. In this example, our goal is to take one Class C network and subnet it so that we have two subnets. We decided that it would take one single fold to accomplish this. Each time the network is folded, this means borrow a host bit and make it a network bit. Sound confusing? Let’s actually see what it looks like when we do it. The default mask noted previously, looks like this: 11111111.11111111.11111111.00000000. If one fold will accomplish our objective then we need to borrow one of those host bits, one of those zeros, and make it a network bit. The new mask looks like this:

11111111.11111111.11111111.1000000. Always borrow from the host bits starting from the left and working to the right. Now we need to know what our newly created mask looks like in decimal. I recommend making a quick chart, especially if you are practicing your subnetting to prepare for a Cisco certification exam.

The chart looks like this:

| 128 | 192| 224 | 240| 248| 252| 254| 255| <- Valid subnet mask values

| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 | <- Decimal weights of the columns

To create the chart, just list the powers of two on the bottom from right to left and then the values in decimal on top as you move from left to right. So you note that 128 on top is the value of the position below. The 192 is just the previous 128 plus the number below, the 64, so that 128 + 64 = 192. The 224 is the previous value of 192 plus the value of the number below, or 192 + 32 = 224. 240 = 224 + 16. Follow this pattern until you complete the chart. You may do this so often that you memorize these values. That is fine if you trust your memory under stress. I recommend the chart because if your nerves get frayed during the exam, it is easier to recreate something than to pull it from a malfunctioning memory. So if you know how to build the chart, you can do it even under pressure. Now that you have the chart, it also speeds up the process by allowing you to avoid unnecessary computations as you can just look at the chart and move on and thereby save precious seconds.

The eight bit positions in the chart are the 8 zeros in the original mask, and if we look to this chart after creating our new mask, we can determine the correct mask to use in our subnetted scenario. Since we have borrowed one host bit, the last octet of the mask is 1000000.

Let’s compare those values to our chart:

| 128 | 192| 224 | 240| 248| 252| 254| 255|

| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |

1 0 0 0 0 0 0 0

Since the values on top are the subnet mask values, and we have come over one bit position with our borrowing, the new mask value is 128. The new mask in its entirety is 255.255.255.128. Are we finished? Not yet, there are a few more things to do before we can say we have met the objectives. The next step is to identify the increment. The increment is just so we know where one network ends so we know where the next one begins. The same is true with our piece of cake that we cut earlier. Each child can see the edges of his cake. If one child places his fork in the other child’s cake…well I’ll say no more. But the same can happen in a networking scheme. If one network admin starts assigning addresses from another admin’s piece of the network cake, there will be repercussions, negative consequences, and a whole bunch of other bad things. So let’s avoid that by finding out where each network starts and ends, shall we?

Back to the idea of the increment. If you are looking at the chart, the easiest way to identify the increment is to look at the number under your newly created mask. In our example, the number under the 128 is also 128. This is the only one where the values are equal. Nevertheless, this means our networks are incrementing by steps of 128. But in which octet are the networks incrementing? Another way to ask this is this: In which octet are the network numbers changing? This octet is often referred to as the ‘interesting octet.’ My quick way to identify the interesting octet is to note the values of the subnet mask and see which octet has a value that is neither 255 nor 0. Which octet fits this description in our new mask? If the new mask is 255.255.255.128, clearly octet number four is the interesting one.

Let me digress for just a moment. You may hear other people telling you their way of doing subnetting, and that’s fine. Once you have decided which method is your favorite, when someone tries to tell you their way, you may want to put your fingers in your ears and start humming. I say this because if you try, especially in the beginning, to assimilate everyone’s method into your consciousness (Borg reference here) you may find yourself with a gooey mess that doesn’t work at all. Having said that, I will mention a couple of other ways to determine the network increment. They all work equally well so it is your choice. I figure if I mention several ways, you can then pick your favorite, always use it, and ignore the others. So here we go: Way number one is as noted earlier, find your new mask on the chart and look at the number below. A reader keen on detail will notice what is happening behind the scenes. Take another look at the chart. What is 128 plus 128? It is 256. How about 192 + 64? Also 256. 224 + 32? Wow, 256. All the way across this turns out to be true. So you can use this knowledge to your advantage. If you look at our newly determined mask, the interesting octet of it was 128. Just subtract that from 256, so you get 256 – 128 = 128. There you have another way to determine the increment. Just subtract the mask value from 256. The next way I will mention is to focus once more on the interesting octet and look at its host bits. How many host bit are left in our new mask after we borrowed one? There are seven. If you raise the number two to that power, or 2 to the 7th power ( 2^{7}). the answer is, you guessed it, 128. So option 3 is to raise 2 to the power of the number of host bits in the interesting octet. All three of these ways work. I just mention them so you are aware of your choices. No you can pick your favorite and stick with it.

Now back to our problem. We have determined our increment and the interesting octet. Once I have gotten this far I like to do the next step IMMEDIATELY, no waiting so I lose track and start incrementing on the wrong octet. Rewrite your beginning network and then write the increment value under the interesting octet.

In our example, it would look like this:

192 .168 . 1. 0

.128

Once you have done this, you can relax and start filling in the rest of the information. Since the first three octets of the mask are all 255, we know the first three numbers in our network ID will not be changing since they already belong to the network.

So let me fill this in.

192 .168 . 1. 0

192 .168 . 1.128

Back in the beginning, we said our goal was to take one network and create two. How many networks are listed here? Exactly two. We have made our reality match our mathematical predictions. Feels good, doesn’t it? We can verify we are done listing by examining where we left off and trying to increment again. Our last subnet ID ended with 128. If I add 128 to that again, my answer is 256. That means the network is ‘full.’ We have used the entire available space with the scheme we have listed. If we let our minds wander back to the piece of paper that we folded once, we ended up with two networks separated by the crease. Once we assign those two network, we are ‘full,’ or out of network IDs. That’s okay, it just means the one network we started with is now two separate networks and both are fully assigned. There is nothing negative about that. Now let’s see the actual breakdown of the two networks. Typically you are asked to list the valid host IP address ranges and the local broadcast addresses for the created subnets. Let’s do that. If the second network starts at .128, we can ask ourselves where the previous one must end. The next number lower than 128 is 127. That is the broadcast address for the previous subnet. If the second subnet is full at 256 (a value we can’t actually place in an IPv4 field), then the broadcast address for the .128 subnet must be .255, which is just below 256. Let’s see how this looks as a list:

Subnet IDs Valid host IP address ranges Local broadcast addresses

192 .168 . 1. 0 192.168.1.1 – 192.168.1.126 192.168.1.127

192 .168 . 1.128 192.168.1.129-192.168.1.254 192.168.1.255

The first available host IP address is just one more than the subnet ID (1.0 is the subnet ID, so the first address is 1.1) and the last available host IP address is just the directed broadcast address minus one (1.127 minus one address is 1.126). Follow the same pattern for the remaining subnets, which in this case is just one more subnet. There will be occasions where you create far more than two subnets, and you usually want to list enough of them to see the pattern of repetition of numbers. Either that, or you will be told how many to list. A good mental picture is to imagine that the left edge (the subnet IDs) and the right edge (broadcast addresses) are the two edges to a cookie, and the host IP addresses are the creamy gooey filling. That means anything inside the creamy gooey middle is fair game to be used as a valid host IP address.

There you have it! You can become a folder yourself by following these steps. I actually like to put my hand in the air and count by powers of two using my raised fingers when subnetting. Each time I say a power of two, I raise a finger. When I am done, I know how many folds I need to meet my objectives. This means I know how many bits to borrow. Then I just follow the easy steps. I will post another blog where I show the use of this method for creating more than two networks, for subnetting other than a Class C network, and even how you can ‘fold the paper’ when you are asked to reserve a certain number of hosts per network. I will also discuss subnetting a subnet. But let’s save some for later.

To summarize, here are the steps:

**“FOLDING THE PAPER” SUBNETTING METHOD**

The ‘paper’ is your one network before subnetting.

1. Identify the class of IP address and the default mask

2. Determine the number of ‘folds’ needed to achieve the required number of subnets

3. Each fold doubles the number of networks, but reduces the available address space

4. The number of ‘folds’ equals the number of host bits you need to borrow

5. Determine the new mask by adding the number of borrowed bits to the given mask

6. Identify the ‘interesting octet,’ the one where the numbers will be incrementing

7. The decimal weight of the rightmost borrowed bit is the network increment

8. Use the increment to list the newly created subnets, valid ranges, and broadcast addresses

Enjoy!

Cisco Instructor – Interface Technical Training

Phoenix, AZ

#### You May Also Like

### A Simple Introduction to Cisco CML2

0 3640 0Mark Jacob, Cisco Instructor, presents an introduction to Cisco Modeling Labs 2.0 or CML2.0, an upgrade to Cisco’s VIRL Personal Edition. Mark demonstrates Terminal Emulator access to console, as well as console access from within the CML2.0 product. Hello, I’m Mark Jacob, a Cisco Instructor and Network Instructor at Interface Technical Training. I’ve been using … Continue reading A Simple Introduction to Cisco CML2

### Cable Testers and How to Use them in Network Environments

0 645 1This content is from our CompTIA Network + Video Certification Training Course. Start training today! In this video, CompTIA Network + instructor Rick Trader demonstrates how to use cable testers in network environments. Let’s look at some tools that we can use to test our different cables in our environment. Cable Testers Properly Wired Connectivity … Continue reading Cable Testers and How to Use them in Network Environments

### How to Build in a PSMethod to your PowerShell Code

0 65 0In this video, PowerShell instructor Jason Yoder shows how to add Methods (PSMethod) to your code using free software that’s added into the PSObject. For instructor-led PowerShell courses, see our course schedule. Microsoft Windows PowerShell Training Download the Building Methods PowerShell script</a> used in this video. <# ╔══════════════════════════════════════════════════════════════════════════════╗ ║ ║ ║ Building Methods ║ ╟──────────────────────────────────────────────────────────────────────────────╢ … Continue reading How to Build in a PSMethod to your PowerShell Code

Pingback: Cisco Supernetting - Subnetting for Networking Professionals subnetInterface Technical Training Blog

Pingback: Folding for Subnetting Professionals - subnetting a subnet and number of hosts per subnet | Interface Technical Training Blog

Pingback: Advanced ‘folding the paper’ subnetting concepts | Interface Technical Training Blog