IPv4 Subnetting

0:01Hello.

0:02My name is Keith Barker.

0:03And on behalf of the entire CBT Nuggets family, I'd like

0:06to welcome you to this course on IPv4 for subnetting.

0:10Let's begin.

0:11Let's start off by verifying that you and I are in exactly

0:15the right place at the right time by answering this

0:17question together.

0:18Who was this course created for?

0:20And in a word, it was created for you.

0:22For example, if you are working with any of these

0:25vendors right here, Cisco, Juniper, HP, PaloAlto,

0:28CheckPoint, or any other major player with networking gear,

0:31it is very likely that you're going to be working and

0:34dealing with IP addresses and subnets all of the time.

0:38A big challenge for people who are just coming into the world

0:41of networking and certification is that they get

0:43beat up, I mean big time beat up, by subnetting in those

0:47entry-level exams.

0:48Maybe up to 30% or 40% of an exam is surrounding IP

0:52addressing and subnetting of some type.

0:55So if you are a certification candidate, especially for the

0:58entry-level certification candidates, you absolutely

1:01want to make sure you take this course.

1:03If you're a network penetration tester, it's very

1:06important to understand subnets.

1:08For example, if you're a pen tester and you're doing an

1:10authorized scan of network devices, you may want to be

1:13familiar with how to calculate subnet ranges so you're

1:17setting your penetration testing on the right sections

1:20or summarizations of networks.

1:22And what I find a lot is there's end users who just

1:25want to know more about how IP addresses work in general.

1:29This is a perfect opportunity for you also to get that

1:32better understanding.

1:33Then one of my favorites that's near and dear to my

1:35heart is a manager who just wants to better understand

1:39what his technicians are talking about.

1:41So when the technician is talking about a slash 28 or a

1:44slash 25, the manager can have a really good understanding of

1:47what that technician is saying just by

1:49participating in this course.

1:51I also am going to add another one down here, and I'm going

1:53to put a line there.

1:54I'm going to get you fill in that one.

1:56It could be server administrators who are working

1:58with operating systems which are connected to networks,

2:01which are usually subnets.

2:03That would apply.

2:04And we could probably make several more.

2:05I'm going to ask you go ahead and in your mind fill in that

2:08last blank.

2:09Who also would benefit?

2:10And out of all of these items, it's very, very likely that

2:14you, my friend, are the prime candidate for this course.

2:18I am super excited to share the time with you.

2:20Let me give you a brief tour of what we're going to cover

2:22together in this course.

2:23We're going to start off with the basics of IPv4, the

2:26classes, the default masks, the private IP addresses.

2:29Taking a look at binary, because, after

2:31all is said and done--

2:32I'm going to share with you a boatload of shortcuts

2:34that you can use--

2:35we still absolutely deserve to understand what's really

2:38happening in binary behind the scenes, including the ability

2:42to convert on demand between decimal and binary and back.

2:46The importance of the mask, how we're stealing host bits

2:49to carve out custom subnets, identifying those subnets,

2:53identifying valid host ranges on each of those subnets.

2:56Making sure that you and I have enough host addressing

2:59space available on our new subnets for all the computers

3:02that need to be there.

3:03How do reverse engineer the process.

3:05For example, if we're given an IP address with a mask, how do

3:08we take that and then reverse engineer to determine very

3:11quickly what the actual subnet is that that customer is

3:15connected to?

3:16The process of summarization is also huge and very, very

3:19important, for example, with network statements or creating

3:22summary routes.

3:23We're going to using the techniques of summarization,

3:26so we're going to cover that in this course as well.

3:28And in a Cisco environment, wild card masks are also an

3:31important aspect of working with summarized or custom

3:35subnets, because they're needed inside of access lists

3:38and network statements if we're going to configure a

3:40Cisco IOS router correctly for custom subnetting.

3:44In non-octet boundaries, we'll take a look at how to start

3:46our custom subnetting somewhere in the middle, not

3:48on a clean octet boundary.

3:50And that's a really important precursor to doing the job of

3:53variable length subnet masking, where together we'll

3:56walk through, soup to dessert, the actual carving out of a

3:59variable length subnet masking plan.

4:01And at the end of that video, if you follow all these with

4:04me, you'll be able to do the exact same process.

4:07The cool thing is as we go through these videos together

4:10you'll be gaining these skills and improving your knowledge

4:13so that by the time we get to this last video called the

4:16final exam you'll have not only the knowledge of how to

4:19do something, you'll also have the measurable

4:21skills to do it.

4:22And that translates to taking those really awesome

4:24subnetting skills that you're going to gain and applying

4:27those to your networks that you deal with and manage on a

4:30daily basis.

4:31That's what gets me so excited about this course is because

4:33it's going to make a difference in your life as you

4:36work with IP subnets.

4:38Now I realize that we all come from different backgrounds and

4:41we're at different levels.

4:43So here's what I did for this course to optimize your time.

4:46I'd like you take all these videos in order, so video 1,

4:502, 3, 4, 5, all the way up to the very end.

4:54But here's the challenge.

4:55I know that some of you have some already pretty great

4:58subnetting skills.

4:59So if you're going through video 1 or 2, you may already

5:02have all the knowledge from that specific video.

5:05Here's what I did.

5:06In every single video, I've got an Opt Out

5:08section at the beginning.

5:10Here's how they work.

5:11At the beginning of each video, there's these Opt Out

5:14questions, and you simply read through them.

5:15If you know the correct answers to those questions,

5:18you can safely and comfortably skip that video.

5:22For example, if we take the Opt Out for video 2 and video

5:253, we look at video 4, and when we're looking at the

5:27questions we don't know the answers to them.

5:29We can then jump in right there and then continue our

5:32journey all the way to the end of the course.

5:35This is also very handy if you want to go back and review

5:38this course at some future time.

5:40By starting the video, looking at the Opt Out questions, you

5:43can very quickly assess whether or not you need to

5:45revisit the content in that video, or you can just go

5:48ahead and answer those questions and move forward.

5:50So we're taking absolute care to optimize your

5:53time in this course.

5:55Another question that I'd like you ask yourself is, how good

5:59do you want to be with IPv6 for subnetting?

6:02Perhaps you just want a casual understanding.

6:04So you can jump in the series, and then once we get up to

6:07variable length subnet masking and some advanced topics, you

6:11can go ahead and say, you know what?

6:11That's enough for me.

6:12I've had enough.

6:13But if you are the type of person who wants to be in the

6:16top 10% of people who understand how IP version 4

6:21subnetting works, I would strongly encourage you to take

6:24this course all the way from the beginning, go all the way

6:26to the end, and then review those pieces where you want to

6:29make sure you have those skills mastered.

6:32To that end, also in every single video I've embedded

6:35some expert exercises that I want you to do along with me.

6:39And as you participate with me in this course, that process

6:42of watch, learn, and conquer will become a reality as you

6:46master the skills of IPv4 subnetting.

6:50One of the reasons I'm so passionate and excited about

6:53this IPv4 something course is because this is the course I

6:57wish someone had created for me about two decades ago when

7:01I was first learning about IPv4.

7:04The great news is that this course is available to you.

7:07And I'm so excited about sharing this

7:09knowledge with you.

7:10Your action them right now is two basic things.

7:12Number one, I'd like you to grab a paper and something to

7:15write with.

7:16And then I'd like you to click Next to start the very next

7:19video as we begin with our basics of IP version 4.

7:23I am so excited about beginning this journey with

7:26you right now.

7:26I hope this has been informative for you, and I'd

7:29like to thank you for viewing.

0:01Putting the fun into IPv4 fundamentals.

0:04Let's begin.

0:06If you, like me, find that time is very, very valuable, I

0:09want to make sure I optimize both of our time together.

0:12What I would like you to do is I'd like you to pause the

0:15video and read through each of these four questions.

0:17If you can correctly answer and are comfortable with each

0:21of these questions, go ahead and skip this specific video,

0:24and I'll see you in the next video in this course.

0:27If on the other hand you find that you're not quite yet

0:30comfortable with one or more of these questions, have no

0:33fear, because you and I are going to address each one of

0:35these in this video.

0:37I'd like you to visualize in your mind's eye the home where

0:40you currently live, whether it's an apartment.

0:43Maybe it's a condo or a house.

0:44I'd like you to visualize what the roof looks like, what the

0:48front door looks like, and also I'd like you look at, in

0:51your mind's eye, the address on your house.

0:54So I'm going to draw this house, and let's say the

0:56address, just for example, is 123.

1:00Now I know the house number that you have might be

1:02slightly different.

1:03But one common thing that all homes have is

1:06they have an address.

1:08And not only do they have a house address, they also have

1:11a street address.

1:12For example, your neighbor over here at 125, and your

1:16neighbor over here at 121.

1:20They all have house addresses, and they're all connected to

1:23the same common street.

1:24So let's say this is Elm Street.

1:27And I've got a question for you.

1:29Why is it that we use street names and house addresses as

1:33part of an address?

1:35In fact, why do we have addresses at all?

1:37You may be saying, well, Keith, you

1:39have to have an address.

1:41For example, let's say that the mail carrier wants to

1:44deliver mail to this house.

1:45If the mail carrier didn't have any idea about streets

1:49and house numbers, these addresses if you will, we

1:52wouldn't have the ability to deliver or even get to a

1:55specific location.

1:57And that, my friend, is absolutely true.

2:00Addresses are very, very handy in the real world that we live

2:03in for both knowing where places are as well as the

2:06ability to deliver something like a piece of mail to that

2:10destination.

2:11Well, in computer networks we also have devices, and we call

2:14them lots of things on networks.

2:16We could call them, for example, a host or a node or a

2:20server or a PC or a network printer.

2:23But they're all devices that sit on networks.

2:26And they also have host identifiers, similar to a

2:30house number.

2:30For example, this may be 121.

2:33This may be device 123.

2:35Maybe this is device 125.

2:37And because they're all connected in this example to

2:40the same network, maybe this network is 1st Street.

2:45Now in computer networks we don't

2:46actually call it streets.

2:47We call them networks.

2:48So I could actually say, instead of 1st Street, we

2:51could call this network number 1.

2:55This device right here could be addressed, if you will,

2:58from a logical IP version 4 addressing system as being

3:02host number 121 on network number 1, just like this house

3:07is house number 121 on Elm Street.

3:10And what's the benefit of that?

3:12The cool thing is is that if we ever need to deliver

3:15packets, for example, to 121, this host at this host address

3:19on this network, because we have this logical IP

3:23addressing, which is very similar to street names and

3:26house numbers, we now have a method of identifying an

3:30individual host, an individual device on that network, so we

3:33can forward data, called packets, to that destination.

3:37So an answer to these first two questions, what exactly is

3:40an IP address?

3:41It's a logical addressing system that identifies

3:45networks that are common to devices and individual host

3:48addresses for each of those devices on that network.

3:52And why do we use them?

3:53The answer is simple.

3:54It is for the exact purpose of being able to send data to a

3:59specific device onto a network based on a Layer 3 IP address.

4:04Let's chat about what an IP version 4 address would look

4:07like if we were to see one.

4:09In the example our house and the street names, we had house

4:13number 121, Elm Street.

4:15That's pretty straightforward, because we're used to it.

4:17With IPv4 addresses, instead of using names for the

4:21streets, we actually use numbers.

4:23It would go something like this 11.23.14.95.

4:30These periods here are the

4:34separators between the numbers.

4:36So an IP version 4 address is four numbers, four decimal

4:39numbers separated by periods.

4:41And a lot of times people say, well,

4:43what's up with the periods?

4:44Why are they important?

4:45Well if--

4:46I'm saying i- we didn't use the periods, and we just had

4:49an IP address of like 11231495, that might be

4:55misinterpreted to mean, oh, it's 112 for the first number,

4:593 for the next number, 149 for the third number, and 5 for

5:03the last number.

5:04So the periods here are simply visual and representative

5:08separators between the four decimal numbers.

5:11Here's our first number, second number, third number,

5:14and fourth number.

5:15And the periods are separating them.

5:17So whenever we hear the term dotted decimal, all we're

5:20talking about is a format where we have four individual

5:23numbers separated by periods.

5:26Now one of the cool things is that everybody who's connected

5:29to a network is going to have an IP address of some type.

5:32The biggest IP version out there at the moment is IP

5:35version 4, and that's what this series and this

5:38course is all about.

5:39There's also IP version 6, which has been making inroads

5:43for many years.

5:44And if you want to learn more on that, go check out my IPv6

5:47series dedicated to that subject at CBT Nuggets.

5:51IPv4 is still going strong and is still the most popular IP

5:55version being used on the planet today.

5:58So how exactly do we find our IP version 4 address?

6:03The answer is really simple.

6:04If you're on any version of Windows, you simply run the

6:07command ipconfig just like that.

6:10And it's going to reveal to you your IP address.

6:12If you're on a Macintosh, you can use ifconfig, and that

6:16will show you your IP address.

6:18If you're on a Linux box, you can also do ifconfig, and that

6:21will show you your IP address.

6:23If you're on some type of a PDA, in the settings it'll

6:26also be able to show you what the current IP address is on

6:30your device.

6:31And for most of the computers that are connected to IP

6:34networks, that IP address assignment of how you actually

6:37got that IP address to use is done dynamically through a

6:41protocol called Dynamic Host Configuration Protocol so that

6:45you don't have to manually plug in an

6:47IP version 4 address.

6:49You are automatically assigned one.

6:51Here's what I'd like you to do.

6:52Whether you're on a Macintosh or a Linux or any flavor of

6:55Windows, I'd like you to right now identify what the IP

7:00address is that is running on your computer.

7:03Again, if you're on Windows you can do an ipconfig, like

7:05I'm doing right here in this demonstration.

7:07What this is showing me is that my IP version

7:104 address is 192--

7:12that's the first number--

7:13168--

7:14that's the second number--

7:151--

7:15that's the third number--

7:1615.

7:17And the little periods are simply separators between the

7:20numbers so we know where one number starts and the other

7:23number stops.

7:24And if you're on Macintosh or on Linux, you'd run ifconfig

7:29to get similar results regarding what your IP address

7:32currently is on your device.

7:34So here's what I want you to do.

7:35If you haven't already, go ahead and pause me and then

7:38run ipconfig or ifconfig on those other platforms just to

7:43validate what your IP version 4 address is.

7:46And I would like you to write that down on

7:48some type of paper.

7:50Once you've jotted that down, go ahead and give yourself a

7:53pat on the back.

7:54Great job.

7:55Because, my friend, it's small incremental steps that are

7:58going to give you the expert skills that you need as you

8:02master not just IP version 4 but also IP version 4 custom

8:06subnetting.

8:08The next thing that you and I absolutely deserve to chat

8:10about is dividing lines.

8:13What do you mean, Keith, dividing lines?

8:15Well, you know in a house and street there's the actual

8:17house number, like 123, and then there's a space, and then

8:21you have Elm Street?

8:23The mail carrier knows exactly what the house number is

8:26versus the actual street.

8:28Well, in an IP address like this one-- we'll use mine as

8:31an example--

8:32in this address--

8:33which appears as four numbers separated by three periods.

8:36That's the dotted decimal format--

8:38the reality is that a portion of this IP address is

8:41representing the actual street or network.

8:44And unlike Elm Street with house addresses, we put the

8:47actual network portion first.

8:50Then we have a dividing line, and then we have the actual

8:53host portion.

8:54So this would be like the street, and this would be like

8:58the house number.

9:00If this is your first exposure to how IP version 4 addresses

9:04work, you just got to get used to the idea that they're going

9:07to put the street name first, which is just a number, and

9:11then the house number after.

9:13Now here's the big question.

9:14We have two parts.

9:15We have a network portion and a host portion

9:18and a dividing line.

9:19The question is where is that dividing line?

9:22For example, is it between the 192 and 168?

9:26Is this all network and this is all host?

9:28Or is it in the middle between the first and second grouping?

9:32So is this all network and is this all host?

9:37Or is it right here between the third and fourth octet,

9:40which would make this all the network address,

9:42and this is the host?

9:44For example, if this was the case where the dividing line

9:47was, we could say that the network is 192.168.1, and the

9:52actual host, or house address if you will, is

9:5515 on network 192.168.1.

9:59So that's the two distinct and separate portions of an IP

10:03version 4 address is that there's a network portion,

10:06which is always going to be somewhere on the left, and

10:08there's going to be a host portion, which is always going

10:11to be somewhere on the right.

10:13Where one stops, the other begins.

10:15And now for the million-dollar question.

10:18What is it that identifies where that dividing line is?

10:22The answer is it is the mask.

10:25For example, if we took that same IP address of

10:28192.168.1.15, and I'm going to put the mask in green.

10:35If we put a mask like this and said these first three

10:38numbers, which are also referred to as octets--

10:42and we'll get into more of the binary in a separate

10:44discussion--

10:48if the mask is indicating that those are all network, meaning

10:53they are representing the network, what is implied,

10:57which is not explicit but it's implied, it's implying that

11:00the last number or the last octet here is

11:04available for host bits.

11:06So I want you to think of it like Hungry, Hungry Hippos.

11:09Whatever the mask devours--

11:10for example, in this case, the mask devoured the first,

11:13second, and third numbers--

11:15and because the mask didn't use or chomp up, if you will,

11:18or take the last number, the last number is available for

11:22host addressing or house numbers on our IP networks.

11:27Here's the deal.

11:28We are going to get into the details and the math a little

11:30bit of behind why that works.

11:32But for this video, I want you to understand that the mask's

11:36only function, the only function of the mask, is to

11:39identify where the dividing line is between the network,

11:43which is always on the left somewhere, and the host

11:46address, which is going to be on the right.

11:49Hey, let's do another example just to reinforce that.

11:51Let's say we have an address of 10.20.42.99.

11:57Now my question for you is, OK, where is the dividing line

12:01for this IP version 4 address?

12:04Is it between the 10 and the or the 20 and 42

12:07or the 42 and 99?

12:08What you should be saying and what I want you to say is,

12:11Keith, I don't know, because I don't know what the mask is.

12:16For any IP address, it's the mask's responsibility to

12:20explicitly say this portion of the IP address is the network.

12:25For example, if I told you that the mask was like this,

12:28and now if I asked you, OK, which portion of this IP

12:31address represents the actual network address, you'd say,

12:34ah, Keith, that's easy.

12:35That's the job of the mask.

12:37The mask indicated that the first two numbers are exactly

12:40the actual network address.

12:42And that implies that the last two numbers, which were not

12:45consumed by the greedy mask, are available as house

12:49addresses, or, in the case of an IP version 4

12:51network, host addresses.

12:54So the little computer that's sitting on the 10.20 network

12:58could have the host address of 42.99.

13:03And what we'd actually see on that computer itself would be

13:06an IP address that looks like this, 10.20.42.99.

13:12It's all put together in one consistent string, and it's up

13:16to the mask to identify where that dividing line is between

13:20the network portion and the host portion.

13:24I have had a blast.

13:25Here's the action items I'd love for you to do.

13:27I'd like you to revisit those Opt Out questions at the

13:30beginning of this video to make sure that you are now

13:33comfortable with each and every one of those.

13:35Secondly, any of the exercises that I've had

13:38you do in this video--

13:40for example, in this one we did a look at our IP address

13:42with ipconfig or ifconfig--

13:44if you haven't done that yet, please take a moment and make

13:47sure you do these small exercises.

13:49Inch by inch, life's a cinch.

13:51But big changes are often very difficult.

13:54My objective for you in this course is to

13:56make it very simple.

13:57And if you'll follow along with me step-by-step, we'll

14:00have you doing custom expert-level

14:02subnetting in no time.

14:04So speaking of time, thank you very much for the time you've

14:06invested in this video.

14:08I hope this has been informative for you, and I'd

14:11like to thank you for viewing.

0:00Default masks, classes and private addresses.

0:04Let's jump in.

0:05I know your time is precious, so here's the gig.

0:08If you know the answers to these questions and are

0:11comfortable with what the correct answers are and why

0:13they are, you can go ahead and skip this video.

0:15And you know what, you and I could have just as much fun in

0:18the very next video.

0:20On the other hand, if you aren't as comfortable as you

0:22want to be with any of these questions, have no fear, we're

0:25going to cover each and every one of them in this video.

0:28So pause me right now, read these questions.

0:30If you want to go through this content I am absolutely

0:33looking forward to it.

0:35When looking at IP version 4 addresses, there's three

0:38distinct groupings.

0:39They call them classes of addresses that we can work

0:42with for usable IP addresses for hosts.

0:45And they include class A, class B, or class C.

0:49So here's what I'd like you to do.

0:50I'd like you to jot down on a separate, physical piece of

0:52paper, I don't care if you use a pen or pencil, but what I've

0:55discovered is that writing things down gives one

0:58additional sense as far as learning it, and it will help

1:01you remember it.

1:02So the three classes of addresses are A, B, and C. Now

1:07the way you recognize a specific class address is we

1:10look at the very first number, before the first

1:13period right here.

1:14We look at the first number, and if it's in the range from

1:171 to 126 it is, da-da, it's a Class A address.

1:22If that very first number is within the range of 128

1:25through 191, it is a class B address.

1:29And for our third category, our third class, or class C,

1:32if the very first number is within the range of 192

1:36through 223 inclusively, that would mean that that IP

1:39address, regardless of what's following,

1:42is a classes C address.

1:44And the cool thing is we only have to look at the very first

1:47number, before that first period, to identify the class

1:51of IP version 4 address that it is.

1:53So here's what I'd like to do.

1:54I'd like to do a little exercise with you where you

1:56and I can identify, based on the first number in the IP

2:01version 4 address, whether or not it's a

2:03class A, B, or C address.

2:05And to do that, let's go ahead and use the command trace

2:07route, which on a Windows machine is t-r-a-c-e-r-t.

2:12We'll use the -d.

2:13That means I don't want to try to resolve every single router

2:16in the path to a host name.

2:18And then we'll put in the IP address of a Google DNS server

2:22at 8.8.8.8.

2:23And what I would like you to do, as well, is I would like

2:26you to do this same thing from your computer.

2:29And I just want to remind you that that -d on a Windows

2:31machine will save us a bunch of time, because it won't try

2:35to resolve the IP address we find in the path to a name.

2:38So let's go ahead and press Enter, and our first hop is my

2:42internal router at 192.168.1.1.

2:44And then we're going out to my service

2:46provider's network at 10.72.0.1.

2:50and then off to other internet routers at 24 et cetera.

2:53And it looks like the device at a hop number 12, whatever

2:56it is, doesn't like feeding back the information regarding

3:00our time to live expiring, which is the

3:02way trace route operates.

3:03So here's what I'd like to do.

3:05Let's go ahead and take this IP address right here,

3:07192.168.1.1, which happens to be my first router in the path

3:12between myself and 8.8.8.8.

3:15and my question for you is simple, is this address a

3:18class A, B, or C address?

3:22So take a moment.

3:23Think about it.

3:24Is it class A, B, or C address?

3:28Now you might be saying, oh, this is easy.

3:29I'm going to look at this chart over here, and you said,

3:31Keith, all I have to do is look at the very first number,

3:34which is 192.

3:35And 192 is in this range right here, which makes it a class

3:38C. You would be absolutely correct.

3:41Fantastic

3:42Let's do yet another one.

3:44How about this one right here.

3:46This is 68.105.30.181.

3:51What is that?

3:51Is in a class A, a class B, or a class C address?

3:56And again, if your saying, well, Keith, that's easy.

3:58I simply look at the very first octet only, the very

4:01first number in that IP version 4 address.

4:04It's 68.

4:05I find out which range it fits into, and boom, it's a class A

4:09address, because the number 68 is absolutely within that

4:13range of 1 through 126.

4:15Excellent, excellent work.

4:17And here's what I would like you to do right now.

4:19If you've done your own trace route, which I hope that you

4:22have, I'd like you to pick the fourth hop, whatever that is,

4:27the fourth hop in your own trace route.

4:29And using that fourth hop, whatever IP address that is,

4:32I'd like you to identify is that IP address that is your

4:36fourth hop, is it a class A, a class B, or class C.

4:40Now, if you're on a device that doesn't have the ability

4:42right now to successfully do a trace route, you can go ahead

4:46and use my fourth hop, which is 24.234.6.185.

4:51And once you've identified that as a class A, or B, or C

4:55address, again based on that first number before the first

4:58period, you can go ahead and resume the

5:00video and we'll proceed.

5:02Meanwhile, go ahead and pause me while you work out the

5:05class of that address.

5:07It is really important to do these expert exercises as I

5:11assign them in this course.

5:12And I want to take a moment to personally thank you for

5:14investing that time to do that exercise.

5:17The next thing that I'd like you to do right now, is on a

5:20piece of paper I would like you to write out

5:23this table of classes.

5:24And it goes class A is 1 through 126, class B is 128

5:29through 191, and class C is 192 through 223.

5:34What I want for you is the ability, on demand, to go

5:38ahead and write those three classes out.

5:40That way, if in any situation you need to remember what the

5:44class A or a class B, or a class C, the exercise that

5:47we're doing right now of having you write that out,

5:50will assist you in measurable terms in remembering that

5:53first octet and the ranges associated with each class.

5:57So take a moment, pause me, and write that out right now.

6:01So thank you for taking that next step into mastering IP

6:05addressing.

6:05That's fantastic.

6:06Now, one of the questions I get a lot is hey, Keith, I see

6:09this is 1 through 126.

6:11And I see the class B starts at 128.

6:14What happened to 127?

6:16Well, in measurable terms 127, an IP address that begins with

6:21that really does fit into the class A address space.

6:24However, the 127 dot anything is a reserved loopback

6:30special-purpose address.

6:31We can't assign that to an actual interface on, like, a

6:34computer or router or anything like that.

6:37It's set aside for special purposes.

6:39So we can actually use 127 in a production sense.

6:43The other question I seem to get a lot, and I want to talk

6:46with you about it right now, is why in the heck do we even

6:49care about if it's a class A, or a class B,

6:52or a class C address?

6:54And the reason we care is because there is a default

6:57mask, that identifier that tells us exactly how much of

7:02that IP address, going from left to right, how much of

7:05that IP address is the network address.

7:07And that's the primary reason why we care.

7:10So let's write out some IP address.

7:11Let's say we have 10.1.2.3.

7:14And let's say we take a class B address, the first octet,

7:17the first number being, let's say, 130.6.9.250.

7:24And let's take a class C. And let's take 200.100.4.5.

7:30So we have a class A, class B, and class C address.

7:33The biggest reason why it even matters at all is because the

7:38default mask, which is controlling which part of the

7:41IP address is the network and which part is left over for

7:44the actual host, for a class A, the default mask is the

7:48first number.

7:50With a class B, the default mask is the first two numbers.

7:54So first number, first two numbers.

7:57And for a class C, any guesses?

8:00And if you're saying, hey, Keith, I'll bet you it's the

8:02first three numbers of the class C, just because of the

8:05pattern, you would be absolutely right.

8:08And that my friends, is important to know with IP

8:11version 4 addresses.

8:13The default mask, which is associated with a class A,

8:16which is different than the default mask associated with a

8:18class B, and different also from a default mask associated

8:22with a class C address.

8:24So here's the expert exercise that I'd like

8:27you to do right now.

8:28On a piece of paper I'd like you to write out the

8:30following--

8:31that a class A address uses these first number as network.

8:37Which means that the mask is taking the first whole number

8:40as the network address, leaving the last three numbers

8:43for host addresses.

8:45A class B takes the first and second numbers

8:49as the network address.

8:52Which leaves the last two numbers for host addressing.

8:55And a class C address uses the first, second, and third

9:02number as the network address.

9:05Which leaves the last number for host addressing.

9:09So take a moment right now, pause me, and go ahead and

9:12write out the fact that class A has the first

9:14number as the network.

9:15Class B has the first and second number as the network.

9:18And that class C has the first, second, and third

9:21number as the network address.

9:23So let's go ahead and test what we've just

9:25learned and apply it.

9:26We're going to do another trace route.

9:28And we'll say don't bother doing the name resolution, and

9:31let's go out to 8.8.8.8 again, and we'll press Enter.

9:34And as that completes I'm going to do a Control-C, so it

9:37doesn't timeout on that last one.

9:39Here's what I'd like you to do.

9:40Let's go ahead and take number nine in this trace.

9:44So number nine says 72.14.238.2.

9:48Now that represents, on the public, routable internet,

9:52some IP address that's associated with a router on

9:55the internet.

9:55In fact, that router happens to be in the path between my

9:58computer and the destination of a 8.8.8.8.

10:02And what I'd like you to do is tell me with this address,

10:0572.14.238.2, I would like you to tell me, if we were using

10:11the default masks associated with class A, B, and C, which

10:16portion of this IP address right here would represent the

10:21actual network address.

10:23And which numbers on the right would represent the actual

10:26host addresses.

10:28So I'd like you take a moment right now, pause, and based on

10:31what we've talked about in this video, go ahead and

10:34answer that question.

10:35And then when you're ready unpause me, and we'll take a

10:38look at it together.

10:40So the way I would approach this, I would say first of

10:42all, which class of IP address is this?

10:45Is it class A, B, or C?

10:47The only thing we have to look at really for that is the very

10:50first number, which is 72.

10:5272 falls in the range of a Class A address, and based on

10:56that we also know that the default mask for a Class A

11:01address is taking only that first number.

11:04So this would be the network right here.

11:06And all of these numbers to the right, by default, would

11:10become the host addresses.

11:13So let's do it one more time.

11:15We'll choose a different IP address this time.

11:17Let's go ahead and choose this guy right here,

11:19216.239.48.167.

11:23So 216.239.48.167.

11:29My friends, if we were using the default masks for this

11:33address how much of this IP address would be the network,

11:37and how much of this address on the right would be the

11:39actual host address?

11:40Where would that dividing line be?

11:43So I can see the light bulb going on for a lot

11:45of you right now.

11:46You're saying, OK, Keith, I got this.

11:48This is 216, is the very first octet.

11:50216 falls in a class C address.

11:53And by default, for class C, it's the first three numbers

11:57are the network--

11:59so the network address is 216.239.48.

12:02and the leftover portion, which isn't consumed by the

12:05mask, is the host address.

12:08And if that's what you thought you are absolutely correct.

12:12For the default, you find out what class it is first, and

12:15then secondly, you apply the default properties for the

12:19mask for that address.

12:20In the case of a class C, the first three numbers are the

12:23network address, leaving the last number for host

12:26addressing.

12:27Another thing that I'd like to share with you right now about

12:29talking about this network 216.239.48, again, if we were

12:33using the default mask, is how would we write that out?

12:36And what you could do, is you could write out 216.239.48.0

12:44when we're talking about the network.

12:45Because we're describing just a network, we don't really

12:48care about host addresses.

12:49So everything to the right of the mask, if you will, you can

12:53go ahead and zero out when you're just talking about that

12:55street, or that specific network.

12:57So we could say that this router is living, if we're

13:01using the default mask for a class C address, that router

13:04is living on network 216.239.48.0.

13:08And his actual host address is 167 on that network.

13:13The next thing I'd like to chat with you about is

13:15terminology.

13:16sometimes we'll hear the term of network, or subnet.

13:21And really what that is, is a network is like a street on a

13:24computer network.

13:25And a subnet is like a subdivision of a street on

13:28that network.

13:29So very often when people talk about networks or subnets,

13:32from a lose perspective, we're really

13:34referring to the same animal.

13:35It's simply the street name for a

13:37given part of our network.

13:39So the last thing I'd like to chat with you about is private

13:43address space.

13:44Let's say, for example, we have the big

13:46cloud called the internet.

13:48And out there we have a server, DNS server or a group

13:51of servers, being represented as 8.8.8.8.

13:55Those are DNS servers from Google.

13:57Now if they were using a default mask, if they were

14:00easy default mask, which part of this IP address for their

14:03DNS, which part would be the network and which part would

14:07be the host?

14:08And if you're saying, oh, Keith, Keith, I got this now.

14:10It's a class A address, it fits in that range, and by

14:13default the first number is the network.

14:15And, again, if they were using that default mask, the last

14:18three numbers would be the actual host address.

14:20Fantastic.

14:21So how exactly does that relate to private address

14:24Space We'll let's say we have a little company called ACME

14:27Incorporated.

14:28And they've got several networks.

14:30So they have a little router.

14:33And they've got a network here, a network here, a

14:34network here, a network here.

14:36And they want to start using IP addressing.

14:38Well, what's preventing them from using the 8 network?

14:41Nothing.

14:42They could absolutely have this be an 8

14:43network right here.

14:45And they could have a PC on that network.

14:46And they could have full interconnectivity maybe to the

14:489 network and the 10 network and the

14:5011 network, no problem.

14:52And they can have full interconnectivity inside of

14:54their environment.

14:54Well, what happens if they try to connect to the internet?

14:57Well, normally, what's going to happen is we're going to

14:59have a router, so I'll label that as router, and that

15:02router's going to do something magical called Network Address

15:05Translation where it's going to swap

15:07out the source address.

15:08And these customers, as they go out to the internet, they

15:11can go ahead and appear as whatever globally assigned IP

15:14address the service provider is allowing

15:16that customer to use.

15:17So you might be asking OK, Keith, what's the problem?

15:20Well, I'd like you to consider this computer

15:22right here a PC1.

15:23If PC1 believes that it is connected to the 8 network,

15:27and it is trying to reach 8.8.8.8, which is a Google DNS

15:32server, this little PC is not going to try to use this

15:35default gateway.

15:36It's going to think, oh, I'm trying to get to 8.8.8.8.

15:40It's on the local network.

15:41It's going to start arping, trying to resolve that IP

15:44address to a layer 2 address.

15:45It's not going to have success.

15:47And what's wrong with this picture is that this PC will

15:50never get out to 8.8.8.8 if this PC believes that the 8

15:54network is local.

15:56So what is ACME Incorporated going to do?

15:58Well, what they can do, and what everybody can do is use

16:01what are called private address spaces.

16:04Inside of the class A, B, and C address ranges, they have

16:08set aside special IP addresses that we can use anywhere we

16:12want to, and we won't have to worry about colliding with

16:14somebody else's IP address space.

16:16For example, we won't use an 8 here, and there'll be a

16:19globally addressable 8 there.

16:21It won't happen if we use private address space.

16:23And so here's what I'd like to do, I would like you to write

16:26out on a piece of paper these ranges, which are the private

16:30IP address ranges, that are commonly used

16:32for IP version 4.

16:34In the class A range, anything this starts with 10.

16:38Boom, that first octet.

16:39If it's 10, that's the private address space that anybody can

16:42go ahead and use for their private networking.

16:45A class B, we have a range of 172, that's the first number,

16:49and then 16 through 31.

16:52The numbers after that don't matter.

16:53So, for example, on the 10 network these last three

16:57numbers could be anything.

16:58With a class B, 172.16 through 31, anything in that range.

17:02The last two numbers don't matter, it's

17:04still a private address.

17:05And then for a class C, we have 192.168.

17:09anything is also considered a private address space.

17:14And that's why, in our IPv4 fundamentals video that we

17:17went to together, when you did an ifconfig on Mac or Linux or

17:21an IP config and looked at your IP address, it is very

17:24likely that if you're a company or an internal

17:27network, it is very likely that you are using, on your

17:30computer, one of the IP addresses from the private IP

17:34address space.

17:35And, again, to get out to the internet, we'll simply use

17:38network address translation to translate one of our private

17:41addresses into a globally routable address.

17:43So the internet doesn't really no what our internal private

17:47addressing space is.

17:48They'll simply see the address that we translated to during

17:51the NAT process.

17:53So take a moment right now with this expert exercise,

17:56write out this private address space for class A, class B,

18:00and class C. And when you have this table written out, go

18:03ahead and click on Play.

18:06So here the action items I would love for you to do.

18:08If you haven't already done the exercises assigned in this

18:11video, go back through, and make sure that you do them.

18:14Remember, small and consistent steps are going to get us to

18:17that destination we want, which is mastering the idea of

18:20IP addresses, and specifically custom subnetting

18:23with IP version 4.

18:25The other thing I'd like you to do is go back and take a

18:27look at the questions at the beginning of this video, and a

18:31walk through them.

18:31And make sure that you're now comfortable with not only what

18:34the questions are, but the correct

18:36answers to those questions.

18:38I have had a blast.

18:39I'm so grateful for your time.

18:41I hope this is been informative for you.

18:43And I'd like to thank you for viewing.

0:01It's important to be familiar with the world of binary, and

0:04we're going to have some fun with that in this video.

0:07Let's jump in.

0:08To maximize your time, here is the opt-out

0:11questions for this video.

0:13Go ahead and take a moment, pause the screen, read those

0:15three questions.

0:16If you're comfortable with the answers to each of those, go

0:20ahead and skip this video.

0:21I'll see you in the next one.

0:22Otherwise, hold on to your seat because we

0:24are in for a ride.

0:26I'd like you imagine that you and I have walked into a

0:29showroom floor.

0:30It could be cars, or boats, or what have you, and on one of

0:33the items that we're looking at, it has a price tag, and it

0:35says this, 45,239.

0:39And I want to ask you, how much is that?

0:43And I'm not talking about euros, or dollars, or pounds,

0:46I'm talking about the actual number itself.

0:48Now, you might be saying, well Keith, this is really obvious.

0:51It's 45,239.

0:54That's the number, and how did you get that so quickly?

0:58And the reality is, is because we've been using base 10

1:03numbering system for all of our lives.

1:05It goes something like this.

1:07We have several positions here.

1:08For example, the 9 is in the ones position, and the 3 is in

1:12the tens position, and the 2 is in the

1:15one hundredths position.

1:16The five right here is in the one thousandths position, and

1:21the 4 is in the ten thousandths position.

1:25And all we're doing, because we use a base 10 numbering

1:28system, is the first number is always a 1, and then the next

1:32position is times 10 times and 10 times and 10

1:35times and times 10.

1:35In fact, we could go all the way down just continuing to

1:39multiply that placeholder by 10, by 10, by 10.

1:42And really it was four 10,000's.

1:46It was five 1,000's.

1:49It was two 100's.

1:50It was three 10's, and nine 1's.

1:57But this is so second nature to us, we didn't have to break

1:59it out like that.

2:00In fact, when we count, for example, our numbers go

2:03through 0 through 9, so we have 10 distinct numbers to

2:05play with, 0 through 9.

2:07And when we count, we do 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

2:12And what do we do next?

2:14Ah-oh.

2:14We're out of numbers.

2:15We simply carry the 1 into the next position,

2:18and we put a 0 here.

2:19So 1 0 in decimal represents one 10 and no 1's

2:24for a total of 10.

2:25And then we go to 11 and then 12.

2:27And then if we get all the way to, for example, 9 9 9 by

2:30continuing counting and we need to go one more, we carry

2:34the 1 again, and we have 1,000.

2:36So that means we have a 1 in the thousandths, position, and

2:39we have zero 100's, zero 10's, and zero 1's.

2:43Now, you might be asking, OK, Keith.

2:45I totally get this is.

2:46This is base 10, the numbering system most humans on the

2:49planet have been using our entire lifetimes.

2:52So what has that got to do with this thing called binary?

2:55Well, binary is simply a different type

2:58of numbering system.

2:59Instead of using base 10, binary uses base 2.

3:03So with base 10, we had numbers of 0 through 9, which

3:06are 10 individual separate numbers, and with base 2, we

3:10have 0 through 1, which are a total of two separate numbers.

3:16With a base 2 numbering system, the first position

3:19over here on the right is a value of 1, and that's true

3:22for all the numbering systems that we use, whether it's

3:24octal, or hexadecimal, or decimal, or binary, that first

3:28position has a value of 1.

3:30And then as we move left, this next position is simply this

3:34first number times the base.

3:36So in the case of binary, it's based 2.

3:39This will be 1 times 2, and I'll put that right here, and

3:43that will be 2.

3:45And this next position over here, this next place holder,

3:48if you will, is going to be this number times 2.

3:51So that would be 4.

3:52And as we go left, it will be this number times 2, which

3:55would be 8, and then times 2, 16, and times 2, 32, and times

4:002 again, which would be 64, and times 2 again,

4:03which would be 128.

4:04And how far can we go at that?

4:06The answer is, we can go forever and ever as long.

4:09As there's numbers to use, we can continue to

4:12multiply that by 2.

4:14So with a base 10 numbering system, it went 1 and then

4:17times 10, times 10, times 10, et cetera.

4:22With base 2, we start with 1 and it's times 2, times 2,

4:25times 2, times 2, et cetera.

4:28It's also important to note that although we could go a

4:31really long way left here, we really only need to worry

4:34about eight positions at a time when we're dealing with

4:37things like IP version 4.

4:40So here, my friend, is your very first expert exercise for

4:44this video.

4:45I want you to write out these value positions for binary.

4:49And again, the way to do it is, you start on the right

4:52with a number 1 and then you simply take that number and

4:55multiply it by the base as you go left.

4:58So 1 times 2 is 2.

5:002 times 2 is 4.

5:014 times 2 is 8.

5:028 times 2 is 16.

5:0316 times 2 is 32.

5:0632 times 2 is 64, and 64 times 2 is 128.

5:10And that my friends, is what I would like

5:12you to do right now.

5:14So here's what I would love for you to be able to do.

5:17On demand, I'd like you to be able to write out this table

5:19of the actual weight values for each of the positions.

5:22On the far right starting with 1 then times 2,

5:25times 2, times 2.

5:26You can also go in the other direction by starting with 128

5:29dividing by 2, dividing by 2, dividing by

5:322, that also works.

5:34And when you do this, if you're doing it on paper when

5:36you write it out, to practice, go ahead and fold that part

5:40over so that when you do it the second time, you're not

5:43simply looking at what you did previously.

5:45Having this skill of writing out the binary weight values

5:49for the positions is an important skill.

5:51I wouldn't ask you to do it unless it was critical.

5:55So please take a moment and make sure that you can write

5:57this out on demand.

5:59So let's take a look at an example of how a

6:01binary number works.

6:02Now, in binary, there's only two numbers that we get to

6:05play with, and they are a 0 and a 1.

6:07See, in decimal, we had 0 through 9,

6:0910 different positions.

6:11In binary, we have two.

6:13We have 0 and 1.

6:14It's sort of like a light switch.

6:15Either it's off or on.

6:17That's our only two choices.

6:18So if we had a binary number like this.

6:20That's 10000110.

6:26Holy snikers.

6:27You know, what exactly is the value of that

6:29number to us as humans?

6:31And the way to figure that out would be saying, OK.

6:34Well, we have a one in the 128ths position, so that's

6:37128, plus 0 because we have no 64's, plus 0, no 32's, plus,

6:45OK, how many 16's are we going to add to this equation?

6:48If you're saying, well Keith, it's like a

6:50light switch, right?

6:50It's either on or off because it's a 0, it's off, which

6:54means we don't have any 16's, so we're going to say

6:560 there, plus 0.

6:58And here we go.

6:59In this third position, we have a 1 on in the position

7:02that's worth 4.

7:03So what will we add down here?

7:05And if you're saying, well Keith, over here we had a 1 on

7:08in the 128 value.

7:09We added that.

7:10I imagine that if we would go ahead and add 4 for this

7:14position right here and that is exactly right.

7:16So we'd add 4 there, and how about the 2?

7:19The answer is yep.

7:20We have one of those, so we'll add the 2 as

7:21well, and then zero.

7:23And then it's simply a game of adding.

7:25All we're going to do if we want to find out the actual

7:29value of this binary number, all we simply do

7:32is add these up.

7:33So it's 128, plus 4, plus 2, and that's it.

7:39So 8 plus 4 is 12, plus 2 more is 14.

7:42We'll carrier our decimal one right there.

7:44That's a 4.

7:462 plus 1 is 3, and then we have a 1.

7:50And so the actual value of this binary number

7:5210000110, is 134.

7:57The key part that I want to make sure you have the ability

7:59to do is write out this table, if you will, of the actual

8:03values of the positions.

8:04That's the most important aspect.

8:06I would like to do one other exercise with you, and let's

8:09say we have a binary number of 00000010.

8:15What is the equivalent value of that binary number?

8:20And again, to figure that out, you simply say, OK.

8:22We don't have any 128s.

8:24We don't have a 64's, no 32's, no 16's, no 8's, no 4's.

8:28We do have a 2, so it's going to be 2 plus and we

8:31don't have any 1's.

8:32So basically it's 2 plus 0, and that is 2.

8:36So last week, somebody at the office sent around a note and

8:39it said this.

8:39This is very, very funny.

8:40It said there are only this many types of

8:47people regarding binary.

8:50Those who get it and those who don't.

8:58And the reason that's funny is because in decimal, right?

9:02that 1 would be in the tens position.

9:03It looks like 10 as in 5 plus 5, a total of 10 people.

9:08However, in binary, that same number of 1 0 is representing

9:13a value of 2.

9:14So there are only two types of people regarding binary, those

9:18who get it and those who don't, which

9:20makes the joke funny.

9:21And for those people who don't understand binary, it's simply

9:24a T-shirt that they read and simply don't get.

9:27So the actual process of doing converting with binary to

9:30decimal and decimal to binary, I've got a separate video for

9:33you and I just for that.

9:34Our focus in this video is simple.

9:36I want you to be able to write out these eight value

9:40positions from right to left or left to right on demand,

9:43make sure you do it accurately, regarding the

9:45binary base 2 numbering system.

9:48Our action items for this video are real simple, to make

9:51sure that we can write out the values for the eight positions

9:55in binary starting with 1 on the right and

9:58128 on the far left.

9:59The other thing I would strongly encourage you to do

10:02is, once you can write out that table successfully and

10:04comfortably, go take a look at the opt-out questions that are

10:08at the beginning of this video, and that will help

10:10validate what you've learned in this video.

10:13I have had a lot of fun.

10:15I really appreciate your time.

10:16I hope this has been informative for you.

10:18And I'd like to thank you for viewing.

0:00Wicked conversion skills between decimal

0:02to binary and back.

0:04That's what this video is all about.

0:06Let's begin.

0:08This is the opt out section for this video.

0:10If you are comfortable with the answers--

0:13the correct answers-- to these three questions, I'll see you

0:16in the next video.

0:17We'll have some fun there.

0:18However, if you are not yet comfortable with binary to

0:21decimal or decimal to binary conversions and you've got

0:24about 12 minutes, you are in the right place.

0:26Lets go.

0:28I remember seeing The Wizard of Oz.

0:30And near the end they pull back the curtain to reveal who

0:32really is acting as a wizard.

0:34And that's what I'd like to do right now with IPv4.

0:38Even though IPv4 is

0:39represented as dotted decimal--

0:42here we have four numbers right here, and they're

0:45separated by three periods to keep each number separate from

0:48the other one-- what's really happening is that's just for

0:52us humans as a convenience.

0:54What's really going on behind the scenes is that each one of

0:57these numbers represents one byte of data.

1:01Now before you freak out and say, a byte of data, it's

1:04really just representing each number 8 bits, which go into

1:08one byte of data.

1:10So each of these numbers, 130, 16, 33, and 17.

1:14Because each number makes up 8 bits, sometimes these numbers

1:19are referred to as an octet.

1:21And an octet is nothing more than 8 bits that are all

1:24represented together in the same grouping.

1:26So whether you want to call this first number the first

1:29number, or the first byte, or the first octet, all of those

1:33mean the same thing.

1:34So the trick is, if we wanted to convert for whatever

1:37reason, including the ability to do things like

1:41summarization and custom subnetting, we first have to

1:44be able to convert these numbers between decimal--

1:48which they're shown here-- and binary.

1:50Or maybe we're given a binary number and we want to convert

1:54that back to decimal so we can go ahead and input it, for

1:57example, in a router or computer.

1:59Now, the great news for you and I is that in converting,

2:02if we needed to to convert binary to decimal or decimal

2:05to binary, it's really straightforward because in

2:08either method we're going to use we're going to first write

2:11out this table.

2:12Now we introduced this table in our video

2:14titled Beautiful Binary.

2:16So you already know what this table is and how to draw it

2:19from memory.

2:20If you don't, I strongly encourage you to go back and

2:24revisit Beautiful Binary.

2:25But that's our starting point.

2:27Now the question might come up, well Keith,

2:29what do I do first?

2:30Do I do decimal to binary or binary to decimal?

2:32Usually you're going to be given something and you need

2:35to convert it to the other.

2:36In this case we have a decimal number that we're going to

2:39convert to binary.

2:40So we're going to do that one first.

2:41And it's really just a game.

2:43And I call it the, does it fit game.

2:46And here's how we play it.

2:47We take a number.

2:49So we're going to first start with 130.

2:50And we're going to write it out.

2:52And all we need to do is take this very first number on the

2:54far left, 128, and ask ourselves the

2:57question, does it fit?

2:58Does 128 fit into 130?

3:01Yes or no?

3:02It's a binary question.

3:04If the answer is yes we're going to put a

3:06bit on in that position.

3:08And we're also going to subtract that value of 128

3:11from the number we're trying to convert.

3:13So the remainder of this is 2.

3:16130 minus 128 is 2.

3:18So we take that remainder and we play the game again.

3:22Does 64 go into 2?

3:24No.

3:24Well, it might a fraction of the time.

3:26But we're looking, for does that number go in an entire

3:29time at least once?

3:31And if the answer is no it doesn't, we put a zero there.

3:35How about 32?

3:36Does it go into 2?

3:37No it doesn't, so that get's a 0.

3:39Does 16 go in?

3:40No it doesn't, that gets a 0.

3:428?

3:42Does it go into 2?

3:43Nope.

3:44How about 4?

3:45Nope.

3:46And then we get down to 2.

3:47Does 2 go into 2?

3:50And the answer is, yes it does.

3:51It goes in exactly one time.

3:53So we'll subtract 2 from it.

3:56And we are down to 0.

3:57So the question is, does 1 go into 0?

4:00And the answer is, it does not.

4:02And so we're going to put a 0 there as well.

4:04It's sort of like accounting.

4:05If you love accounting, with debits and credits, trying to

4:08get them to equalize, that's all we're doing here is we're

4:10trying to whittle this number down to 0.

4:13Also, if you ever come across a time when the number you're

4:16looking at goes in more than once, like 2 times, there's a

4:21math problem somewhere.

4:23So again, we start on the left and we play the,

4:25does it go in, game.

4:27And if it does we take the remainder and then continue

4:29working our way right.

4:30So this number right here, 10000010 is 130 in decimal.

4:38So let's do one more together.

4:40And then I'm going to have you do your expert exercise with a

4:43number on your own.

4:44So let's go ahead and clear the page.

4:46And let's go ahead and do 16.

4:48The game is we want to convert 16 into binary.

4:51We're going to play the, does it fit, game.

4:54So we're going to write out our paper 16, the

4:56number we're after.

4:57And ask ourselves the question, does 128 go in?

4:59The answer is no, negative.

5:01Does 64 go into 16?

5:03No, negative.

5:04Does 32 go into 16?

5:07It does not.

5:07Does 16 go into 16?

5:09[MAKES SIREN SOUND]

5:11The lights go off.

5:12Yes, it does fit.

5:13So we take that number that we just put in, we subtract that

5:16from our number, we take the remainder, and we play the

5:19rest of the game.

5:20You can't stop playing until you've given all 8 bits in

5:23that octet or that byte.

5:25So 8 doesn't go into 0, nor does 4, nor

5:27does 2, nor does 1.

5:29This is our binary number that represents 16.

5:33It is 00010000.

5:37And that, my friends, is also why, as humans, we input IPv4

5:42addresses as dotted decimal.

5:44Is saves us a whole bunch of typing.

5:46So we're going to input, when we configure routers and

5:49devices with IP addresses, we're actually going to put in

5:51the value of 16 for that second octet.

5:54But what the computer knows and the router knows is that

5:57this is the binary value of that second octet.

6:00So here, my friend, is your expert exercise.

6:04Your first one for this video.

6:06I'd like you take this number, 33.

6:08And your mission, which I hope you accept, is to convert 33

6:13into the 8 bit binary number that 33 is representing.

6:19So I'd like you to take a moment right now.

6:21Pause this.

6:22Now if you say, well Keith, how do I start?

6:24What I would encourage you to do is start by writing out

6:26this table.

6:27And then simply writing out 33 and playing the game called,

6:31does it fit?

6:32So does 128 go in?

6:34Does 64 go in?

6:35Et cetera, et cetera.

6:36Every time it does go in you put a 1, and you subtract that

6:39value from your number and play the game again,

6:43continuing on with the remainder.

6:45So go ahead and pause me right now.

6:47Work out the binary equivalent of the decimal 33.

6:51And when you come back we'll validate what that

6:53answer is in binary.

6:57So excellent work.

6:58I absolutely appreciate you practicing and verifying that

7:01you can do this on your own.

7:02This is a critical, fundamental skill that we're

7:05going to be leveraging inside our world of IPv4 custom

7:08subnetting.

7:09So the game goes like this, 33 is right here.

7:12And we say, does 128 go into 33?

7:14The answer is no.

7:1564 doesn't go in.

7:1632 does.

7:17So we're going to put a 1 there.

7:19We'll say, minus 32.

7:21And our remainder is 1.

7:2316 doesn't go, nor does 8, nor does 4, nor does 2.

7:26But 1 goes in cleanly one time.

7:28And our accountant is happy because we've had a 0 balance

7:32at the end, which is how it should be.

7:34So the decimal number of 33 is representing our binary number

7:38of 00100001.

7:42If that's the answer that you got, absolutely great job.

7:46I've got one more task for you as another expert exercise.

7:50And that is this.

7:50I'd like you to take 17, that one byte of data, and tell me

7:55what the equivalent binary number is for 17.

7:59Go ahead and pause me and do that now.

8:03So I know that some of you have already shortcutted this,

8:07which is perfectly fine if you're to that point.

8:09But the manual way, which is a great way to start if you're

8:12just learning this, is to say, OK great.

8:14The number is 17.

8:15128 doesn't go in.

8:16Nor does 64, nor does 32.

8:18But 16 does.

8:20And the remainder is 1.

8:218 doesn't go, 4 doesn't go, 2 doesn't go, but 1 does.

8:23But many of you looked at 17 and said, you know

8:26what, I get this 17.

8:28Is one 16 plus one more.

8:30All the rest are 0s, I'm done.

8:32And as you practice more and more with the converting of

8:37decimal to binary your skills will improve.

8:40But it doesn't happen by accident.

8:43It happens based on practice doing the conversion.

8:46So I'd like you to do one more for me.

8:49And I'm going to have you do this entire IPv4

8:51address on your own.

8:53And the number is this, 194.17.95.136.

9:00That is number that I'd like you to convert.

9:03And you're going to do it one octet, one number at a time

9:06converting those to their binary equivalent.

9:09If you've joined me for all of these videos in order and

9:13you've watched the prior five minutes, you should be able to

9:16calculate the binary equivalent of each of these

9:18numbers completely on your own.

9:21Go ahead pause me now and convert this IP address into

9:25its binary equivalent.

9:28I want to thank you for taking the time to go through these

9:31expert exercises.

9:32As you practice more and more your skills

9:35will measurably improve.

9:36Now, our next task is, what if we needed to convert a binary

9:40number that we're given in binary to decimal?

9:43Well, we already had a sneak peak at doing exactly that in

9:46our beautiful binary video.

9:48It's really, really simple to do.

9:50Let's say we're given a binary number of

9:5210100111 as an example.

9:58How do we convert that to decimal, the decimal

10:01equivalent?

10:02The answer is we're going to take everywhere there's a 1.

10:04We're going to take that value from the placeholder it's in

10:07and simply add them up.

10:08So we're going to add up 128, plus 32 more, plus 4,

10:12plus 2, plus 1.

10:13So we could do that long hand.

10:14128 plus 32, plus 4, plus 2, plus 1.

10:198 plus 2 is 10.

10:21Plus 4 more is 14.

10:22Plus 2 more is 16.

10:23Plus one more is 17.

10:25There's our 1, there's our 7.

10:28Then we have in this column 3 plus 2 plus 1 is 6.

10:32And the hundreds position we have a 1.

10:34So that value of this binary number right here is 167.

10:39And I put 167 equals 167.

10:42I guess that's a little bit redundant.

10:43So when converting from binary to decimal, we simply look for

10:47the 1s and then add up the values of those positions for

10:52our equivalent total value.

10:54So now it's time for your expert exercise in converting

10:57binary to decimal.

10:59And what I'd like you to convert is this.

11:00This number right here into decimal.

11:05So go ahead and pause me.

11:07When you're done, go ahead and resume.

11:09And we'll confirm our answer.

11:13All right, welcome back.

11:14Let's see how we did.

11:15So for this answer, which we'll call option number a

11:18here, we have 64 plus 32 more plus 16 more plus 4 plus 2,

11:27and that's it.

11:28So if we add all of those up, there's 4, 5, 6.

11:316 more is 12.

11:33Plus 4 is 16.

11:34Plus 2 more is 18.

11:35We'll carry the 1.

11:36There's an 8.

11:37So for the tens position we have 6 plus 1 more is 7.

11:40Plus 3 more is 10.

11:42Plus one more is 11.

11:44That would be 118.

11:46And if that's what you came up with, congratulations.

11:49You have the ability to convert

11:51from binary into decimal.

11:53Now let me give you a couple more that I'd like you to

11:56practice with as well.

11:57Let's take this one right here.

11:58Well, 00000000.

12:02I want you to do that one if you would.

12:03As well as this one, 11111111.

12:08And one more.

12:10Let's have you go ahead and do 11110000.

12:15And we'll call those a, b, and c.

12:19And what I'd like you to do is write out on paper what the

12:22decimal equivalent of a, b, and c is.

12:26And if you're saying, Keith, I think I've got the a, it's 0,

12:30you'd be absolutely right.

12:32It might take you a little bit longer for b and c.

12:34So go ahead and pause me while you do all three of those.

12:37Write out your answers and then click on Resume, and

12:40we'll compare notes.

12:44OK, welcome back.

12:46So let's take this first one, option a, first.

12:49And option a is 0 plus 0 plus 0 plus 0 plus 0 plus 0.

12:52OK, so a equals 0.

12:55Now in this next one we have some more adding to do.

12:58So we have 128.

13:00And here's what I'd recommend.

13:02Don't just do it in your mind.

13:03If you're new to this, do it as we have in this video, by

13:07writing out 128 plus 64, plus 32, which is

13:11what this is all about.

13:13So for answer b it would be 128 plus 64

13:15more, which is 192.

13:18Plus 32 more, which is 224.

13:21Plus 16 more, which is 240.

13:24Plus 8 more, which is 248.

13:26Plus 4 more, which is 252.

13:29Plus 2 more, which is 254.

13:32Plus one more is 255.

13:34So b equals 255.

13:37And you might say, well Keith, you did that in your mind.

13:40You didn't even write that out.

13:42And that's because this is one of those values that you're

13:45going to see a lot of, 255.

13:49And it's just because of raw practice with these numbers

13:52that I can do that in my head.

13:53Otherwise I'd be writing it out.

13:55So 128 plus 64 plus 32 plus 16 plus 8 plus 4 plus 2 plus 1

14:02equals 255.

14:03And for answer c we have 128 plus 64 plus 32 plus 16.

14:12And if we add all that up the long way, the short way, use a

14:15calculator, what have you, it's going to

14:16end up to be 240.

14:19If those are the three values that you got when you did the

14:22expert exercise on your own before we compared

14:25notes, my hat's off.

14:26If you didn't get these three numbers, I would ask you to go

14:30back manually--

14:31like we did right here and here--

14:33and add them up once again just to confirm that you're

14:37doing the conversion from binary into decimal correctly

14:41Also the valid range, if you will, for any octet, any

14:45number in IPv4 is going to be between o and 255.

14:51It can't be any lower than 0, because then we're going into

14:53negative numbers.

14:54And it can't be any higher than 255.

14:57Because in an octet if every single binary number is on,

15:01the maximum it can never get to is 255.

15:04But I also, just with a little caution, also want to point

15:07out that 0 through 255 is actually

15:10256 different numbers.

15:14Because 0 indeed is a value.

15:16But the numerical high number you're ever going to see is

15:19going to be 255.

15:21Our action items for this video are to, number one, make

15:24sure we've practiced the binary to decimal and decimal

15:27to binary exercises that I assigned in this video.

15:30And secondly, I'd have you go back to the opt out questions

15:34at the beginning.

15:35When you can now comfortably answer those questions in the

15:38opt out section for this video, you are ready for the

15:41next video.

15:42I had a great time.

15:43I sure appreciate you joining me.

15:45I hope this has been informative for you.

15:47And I'd like to thank you for viewing.

0:01The bits and bytes of the mask--

0:02let's begin.

0:04Here are the opt out questions for this video.

0:07If you can answer all five questions comfortably and

0:10correctly, you can go ahead and skip

0:12directly to the next video.

0:13For everybody else, you are in for a treat.

0:15We're going to identify the magic and mechanism behind the

0:19mask and how it identifies which portion of an IP address

0:22is the network and which portion is left over for host

0:26addressing.

0:27I'd like you to imagine that a friend walks up to you and in

0:30casual conversation they ask you, can you tell me, says

0:34your friend, about a mask?

0:36Exactly what it does?

0:38And as you think back to one of our very first videos in

0:41this course, in fact it was the video titled Fun with IPv4

0:45basics, we discussed the purpose of a

0:47mask and what it does.

0:49And my question is, do you remember the

0:51purpose of a mask?

0:53Now if you're saying, ooh, ooh, Keith, I know, I know!

0:55It absolutely identifies out of an IP version 4 address, it

1:00identifies which portion of that IP

1:03address is the network.

1:05And everything else beyond that is the actual host

1:08addresses, specifically the host

1:10addresses for that network--

1:12if that's what you're saying, that's excellent.

1:14If you need a brief refresher on the basic function or

1:18purpose of an IP version 4 mask I would strongly

1:21encourage you to go back and review that video called Fun

1:25with IPv4 Basics.

1:27Because in this video, you and I get to take what we already

1:30know and build upon it as a foundation.

1:33So here, my friend, are the details behind how the mask

1:36identifies which portion of an IP address is the network.

1:39So I IPconfig on my Windows machine.

1:42And this is what it gave me.

1:43It said my IP addresses 192.168.1.15.

1:47Fantastic.

1:48So I broke that into binary, just for display purposes.

1:52And the first number 192, I put in red in binary here.

1:55168 right here in blue.

1:58The 1 in green, and the 15.

2:00So there's the decimal notation that we normally use

2:03and the binary equivalent of each one of those.

2:06Now what I'd like to do is talk about the mask.

2:09There is also a 32-bit mask associated with each and every

2:1532-bit IP version 4 address.

2:18So in the output of IPconfig up here it says that my mask--

2:22and that also brings me to a point of nicknames.

2:25For example, sometimes it's referred to as the mask.

2:28Sometimes it's referred to as the network mask.

2:31Sometimes it's referred to as the subnet mask.

2:33But anyway you slice it, when we're talking about IP version

2:374, it's referring to this device that

2:40identifies which portion--

2:42going from left to right--

2:44which portion of that IP address is the network and

2:48which remaining portion is available for host addressing.

2:51So this is how it does it.

2:52That 32-bit mask is also represented in dotted decimal.

2:57So I have the mask right here.

2:58It's 255.255.255.0.

3:02So that's the mask, literally, off of the

3:04computer that I'm using.

3:05For display purposes, I converted the

3:07mask octets into binary.

3:10So there's the first 255, and the second 255, the third 255,

3:14and of course this last octet of all zeros represents that

3:18decimal zero right there.

3:19So here's the magic.

3:21What happens is the computer lines up all of the bits of

3:25the actual IP address with those same bits in the mask as

3:29shown here.

3:31So here's what the mask does.

3:32We simply follow the bits that are on.

3:35The bits that are on in the mask is representing which

3:38portion of the IP address is the network.

3:41So we simply follow the mask and the bits that are on, and

3:44then stop when they stop.

3:45Which in this case, happens to be right here--

3:47that, my friends, is the dividing line.

3:49Everything to the left is the network.

3:52And everything to the right is the actual host portion.

3:56So in this case, we could say that my computer is on network

3:59192 168 1, the first three octets.

4:04And that my host address is .15 on that network.

4:09And there's an additional little piece that I'm going to

4:11share that you don't really have to memorize, but some of

4:14you are going to be interested in it, so I'm

4:16going to share it.

4:17The way it actually determines this is by doing some

4:19multiplication.

4:20It multiplies the bit in the mask against the corresponding

4:23bit in the IP address.

4:24And if we did that--

4:26for example, 1 times 1 equals 1.

4:28And 1 times 1 equals 1.

4:301 times 0 equals 0.

4:31Effectively we're going to have the same exact number

4:34that we have up here down below.

4:37And so this one's going to be 1-0-1-0-1-0-0-0.

4:42And this third one is going to be 0-0-0-0-0-0-1.

4:47And the very last octet, what it's going to be if you

4:49multiply all those by 0?

4:51They're all going to be 0, no matter what.

4:53So if we converted this back into decimal it would be

4:57192.168.1.0.

5:01And that's how we represent networks inside

5:04of IP version 4.

5:05And more specifically, we could put a slash here and say

5:0824, which literally means that the first 24 bits--

5:138 bits here, and 8 bits here, and 8 bits here-- those first

5:17consecutive 24 bits going from left to right

5:20represent the network.

5:22And the last 8 bits are available for host addresses,

5:25or like house addresses on those streets.

5:28Now I've got a question for you.

5:30Why in the world can we just go ahead and say this is a

5:3324-bit network?

5:35That the network is the first 24 bits?

5:37And the reality is, I'm not saying.

5:39I'm just saying that the computer is telling me that's

5:43the fact of how this current computer is configured.

5:46The mask is the first 24 bits that are on.

5:49And that is what's telling me that this is a 24-bit network.

5:54It also implies that the last 8 bits, these bits right here,

5:57are available for host addresses on this network.

6:01I've got a little exercise I'd like you to do with me.

6:04And that is this.

6:05Let's pretend that this mask isn't this one right here.

6:08So we're going to replace that for a moment.

6:10And let's say that the mask instead is 255.255.0.0.

6:16So the mask in this octet would all be

6:19zeros, just like that.

6:22And here's my question for you--

6:23now that we have this mask, what is the actual network

6:27address if this is our mask?

6:29And how many bits of the IP address are being used for

6:32network and how many bits are now available for host

6:36addressing on that network?

6:38So take a moment right now.

6:40Go ahead and pause me.

6:41Determine what you think the correct answer is for the

6:43actual network address and then we'll compare notes.

6:48Awesome, thank you for taking a moment to do that.

6:50So here's how I would look at this.

6:52I'd say, well, we're going to follow the bits in the mask

6:55until they stop.

6:56And then you can draw a line.

6:58And everything to the left of that is the network and

7:01everything to the right are the host addresses.

7:04So we could say that with this mask, the network is 192.168.

7:09And then anything beyond the mask when we're identifying

7:13the network, we just zero out.

7:15So this is the 192.168.0.0 network slash 16.

7:19It's a 16 bit network and we have another 16 bits available

7:25for host addresses on that network.

7:28Let's do one more exercise just like that, except this

7:31time let's go ahead and change the mask.

7:34We're going to make it 255.0.0.0 for our new mask.

7:40So this is going to be a 0 and a 0 and we're going to have

7:44all these zeroed out here as well.

7:46So now if this is what our computer showed us, now my

7:50question is, what is the actual network address that

7:53this computer is on?

7:55How many bits is it?

7:56How long is it?

7:57And how many hosts bits are available?

8:01So go ahead and pause.

8:02Make your decisions.

8:04And then let's compare notes after you resume.

8:08Awesome, thanks for taking a moment to do that.

8:10So here's one way we could approach this.

8:12We simply look at the mask first, that's

8:14the very first clue.

8:15And we're going to say, OK.

8:16This mask says that the first 8 bits are being

8:19used for the network.

8:20And if all the rest of the bits are 0s, that's the

8:23dividing line.

8:24And the cool thing is about a mask, it won't jump.

8:27This network mask, or subnet mask, or whatever you want to

8:30call it, doesn't jump.

8:32It's not going to take like a bit here, and a bit over

8:34there-- they are going to be contiguous bits moving from

8:37left to right.

8:39So a mask will never say 110111.

8:42It's going to be contiguous.

8:44So because the dividing line is right here, our very first

8:47octet is the network.

8:50Everything after that is zeroed out from the network

8:53address perspective.

8:54And that's 8, because it's the first 8 bits

8:56representing the network.

8:58And now we have the remaining 24 bits of that IP address

9:03which are now representing host addresses on network 192.

9:08So let's do one more example to help reinforce the concept.

9:11Let's say we have a Macintosh, or a Linux, or a Windows box

9:15sitting on a network and it's a happy, happy computer.

9:18You want to know why it's so happy?

9:20Because it's got an IP address.

9:21It's got the IP address of 10.25.3.99.

9:27That's its IP address.

9:28And guess what it also has?

9:30It also has a mask.

9:31That mask in decimal is 255.255.0.0.

9:38And what I would love for you to do right now is tell me

9:41what is the actual network that this

9:44computer is sitting on?

9:45What is the host address for this computer?

9:50And what is the number of bits that are currently being used

9:54by that network for network addressing?

9:57And how many bits are left over for host addressing on

10:01that network?

10:02So take a moment, go ahead and pause me right now.

10:05Take as much time as you need.

10:06And once you've calculated what the actual network

10:09address is that this computer is sitting on, go

10:11ahead and resume me.

10:13And then we'll compare notes.

10:15Awesome, welcome back.

10:16So in this example of 10.25.3.99, the very first

10:21thing that we're going to look at isn't the

10:22IP address at all.

10:24It's the mask, because the mask is controlling which

10:26portion of that IP address is the network and which portion

10:30is available for host addresses.

10:31And the mask is saying I am consuming--

10:33I'll use green for this--

10:35I am consuming the first octet for network.

10:37So we know that the 10 is part of the network address that

10:40the computer is sitting on.

10:42We also know, based on the mask, that the second octet is

10:45also consumed and being allocated for the purpose of

10:48network addressing.

10:49And that's it.

10:50The third and fourth octet-- the mask

10:52isn't taking anything.

10:53So we can draw our dividing line right there.

10:55This computer is sitting on network 10.25.

10:59And then we simply zero out the bits that host addresses

11:02are going to have.

11:030.0, as we describe the network--

11:05and that is a total of 8 bits here and 8 bits here.

11:09A total of 16 bits being used for the network address.

11:13Now that also implies that we have 16 bits left over that

11:17are not being used for the network address portion that

11:20we can then use for individual host

11:22assignments on that network.

11:24So this computer, with the IP address of 10.25.3.99--

11:29the first two numbers are the actual network, right here.

11:32And the last two numbers of 3.99 represent the actual host

11:37portion, or this guy's unique identifier, on that network

11:41regarding IP addressing.

11:43And as we mentioned, there are 16 bits being

11:45used for the network.

11:46And there's also 16 bits available for host addressing.

11:50So I've got one more exercise.

11:51And this one I'm going to have you do on your own with the

11:54computer that you're currently using.

11:55If you're on Windows, you can run an IPconfig What I'd like

11:58you to do is display your IP address and mask.

12:01And once you do so, I would like you then to write out

12:05what network is your computer currently connected to?

12:09And I'd like you go ahead and include the number of bits of

12:12that network.

12:13And the only way to really determine that is by looking

12:16at the mask, seeing how long it is-- how

12:18many bits it's taking.

12:20Drawing the line--

12:21everything to the left of the network.

12:23And everything to the right of that line is the space

12:26available for host addressing on that network.

12:29And that, my friend, is your homework assignment.

12:32I have had a great time.

12:34Here is the two action items for you.

12:35Number one, make sure you do the expert exercises that I

12:38assigned, including the homework.

12:40And secondly, go back and take a peek at the opt out

12:43questions at the beginning of this video just to validate

12:46that you now understand those topics and have the ability to

12:50go ahead and identify the network portion based on a

12:53mask of an IP address.

12:56I hope this has been informative for you.

12:58And I'd like to thank you for viewing.

0:01In this video, you and I are going to address stealing

0:03bits-- host bits-- and allocating them for network

0:06use, and moving the mask to represent that we've made a

0:09change in the network.

0:11Here's the opt out section for this video.

0:13If you are comfortable with the answers to these

0:15questions, and you know the finger game, and how to

0:18calculate the number of bits to use for custom subnetting,

0:21I'll see you in the next video.

0:23For everybody else, you are in for a treat.

0:25Let's begin.

0:27I'd like you to imagine that you and I have shown up for

0:29work one day, and our boss meets us with a big smile on

0:32their face, and says can you help me with a small project

0:35I'm working on?

0:36And we say, sure, what do you need?

0:37And our boss shows us this topology right here, that they

0:40have drawn, like, on a napkin or something during a lunch.

0:43And they ask us, can you put this together?

0:45We have a pilot program we're doing, and I want to just test

0:48some things.

0:48Can you make that all happen?

0:50And we say sure.

0:50We've got some extra gear, so we round up some routers, and

0:53we connect them with switches.

0:55We even have a back-to-back serial

0:56connection that we put together.

0:58And then we go to go ahead and do the addressing.

1:00So maybe over here on this network that is common to R3,

1:03R1, and R2, we use the network 192.168.1.0/24.

1:10Now, if we analyze that, that means that the first 24 bits

1:14of this number, which is the first three octets, are the

1:17network, and this last octet is available for host

1:21addressing.

1:22We've learned that in our previous

1:23Nuggets in this course.

1:25And then for this network right here, between R2 and R4,

1:29maybe we use the 192.168.2.0/24.

1:36And for the network between R4, R5, and R6 right here,

1:41maybe we use network 192.168.3.0/24.

1:47Now once we've implemented these IP addresses, we go back

1:50to our boss all proud, and say hey, we're all

1:51done, take a look.

1:53And he looks at it on paper, and says oh, I forgot to tell

1:56you something.

1:57And we say, oh what's that?

1:59And the boss says this kind of needs to fit into

2:01our existing network.

2:03And if you could, says the boss, I need this entire

2:06topology to fit in this space of 192.168.5.0/24.

2:15I want to use that network to support this entire topology.

2:20Now at that point we have a couple of options.

2:22One, we could say, uh, this is only one network address.

2:26We have three individual, separate networks that we need

2:29to deal with-- off of every router interface is a separate

2:32network, so we have network A, network B, network C--

2:35we could argue that we need more IP addressing space.

2:39Or the other option, my friend, is to go ahead and do

2:43custom subnetting.

2:45The process of subnetting is simply taking an existing

2:48network space that we're given and chopping it up into

2:51smaller pieces.

2:53Sort of like if we had Sunset Street, for example.

2:57So if we had Sunset Street, which is a physical road

2:59somewhere in some town, and we needed to break that up into

3:02smaller sections, maybe we could have Sunset Boulevard,

3:07Sunset Avenue, Sunset Lane, for example, and we

3:13can break it up.

3:14All we're doing when we're doing custom subnetting is

3:17we're taking one network address space, like the

3:21192.168.5 network, and we are going to chop it up into

3:25smaller pieces so we can make additional smaller networks.

3:29Now unfortunately, there is a price that's going to be paid

3:33if we take a perfectly good network like 192.168.5 and we

3:37chop it up.

3:38This network, which currently has 24 bits for the network,

3:42and an eight bits over here for the host portion, in order

3:46to do custom subnetting, what we have to do is we're going

3:49to say goodbye to a few good host bits.

3:53Those eight host bits which are over here, we are going to

3:56have to sacrifice some of them.

3:58Did I say have to?

3:59And the answer is yes.

4:00We are going to voluntarily take some of the bits over in

4:04this host portion from the network that we're dealing

4:07with, and we are going to allocate some of those bits

4:10over towards network addressing.

4:12And effectively what it's going to do is it's going to

4:14make more room for network address space, and we're going

4:17to use that additional space, those additional bits, to

4:20carve out additional subnets.

4:23So let's use a practical example here.

4:24Let's say we do have a 192.168.5.0/24 network, and we

4:32have to use that major network to go ahead and create

4:35additional space.

4:36The very first question to ask us in this scenario is how

4:40many new networks--

4:41or new subnets, if you will--

4:43do we need to create for our topology?

4:45In this example, we need one, two, and three.

4:49So step number one--

4:50I'd like you to write this down with me-- is identify the

4:54number of new subnets needed, because that is

5:02the very first step.

5:03Identify the number of new subnets needed.

5:06So once you've got that jotted down, I'm next going to share

5:09with you how you can calculate how many

5:12bits you need to take--

5:14I'm talking about the stealing bits from the valid host bits

5:17which are currently available, and we're going to sacrifice

5:20them to network address space.

5:22And that's done through something

5:23called the finger game.

5:25Now if you're wondering, Keith, what the heck is the

5:27finger game, you're not going to have to wonder too much

5:30longer, because we're going to play it together.

5:32I'm going to do this literally with you.

5:34So here's what I'd like you do.

5:35I'd like you to look at your fingers and include your thumb

5:38in that discussion.

5:39So look at your fingers, and I'd like you to imagine that

5:43your fingers are bits.

5:45So if you hold up all your digits on your right hand or

5:48your left hand, you look at them, how many digits are

5:50there, how many bits are there?

5:52And the answer for most people is going to be five.

5:54Unless you're like my shop teacher in high school, but

5:56that's another story.

5:57So let's go ahead and use the presumption that most people

5:59are going to have five digits on their hand.

6:02And for this game, each of those digits represents a bit.

6:05So here's what I'd like you do.

6:07I'd like you to go ahead and act like

6:09Fonzie from Happy Days.

6:10If you don't know who that is, I'll go ahead and walk you

6:12through this.

6:13You're going to make a fist with your right hand, stick it

6:16out in front of you, and then stick just your

6:18thumb up in the air.

6:20So with your thumb in the air, I'd like you to look at the

6:22back of your thumb, look at your thumbnail.

6:24I'd like you to imagine that somebody took a black

6:28permanent marker, and they wrote, right on your

6:30thumbnail, the number 2.

6:32So look at it, see it-- what kind of a font did they use,

6:36is it clean, is it a sloppy written 2-- but see that 2 on

6:39the back of your thumb, and here's what we're going to do.

6:42If you only need two new subnetworks, all you need to

6:47do is steal, or take, a single host bit from the current

6:51available host bits to accomplish that.

6:53So the 2 is on your thumb, your thumb represents that one

6:56bit, and that's the formula.

6:59Now in our case, we need more than just two subnets, so

7:03here's what we're going to do.

7:04With your thumb still up in the air, we're going to go

7:06ahead and bring up another digit, like your pointer

7:09finger, and when you bring that finger up, I want you to

7:12double the 2 on your thumb.

7:15So that goes to 4.

7:16The number that you verbally said is the number of subnets

7:20you can create.

7:21If you look at the number of digits in the air, which are

7:24now two, that's how many bits it takes to

7:27generate that many subnets.

7:29Just for grins-- that meets our needs, all we really

7:31needed to do is take two bits, and that'll create four

7:34subnets, which meets our need of three--

7:36so let's do this.

7:37Let's start from scratch, and let's see how many subnets we

7:40could create if we stole or took five host bits.

7:45So the game always starts like Fonzie.

7:47You make a fist, you put your thumb in the air, on the back

7:50of your thumb there's a 2.

7:52And the next thing we're going to do is bring up our pointer

7:54finger and verbally double that number to go to 4.

7:57And bring up another finger, so we have three digits in the

8:00air, and double the number to 8.

8:03Bring up another digit, double the number to 16.

8:06Bring up another digit, now all five digits are up, and

8:10double that number to 32.

8:12And I want to remind you what the importance of this game

8:14is, what the relevance is.

8:16If you look at your fingers, you've got five digits in the

8:19air, that means if you take five bits away from the host

8:23addresses, and you allocate them for network addressing,

8:27you can have 32 brand new subnets by using the address

8:32space available in those five reallocated bits.

8:36And this finger game, that we can use to calculate the

8:39number of bits, or digits on our fingers, to use to create

8:43a certain number of subnets is a very valuable skill that'll

8:46come in very handy for you.

8:48So in our case, we only need three subnets to support this

8:53topology right here.

8:54So just as a review, let's do the thumb game once again, and

8:58we want to make sure we're going to identify how many

9:00bits it takes to create up to three subnets.

9:04So we play the finger game by making a fist, we put our

9:06thumb in the air, there's a 2 on our thumb.

9:09Two is not enough.

9:10We bring up another digit, we double that number to 4, and

9:14that means with two bits, represented by the two digits

9:17that are up in our hand, we can create up to four subnets.

9:21So that third step is to identify

9:25number of bits to sacrifice.

9:29And I do say sacrifice, because they were available

9:33host bits, and once we sacrifice them over for

9:36network addressing, they will no longer be

9:39available for host bits.

9:41So in our case, we are going to sacrifice two host bits,

9:45because that allows us to have up to four subnets, which

9:47meets our needs.

9:48One bit wasn't enough, and two bits gives us up to four

9:52subnets, which meets our needs.

9:54And the fourth step-- and this is the most important--

9:57is to go ahead and let everyone know.

10:02What do you mean, Keith, you have to let everyone know?

10:04You see, if we are going to change the rules and use two

10:08host bits for the network address, we need to make sure

10:11that all the devices on the network know about it.

10:14So what we're going to do is we are going

10:16to modify the mask.

10:19You see, for this network at the moment, the mask is only

10:22claiming the first three octets, the first 24 bits of

10:27the IP address space.

10:29But now if we're going to use the additional first two bits

10:32of that last octet, we need to change the mask.

10:35And that, my friend, is how we communicate the details of

10:39using additional bits for the purpose of networking.

10:41We're simply going to move the mask that many bits to the

10:45right, and they're still going to be contiguous.

10:48So now it's going to be the first 24 bits here, plus the

10:51first 2 of this last octet.

10:53The new mask is going to be 26.

10:56Now out of our beautiful IP address space, now we only

10:59have six host bits available left for host addressing,

11:03which is restricting us a little bit on that end, but

11:06now we have more address space to play with, so we can create

11:09up to four brand new subnets.

11:12So your Expert Exercise, right now, is to write out these

11:16four steps.

11:17And that is to identify the number of new subnets that you

11:20need to create.

11:21Use the finger game with a 2 on your thumb, with your

11:24fingers representing bits, and doubling the number every time

11:28you bring up a new digit-- remember, start with a 2 on

11:30your thumb.

11:31And then once you calculate how many fingers are in the

11:33air that meets your requirements for the number of

11:36subnets, you identify that.

11:38In our example we only needed to take two bits.

11:40And the fourth step is to modify the mask to let

11:44everybody know about it, and that's moving the mask to the

11:46right by that quantity of bits.

11:49So take a moment, make sure you have those four steps

11:53written down, and what I would like you to do is go

11:55ahead and pause me.

11:57Turn the paper over.

11:58And I'd like you to go ahead and from memory

12:01repeat those steps.

12:02If you need to peek over at the other side as a refresher,

12:05that's perfectly fine at the beginning, but I want to make

12:07sure that you, on your own, know this exact process.

12:11When you've written these out and are comfortable that you

12:14understand the process that you should go through, go

12:17ahead and resume me, and I want to share with you one

12:20more technique that's really important regarding the moving

12:23of that mask those two additional bits.

12:26Now here's one of the challenges that's going to

12:27come up when we move that mass from a /24, which it was, over

12:31to a /26 is that how do we actually

12:34represent that in decimal?

12:36Because when we work with IP addresses, we're putting in

12:39dotted decimal.

12:40So what does a /26 look like in dotted decimal?

12:43Well, the first 24 bits for the mask are 255.255.255.

12:49Now that's not new.

12:50We've already been through that in this course.

12:52However, what is new is how do we represent the first two

12:56bits of that last octet, these guys right here, for the mask

13:02that they're on?

13:03And the answer is, we're going to go back to binary for that.

13:07This bit on and this bit on.

13:09So that's bit 25 and bit 26.

13:12And all these bits in the mask are now off.

13:15What would that be in decimal?

13:17Because that's how we're going to have to input it to the

13:19device we're working on, whether it's

13:20a router or a computer.

13:21And to figure this out, we already know how to do the

13:24conversion from binary to decimal, we

13:26simply add the values.

13:28So we add 128 and 64, and that's a

13:31whopping total of 192.

13:34So for the mask in the last octet, we would put 192.

13:38And what that tells the router or the computer that your on

13:41is that, hey, we're using a /26-bit mask.

13:45The first three octets are all taken for network addressing,

13:48and the first two bits of that last octet are also taken for

13:52network addressing.

13:54Now I can hear it already.

13:55Some of you might be saying, ugh, I don't want to have to

13:58convert from binary into decimal every single time I

14:01put some type of a custom or non-default mask on an IP

14:06address and I'm totally with you.

14:08And that's why what I would recommend you do is create

14:11this mask values table as well.

14:13So right when you sit down to start working with IPv4

14:16subnetting, you should definitely write out this

14:18table right here, which is the weights to the various

14:21positions for one byte of data and you should also jot down

14:25the mask values for each of those positions.

14:28For example, if we had a bit on in this position by itself

14:31and nothing else, that would be a value of 128.

14:34If we take 128 plus 64, that would be two bits on, it'd be

14:38a total of 192.

14:39If we had the first three bits on, for example, it would be

14:41128 plus 64 plus 32, which is 224.

14:46And plus 16 more would be 240.

14:48And plus 8 more would be 248.

14:50Plus 4 more would be 252.

14:52At some point if you work with IPv4 a lot, you're going to

14:55have these values up here absolutely memorized.

14:58But until then, what you could do is this.

15:01Simply write out this table.

15:03Write the weights first, and then simply

15:05write the mask values.

15:07Which the mask values are going to be 128 plus 64 plus

15:1032 plus 16, and that's that top row right here.

15:13So for example, if we're using two additional bits from the

15:18host portion like this, that would be the mask value,

15:21there's our dividing line, and we're set.

15:24If we had a situation where we needed to use five bits for

15:29custom subnetting, because we had a requirement for 32

15:32subnetworks and we needed to take five additional bits, it

15:36would look like this in binary.

15:37We take that one, that one, that one, that one, and that

15:39one, we would leave these last three bits for host

15:42addressing, the dividing line would be right here, and our

15:45mask value would be 248.

15:47And if you needed to, you could manually calculate that,

15:50128 plus 64 plus 32 plus 16 plus 8, but having this table

15:54here is very, very handy.

15:57So here are the two things that I want you to take away

15:59from this video.

16:00Number one, I want you to be comfortable with the idea that

16:05we are stealing.

16:06We are taking away available host bits and sacrificing them

16:10for the purpose of creating additional networks.

16:13What used to be host bits, what used to be a large group

16:16of host bits are being whittled away from the high

16:19end and being sacrificed over for network addressing.

16:22The other thing I want to make sure you're comfortable with

16:24is quantity.

16:26How many bits do we need to take in order to create a

16:29certain number of subnets.

16:31And that's all about using the finger game.

16:34And to confirm that you get that game, here's what I'd

16:36like you to do right now as an Expert Exercise.

16:39I'd like you to do a scenario where you need to create 42

16:43new subnets.

16:45So here's my question.

16:47If you needed to create 42 brand new subnets, how many

16:51host bits would you have to sacrifice to

16:55meet the need of 42?

16:56And the cool thing is this, this applies--

16:59this concept applies to class A or class

17:02B or class C addresses.

17:03Because maybe you have a 10 network, that's starting with

17:06an 8-bit mask, or a 172.16 that's starting with a 16-bit

17:12mask, or a 192.168.5 that starting with a 24-bit mask,

17:17it really doesn't matter.

17:19Because all we're doing is we're stealing subnet bits

17:22from the current host portion.

17:24So in a network that had an 8-bit mask, we would start

17:27stealing the bits from this octet right here, because

17:29that's where the host bits start.

17:31In a 16-bit network we would start stealing host bits from

17:34this third octet, because that's where

17:36the host bits start.

17:37And from a network that had a /24 bit mask, we would start

17:41stealing the actual host bits from the host bits portion,

17:45which in this case is the fourth octet that we would

17:48begin stealing from.

17:49The actual quantity calculation doesn't change.

17:53It's all a matter of how many bits it's going to take to

17:55create a certain quantity of subnets.

17:58So here's what I want you to do right now.

18:00Go ahead and calculate, using the finger game, how many host

18:03bits are we going to have to sacrifice to network

18:06addressing in order to get 42 subnets.

18:09Go ahead and pause me right now.

18:11Go ahead and do the finger game.

18:12If you're in a cubicle, and people can see you, it's

18:15perfectly OK.

18:16Get those fingers flying, starting with

18:18that 2 on your thumb.

18:19So go ahead and pause me and do that now.

18:22All right, so let's see how you did.

18:24I'm going to go ahead and I'm going to do my thumb in the

18:27air right here, and this is going to be my fist.

18:30And on the back of my thumb, I've got the number 2.

18:34So that's where we start the finger game, is a number 2 on

18:37the back of out thumb.

18:39So our goal is to get up to 42.

18:42That's how many new subnets we need.

18:43So we put our thumb in the air, we say

18:452, that's not enough.

18:46We bring up another finger, and we go to

18:494, that's not enough.

18:50We bring up another finger, we go to 8, that's not enough.

18:54We bring up another finger, that's 16, that's not enough.

18:58We bring up another finger, that is 32,

19:02and that is not enough.

19:04So it we sacrificed five bits for custom subnetting, we

19:08would only get 32 subnets, which isn't enough.

19:10So what do we do in this situation?

19:12The answer is, you keep that one hand with all five digits

19:16up, and you bring up the other hand and continue to double.

19:19So on our other hand-- so I'll bring up

19:21another finger there--

19:22and we go to 64, and we stop, because 64 will meet the

19:27requirement of 42 subnets.

19:29And here's how the counting goes.

19:30We have one, two, three, four, five, six digits in the air,

19:35that means we need to take six bits.

19:38And six bits will create for us 64 subnets.

19:42It's kind of a funny little game, but it's a great way to

19:46consistently get that information right, how many

19:49subnets do you need to create, how many bits will it take,

19:53using the finger game, and then changing the mask to

19:56reflect that.

19:57So if we're taking six more bits, let's apply that to

20:00changing the mask.

20:01In the case of a current mask of eight, the new

20:04mask would be 14.

20:07We're simply adding six bits.

20:09In the case of 16, the new mask would be

20:1122, 16 plus six more.

20:14And the case of 24, the new mask would be 30.

20:18So to represent those six bits, it would look

20:20something like this.

20:21One, two, three, four, five, six, that's the new mask, we

20:25put the dividing line right there, and the new

20:27mask would be 252.

20:30So the new mask for the second octet for this network would

20:32be 252, the new mask for the third octet would be 252, and

20:37the new mask on this network would be 192.168.5.0/30, that

20:41would be in the fourth octet, the mask would be 252.

20:45It's representing on each of those networks, that we're

20:47stealing the additional six bits and allocating them for

20:50network address space, and the concept is the same for each

20:54and every one of them.

20:55In the next video, I'll walk you through how to go ahead

20:57and determine the actual values of

21:00those additional subnets.

21:02All right, here's the action items for us in this video.

21:05Number one, if you haven't already done the Expert

21:07Exercises, which absolutely include the finger game, I

21:11would strongly recommend you practice that and make sure

21:14you can do those calculations.

21:15Secondly, before you leave this video, go back and

21:18revisit the opt out questions near the beginning, just to

21:21verify that you can now answer those questions and that you

21:24are comfortable with them.

21:26I appreciate the time that you've invested in this course

21:28with me, I've had a great time.

21:30I hope this has been informative for you, and I'd

21:33like to thank you for viewing.

0:01IDs for new subnets.

0:04Every person really needs a name.

0:05And our new subnets need a new number.

0:08In this video, we'll identify exactly how to identify the

0:12new subnets you create and make it a simple process.

0:15Here are the opt out questions for this video.

0:17If you can comfortably answer these three questions

0:20correctly, please join me in the next video.

0:23For everybody else, you're in for a treat here as well too.

0:25We're going to identify a simple and concise way of

0:29identifying the new subnets created when we're stealing

0:32host bits for custom subnetting.

0:34Let's begin.

0:35In our previous video together, called "Stealing

0:38Host Bits," we identified a couple of cool tricks.

0:41Number one, we use the finger game to calculate the quantity

0:45of host bits to steal.

0:47And we also identified how we can move the mask to tell all

0:51the network devices that we're playing by

0:53the different rules.

0:54Our next challenge is, what exactly are the new subnet

0:58numbers that we are creating?

1:00And to do that, let's do an example.

1:01Now, most of the first part of this is a review from things

1:05that we've seen in our previous videos together.

1:07So let's take a network of 10.0.0.0/8.

1:11And my question for you is, what does that 8 represent?

1:15Now if you're saying OK, Keith, that's easy.

1:178 represents the fact that the first 8 bits of this address

1:22right here that we're looking at represents the network,

1:25which also implies that the last 24 bits are all host

1:29addressing space.

1:30That is perfect.

1:32My other question for you is, what would this mask look like

1:35in dotted decimal?

1:37And if you're saying, OK, Keith, that's easy.

1:38We had that in a previous video in this course as well.

1:41That would be 255, which represents eight ones for the

1:45mask, and then 0.0.0.

1:48And that is the mask in dotted decimal.

1:51Fantastic.

1:52Perfect.

1:53So here's the task I'd like to go ahead and give us.

1:56If we needed to create subnets for this topology right here,

2:02and this topology has 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

2:09subnets that we need to address.

2:11And we need to make it all fit inside of the space of

2:1410.0.0.0/8.

2:18Everything that you see in this topology has to be within

2:21this boundary with an 8-bit mask.

2:23So my question for you is, how do we go ahead and do that?

2:27Now, we've covered this in our video called "Stealing Host

2:31Bits." And the reason I mentioned that video is that's

2:33the first thing we need to decide, how many host bits do

2:37we need to steal or reallocate from the host portion?

2:40So right now we have 24 host bits.

2:44And we need to sacrifice a few of those to create subnets.

2:48And my question is, how many of those 24 host bits do we

2:52need to sacrifice to create up to 12 subnets?

2:56And my friend, to solve that you simply

2:59play the finger game.

3:00We also discussed the finger game in the previous video

3:03called "Stealing Host Bits." So I want you to pause just

3:06for a second and calculate right now, how many bits, how

3:11many hosts bits, would we have to reallocate or a give away

3:14to the network address space to create up to 12 subnets?

3:19OK, fantastic.

3:20So we need to steal four host bits.

3:23See, three wouldn't be enough.

3:24Three would only give us eight subnets.

3:27By stealing four host bits, we can get up to 16 subnets,

3:30which meets our requirement.

3:32So then the question is, what would the new mask be?

3:35The original mask is a /8.

3:38We're stealing four more additional host bits.

3:42Those are going to come out of the second octet in this

3:44example, because that's where our host bits are starting.

3:47And so if we stole an additional four host bits and

3:52allocated them to the network address space, what would the

3:55new mask be that identifies where that new boundary is?

3:59Now, if you're saying the new mask would be the old mask

4:03plus the four additional bits, which would be 12, you are

4:06absolutely correct.

4:08That's fantastic.

4:09And all of that we just did we have learned in our previous

4:13videos in this course.

4:15And now, my friends, it's time to identify what the actual

4:19subnet IDs are going to be for those new subnets.

4:23Now, by stealing four bits, we actually are going to have a

4:26possibility of 16 new subnets.

4:31So we're going to have four left over that we're not

4:33using, because we only need to go up to 12.

4:35And that's perfectly fine.

4:37But what exactly are those subnets?

4:40And to solve that, oh, this is the fun part.

4:42To solve that question of what exactly are the subsets for

4:46this guy and this guy and this guy, all we're going to do is

4:49these two simple rules.

4:51And let's start with number one.

4:52We are going to, first of all, determine the block size.

4:56Now, the block size-- and I affectionately refer to it as

4:58BS sometimes, just because the shock factor sometimes reminds

5:03people to go ahead and look for it.

5:05The block size is nothing more than the least significant bit

5:10of the new mask.

5:11Whoa, Keith, stop the truck.

5:13What do you mean the least significant

5:15bit of the new mask?

5:17Well, if you take a look at these four bits that are on,

5:19and we're looking at the second octet here.

5:22If you look at these four bits in the mask, which one is the

5:25least significant, has the lowest value?

5:28And you may be looking to say, well, Keith, it's obvious.

5:32If we look at each of these bits, the very least one, the

5:36one that has the lowest value, is this guy right here.

5:39And that is the new block size.

5:43And what I'm going to have you do if you've written this out,

5:45which I would encourage you to do every time you working with

5:48IP version 4 subnetting, these weights, I would have you put

5:52a square around that number.

5:54So wherever the least significant bit is of the

5:56mask, I'd like you to put a block around that value.

6:01And that is your block size.

6:03In this case, it's 16.

6:05If we were stealing 5 bits, it would be 8.

6:07If we were stealing 7 bits, it would be 2.

6:10So the least significant bit, we've determined the block

6:13size in this case is 16.

6:15Now how's that going to help us?

6:16This part is almost magical.

6:19What we're going to do is we're going to begin at 0 and

6:22then simply add the block size.

6:24So for step number two, in this example let's go ahead

6:27and take 0.

6:28Now, that's really easy to get to.

6:30That is our first subnet.

6:31And sometimes it's called subnet 0.

6:34So that's our very first subnet, is subnet 0.

6:37And then for our next subnet, we simply add the block size.

6:40So it's 16, so we add 16 to this.

6:43That is our second subnet.

6:45And the third one, we're simply going to add the block

6:48size again.

6:50So plus 16 more is 32.

6:52That's our third subnet.

6:54And then we're going to add 16 more again.

6:56That makes 48.

6:58Now, don't go doubling these.

7:00We're just adding the block size.

7:01So take care that you don't start doubling numbers and

7:04such, because we're just adding the block size for

7:07every new subset.

7:08So that's our fourth subnet.

7:10And our next one's going to be 64 for our fifth subnet.

7:14Again, we're simply adding 16.

7:16And we simply add and add and add.

7:19And if we added 16 again, it would be 80.

7:21So that'd be our sixth subnet.

7:23So now as we look at these subnets, what's the problem?

7:26Well, they don't really look like subnets, do they?

7:29They just look like a digit or a coupled digits, and they're

7:32not really in the format of an IP version 4 address.

7:35So here's how we complete the picture.

7:37See this first network of 10.0.0.0?

7:40The new mass is going to be 12.

7:42All we're going to do is we're going to bring that same

7:44network that we started with up, 10.0.0.0.

7:49We have the new mask, /12, and guess what?

7:52That is subnet 0.

7:54That is our first network.

7:56And that means that in this second octet right here we

7:59haven't added a block size to it.

8:01That's our starting point.

8:03So subnet 0 looks like the regional

8:05network with a new mask.

8:06For the next subnet, we're going to add that 16.

8:09So it's going to be 10.16.0.0/12.

8:13And that's our second network.

8:15And then 10.32.0.0/12, and that's our third network.

8:22And then 10.48.0.0/12.

8:26And it's important to put the mask on there so that you can

8:29communicate exactly how many bits are being used for the

8:32network and the remainder bits are host bits.

8:35And then we have 10.64.0.0/12 and 10.80.0.0/12.

8:44And if we continue this process, we would actually get

8:47up to a point where we have 16 possible new subnets because

8:51of the four bits that we're stealing.

8:53And the reason I showed you this first without including

8:56it inside the IP address is I wanted to show you a process

9:00that is simple to follow.

9:02And that is, you identify the block size.

9:04Put a little square around it to remind you, hey, this is

9:07the block size.

9:08You begin at 0, which is subnet 0, which looks like the

9:12major network with just a longer mask.

9:14And then you simply add that block size to

9:17the appropriate octet.

9:18So because here we start with a /8 and we started slicing

9:21and dicing in this second octet, that's exactly where

9:25we're going to add the block size value.

9:26So let's do another example.

9:28And I want to do it from start to finish each time so that

9:31you get in a rhythm or a pattern of

9:33exactly how to do this.

9:34Let's say that we want to have this network

9:36here still 12 subnets.

9:38And we want to make it all fit in the address space of

9:4110.50.0.0/16.

9:46That's our starting point for all of our new networks.

9:49We're still going to be stealing four additional bits,

9:52because the actual quantity of subnets hasn't changed.

9:55Our new mask is still going to look like this with a dividing

9:59line right here.

10:00Except now, we're starting to steal against the host bits

10:03which are in the third octet instead of the second octet.

10:06And that's because the 16 bits we're starting with indicate

10:09our starting point for the already

10:12allocated network bits.

10:13So here's what I'd like you to do.

10:15I'd like you to do these two steps.

10:16This is your expert exercise right now.

10:19I'd like you to determine the block size based on us using

10:22four additional bits for custom subnetting.

10:26And I'd like you to list out on paper the first six subnets

10:30that we would be using on this topology.

10:34All right.

10:35For those of you who are able to do this on

10:37your own, that's great.

10:38This does take a couple of practices to

10:40get the hang of it.

10:41So our subnets are going to be right here.

10:44Determine a new block size, which is 16.

10:46So you're going to put a block around that to remind you that

10:49is the block size.

10:50You're going to begin at 0.

10:51And here's our subnets.

10:52They are 0, and 16, and 32, and 48, and

10:5764, and 80, and 96.

11:01One, two, three, four, five, six, seven.

11:03OK, so that's the first seven subnets.

11:05Now what exactly are those going to look like as far as

11:08network addresses?

11:09Well, the first one is going to be 10.50, because those

11:13were already locked in stone before we got there.

11:15That's what we were given.

11:16And what we're doing is we're stealing the first four bits

11:19from the third octet.

11:20So subnet 0 looks like the parent--

11:23I call it the parent network--

11:25and it looks like the same exact network except for the

11:28longer mask.

11:29The mask was 16.

11:30We're stealing four more bits.

11:32The new mask is now going to be 20.

11:36The next subnet is going to be 10.50.16.0/20, and the next

11:42one is 10.50.32.0/20.

11:47And it's just going to continue all the way down.

11:49So in a topology diagram like this, we might just say in the

11:53documentation that this is the 10.50.x.0/20 network.

12:00Then for these subsets, instead of writing out the

12:02entire subnet address, we might just put the value of x.

12:06For example, this is a subnet 0.

12:08This is subnet 16.

12:10This is a subnet 32.

12:12This is subnet 48, et cetera.

12:15And then somebody looking at the topology could say, oh,

12:17this is the network 10.50.0.0/20.

12:20This is the network 10.50.16.0/20, and so forth.

12:25This time, let's mix it up a little bit more.

12:28And this will give us another opportunity to review the

12:30process and make sure that we have it down pat.

12:32In this case, let's say we don't need 12 subnets.

12:35Let's say we just need six subnets.

12:37So one, two, three, four, and five and six.

12:41So all we need is six subnets.

12:43And we want to make it all fit within 25.35.65.0/24.

12:53So that's our starting point, is that 24-bit network.

12:56We need to make this all fit.

12:58So my question is, when we're given this, the very first

13:01thing that you'd have to do is what?

13:03What's our very first step?

13:05Now, when I look at this, it's like a game.

13:08It's like we have to find out some value first.

13:10And the first thing we really need to calculate is, OK, how

13:14many bits do we need to steal?

13:16Right out of our video called "Stealing Host Bits," how many

13:19hosts bits do we need to take to create up to six subnets?

13:23And the answer is three.

13:25So we play the finger game.

13:26We determine that we need to take three bits.

13:28And we are going to change the mask by

13:30increasing it by three.

13:32So it would visually look like that.

13:35All the rest of the mask for that octet, in this case the

13:38fourth octet, would be zeroed out.

13:40And the new mask, because we're using three more bits,

13:43would not a /24.

13:44The new mask would be a /27.

13:47So that's all the finger game, in calculating what the new

13:50mask is going to be and how many bits

13:51we took to get there.

13:53And now my friends is time for your expert exercise.

13:57What I would love you to do is these two things.

14:00Determine the block size.

14:02And then secondly, I'd like you to identify all six

14:06subnets that we would need for this topology.

14:10So pause me right now.

14:12Take a moment.

14:13Work through that.

14:15And then when you're ready, we'll compare notes.

14:19So here's the process that I would go

14:21through in solving this.

14:22I literally would.

14:23If you were watching me sitting at a desk and actually

14:27going through this, I would have written out the weights.

14:30Now, I do have a lot of it memorized.

14:32But on an average day, I would write out the weights.

14:35And I say, OK, great.

14:36My block size is 32, because that's the least significant

14:40bit of the mask, the new mask.

14:42And I would say my subnets are 0, because that's where we

14:46always start.

14:47And the next subnet would be 32 more.

14:50And the next subnet would be 32 more.

14:52And the next subnet would be 32 more.

14:55And next subnet would be 96 plus 32.

14:57And we could just add that up.

14:5896 plus 32.

15:01That'd be eight and that'd be 12, which is 128.

15:05When in doubt, do the long hand math to make sure you

15:07have the numbers right.

15:09And plus 32 more, that's a 0, that's a 1, and we actually

15:13have a couple more.

15:14Because with three bits, we can actually

15:16create eight subnets.

15:18But we're only going to use the first six.

15:20So the literal subnets would be 25.35.65.

15:26That's what we started with.

15:28And remember that first subnet, which is

15:29called subnet 0?

15:30It actually looks like the major network, but it has that

15:34new mask of /27?

15:35And the next subnet would be x.x.x?

15:39There's no reason to repeat the first three octets,

15:42because we can assume those are not changing.

15:44And the last octet is going to be 32/27.

15:49And then we have 64/27.

15:52And these are our new subnets.

15:53So over here, for example, in our topology, we

15:56could just write out.

15:56This is the 25.35.65.x/27, and this is subnet 0, subnet 32,

16:07subnet 64, subnet 96 and so forth.

16:11The secret, my friend, is all about the block size.

16:15Don't get caught up in the actual

16:17numbers of the IP address.

16:20Get caught up in what the actual least significant bit

16:23of that mask is.

16:25That will show you the block size.

16:27And then you can identify all of your subnets based on the

16:30block size.

16:31The BS in this case is the most important aspect of

16:35determining your subnets.

16:38So I'd like to do one more with you.

16:40And I'd like to go a little bit abstract.

16:42Let's say we have a network that is a /16.

16:46So forget about the first two octets, whatever they are.

16:49They are locked in stone.

16:51We are dealing with now the third octet as we're going to

16:53start stealing bits.

16:55And let's say, for the purpose of this discussion, that we

16:58need to steal five bits from host addressing

17:01in that third octet.

17:03And that would allow us to create up to 32 subnets.

17:06So are dividing line is right here.

17:08And make question for you is this.

17:10What would the new mask be if we're

17:13stealing these five bits?

17:14And what would the first five subnets be?

17:17And again, it really doesn't matter about these first two

17:19octets, because they're going to stay the same for the

17:22entire discussion.

17:23It's really all about the third octet, where we're

17:26splitting and slicing and dicing the bits for subnetting

17:29purposes that we need to pay attention to.

17:32So again, what's the new mask?

17:34And what are the first few subnets?

17:36Go ahead and pause me and work those out right now.

17:40So thank you for taking time to work through that.

17:43What is really cool about this process is that it's the same.

17:47We're going to go ahead and, first of all, determinable the

17:49block size.

17:49In this case, the least significant bit is in the

17:52position of 8.

17:53So that's our new block size.

17:55The subnets are going to be 0.

17:59Again, we're in that third octet, because the first two

18:01are already chewed up.

18:02So our first subnet's going to be the 0 subnet.

18:04The next subnet is going to be 8 subnet.

18:08And then we're going to have 16.

18:11And then this is the-- for some, this is a little bit of

18:14a challenge, but only add 8 again.

18:16Don't go doubling.

18:17This is just adding the block size, adding the block size,

18:19adding the block size.

18:21So this would be 24.

18:23And this would be 32.

18:26And of course, we have another octet out there.

18:28So we'd have to hang that guy off as well.

18:31And then the new mask, what's that going to be?

18:33The original mask was 16.

18:34We're taking five additional bits.

18:36So 16 plus 5 is a /21.

18:40And if we had to write out that mask in dotted decimal,

18:45it would be 255, which means the first

18:48octet is all network.

18:50255, the second octet is all network.

18:53That was that way before we got here.

18:56And what we've done is we've stolen five bits from that

18:59third octet.

19:00And to represent that, it would be 128 plus 64 plus 32

19:04plus 16 plus 8, or--

19:07and we have 248 already written for us--

19:10we could just say it's 248.

19:12Any way you want to get there is perfectly fine.

19:14It's just math.

19:15And then the last octet is all host bits.

19:18So the host bits available are the three host bits from this

19:21third octet plus all eight bits from the last octet, for

19:25a total of 11 host bits available.

19:29Our action items in this video are really simple.

19:31Number one, make sure you've gone through the expert

19:34exercises with me, that you can now identify the actual

19:37block size and these subnets that would be available when

19:41doing custom subnetting.

19:42Secondly, I'd have you go back and take a look at the opt out

19:45questions at the beginning.

19:46Because now, after working through each of these

19:49exercises, you should be comfortable and able to answer

19:53the questions in the opt out section for this video.

19:57I have had a great time.

19:58I appreciate the time we have spent together.

20:01I hope this has been informative for you.

20:03And I'd like to thank you for viewing.

0:02In this video, you're going to learn how to identify the

0:04range of valid IP address then we can actually assign to

0:07hosts on each of our new custom subnets.

0:11And here's the opt out questions for this video.

0:13If you can answer all four correctly and you're

0:15comfortable, I'll see you in the next video.

0:17For most people, however, we are going to have a fantastic

0:20time right here, right now, as we identify how to quickly and

0:25easily identify the range of valid IP addresses on any of

0:29our given subnets.

0:30Let's begin.

0:31In our previous video together, we identified the

0:34individual subnets that can be created.

0:36And in this video, we're going to focus on the valid hosts

0:39that would fit on those subnets.

0:41So to do that, let's go ahead use an

0:42example of this topology.

0:44We have three subnets that are required so far.

0:47Let's add a few more.

0:47Let's add a network out here, here, here, and here.

0:50So we'll need a total of one, two, three, four, five, six,

0:56seven subnets.

0:57So let's say we have a /24 network to begin with.

1:00So x.x.x.0/24.

1:04Now, do you get it that these first three numbers are going

1:07to be the same across the entire board, if this is our

1:10major network?

1:11So we're going to start from that point.

1:13And we're going to start stealing bits from the host

1:15portion, which is the last eight bits.

1:18So by using the finger game, we can calculate that we need

1:21to steal three bits that will give us up to eight subsets,

1:25which is enough for our topology right here.

1:27So our new dividing line is right there.

1:29Our block size is 32, and our subnets are going to be subnet

1:330, subnet 32, subnet 64, subnet 96,

1:39subnet 128, subnet 160--

1:43again, we're just adding the block size

1:45to each one of these--

1:46subnet 192, and subnet 224.

1:50So here are eight of the possible

1:52subnets that we can create.

1:54We're only going to need seven of them.

1:56So over here, for example, we can have this be subnet 0.

1:59This could be subnet 32.

2:01This could be subnet 64, right there.

2:05This could be subnet 128.

2:07Subnet 160, subnet 96, I didn't mean to leave him off.

2:11And over here, is subnet 192.

2:13So those are our subnets.

2:14And of course, the first three octets would the x.x.x,

2:18meaning they would be whatever they were over here followed

2:21in the last octet by this value.

2:23So let's say we've identified these subnets, we know where

2:26we're going to put them, and we want to go and

2:27configure an interface.

2:29For example, let's take a look at serial 0/0 on router 2.

2:34We go into interface configuration mode.

2:36We want to configure the actual IP address.

2:38And then we realize, oh my goodness, what are the valid

2:42IP addresses that are on subnet 128?

2:46And the focus of this Nugget, this video, is to go ahead and

2:49walk you through the very straightforward process of

2:52identifying exactly what the valid IP addresses are for

2:56subnet 128.

2:58And the process is right here.

3:00You're going to start by listing the subnets.

3:02So here we have all eight subnets.

3:04And I have the s in plural because you don't have to list

3:08all the possible subsets.

3:10You can just go ahead and start listing the ones that

3:12you're going to be using, or the ones that

3:13you're concerned about.

3:15And again, we're going to use the block size to determine

3:17our subnets.

3:18Once we have the subnets listed and we're interested,

3:21for example, in the range, let's go ahead and takes

3:23subnet 128 as an example.

3:26The very first host, the first valid host IP address on a

3:30subnet is going to be that subnet plus 1 in

3:34the very last octet.

3:36Now in this case, we're already in the very last octet

3:39right here.

3:41So for the 128 subnet, the very first host

3:44is going to be 129.

3:47So I'll call this column right here First Host.

3:51Now, I want to ask you a question.

3:53If 129 is the first host, do you think 130 is also a valid

3:57IP address on this subnet?

4:00And if you're saying, yeah Keith, it sounds

4:01like it would be.

4:01It's right next to it.

4:02How about 131, and 132, and 133?

4:06And if you look at the numbers everything that is lower than

4:09160 is part of the 128 subnet.

4:13If we go high enough, we're going to bump into subnet 160.

4:16And the reason that's important to know what the

4:18next subnet is, is that the range of IP addresses on the

4:22128 subnet will never go as high as 160.

4:26Why is that?

4:27Because 160 is the next subnet.

4:30So if we wanted to calculate all the valid IP addresses on

4:33the 128 subnet, the very first host would be the subnet plus

4:371, and the very last host is going to be the next subnet,

4:42right here.

4:42I'd like you to read this with me.

4:44The last host is going to be the next subnet minus 2.

4:49So if this guy's 160, if we subtract 2 from that, the last

4:53host on the previous subnet is going to be 158.

4:57Now, the first knee-jerk reaction is, why?

5:00Why do we have to subtract 2?

5:02Why can't we just use the next subnet minus 1?

5:05And the reason for that is the next subnet minus 1 is the

5:09broadcast address for the previous subnet.

5:13So the first host is this column.

5:15The last host is right here.

5:18And the formula for that is the next subnet minus 2.

5:21And the broadcast address is going to be the next subnet

5:26minus 1, which is 159 in this case.

5:30So what that means to us if we want to configure the IP

5:33addresses here on subnet B-- which is, more specifically,

5:36subnet 128--

5:37the valid IP addresses that you and I could choose to use

5:40for any device on this network--

5:42and I'm laughing because there's only two here.

5:44But the range IP addresses could be

5:47anywhere between 129--

5:49so x.x.x.129 through 158.

5:53We couldn't use 128 because that's the actual street name

5:57all by itself.

5:58That is the subnetwork address.

5:59The first valid host is 129.

6:01The last valid host is 158.

6:04And regarding this subnet right here?

6:06The broadcast address that we would associate with this

6:10subnet is 159.

6:12One more IP address higher and we're

6:14looking at the next subnet.

6:16So let's play that game again.

6:17And what we're going to do is we're going to use this

6:19formula right here.

6:20And let's pick on this subnet right here, subnet 192.

6:24So my question for you is this.

6:26What is the first valid host on the 192 subnet?

6:31What is the last valid host on the 192 subnet?

6:34And that what is the broadcast address for the 192 subnet?

6:40So on the 192 subnet, the rule is that the first host is the

6:44subnet itself plus 1.

6:46So for the 192 subnet, that means the first

6:49host would be 193.

6:53The last valid host on this subnet is going to be the next

6:56subnet minus 2.

6:57Well, the next subnet is 224, so minus 2 would put our last

7:02valid host at 222.

7:05And the broadcast address for this 192 subnet is the next

7:09subnet minus 1, which is 223.

7:13That's it.

7:14That's how you calculate the valid range of IP addresses on

7:18a given subnet.

7:20So what I'd like you to do right now as your first expert

7:23exercise in this video, is I'd like to write

7:25down these four steps.

7:28List the subnets.

7:29The first host is the subnet plus 1.

7:32The last host is the next subnet minus 2.

7:34And the broadcast address is the next subnet minus 1.

7:38As you get more and more experienced, you're going to

7:40be able to take additional shortcuts.

7:41But if you're new to this, having this process in mind of

7:45exactly what to do first, what to do next, what to do next,

7:48that will assist you in identifying the valid host

7:52addresses on a given subnet.

7:55So take a moment.

7:56Pause me and write out these four steps right now.

8:01So let's you and I do another exercise.

8:03For our requirement, let's say we have a /16 to begin with.

8:07And it really doesn't matter what those

8:09first two octets are.

8:10If the initial mask is 16, that's what the

8:12initial mask is.

8:14And let's say we have a requirement to

8:16create 15 new subnets.

8:20What I would like you to do is I'd like you to go ahead and

8:22list the first four subnets and their ranges, their ranges

8:29for valid host address on those first four subnets.

8:32And for bonus points, go ahead and include the broadcast

8:36address for each of those subnets as well.

8:39So just to be clear, we're starting off with a /16.

8:42You need 15 new subnets.

8:44You're going to list the first four subnets and their ranges

8:47of valid hosts.

8:48Go ahead and pause me and do that right now.

8:54All right, welcome back.

8:55I'm curious, how did you do?

8:57Were you able to put all the pieces together?

8:59Here's how I would approach this.

9:01I'd say, first of all, we have this /16 network, right?

9:04We need 15 new subnets.

9:06So of course, we're going to do the finger game to identify

9:09how many bits we have to take away from host addresses to

9:13create at least 15 new subnets.

9:16The answer to that is four fingers, or four bits.

9:19And that new mask would look like this.

9:21There's our dividing line.

9:23There's our block size of 16.

9:25And the first four subnets would be 0 for subnet 0, 16,

9:30plus 16 more is 32, plus 16 more is 48.

9:34And that's all I asked for.

9:36It was the first four subnets.

9:38Now what's different about this than the last example is

9:40we are working in this third octet right here.

9:43So this byte of data that we're cutting into, the host

9:47portions, represents the third octet in this network that

9:51began with a 16-bit mask.

9:53So our new mask, it was a 16, so the new mask is

9:56going to be a /20.

9:58And I'm going to bring those subnets down here.

10:00We have x.x representing the first two octets.

10:03We have .0 and x.x.16 and x.x.32 and x.x.48.

10:12Those are our first four subnets.

10:13Now, because we are in the third octet, we have another

10:17eight bits to represent over here that are all host bits.

10:21So a total of 12 host bits-- these four here from the third

10:24octet, plus all eight bits from the last octet for host

10:28addressing.

10:29Now, I did throw you a little bit of a curveball, because we

10:32are no longer in the last octet.

10:34We are in the third octet that we're actually

10:37stealing bits from.

10:38So if we wanted to calculate the first valid host address

10:41on these subnets, how would we do it?

10:44And the answer is, the same exact way

10:47that we did it before.

10:49Our first task is to list the subnets.

10:51Well, here's the first four.

10:52That's done.

10:53The first host is going to be the subnet plus 1.

10:56And we add that plus one to the last octet.

10:59So this network of x.x.0.0, the first valid host--

11:03I'll write "first" here--

11:04is going to be x.x.0.1.

11:07That's our first valid address.

11:10The first valid address for the 16 subnet.

11:12I'm going to leave off the x's, by the way.

11:14I'm just going to leave the arrow down there.

11:16The first valid host on the 16 subnet is going to be 16.1.

11:20The first valid host on the 32 network is going to be 32.1.

11:24And the first valid host on the 48 network is going to be

11:2748, and you got it.

11:29We're just simply going to add 1 to the last octet, 48.1.

11:33So piece of cake.

11:34We've got the first valid IP address on

11:37each of those subnets.

11:39The next question, what is the last valid IP address?

11:43Or we might even want to go for the broadcast address

11:46first if you want.

11:47And then we could simply subtract one more from that

11:50for the last.

11:51It really doesn't matter in which way you do it, as long

11:53as you're comfortable with the process of what you are doing.

11:57So let's say for the 0 subnet.

11:59That's right here.

12:00Our first subnet is subnet 0.

12:01The first valid host for us is 0.1.

12:04And I think the broadcast address is going to be the

12:07next subnet minus 1.

12:09You know why I think that?

12:10Because that's exactly how that works.

12:13Right here, the broadcast address is the next

12:15subnet minus 1.

12:17So if we wanted to look at the next subnet, which is 16.0,

12:21what is 16.0 minus 1?

12:24It's going to look like 15.255.

12:28And let me show you that in binary.

12:30In the third octet, we have four bits that are on.

12:34And then in the last octet we have 8 bits that are on.

12:36So that is 15 and that is 255 right there.

12:41And our mask is right here.

12:43So my question is, what happens if you add one more,

12:46plus 1, right here?

12:47Well, all of these are going to carry over.

12:50So the plus 1 is going to topple all of these to zeroes.

12:53This is going to turn to 16, because they're all going to

12:56topple over.

12:57And that's the binary behind it.

12:59So 16.0 minus 1 is 15.255.

13:04You simply put 255 for the last octet and you take this

13:07number and say minus 1.

13:09So the next question is, OK, what's the last valid host on

13:12the 0 subnet?

13:14Well, it's the next subnet minus 2.

13:16So if the broadcast is 15.255, this last IP address is going

13:20to be 15.254.

13:24So our range of valid IP addresses on the 0 subnet is

13:28going to be whatever those first two octets are, 0.1

13:32through whatever those first two octets are, 15.254 with a

13:37broadcast address of 15.255.

13:40Let's go ahead and do that same game again.

13:42And let's do it for subnet 32.

13:44And we can follow these exact steps.

13:47So on the 32 subnet, the first valid host is 32.1.

13:51The last valid host is going to be the next subnet, which

13:53is the 47 subnet minus 2.

13:56And minus 2 would be 47.254.

14:01And the broadcast would be 47.255.

14:06And then the next subnet of course is 48.

14:08So here's our first.

14:10Here's our last.

14:11And here's our broadcast address for the subnet.

14:15For this next one, let's go ahead and use a /8.

14:17So our network is x.0.0.0.

14:20Our host bits are going to start in that second

14:22octet with a /8.

14:24And let's say we need to create 120 new subnets.

14:30So with the finger game, we get our thumb out and we start

14:32counting 2, 4, 8, 16, 32, 64, 128, I have seven bits, or

14:38seven fingers up, that represent that's how many bits

14:41it would take to create at least 120 new subnets.

14:45So our new mask is going to be seven bits into that second

14:48octet, right there.

14:51So there's the dividing line.

14:53So our new mask is going to be 7 bits above and beyond the 8

14:57bits we started with, which is 15.

14:59That new mask would be represented as 250, in dotted

15:02decimal as 255 dot and 254 for that second octet.

15:07Which simply means that the mask is taking the first 7

15:10bits of that second octet for the

15:12purpose of network address.

15:15So let's go ahead to list our subnets and the ranges.

15:17Now, we have a whole bunch of subnets.

15:20In fact, we're going to have the ability to

15:22have up to 128 subnets.

15:25I don't want to list all 28, but let's go ahead and list

15:28like four or five of them to get the feel for it.

15:31So the first subnet is going to be subnet 0.

15:34And then our block size, because it's a 2, the next

15:37subnet is going to be 2.

15:38And then add two more, and add two more, and add two more, et

15:42cetera, et cetera.

15:44So that's our block size, and that's why we're adding that.

15:46And those are out subnets.

15:48So our subnets are going to be x dot, x dot, x dot, x dot, x

15:53dot, with that x being whatever it was.

15:55It could be a 10, it could be a 40.

15:57It could be a 195.

15:59Whatever it is, it's going to stay that way.

16:02Now, because this is the second octet where we're doing

16:05our custom subnetting, we still have two more octets of

16:08zeroes so we'll put them in as well.

16:10So there's our first five subnets.

16:13Subnet 0 would be our first.

16:15And then we have second, third, fourth and fifth.

16:18We could also refer to them as subnet 2, subnet 4,

16:22subnet 6, et cetera.

16:24So now let's go ahead and let's determine what the

16:27actual valid ranges are for each of these subnets.

16:31In fact, let's go ahead and just pick on subnet

16:342 just for a moment.

16:36And what I'd like to do is, for subnet 2, let's identify

16:39the first host, the last host, and the broadcast

16:44address for subnet 2.

16:47The rules are exactly the same.

16:49We've listed our subsets.

16:51That's already done.

16:51We've got five of them right here.

16:53For the first host for subnet 2, it's going to be one more

16:58than the actual subject value itself.

17:00So the first host is going be x.2.0.1.

17:05And that's the first valid IP address on subnet 2.

17:09Now the last valid IP address is going to be the next

17:11subnet minus 2.

17:13And the broadcast is going to be the next subnet minus 1.

17:16Whichever one you want to do first, you absolutely can.

17:19So let's do the last address.

17:21That would be x.4.0.0 minus 2.

17:25So that would look like this. x.3.255.254.

17:33And that is the last valid IP address on subnet 2.

17:37And the broadcast address is going to look just like the

17:40last IP address, except it's going to be one greater than.

17:44So the broadcast address is one greater

17:46than the last IP address.

17:48And it happens to be one less than the very next subnet.

17:52Let's do one more.

17:54Let's go ahead and do it for subnet 6 right here, which is

17:58our fourth subnet.

18:00And what I would like you to do is go ahead and

18:02pause me right now.

18:03I'd like to write out, what is the first valid host for this

18:07fourth subnet?

18:08And what is the last valid host?

18:10And what is the broadcast, using this same exact process

18:14that we just went through together.

18:15So pause me right now.

18:17When you're done, unpause me.

18:18And we'll compare notes.

18:21So for this fourth subnet, which is subnet 6, the first

18:25valid IP address is going to be x.6.0.1.

18:30It's the subnet plus 1.

18:32The last valid host is going to be the next subnet minus 2.

18:37So that next subject value is x.8.

18:39So it's going to be x.7.255.254.

18:46That, in measurable terms, is the next subnet minus 2.

18:50And our broadcast address is one less than the next subnet.

18:54So that would end in .255.

18:57It'd be x.7.255.255 for our broadcast.

19:02And that's it.

19:03What we've done in this video together is we've identified

19:08for an 8-bit or a 16-bit or a 24-bit mask how we would go

19:13about identifying not only the subnets, but also the valid IP

19:17addresses of hosts that could be in those subnets.

19:21Here's our action items for this video.

19:23Number one, of course, is you need to make sure that you've

19:26participated in the exercises in this video about

19:29calculating the first valid IP address and the last valid IP

19:33address for a given subnet.

19:35Secondly, go back to the opt out questions at the very

19:38beginning of this video, just to validate that you can now

19:41correctly and comfortably answer each and

19:44every one of them.

19:46I have had a great time.

19:47And I absolutely appreciate the time that

19:49we have spent together.

19:51I hope this has been informative for you, and I'd

19:53like to thank you for viewing.

0:01Is there room for one more, says the computer?

0:03In this video, we're going to take a look at calculating the

0:06quantity of how many valid IP addresses are available for

0:10each of our subnets.

0:11Here's the OPT out questions for this video.

0:14If you can answer all three of these correctly and

0:16comfortably, please join me in the next video.

0:19Otherwise for everybody else, we're going to have a great

0:21time as we determine the exact number of hosts that can be

0:25fit into a given subnet.

0:27Let's begin.

0:29I'd like you to imagine that you and I have just finished a

0:32custom subnetting plan for this network topology.

0:35And that we're pretty darn happy about it too because

0:37here's what we did.

0:38We identified how many subnets we'd have to create, we

0:41recognized how many bits we'd have to steal from host

0:44address space to create those subnets, we identified the new

0:48subnets, we moved the mask over to represent the new mask

0:51for the entire network.

0:52And not only did we identify the subnets, we also

0:55identified the valid IP address host range within each

0:58of those subnets.

0:59Now what we haven't yet done is we haven't yet identified

1:03how many hosts will fit in a given subnet.

1:07Now I suppose we could do this, we could say well the

1:09first host is X, and the last host is Y. And we could

1:14manually count between X and Y inclusively to figure out how

1:19many individual IP addresses are there in that subnet.

1:22But there's a much better way just to calculate rock

1:26quantity and that process is this.

1:28Number one, we're going to identify the number of host

1:31bits available.

1:32So in our topology, let's say we ended up with a /27 mask.

1:37And for this question it doesn't even matter where we

1:40started, it's just a matter of where we ended.

1:43So we have a /27 bit mask.

1:45And my question is, how many host bits are available that

1:49the mask didn't take and allocate

1:51for the network address.

1:53So if you're thinking well Keith, let

1:54me think about this.

1:55We have a 32-bit IP version 4 address, we're using 27 of

1:59those bits for the mask.

2:01That would leave exactly 5 bits available for host

2:05addressing if we're using this mask.

2:08And that is absolutely correct.

2:09So that's our first step for calculating the quantity of

2:13PCs, printers, router interfaces, switch IP

2:17addresses that may be in that subnet.

2:19That's the very first step is to identify how many hosts

2:22bits we have to play with for that subnet.

2:25And here the answer is 5.

2:26The second thing we're going to do is we're going to use

2:29the finger game.

2:30And again, our fingers, our digits are representing the

2:33actual bits.

2:34In this case however, our fingers, our digits are

2:36representing the five available host bits.

2:39So we're going to stick our thumb up in the air with that

2:42big old two on it and we're going to say two.

2:45And then we'll bring up our second digit and say four.

2:47The third digit and say eight.

2:49The fourth digit and say 16.

2:51And that fifth--

2:52and that's our goal by the way, that fifth digit in the

2:55air, and we'll see say 32.

2:57And that my friends is very close, not exactly, but close

3:02to the number of valid host IP addresses

3:06in that given subnet.

3:08Now you might be saying OK Keith, what do

3:11you mean it's close?

3:12This is mask, it either works, or it doesn't work.

3:14Well it is true, that if we have five bits we have 32

3:18different combinations.

3:20However, not all of those are valid host addresses.

3:24For example, with a /27 we know that we're stealing the

3:28first, second, and third bits out of that fourth octet.

3:32So right here is the 24-bit boundary, there's 25, 26, 27.

3:37So here's our new boundary line if you will, between the

3:41network, and host bits.

3:42Network on the left of the blue line,

3:44host bits on the right.

3:46So here's our five host bits right here that the mask

3:49didn't take.

3:50So for a /27, if we wanted to know that the subnets--

3:54here's the block size right there, 32.

3:56We know the subnets are 0, 32, 64, 96, and so forth.

4:02And the first three numbers we really don't care about

4:06because they're going to be the same on every single one

4:08of our subnets.

4:10It's this last octet where we're slicing and dicing.

4:13And the new mask of course would be

4:15/27 for each of those.

4:18So let's pick an example here, let's say that this subnet two

4:21is going to be subnet 64.

4:23So this subnet right there.

4:25So what is the first valid host?

4:27Well Keith, the first valid host is the subnet as we

4:30learned in our course.

4:31And it's the subnet plus 1 more.

4:33So the first valid host would be 65.

4:35Excellent.

4:36So that's the first valid host.

4:38What's the last valid host?

4:40Well the last valid host as we've learned, is the next

4:43subnet minus 2.

4:44So if the next subnet is 96, the last valid host on the 64

4:48subnet would be 94.

4:51And that is our range.

4:52And the broadcast address--

4:54I'll put B for broadcast right here-- would be 95.

4:58So the reason I point that out is that this 32 is all the

5:02possible combinations we can get with five bits.

5:05However we cannot I repeat, we cannot assign the actual

5:09subnet address to a host interface like a router

5:13interface, or printer, or a PC.

5:14It won't allow it.

5:16It'll say, hey, this is the actual subnet.

5:18There's no bits that are in the host portion.

5:21It's sort of like me saying, I live on 123 Elm Street.

5:25And you ask me for my address, I'd be like saying, I live on

5:27Elm Street.

5:28Well, what house are you on Elm Street?

5:31No, no I just live on Elm Street.

5:33It's not enough information.

5:35We have to have at least one bit of the host portion that

5:38is on for it to be a valid IP address that we can assign to

5:42an interface.

5:43So what that means is we have 32 minus 1 for the subnet,

5:48which we cannot assign to an individual interface.

5:51And the other one that we cannot assign to an interface

5:54is the broadcast address for that same subnet.

5:58So we're also going to do minus 1 based on

6:01the broadcast address.

6:03And for that reason, when we calculate the number of the

6:06hosts available on a subnet we're going to

6:09play the finger game.

6:10But when we get our results, we're going to go ahead and

6:12subtract two.

6:14And that's because we cannot use the subnet itself, that

6:17subset address, nor the broadcast as a valid IP

6:20address on interface.

6:21So I'd like to do one more example with you on that.

6:24And that example is this, let's say we have a /30.

6:28So we have a /30 mask.

6:30My question for you is, how many valid hosts could we put

6:35on a subnet that's a /30.

6:37Now at this point, I want you go through this process.

6:40I'd also like you to take a moment right now and pause the

6:43screen, and write down these three steps regarding how to

6:47exactly calculate the quantity of host on a subnet.

6:51So go ahead and pause me.

6:52Write these three steps down.

6:54Do the math for a /30.

6:56And then, resume me.

6:57And we'll compare notes.

7:00All right, how did you do?

7:01Well our first up on this is to count the number of host

7:04bits available.

7:04Well, 30 bits are being used for the network.

7:07That leaves only two bits for host addressing.

7:10So the answer to that is two.

7:11We're going to use the finger game with our digits

7:13representing host bits.

7:15So we'll put two fingers up in the air and we'll count

7:17verbally to four, that's our result.

7:20And then we subtract two because we can't use the

7:22actual subnet, or broadcast address

7:25on an actual interface.

7:26So minus 2 equals a total of two possible IP addresses for

7:31a valid host on a /30 network.

7:34So you've got it my friend.

7:35That's exactly how we can calculate the total number of

7:39hosts that will fit as far as valid IP host addresses on a

7:43sub network.

7:45Our exercises for this video are simple, it's to make sure

7:47that you have practiced along with me in this video

7:50regarding calculating the actual number of hosts that

7:53would fit on a given subnet based on the mask.

7:56And secondly, go ahead and take a moment and check out

7:58the OPT out questions at the beginning of this video, just

8:01to make sure that you are now comfortable, and capable of

8:04answering those questions.

8:06I've had a great time.

8:07I appreciate you joining me.

8:09I hope this has been informative for you.

8:11And I'd like to thank you for viewing.

0:01In this video, we're going to learn how to reverse engineer

0:04a subnet based on a computer's host IP address.

0:08Here's our Opt Out questions for this video.

0:10If you know the answers to these questions and are

0:13comfortable with them, I'll see you, my friend, in our

0:15next video.

0:16For everybody else, oh, you are in for a treat.

0:18We are going to take a look at how to look at an IP version 4

0:22address on a host and reverse engineer out of that to

0:26determine what the actual subnet is that that host is

0:29connected to.

0:30Let's begin.

0:31I'd like to start off this Nugget by taking a look at a

0:33router interface.

0:35Let's do a show run for interface gig 1/0 on this

0:39Cisco IOS router.

0:40And here's the IP address currently

0:42configured on that interface.

0:44It's 42.255.74.251.

0:48And the mask says that the first 8, 16, and that goes out

0:53to the first 22 bits are all being used for network

0:57addressing.

0:58So that's 8 bits there plus 8 more and 6 bits, so 252.

1:02The binary representation of that would be 11111100.

1:07And there's our dividing line.

1:09The last two bits of this octet and the final octet as

1:13well, which is all 0's, are all available for host bits.

1:16The question I have for you and the reason I brought you

1:19here is what if we are given an IP address like this that's

1:22sitting on some subnet and we are asked to

1:25reverse engineer it?

1:27So what we get to do in this video is take a look at how we

1:30can, in measurable terms, take an IP address like this and

1:35determine from that IP address what the actual subnet is that

1:39this client is sitting on.

1:41Let's bring that IP address back here.

1:43It was 42.255.74.251, and it had a slash 22-bit mask.

1:53So as we look at where we're slicing and dicing, we know

1:56that the first two octets for sure are

1:58all the network address.

2:00And we have 6 bits into this third octet.

2:03So the mask would look like this, 111111.

2:07There's our dividing line, and the last two bits of the mask

2:09would be 0's.

2:11Just be sure, we could double check.

2:13We have 16 up to right here.

2:14Then we have 17, 18, 19, 20, 21, 22.

2:18And that is correct.

2:19Also, the mask value showed 252, which is another

2:22reinforcer that we've got the mask correct.

2:25All right.

2:26How do we reverse engineer this?

2:28It's really straightforward.

2:29What I'd like you to do right now is I'd like you to write