WEBVTT

0:00:07.940000 --> 0:00:14.920000
 So, all this time with subnetting, we've
 been doing something called same

0:00:14.920000 --> 0:00:17.180000
 length subnetting.

0:00:17.180000 --> 0:00:20.920000
 And there is a problem
 to this approach.

0:00:20.920000 --> 0:00:27.740000
 The problem is we've been designing these
 networks purely from the perspective

0:00:27.740000 --> 0:00:32.860000
 of how many networks do I need, creating
 a subnet mass that's the same

0:00:32.860000 --> 0:00:37.140000
 for every single network based on how
 many total quantity of networks

0:00:37.140000 --> 0:00:39.720000
 I need and it was not
 even a consideration.

0:00:39.720000 --> 0:00:44.300000
 We didn't even think about how many hosts
 do we need in each one of those

0:00:44.300000 --> 0:00:46.720000
 networks. And that would
 result in a problem.

0:00:46.720000 --> 0:00:48.840000
 For example, take a look at this.

0:00:48.840000 --> 0:00:53.060000
 We start here with a single
 base network, a slash 24.

0:00:53.060000 --> 0:00:56.540000
 That one network gives us the
 whole range of host space.

0:00:56.540000 --> 0:01:00.400000
 So, in that last octet, we've
 got from 0 to .255.

0:01:00.400000 --> 0:01:02.340000
 That's the full range
 of host addresses.

0:01:02.340000 --> 0:01:04.840000
 Now, we know that two of those
 we can't use, right?

0:01:04.840000 --> 0:01:07.020000
 The .0 and the .255.

0:01:07.020000 --> 0:01:11.000000
 But that circle there represents the
 full range of host space in that

0:01:11.000000 --> 0:01:17.420000
 last octet. Now, if we used our previous
 approach of same length subnetting,

0:01:17.420000 --> 0:01:20.880000
 and let's say we needed four networks
 like this building right here, needs

0:01:20.880000 --> 0:01:23.780000
 four networks, well, what's the approach
 we would have come up with?

0:01:23.780000 --> 0:01:26.600000
 Well, we would have said, okay, well,
 if I steal two networking bits,

0:01:26.600000 --> 0:01:29.860000
 if I steal two subnet
 bits, there I go.

0:01:29.860000 --> 0:01:31.780000
 That'll give me four
 subnets, right?

0:01:31.780000 --> 0:01:34.180000
 So, now we've got
 that circle there.

0:01:34.180000 --> 0:01:38.880000
 We divide it into four sections,
 a pi of four equal slices.

0:01:38.880000 --> 0:01:42.000000
 And they're all equal because every
 single network is going to have the

0:01:42.000000 --> 0:01:43.440000
 exact same subnet mass.

0:01:43.440000 --> 0:01:45.980000
 They're all going to be slash 26.

0:01:45.980000 --> 0:01:49.320000
 And with a slash 26,
 what do we know?

0:01:49.320000 --> 0:01:58.520000
 Going back to this right here, with
 a slash 26, we know that each one

0:01:58.520000 --> 0:02:04.640000
 of these networks is going
 to have 62 host addresses.

0:02:04.640000 --> 0:02:06.660000
 62 host addresses.

0:02:06.660000 --> 0:02:12.340000
 So 64 addresses total, the network address,
 62 host addresses, and then

0:02:12.340000 --> 0:02:13.660000
 the broadcast address.

0:02:13.660000 --> 0:02:15.920000
 So 64 addresses total.

0:02:15.920000 --> 0:02:19.040000
 So that's what you see right here.


0:02:19.040000 --> 0:02:22.260000
 Network one, two, three, and four.


0:02:22.260000 --> 0:02:28.100000
 And they're all equal, right?

0:02:28.100000 --> 0:02:34.000000
 Network one starts at the network address
 of .0, broadcast address ends

0:02:34.000000 --> 0:02:43.240000
 on .63. Network two begins at address
 64, ends at broadcast address .127.

0:02:43.240000 --> 0:02:49.220000
 Network three begins at network address
 128, broadcast address 191, and

0:02:49.220000 --> 0:02:52.660000
 then the remaining host space
 is network number four.

0:02:52.660000 --> 0:02:58.380000
 So we do have our four networks,
 but we have a problem here.

0:02:58.380000 --> 0:03:05.200000
 Check it out. Network number two,
 it requires more than 62 hosts.

0:03:05.200000 --> 0:03:07.220000
 He needs 80 hosts.

0:03:07.220000 --> 0:03:12.420000
 80 hosts won't fit into any of
 these slices of pie right here.

0:03:12.420000 --> 0:03:14.120000
 It's not going to fit.

0:03:14.120000 --> 0:03:16.860000
 Not only that, look at some
 of these other networks.

0:03:16.860000 --> 0:03:18.860000
 For example, look at
 network number one.

0:03:18.860000 --> 0:03:21.440000
 There's only five hosts in that.

0:03:21.440000 --> 0:03:26.340000
 And yet we've allocated 62
 hosts in that one network.

0:03:26.340000 --> 0:03:29.460000
 That's far more host space
 than we really need.

0:03:29.460000 --> 0:03:33.220000
 We've got a whole bunch of extra bits
 that aren't even being used because

0:03:33.220000 --> 0:03:36.260000
 this network is far larger and
 can support for the network.

0:03:36.260000 --> 0:03:39.380000
 Far more hosts than
 is actually needed.

0:03:39.380000 --> 0:03:44.320000
 So this is the problem with
 same length subnetting.

0:03:44.320000 --> 0:03:48.120000
 We're completely ignoring our host
 requirements, which means we might

0:03:48.120000 --> 0:03:52.340000
 end up with subnets that are either
 far larger than we actually need and

0:03:52.340000 --> 0:03:56.020000
 it's a complete waste of space
 or just the opposite.

0:03:56.020000 --> 0:03:59.360000
 We might come up with subnets
 that are too small.

0:03:59.360000 --> 0:04:03.260000
 Like none of these subnets here will fit
 our requirement for network number

0:04:03.260000 --> 0:04:08.320000
 two. So this is where we take
 a different approach.

0:04:08.320000 --> 0:04:12.180000
 Something called variable
 length subnet masking.

0:04:12.180000 --> 0:04:16.340000
 Now with variable length subnet masking,
 here's basically what we're going

0:04:16.340000 --> 0:04:22.360000
 to do. Instead of starting with the
 position of okay, I need to figure

0:04:22.360000 --> 0:04:24.840000
 out how many total
 networks I need.

0:04:24.840000 --> 0:04:28.920000
 And then create one subnet mask that
 will come up with that total quantity

0:04:28.920000 --> 0:04:31.760000
 of networks. We're going to do
 it from a different approach.

0:04:31.760000 --> 0:04:36.160000
 Instead, we're going to say, I'm going
 to create my subnets based on how

0:04:36.160000 --> 0:04:39.380000
 many hosts are needed
 in each subnet.

0:04:39.380000 --> 0:04:41.160000
 Oh, this subnet's really large.

0:04:41.160000 --> 0:04:42.500000
 It needs a lot of hosts.

0:04:42.500000 --> 0:04:46.620000
 Okay, that'll have a subnet
 mask of maybe a slash 26.

0:04:46.620000 --> 0:04:50.580000
 Oh, and then there's a tiny little subnet
 over here that only needs four

0:04:50.580000 --> 0:04:54.060000
 hosts. Don't need a slash
 26 for that one.

0:04:54.060000 --> 0:04:56.600000
 Why don't we use a slash
 29 for that one?

0:04:56.600000 --> 0:05:01.060000
 And so we're going to create subnet
 masks of variable sizes, hence the

0:05:01.060000 --> 0:05:03.780000
 name variable length
 subnet masking.

0:05:03.780000 --> 0:05:08.820000
 They're finely tuned or finely designed
 based on the host requirements

0:05:08.820000 --> 0:05:12.500000
 that each network actually needs.

0:05:12.500000 --> 0:05:14.820000
 So let's do the same example here.


0:05:14.820000 --> 0:05:21.820000
 In this particular case, base our
 subnets based on host required.

0:05:21.820000 --> 0:05:25.940000
 So typically the way you do this is
 you start with the largest network,

0:05:25.940000 --> 0:05:28.300000
 the network that's going to have
 the biggest host requirement.

0:05:28.300000 --> 0:05:30.000000
 So I say, okay, let's see here.

0:05:30.000000 --> 0:05:32.960000
 80 hosts. I need 80 hosts.

0:05:32.960000 --> 0:05:36.620000
 Well, going back to my chart.

0:05:36.620000 --> 0:05:40.760000
 If I need 80 hosts,
 what does that mean?

0:05:40.760000 --> 0:05:46.660000
 That means I'm going to have to
 use a slash 25, doesn't it?

0:05:46.660000 --> 0:05:51.380000
 Because a slash 25 will
 give me 126 hosts.

0:05:51.380000 --> 0:05:57.140000
 Anything else like a slash 26 or slash
 27 won't support the 80 hosts that

0:05:57.140000 --> 0:06:00.940000
 I need. So for that particular slice
 of the pie, it's going to be pretty

0:06:00.940000 --> 0:06:05.640000
 big. It's going to
 support 126 hosts.

0:06:05.640000 --> 0:06:13.240000
 So there we go. That's what I'm going
 to divvy up for network number two.

0:06:13.240000 --> 0:06:18.800000
 A slash 25. So dot zero is going
 to be my network address.

0:06:18.800000 --> 0:06:22.640000
 Dot 127 is going to be
 my broadcast address.

0:06:22.640000 --> 0:06:26.540000
 And then I'll have 126 hosts
 in the middle for use.

0:06:26.540000 --> 0:06:28.000000
 I'll use 80 of them.

0:06:28.000000 --> 0:06:30.960000
 And that gives me a little
 bit for future expansion.

0:06:30.960000 --> 0:06:32.940000
 Okay, now we go to the next one.

0:06:32.940000 --> 0:06:35.000000
 We say, okay, what's
 the next largest one?

0:06:35.000000 --> 0:06:40.360000
 22 hosts. Okay, let's
 go back to here again.

0:06:40.360000 --> 0:06:46.260000
 22 hosts. Well, it looks like according
 to this, to get 22 hosts, I would

0:06:46.260000 --> 0:06:49.380000
 need a slash 27.

0:06:49.380000 --> 0:06:52.820000
 They'll get me up to 30 hosts.

0:06:52.820000 --> 0:06:57.600000
 All right, so my next network
 is going to be a slash 27.

0:06:57.600000 --> 0:07:00.340000
 Not quite as large of a pie.

0:07:00.340000 --> 0:07:04.140000
 I should say the piece of the pie
 is not as large as the other one.

0:07:04.140000 --> 0:07:08.660000
 And with slash 27, so notice here,
 in my first network, I already used

0:07:08.660000 --> 0:07:11.900000
 up all the addresses from
 dot zero to dot 127.

0:07:11.900000 --> 0:07:14.640000
 Those were used up in
 the first subnet.

0:07:14.640000 --> 0:07:18.780000
 So I know that the next subnet, regardless
 of how big it's going to be,

0:07:18.780000 --> 0:07:22.860000
 when I start, even before I look at the
 next subnet, what do I know about

0:07:22.860000 --> 0:07:28.280000
 it? I know it's going to start with dot
 128, because that's the next available

0:07:28.280000 --> 0:07:33.220000
 address. The previous one ended on dot
 127, so the next one is going to

0:07:33.220000 --> 0:07:35.660000
 start on dot 128.

0:07:35.660000 --> 0:07:40.540000
 So I already know my starting network
 number is going to be 199, 199,

0:07:40.540000 --> 0:07:45.600000
 199 dot 128. The only thing I need
 to figure out is, what's the subnet

0:07:45.600000 --> 0:07:47.300000
 mask going to be for that?

0:07:47.300000 --> 0:07:48.640000
 Well, I just did that.

0:07:48.640000 --> 0:07:54.700000
 I said, well, based on 22 hosts, the
 subnet mask needs to be a slash 27.

0:07:54.700000 --> 0:08:02.280000
 And with a slash 27, we saw that gives
 me a total of 32 addresses, 30

0:08:02.280000 --> 0:08:09.380000
 host addresses, plus the network, plus
 the broadcast, gives me 32 addresses.

0:08:09.380000 --> 0:08:13.240000
 So I take my starting network of 128,
 I say, okay, let's see, what's 128

0:08:13.240000 --> 0:08:16.940000
 plus 32? Oh, that's 160.

0:08:16.940000 --> 0:08:19.040000
 So that's my next network.

0:08:19.040000 --> 0:08:23.260000
 So I know now that network number three
 is going to be the 128 network.

0:08:23.260000 --> 0:08:29.260000
 His broadcast address will be 159,
 and then the next network available

0:08:29.260000 --> 0:08:32.120000
 will be dot 160.

0:08:32.120000 --> 0:08:36.080000
 I say, okay, let's see here, the next
 largest one is network number four.

0:08:36.080000 --> 0:08:44.160000
 So apparently, network number four
 is going to be 199, 199 dot 160.

0:08:44.160000 --> 0:08:45.520000
 That's where it's going to start.

0:08:45.520000 --> 0:08:48.100000
 So we rinse and repeat.

0:08:48.100000 --> 0:08:52.860000
 So the question now is, okay, how big
 of a slice of the pie does that

0:08:52.860000 --> 0:08:56.060000
 network need? What kind of subnet
 mask do I need for that?

0:08:56.060000 --> 0:09:02.900000
 Well, 12 hosts. Let's see here, if I
 go back, 12 hosts, that means I need

0:09:02.900000 --> 0:09:09.540000
 a slash 28. Slash 28 will
 give me 14 hosts.

0:09:09.540000 --> 0:09:16.260000
 So with a slash 20, I have a total
 of 16 host combinations.

0:09:16.260000 --> 0:09:20.200000
 Right, I've got the network address,
 14 hosts available, and the broadcast

0:09:20.200000 --> 0:09:23.060000
 address, which gives me 16.

0:09:23.060000 --> 0:09:25.660000
 My networks are increments of 16.

0:09:25.660000 --> 0:09:32.400000
 So if I take 160 plus
 16, that gives me 176.

0:09:32.400000 --> 0:09:37.920000
 That will be my next, and in
 this case, final network.

0:09:37.920000 --> 0:09:41.140000
 So my last network, which, knows
 what I was doing here.

0:09:41.140000 --> 0:09:46.320000
 I start with the largest network, figured
 out the appropriate subnet mask

0:09:46.320000 --> 0:09:53.480000
 for that network, figured out where
 that network ended, and then I said,

0:09:53.480000 --> 0:09:57.680000
 okay, now I know the next available
 address will start my next network,

0:09:57.680000 --> 0:09:59.860000
 and then I repeated the process.

0:09:59.860000 --> 0:10:02.100000
 And I went from largest all
 the way down to smallest.

0:10:02.100000 --> 0:10:07.900000
 So in this particular case, network
 number one is the smallest that I

0:10:07.900000 --> 0:10:10.960000
 could get by with a slash 29 mask.


0:10:10.960000 --> 0:10:17.280000
 Slash 29's are always in multiples
 or increments of 8's.

0:10:17.280000 --> 0:10:19.980000
 Right, if we go back to this.

0:10:19.980000 --> 0:10:28.220000
 Slash 29's are always
 in increments of 8's.

0:10:28.220000 --> 0:10:34.720000
 So if it started at 176,
 176 plus 8 is dot 184.

0:10:34.720000 --> 0:10:38.240000
 So that's where that little slice is
 going to fit for network number one,

0:10:38.240000 --> 0:10:44.920000
 and now I've got all this space here
 from dot 184 to dot 255 as all unused

0:10:44.920000 --> 0:10:46.880000
 space for future expansion.

0:10:46.880000 --> 0:10:52.300000
 So I could have more networks in
 the future if my building grows.

0:10:52.300000 --> 0:10:57.260000
 So with same length subnet masking,
 all we cared about was the quantity

0:10:57.260000 --> 0:10:59.080000
 of networks that we needed.

0:10:59.080000 --> 0:11:05.160000
 Therefore, each resulting subnet had
 the exact same subnet mask, but that

0:11:05.160000 --> 0:11:09.500000
 was very risky. Some of those subnets
 might not be big enough for our

0:11:09.500000 --> 0:11:11.200000
 really big networks.

0:11:11.200000 --> 0:11:16.140000
 With variable length subnet masking,
 we're creating each subnet to be

0:11:16.140000 --> 0:11:22.760000
 finally tailored to the network.

0:11:22.760000 --> 0:11:26.400000
 Actually, before we talk about classless
 inter-domain routing, let's just

0:11:26.400000 --> 0:11:31.400000
 do one more example of VLSM before
 I throw a couple of quiz slides at

0:11:31.400000 --> 0:11:34.980000
 you. Okay, so let's say
 that we had this.

0:11:34.980000 --> 0:11:47.280000
 Your starting network
 will make it easy.

0:11:47.280000 --> 0:11:50.220000
 Something that falls on a
 nice even bit boundary.

0:11:50.220000 --> 0:11:58.380000
 200, 200, 200.0.

0:11:58.380000 --> 0:12:04.860000
 Here is what you need
 to create subnets.

0:12:04.860000 --> 0:12:09.040000
 So let's say we've
 got engineering.

0:12:09.040000 --> 0:12:20.260000
 Let's not give names to them.

0:12:20.260000 --> 0:12:26.460000
 Network two, which is real tiny,
 that only needs two hosts.

0:12:26.460000 --> 0:12:34.860000
 Network three, which is going
 to require about 16 hosts.

0:12:34.860000 --> 0:12:42.400000
 And network four, which is
 going to require 49 hosts.

0:12:42.400000 --> 0:12:44.680000
 Okay, so how do we use variable
 length subnet masking?

0:12:44.680000 --> 0:12:49.520000
 Like I said, we start with our largest
 network, our biggest one.

0:12:49.520000 --> 0:12:52.820000
 So that will clearly be
 network number one.

0:12:52.820000 --> 0:12:57.980000
 And using our subnet sheet sheet, what
 kind of subnet mask do we need

0:12:57.980000 --> 0:13:02.940000
 to give us at least 70 hosts?

0:13:02.940000 --> 0:13:12.240000
 Well, we need a slash 25.

0:13:12.240000 --> 0:13:17.300000
 With a slash 25, that will
 give us 126 hosts.

0:13:17.300000 --> 0:13:19.900000
 If we go any bigger than
 that, we do a slash 26.

0:13:19.900000 --> 0:13:21.960000
 It's not a big enough
 slice of the pie.

0:13:21.960000 --> 0:13:24.740000
 A slash 26 only gives us 62 hosts.


0:13:24.740000 --> 0:13:32.860000
 And we need 70. So we
 got to do a slash 25.

0:13:32.860000 --> 0:13:38.160000
 Okay, so we start with
 200, 200, 200.0.

0:13:38.160000 --> 0:13:40.860000
 But now it's going
 to be a slash 25.

0:13:40.860000 --> 0:13:49.860000
 We say, okay, when our networks are
 in multiples of slash 25, I should

0:13:49.860000 --> 0:13:54.700000
 say when the subnet mask is a slash
 25, let me rewrite this here.

0:13:54.700000 --> 0:14:01.600000
 What increment or multiple
 are the networks?

0:14:01.600000 --> 0:14:07.840000
 Oh, a slash 25, they're always
 in multiples of 128.

0:14:07.840000 --> 0:14:12.940000
 So if I add 128 to this, that
 will give me my next network.

0:14:12.940000 --> 0:14:14.120000
 So let's see, what's the next one?


0:14:14.120000 --> 0:14:17.780000
 Oh, that's 49. So remember, I'm
 going from largest to smallest.

0:14:17.780000 --> 0:14:22.160000
 So 200.200.200.128.

0:14:22.160000 --> 0:14:27.340000
 Because I said, that was my next
 available network address.

0:14:27.340000 --> 0:14:34.140000
 Okay, but this network here doesn't
 necessarily need a slash 25.

0:14:34.140000 --> 0:14:38.240000
 That's the subnet mask that was appropriate
 for this size network.

0:14:38.240000 --> 0:14:42.840000
 What subnet mask do we need that's
 appropriate for 49 hosts?

0:14:42.840000 --> 0:14:52.640000
 Let's go back. 49 hosts.

0:14:52.640000 --> 0:14:59.720000
 With 49 hosts, we would
 need a slash 26.

0:14:59.720000 --> 0:15:05.000000
 That will support up to 62
 hosts with a slash 26.

0:15:05.000000 --> 0:15:08.440000
 We put that down here, that's our new
 subnet mask for this particular

0:15:08.440000 --> 0:15:10.540000
 slice of the pie.

0:15:10.540000 --> 0:15:16.800000
 And now we ask ourselves, okay, in slash
 26, our networks, our subnetworks,

0:15:16.800000 --> 0:15:20.940000
 are always in multiples
 or increments of what?

0:15:20.940000 --> 0:15:26.180000
 They're always in increments
 or multiples of 64.

0:15:26.180000 --> 0:15:32.400000
 64. So I take my existing network
 and I add 64 to it.

0:15:32.400000 --> 0:15:35.660000
 128 plus 64 is what?

0:15:35.660000 --> 0:15:39.820000
 92. That's going to be my
 next available network.

0:15:39.820000 --> 0:15:48.820000
 200.200.192. Once again, don't worry
 about your existing subnet masks.

0:15:48.820000 --> 0:15:51.520000
 Now we need to come up with a subnet
 mask that's appropriate for this

0:15:51.520000 --> 0:15:54.340000
 network. 16 hosts.

0:15:54.340000 --> 0:16:02.600000
 Well, to support 16 hosts,
 I need a slash 27.

0:16:02.600000 --> 0:16:05.220000
 That will give me up to 30 hosts.

0:16:05.220000 --> 0:16:09.780000
 I could almost do a slash 28, but
 slash 28 wasn't quite big enough.

0:16:09.780000 --> 0:16:13.900000
 It was too hot shy, so I need
 to go with a slash 27.

0:16:13.900000 --> 0:16:23.780000
 So slash 27. And with slash 27s, my
 subnets are always in increments of

0:16:23.780000 --> 0:16:26.940000
 32. They're always
 in multiples of 32.

0:16:26.940000 --> 0:16:31.320000
 So I take the number 32 and I add
 it to my existing network number.

0:16:31.320000 --> 0:16:36.060000
 What's 192 plus 32?

0:16:36.060000 --> 0:16:42.520000
 That is 224, which gives
 me my last network.

0:16:42.520000 --> 0:16:50.900000
 And finally, what subnet mask is
 appropriate to support two hosts?

0:16:50.900000 --> 0:16:56.180000
 That fits just perfectly
 with a slash 30.

0:16:56.180000 --> 0:17:00.340000
 Slash 30 supports two hosts.

0:17:00.340000 --> 0:17:14.260000
 And that, my friends, is variable
 length subnet masking.

0:17:14.260000 --> 0:17:20.000000
 Before I show a couple more quiz questions
 to you, what questions do you

0:17:20.000000 --> 0:17:39.580000
 have? All right, let's give you
 an opportunity to practice this.

0:17:39.580000 --> 0:17:46.840000
 I know I'm skipping the slide on
 classless inter-domain routing.

0:17:46.840000 --> 0:17:47.980000
 I will come back to that.

0:17:47.980000 --> 0:17:51.700000
 I just want to give you a chance right
 now to practice variable length

0:17:51.700000 --> 0:17:59.860000
 subnet masking. Starting with the base
 network that you see right there,

0:17:59.860000 --> 0:18:04.260000
 use VLSM to divide the single network
 into multiple subnetworks appropriate

0:18:04.260000 --> 0:18:09.520000
 to fit the requirement shown below,
 just like I did in the whiteboard.

0:18:09.520000 --> 0:19:12.840000
 So I will give you one
 minute to work on this.

0:19:12.840000 --> 0:19:15.540000
 Okay, let's work through this one.


0:19:15.540000 --> 0:19:23.100000
 First thing was hopefully you reordered
 them by largest network.

0:19:23.100000 --> 0:19:27.840000
 I should say largest host requirement
 to smallest host requirement.

0:19:27.840000 --> 0:19:31.580000
 So from what we saw before, the biggest
 network was network number three,

0:19:31.580000 --> 0:19:33.420000
 marketing with 100 hosts.

0:19:33.420000 --> 0:19:35.940000
 So we start with that one.

0:19:35.940000 --> 0:19:41.080000
 And we needed a slash 25 subnet
 mask to support up to 100 hosts.

0:19:41.080000 --> 0:19:48.160000
 Slash 25 is always an increments or multiples
 of 128, so our next network

0:19:48.160000 --> 0:19:53.500000
 was 128. So that's what we moved down
 to the next one, the next largest

0:19:53.500000 --> 0:19:57.980000
 network, which was 49 hosts.

0:19:57.980000 --> 0:20:01.640000
 That requires a subnet
 mask of slash 26.

0:20:01.640000 --> 0:20:09.620000
 Slash 26 is always an increments
 or multiples of 64.

0:20:09.620000 --> 0:20:14.340000
 So we take 192 plus 64.

0:20:14.340000 --> 0:20:19.520000
 And that gives us our next
 available network.

0:20:19.520000 --> 0:20:22.860000
 I'm sorry, 128 plus 64.

0:20:22.860000 --> 0:20:27.600000
 So we take our existing network of 128,
 add 64 to it, and our next available

0:20:27.600000 --> 0:20:29.560000
 network was 192.

0:20:29.560000 --> 0:20:32.980000
 And so that's where we put
 on network number four.

0:20:32.980000 --> 0:20:39.360000
 With 19 hosts, we use a
 slash 27 subnet mask.

0:20:39.360000 --> 0:20:43.960000
 Slash 27s are always
 an increments of 32.

0:20:43.960000 --> 0:20:47.000000
 So we take 192 plus 32.

0:20:47.000000 --> 0:20:49.220000
 That gives us 224.

0:20:49.220000 --> 0:20:54.220000
 And that gives us
 our final network.

0:20:54.220000 --> 0:21:04.660000
 And let's do one more of these.

0:21:04.660000 --> 0:21:10.680000
 Same thing. There's your
 starting network.

0:21:10.680000 --> 0:21:12.440000
 There are your host requirements.

0:21:12.440000 --> 0:21:16.180000
 I'll give you one minute to
 work through this question.

0:21:16.180000 --> 0:21:27.920000
 All right, time's up for this one.


0:21:27.920000 --> 0:21:30.860000
 And here are the answers.

0:21:30.860000 --> 0:21:35.680000
 So we start with our largest network
 here, which was one requiring 220

0:21:35.680000 --> 0:21:43.500000
 hosts. For that, we actually need a
 slash 24, which supports up to 254

0:21:43.500000 --> 0:21:52.080000
 hosts. So that consumed
 all of 140, 140.0.

0:21:52.080000 --> 0:21:58.340000
 So 140, 140.1 would
 be our next network.

0:21:58.340000 --> 0:22:03.460000
 So that's where we put on network
 number three with 45 hosts.

0:22:03.460000 --> 0:22:10.580000
 A slash 26 is an appropriate subnet
 mask to support 45 hosts.

0:22:10.580000 --> 0:22:14.980000
 Our networks are always going to be in
 multiples or increments of 64 with

0:22:14.980000 --> 0:22:19.940000
 a slash 26. So we take our
 existing network of 1.0.

0:22:19.940000 --> 0:22:21.560000
 We add 64 to it.

0:22:21.560000 --> 0:22:24.480000
 And that gives us 1.64.

0:22:24.480000 --> 0:22:30.300000
 That's what we place on our
 next smallest network.

0:22:30.300000 --> 0:22:33.880000
 Only six hosts. That means we can get
 away with a subnet mask of slash

0:22:33.880000 --> 0:22:41.040000
 29. Slash 29s are always
 in multiples of 8s.

0:22:41.040000 --> 0:22:49.480000
 So 64 plus 8 is 72, which goes on our
 final network, which gives a subnet

0:22:49.480000 --> 0:22:56.560000
 mask of slash 30 based on
 its host requirements.

0:22:56.560000 --> 0:23:00.740000
 Okay, let's go back to that one slide
 I skipped so that you understand

0:23:00.740000 --> 0:23:05.440000
 what that concept is of classless
 interdomain routing.

0:23:05.440000 --> 0:23:07.880000
 What's that talking about?

0:23:07.880000 --> 0:23:14.980000
 So classless interdomain routing is
 just basically a fancy way of saying

0:23:14.980000 --> 0:23:20.240000
 that this whole idea of classes,
 A, B and C, is now irrelevant.

0:23:20.240000 --> 0:23:23.080000
 Irrelevant. What do
 I mean by that?

0:23:23.080000 --> 0:23:33.360000
 Well, if you had TCPIP software running
 on your laptop or your PC that

0:23:33.360000 --> 0:23:39.640000
 followed the classful rules, it might
 still let you do subnetting.

0:23:39.640000 --> 0:23:45.420000
 If I start with a class B address, I could
 put in a subnet mask that instead

0:23:45.420000 --> 0:23:50.160000
 of a slash 16, which is the classful
 mask, it might allow me to put in

0:23:50.160000 --> 0:23:55.060000
 a subnet mask of slash 17 slash 18 slash
 30, whatever, as long as I didn't

0:23:55.060000 --> 0:23:57.820000
 go less than slash 16.

0:23:57.820000 --> 0:24:01.640000
 With classless interdomain routing,
 that means the whole idea of classes

0:24:01.640000 --> 0:24:04.140000
 is completely gone.

0:24:04.140000 --> 0:24:11.220000
 That means you can apply any subnet
 mask you want to any address.

0:24:11.220000 --> 0:24:17.220000
 For example, let me bring
 up one right here.

0:24:17.220000 --> 0:24:24.860000
 So right now, I'm logging, this is
 actually a router, it's not a host,

0:24:24.860000 --> 0:24:28.980000
 but I can go into his interface.

0:24:28.980000 --> 0:24:36.040000
 Now I can say IP address, let's give him
 a class B address, anything that's

0:24:36.040000 --> 0:24:39.620000
 128 or greater, let's say 130.

0:24:39.620000 --> 0:24:50.160000
 Now look at this, if this was a classful
 system, it wouldn't let me do

0:24:50.160000 --> 0:24:56.000000
 that, because 255, 248, what
 is that telling the system?

0:24:56.000000 --> 0:25:02.180000
 That's saying, okay, of that address
 I just gave you, the first 8 bits,

0:25:02.180000 --> 0:25:07.180000
 so the whole number of 130 is networking
 bits, and of the second byte,

0:25:07.180000 --> 0:25:11.520000
 5 of those bits are
 networking bits.

0:25:11.520000 --> 0:25:18.040000
 So it's basically saying of that number,
 13 of the bits, if I did that

0:25:18.040000 --> 0:25:22.620000
 right, 8 plus 5, 9, 10, 11, 12, 13,
 yeah, 13 bits are networking bits.

0:25:22.620000 --> 0:25:27.880000
 If this is a classful base system, it's
 a no, no, no, you can't do that,

0:25:27.880000 --> 0:25:35.140000
 130 falls in the class B space, this
 number at least 16 bits have to be

0:25:35.140000 --> 0:25:40.000000
 the networking. You can give me more,
 but at least 16 of the bits have

0:25:40.000000 --> 0:25:42.340000
 to be networking because
 this is class B.

0:25:42.340000 --> 0:25:49.760000
 But because this is a classless inter
-domain routing device, I guess it

0:25:49.760000 --> 0:25:52.120000
 would help if I actually
 did it on an interface.

0:25:52.120000 --> 0:25:59.660000
 It takes it, no problem.

0:25:59.660000 --> 0:26:03.900000
 He says, look, you can give me any
 32-bit IP address, I don't care.

0:26:03.900000 --> 0:26:06.900000
 As long as you tell me where the dividing
 line is between network and

0:26:06.900000 --> 0:26:09.280000
 host. As a matter of fact, I could
 do something real crazy.

0:26:09.280000 --> 0:26:14.760000
 Look at this. IP address, let's
 give him the same address.

0:26:14.760000 --> 0:26:21.340000
 And what if I say, look at that,
 what's that telling him?

0:26:21.340000 --> 0:26:27.100000
 That's saying of that address that you
 have, only the first 2 bits represent

0:26:27.100000 --> 0:26:33.540000
 your group. Everybody in your group
 has an address beginning with 1, 0.

0:26:33.540000 --> 0:26:38.560000
 Because if I break 1.30 down, it starts
 with a 128-bit on, the 64-bit

0:26:38.560000 --> 0:26:42.260000
 off, 1, 0. And this subnet mask is
 saying that's all you care about.

0:26:42.260000 --> 0:26:47.540000
 Your group is 1, 0, anything.

0:26:47.540000 --> 0:26:51.980000
 This is classless inter-domain routing
 where the whole idea of A, B, or

0:26:51.980000 --> 0:26:54.440000
 C is completely thrown
 out the window.

0:26:54.440000 --> 0:27:00.080000
 The subnet mask is in charge of dictating
 where the dividing line is in

0:27:00.080000 --> 0:27:03.340000
 these bits between
 network and host.

