I'd like you to imagine that you and I have shown up
for work one day, and our boss meets us
with a big smile on their face and says,
can you help me with a small project I'm working on?
And we say, sure, what do you need?
And our boss shows us this topology right here.
And they ask us, can you put this together?
We have a pilot program we're doing
and I want to just test them things.
Can you make that all happen?
And we say, sure.
We've got some extra gear so we round up some routers
and we connect them with switches.
And then we can go ahead and do the addressing.
Maybe over here on this network, that is common to our R3, R1,
and R2, we use the network 192.168.1.0/24.
Now if we analyze that, that means
that the first 24 bits of this number,
which is the first three octets, are the network.
And this last octet is available for host addressing.
And then for this network right here, between R2 and R4,
maybe we use the 192.168.2.0/24.
And for the network between R4, R5, and R6, right here,
maybe we use the network 192.168.3.0/24.
Now once we've implemented these IP addresses,
we go back to our boss all proud and say, hey, we're all done.
Take a look.
And he looks at it on paper and says, oh.
I forgot to tell you something.
And we say, oh, what's that?
And the boss says, this kind of needs
to fit into our existing network.
And if you could, says the boss, I need this entire topology
to fit in the space of 192.168.5.0/24.
I want to use that network to support this entire topology.
Now at that point, we have a couple of options.
One, we can say, this is only one network address.
We have three individual separate networks
that we need to deal with.
We have network A, network B, network C.
We could argue that we need more IP addressing space.
Or the other option, my friend, is
to go ahead and do custom subnetting.
The process of subnetting is simply taking an existing
network space, that we're given, and chopping it
up into smaller pieces.
Sort of like if we had Sunset Street, for example,
and we needed to break that up into smaller sections.
Maybe we could have like Sunset Boulevard,
Sunset Avenue, Sunset Lane, and we can break it up.
All we're doing when we're doing custom subnetting,
is we're taking one network address
space like the 192.168.5 network,
and we are going to chop it up into smaller pieces
so we can make additional, smaller networks.
Now unfortunately, there is a price
that's going to be paid if we take
a perfectly good network like 192.168.5 and we chop it up.
This network, which currently has 24 bits for the network
and an eighth bit over here for the host portion,
in order to do custom subnetting, what we have to do
is we're going to say goodbye to a few good host bits.
Those 8 host bits, which are over here,
we're going to have to sacrifice some of them.
Did I say have to?
And the answer is, yes.
We are going to voluntarily take some of the bits
over in this host portion from the network
that we're dealing with.
And we are going to allocate some of those bits
over towards network addressing.
And effectively, what it's going to do
is it's going to make more room for network address space.
And we can use that additional space, those additional bits,
to carve out additional subnets.
Let's use a practical example here.
Let's say we do have a 192.168.5.0/24 network.
And we have to use that major network to go ahead and create
additional space.
The very first question to ask us in this scenario
is, how many new networks, or new subnets, if you will,
do we need to create for our topology?
In this example, we need 1, 2, and 3.
Step number one, I'd like you to write this down with me,
is identify number of new subnets needed.
Because that is the very first step.
Identify the number of new subnets needed.
Once you've got that jotted down,
I'm next going to share with you how you can calculate
how many bits you need to take.
I'm talking about the stealing bits
from the valid host bits which are currently available.
And we're going to sacrifice them to network address space.
And that's done through something called the finger
game.
Now if you're wondering, Keith, what the heck is the finger
game, you're not going to have to wonder too
much longer, because we're going to play it together.
I'm going to do this literally with you.
So here's where I'd like to do.
I'd like you to look at your fingers,
and include your thumb in that discussion.
Look at your fingers.
And I'd like you to imagine that your fingers are bits.
So if you hold up all your digits
on your right hand or your left hand and you look at them,
how many digits are there?
How many bits are there?
And the answer for most people is going to be 5.
Unless you're like my shop teacher in high school,
but that's another story.
So let's go ahead and use the presumption
that most people are going to have 5 digits on their hand.
And for this game, each of those digits represents a bit.
Here's what I'd like you to do.
I'd like you to go ahead and act like Fonzie from Happy Days.
If you don't know who that is, I'll
go ahead and walk you through this.
You're going to make a fist with your right hand,
stick it out in front of you, and then stick
just your thumb up in the air.
With your thumb in the air, I'd like
you to look at the back of your thumb.
Look at your thumbnail.
I'd like you to imagine that somebody
took a black, permanent marker and they
wrote, right on your thumbnail, the number 2.
So look at it.
See it.
What kind of font did they use?
Is it clean?
Is it a sloppy written 2?
But see that 2 on the back of your thumb, and here's
what we're going to do.
If you only need 2 new subnetworks, all you need do
is take a single host bit from the current available host bits
to accomplish that.
The 2 is on your thumb.
Your thumb represents that one bit, and that's the formula.
Now in our case, we need more than just 2 subnets.
So here's what we're going to do.
With your thumbs still up in the air,
we're going to go ahead and bring up another digit,
like your pointer finger.
And when you bring that finger up,
I want you to double the 2 on your thumb.
So that goes to 4.
The number that you verbally said
is the number of subnets you can create.
If you look at the number of digits in the air, which
are now 2, that's how many bits it takes
to generate that many subnets.
Just for [INAUDIBLE] that meets our needs.
All we really need to do is take 2 bits
and that'll create 4 subnets, which meets our need of 3.
So let's do this.
Let's start from scratch.
And let's see how many subnets we could create if we
stole or took 5 host bits.
The game always starts like Fonzie.
You make a fist, you put your thumb in the air.
On the back of your thumb there's a 2.
The next thing we're going to do is bring up our pointer finger
and verbally double that number, to go to 4.
And bring up another finger.
So we have 3 digits in the air and double the number to 8.
Bring up another digit.
Double the number to 16.
Bring up another digit.
Now all 5 digits are up and double that number to 32.
And I want to remind you what the importance of this game
is, what the relevance is.
If you look at your fingers, you have 5 digits in the air.
That means if you take 5 bits away from the host addresses
and you allocate them for network addressing,
you can have 32 brand new subnets
by using the address space available in those 5
reallocated bits.
And this finger game that we can use
to calculate the number of bits or digits
on our fingers to use, to create a certain number of subnets,
is a very valuable skill that will come in very handy
for you.
In our case we only need 3 subnets
to support this topology right here.
Just as a review, let's do the thumb game once again.
And we want to make sure we're going
to identify how many bits it takes
to create up to 3 subnets.
So we play the finger game by making a fist,
we put our thumb in the air, there's a 2 on our thumb.
2 is not enough.
We bring up another digit, and we double that number to 4.
And that means, with 2 bits, represented
by the 2 digits that are up in our hand,
we can create up to 4 subnets.
That third step is to identify number of bits to sacrifice.
And I do say sacrifice, because they were available host bits.
And once we sacrificed them over for network addressing,
they will no longer be available for host bits.
So in our case, we are going to sacrifice 2 host
bits, because that allows us to have up to 4 subnets.
1 bit wasn't enough and 2 bits gives us up to 4 subnets,
which meets our need.
And the fourth step, and this is the most important,
is to go ahead and let every one know.
What do you mean, Keith, you have to let everyone know?
You see, if we're going to change the rules
and use 2 host bits for the network address,
we need to make sure that all the devices on the network
know about it.
What we're going to do is, we're going to modify the mask.
For this network, at the moment, the mask
is only claiming the first 3 octets, the first 24
bits of the IP address space.
But now, if we're going to use the additional first 2
bits of that last octet, we need to change the mask.
And that, my friend, is how we communicate
the details of using additional bits
for the purposes of networking.
We're simply going to move the mask that many bits
to the right, and they're still going to be contiguous.
Now it's going to be the first 24 bits here, plus the first 2
of this last octet.
The new mask is going to be 26.
Now out of our beautiful IP address space,
now we only have 6 host bits available
left for host addressing, which is restricting
us a little bit on that end.
But now we have more address space to play with,
so we can create up to 4 brand new subnets.
Your exercise right now is to write out these four steps.
And that is to identify the number of new subnets
that you need to create, use the finger game,
with the 2 on your thumb, with your fingers representing
bits and doubling the number every time
you bring up a new digit-- remember to start with the 2
on your thumb.
And then once you calculate how many fingers
are in the air that meets your requirements for the new number
of subnets, you identify that.
In our example, we only needed to take 2 bits.
And the fourth step is to modify the mask
to let everybody know about it.
And that's moving the mast to the right
by that quantity of bits.
Take a moment, make sure you have
those 4 steps written down.
And what I would like you to do is go ahead and pause me,
turn the paper over, and I'd like
you to go ahead and, from memory, repeat those steps.
If need to peek over the other side as a refresher,
that's perfectly fine in the beginning.
But I want to make sure that you, on your own,
know this exact process.
When you've written these out, and are comfortable that you
understand the process that you should go through,
go ahead and resume me.
And I will share with you one more technique
that's really important regarding
the moving of that mask, those 2 additional bits.
Now here's one of the challenges that's going to come up when we
move that mask from a /24, which it was, over to a /26,
is that how do we actually represent that in decimal?
Because when we work with IP addresses,
we're putting in data decimal.
So what does a /26 look like in data decimal?
Well, the first 24 bits are good for the mask, or 255.255.255.
Now, that's not new.
What is new is, how do we represent the first 2
bits of that last octet, these guys
right here, for the mask that they are on?
And the answer is, we're going to go back to binary for that.
This bit on and this bit on.
So that's bit 25 and bit 26.
And all these bits in the mask are now off.
What would that be in decimal?
Because that's how we're going to have to input it
to the device we're working on, whether it's
a router or a computer.
And to figure this out, we already
know how to do the conversion from binary to decimal.
We simply add the values.
We add 128 and 64, and that's a whopping total of 192.
So for the mask in the last octet, we would put 192.
And what that tells the router or the computer that
you're on is that, hey, we're using a /26 bit mask.
The first 3 octets are all taken for network addressing,
and the first two bits of that last octet
are also taken for network addressing.
Now I can hear it already.
Some of you might be saying, oh, I
don't want to have to convert from binary into decimal
every single time I put some type
of a custom or non-default mask on an IP address.
And I'm totally with you.
And that's why what I would recommend you do
is create this mask values table, as well.
Right when you sit down to start working with IP version
4 subnetting, you should definitely write out this table
right here, which is the weights of the various positions
for one byte of data.
And you should also jot down the mask values
for each of those positions.
For example, if we had a bit on in this position
by itself and nothing else, that would be a value of 128.
If we take 128 plus 64, that'd be 2 bits on,
it'd be a total of 192.
If we had the first 3 bits on, for example,
it'd be 128 plus 64 plus 32, which is 224.
And plus 16 more would be 240.
And plus 8 more be 248.
Plus 4 more be 252.
At some point, if you work with IP version 4 a lot,
you're going to have these values up here absolutely
memorized.
But until then what you could do is this.
Simply write out this table.
Write the weights first, and then
simply write the mask values.
The mask values are going to be 128, plus 64, plus 32, plus 16,
and that's that top row right here.
If we had a situation where we needed
to use 5 bits for custom subnetting,
because we had a requirement for 32 sub networks,
and we needed to take 5 additional bits,
it would look like this in binary.
We take that one, that one, that one, that one, and that one.
We would leave these last 3 bits for host addressing.
The dividing line would be right here and our mask value be 248.
And if we needed to, you could manually calculate that.
128 plus 64 plus 32 plus 16 plus 8.
But having this table here is very, very handy.
Here are the 2 things that I want you
to take away from this video.
Number 1, I want you to be comfortable with the idea
that we are stealing, we are taking away,
available host bits and sacrificing them
for the purpose of creating additional networks.
The other thing I want to make sure you're comfortable with
is quantity.
How many bits do we need to take in order
to create a certain number of subnets?
And that's all about using the finger game.
I hope this has been informative for you,
and I'd like to thank you for viewing.