WEBVTT

0:00:08.500000 --> 0:00:13.940000
 Okay, so up until this point in time,
 we've had this concept where some

0:00:13.940000 --> 0:00:19.440000
 device was running TCP
 IP, the protocol stack.

0:00:19.440000 --> 0:00:23.900000
 And part of TCP IP meant that that
 device had to have a 32-bit number

0:00:23.900000 --> 0:00:26.460000
 assigned to it, an IP address.

0:00:26.460000 --> 0:00:30.260000
 And how that device looked at that
 32-bit number was, was it a really

0:00:30.260000 --> 0:00:31.980000
 old-style device?

0:00:31.980000 --> 0:00:35.400000
 We just looked at the first
 8 bits, and that was it?

0:00:35.400000 --> 0:00:39.360000
 Or was it a newer device that used
 classical dressing, where it said,

0:00:39.360000 --> 0:00:42.980000
 well, I'm going to look at the first
 2 or 3 bits there and determine if

0:00:42.980000 --> 0:00:45.140000
 my address is A, B, or C.

0:00:45.140000 --> 0:00:48.160000
 And then based on that, I'll figure out
 where the dividing line is between

0:00:48.160000 --> 0:00:53.640000
 my network bits and everything
 left over, my host bits.

0:00:53.640000 --> 0:00:58.440000
 Well, even though this classical addressing
 did end up giving us thousands

0:00:58.440000 --> 0:01:04.180000
 and thousands of more available networks,
 even that very soon became apparent

0:01:04.180000 --> 0:01:07.180000
 that it was not going
 to be enough.

0:01:07.180000 --> 0:01:08.900000
 Wasn't going to be enough.

0:01:08.900000 --> 0:01:15.860000
 So it soon became apparent that, hey,
 look, if a company goes to their

0:01:15.860000 --> 0:01:20.620000
 regional internet registry, or a service
 provider, and that company says,

0:01:20.620000 --> 0:01:24.560000
 look, I'm really big, and I'm
 going to need 1,000 networks.

0:01:24.560000 --> 0:01:28.080000
 You know, I've got 800 different
 departments of employees.

0:01:28.080000 --> 0:01:31.860000
 In addition to that, I want all
 my printers on one network.

0:01:31.860000 --> 0:01:34.160000
 I want all my voice
 phones on another.

0:01:34.160000 --> 0:01:35.980000
 I want all my fax machines
 on another one.

0:01:35.980000 --> 0:01:40.540000
 So I actually need 1,000 broadcast
 domains, 1,000 networks.

0:01:40.540000 --> 0:01:43.200000
 Well, if their regional internet registry
 or their service provider gave

0:01:43.200000 --> 0:01:50.440000
 them 1,000 public-classful networks, at
 that rate, those classical networks

0:01:50.440000 --> 0:01:54.160000
 were soon going to be gone.

0:01:54.160000 --> 0:02:01.940000
 So this is where in 1985, the concept
 of subnets came into play.

0:02:01.940000 --> 0:02:04.000000
 So originally we had this.

0:02:04.000000 --> 0:02:05.300000
 We have a building.

0:02:05.300000 --> 0:02:08.420000
 Four floors in the building, and let's
 just assume that each floor requires

0:02:08.420000 --> 0:02:10.880000
 its own unique network.

0:02:10.880000 --> 0:02:13.680000
 So back in the classical days, we said,
 okay, we'll give each one of those

0:02:13.680000 --> 0:02:18.840000
 floors its own unique classical network,
 the 20, the 21, the 22, and the

0:02:18.840000 --> 0:02:22.920000
 23 networks. But that
 wasn't very scalable.

0:02:22.920000 --> 0:02:24.520000
 Even that was going to run out.

0:02:24.520000 --> 0:02:26.800000
 So instead they said, okay, here's
 what we're going to do.

0:02:26.800000 --> 0:02:31.460000
 We will give you a single classical
 network, the 20 network, the class

0:02:31.460000 --> 0:02:37.960000
 A20 network, and you will now divide that
 one network into multiple smaller

0:02:37.960000 --> 0:02:41.780000
 pieces, what we call sub-networks.


0:02:41.780000 --> 0:02:47.360000
 Now in a classful scheme, if all those
 devices in that building on the

0:02:47.360000 --> 0:02:51.660000
 right were doing classful IP addressing,
 they would say, we're all in

0:02:51.660000 --> 0:02:57.440000
 one network. We look at the first byte,
 and the number 20 in binary starts

0:02:57.440000 --> 0:02:58.620000
 out with zero, right?

0:02:58.620000 --> 0:03:01.180000
 The 128 bit is off.

0:03:01.180000 --> 0:03:04.260000
 So they say, oh, the 120 bit is off,
 which means that this is a class

0:03:04.260000 --> 0:03:08.840000
 A address, which means the first
 byte tells us our network.

0:03:08.840000 --> 0:03:10.480000
 Oh, the first byte
 is the number 20.

0:03:10.480000 --> 0:03:14.080000
 Okay, anything beginning with the number
 20 is in my network, belongs

0:03:14.080000 --> 0:03:18.000000
 to my group. But clearly
 that's not the case here.

0:03:18.000000 --> 0:03:21.800000
 Here we've got four different
 broadcast domains.

0:03:21.800000 --> 0:03:26.900000
 So with sub-netting we're saying, hey,
 look, don't worry about your class.

0:03:26.900000 --> 0:03:29.260000
 Your class is kind of irrelevant.

0:03:29.260000 --> 0:03:32.100000
 Don't look at the first bit
 or two bits or three bits.

0:03:32.100000 --> 0:03:35.580000
 Instead, look at something else.

0:03:35.580000 --> 0:03:37.900000
 So now you're not going to look at
 your class identifier anymore.

0:03:37.900000 --> 0:03:41.880000
 Now I'm going to give you a new piece
 of information that tells you of

0:03:41.880000 --> 0:03:45.780000
 that 32 bit number where to draw that
 dividing line between the network

0:03:45.780000 --> 0:03:47.880000
 portion and the host.

0:03:47.880000 --> 0:03:51.280000
 And this is where a sub-net
 mask comes into play.

0:03:51.280000 --> 0:03:55.380000
 Can't do sub-netting without
 a sub-net mask.

0:03:55.380000 --> 0:04:03.320000
 So we know as a review that when you
 get a network from an ISP, you're

0:04:03.320000 --> 0:04:06.060000
 going to have the network
 part and the host part.

0:04:06.060000 --> 0:04:12.220000
 Now from the ISP's perspective, the
 service provider, they don't care

0:04:12.220000 --> 0:04:14.460000
 what you do with your host bits.

0:04:14.460000 --> 0:04:17.740000
 They're going to assume that you're
 just going to assign those host bits

0:04:17.740000 --> 0:04:21.240000
 and unique combinations to your laptops
 and your PCs and your servers

0:04:21.240000 --> 0:04:23.780000
 and so on and so forth.

0:04:23.780000 --> 0:04:28.260000
 But what they do care about is they
 say, look, we just gave you, let's

0:04:28.260000 --> 0:04:29.840000
 say, an 8-bit network.

0:04:29.840000 --> 0:04:32.040000
 We gave you the number 20.

0:04:32.040000 --> 0:04:36.240000
 So the ISP says that is
 now registered to you.

0:04:36.240000 --> 0:04:41.240000
 No other company in the entire world
 can have that 8-bit pattern on their

0:04:41.240000 --> 0:04:42.760000
 network. That belongs to you.

0:04:42.760000 --> 0:04:46.140000
 And we will make sure that we advertise
 to all the other ISPs throughout

0:04:46.140000 --> 0:04:50.420000
 the entire world that the 20
 network belongs right here.

0:04:50.420000 --> 0:04:54.120000
 So in Germany, Mongolia, China, if
 you guys ever need to send a packet

0:04:54.120000 --> 0:04:58.880000
 to something starting with 20, send it
 here and we'll get it to this company,

0:04:58.880000 --> 0:05:00.960000
 which is our customer.

0:05:00.960000 --> 0:05:05.180000
 So it's very important that the network
 they gave you, the network bits,

0:05:05.180000 --> 0:05:06.380000
 you don't mess around with those.

0:05:06.380000 --> 0:05:09.320000
 Because if you start changing your
 network bits, now you're infringing

0:05:09.320000 --> 0:05:11.160000
 on some other company.

0:05:11.160000 --> 0:05:20.540000
 So let's say, for example, an ISP leases
 you this network, 129.1.0.0.

0:05:20.540000 --> 0:05:26.180000
 Now, if we're dealing with a classful
 architecture, classful IP addressing,

0:05:26.180000 --> 0:05:28.920000
 you would look at that and you
 say, okay, let's see, 129.

0:05:28.920000 --> 0:05:30.540000
 Let's convert that into binary.

0:05:30.540000 --> 0:05:38.460000
 128-bit is on, so 128-bit is on,
 64-bit is off, boom, undone.

0:05:38.460000 --> 0:05:43.400000
 That is a class B address, which tells
 me that the first half of that

0:05:43.400000 --> 0:05:48.540000
 address, the first two bytes,
 129.1, is the network.

0:05:48.540000 --> 0:05:50.160000
 So this is what the
 ISP is thinking.

0:05:50.160000 --> 0:05:54.460000
 The ISP is thinking, okay, Keith Company
 over here that we just leased

0:05:54.460000 --> 0:05:59.040000
 this network to, they own 129.1.

0:05:59.040000 --> 0:06:02.500000
 Nobody else in the whole
 world owns 129.1.

0:06:02.500000 --> 0:06:07.980000
 So there's what looks
 like in binary.

0:06:07.980000 --> 0:06:12.700000
 So the ISP says, don't change those
 bits in red, if you do, we're going

0:06:12.700000 --> 0:06:14.820000
 to be very unhappy with you.

0:06:14.820000 --> 0:06:18.940000
 But you can do whatever you want
 with those last 16 bits.

0:06:18.940000 --> 0:06:22.060000
 Those are host bits.

0:06:22.060000 --> 0:06:24.600000
 So the ISP is a sum, assumption.

0:06:24.600000 --> 0:06:29.480000
 The service provider's assumption is that
 I have one network, one broadcast

0:06:29.480000 --> 0:06:35.940000
 domain, that uses that 16-bit pattern
 to identify itself, 129.1.

0:06:35.940000 --> 0:06:40.100000
 But that raises the question, well, what
 if I have other broadcast domains?

0:06:40.100000 --> 0:06:42.380000
 What if I need two networks,
 or three or four?

0:06:42.380000 --> 0:06:47.180000
 Well, certainly the ISP would be more
 than happy to take my money to buy

0:06:47.180000 --> 0:06:50.100000
 another network, and
 another, and another.

0:06:50.100000 --> 0:06:54.860000
 The ISP would say, oh, sure, yeah, we'd
 love to sell you 129.2, and 129

0:06:54.860000 --> 0:06:59.880000
.3, and 129.30. Come to us with your money,
 we'll give you as money networks

0:06:59.880000 --> 0:07:07.720000
 as you need. So I say, well, you know,
 if I'm spending $100 a month on

0:07:07.720000 --> 0:07:12.060000
 that one network, I don't necessarily
 have another $2,000.1.1.

0:07:12.060000 --> 0:07:16.540000
 It's $1000 a month to spend to get
 a couple dozen more networks.

0:07:16.540000 --> 0:07:19.300000
 So remember, the ISP says, look, as
 long as you don't change those red

0:07:19.300000 --> 0:07:22.560000
 bits, that's all we care about.

0:07:22.560000 --> 0:07:25.240000
 So I say, well, wait a second.

0:07:25.240000 --> 0:07:29.260000
 We know that all the devices in the
 same broadcast domain all have to

0:07:29.260000 --> 0:07:34.320000
 agree on what the name of their group
 is in binary, what the binary pattern

0:07:34.320000 --> 0:07:39.040000
 is for their broadcast domain,
 what their binary network is.

0:07:39.040000 --> 0:07:44.400000
 I know I can't do anything, I can't
 change the first 16 bits.

0:07:44.400000 --> 0:07:46.020000
 But why not do this?

0:07:46.020000 --> 0:07:50.840000
 Why not give them a unique
 18-bit pattern like this?

0:07:50.840000 --> 0:07:54.620000
 I'll keep the first 16 bits the same,
 because I can't change that.

0:07:54.620000 --> 0:07:56.720000
 That's what my service
 provider gave me.

0:07:56.720000 --> 0:08:00.960000
 But of the last 16 bits, I'm going to
 take those two bits there in green.

0:08:00.960000 --> 0:08:05.060000
 Instead of telling my laptops, hey,
 look at those two bits as per your

0:08:05.060000 --> 0:08:08.840000
 host pattern. I'm going to say,
 no, I want you to do that.

0:08:08.840000 --> 0:08:13.620000
 All laptops on that segment on the left
 there of your 32-bit number for

0:08:13.620000 --> 0:08:19.980000
 all of you, the first 18 bits represent
 your network, your group.

0:08:19.980000 --> 0:08:22.960000
 So basically what I've done is I've
 taken these two green bits here that

0:08:22.960000 --> 0:08:29.000000
 used to be host bits, and I've repurposed
 them, I've converted them into

0:08:29.000000 --> 0:08:30.280000
 networking bits.

0:08:30.280000 --> 0:08:35.240000
 I've added them to the existing 16
 networking bits I already had that

0:08:35.240000 --> 0:08:37.500000
 I couldn't change.

0:08:37.500000 --> 0:08:42.520000
 And because the ISP doesn't care what
 I do with these 16 bits on the end,

0:08:42.520000 --> 0:08:44.940000
 I can do whatever
 I want with that.

0:08:44.940000 --> 0:08:49.580000
 So I say, okay, all you guys here on the
 left, this is your 18-bit network.

0:08:49.580000 --> 0:08:55.560000
 And all you guys on the right, I'll
 use a different 18-bit network for

0:08:55.560000 --> 0:09:01.620000
 you. Still keeping the 16 bits I got
 from my ISP consistent, but now this

0:09:01.620000 --> 0:09:03.340000
 is what's called subnetting.

0:09:03.340000 --> 0:09:09.380000
 Subnetting is taking one network and
 dividing it into two or three or

0:09:09.380000 --> 0:09:14.800000
 four or five or hundreds of sub networks,
 keeping the original bit pattern

0:09:14.800000 --> 0:09:19.540000
 of your original network consistent
 across all of them.

0:09:19.540000 --> 0:09:25.560000
 So in this particular example here of
 my 32-bit number now, we can classify

0:09:25.560000 --> 0:09:28.700000
 those 32 bits into one
 of three buckets.

0:09:28.700000 --> 0:09:32.400000
 We've got our original networking bits,
 which are the ones in red, those

0:09:32.400000 --> 0:09:35.880000
 are the ones I can't change that I bought
 and paid for, from my regional

0:09:35.880000 --> 0:09:39.080000
 internet registry or from
 my service provider.

0:09:39.080000 --> 0:09:42.220000
 And then we have some host bits which
 are no longer host bits, which I've

0:09:42.220000 --> 0:09:45.600000
 now repurposed or reused
 as networking bits.

0:09:45.600000 --> 0:09:50.040000
 I'm not telling my laptops, add that
 to your existing network section.

0:09:50.040000 --> 0:09:52.560000
 That's part of your group name.

0:09:52.560000 --> 0:09:55.100000
 And those are called subnet bits.

0:09:55.100000 --> 0:09:59.140000
 And I've got my host
 bits on the end.

0:09:59.140000 --> 0:10:01.800000
 So here's the question.

0:10:01.800000 --> 0:10:07.880000
 Original IP, a device is just assumed
 back in the 1960s, the first eight

0:10:07.880000 --> 0:10:12.100000
 bits represented their group,
 represented their network.

0:10:12.100000 --> 0:10:16.460000
 Move forward to what was it, 1985,
 I think it was, or 1981, it was in

0:10:16.460000 --> 0:10:18.900000
 the slides back to classful
 addressing.

0:10:18.900000 --> 0:10:23.380000
 Now a device took a look at the first
 few bits of the IP address and said,

0:10:23.380000 --> 0:10:25.720000
 what class am I, A, B, or C?

0:10:25.720000 --> 0:10:30.200000
 They'll tell me where my network ends
 and where my host portion begins.

0:10:30.200000 --> 0:10:34.380000
 Now we're saying, as a third alternative,
 don't use either one of those

0:10:34.380000 --> 0:10:38.500000
 methods. I'm going to arbitrarily tell
 you that of your 32-bit number,

0:10:38.500000 --> 0:10:44.480000
 the first 18 bits, or the first 20 bits,
 or the first 28 bits represent

0:10:44.480000 --> 0:10:48.200000
 your group. But how do I
 give it that information?

0:10:48.200000 --> 0:10:51.980000
 How do I tell it of those 32 bits where
 that dividing line can arbitrarily

0:10:51.980000 --> 0:10:58.840000
 fall? And that's where a subnet
 mask came into place.

0:10:58.840000 --> 0:11:05.260000
 So here we see. Prior to subnet masks,
 just the first few bits identified

0:11:05.260000 --> 0:11:08.140000
 how much of the address belonged
 to your network.

0:11:08.140000 --> 0:11:09.020000
 And then you were done.

0:11:09.020000 --> 0:11:13.440000
 That was it. You fell into an A,
 B, or C, and that's all you had.

0:11:13.440000 --> 0:11:18.900000
 So in this particular case, the PC on the
 left says, okay, I've now identified

0:11:18.900000 --> 0:11:22.920000
 my network numbers being 129.1.

0:11:22.920000 --> 0:11:27.580000
 So if I need to create a packet, and
 if the destination of that packet

0:11:27.580000 --> 0:11:30.840000
 is also 129.1, great!

0:11:30.840000 --> 0:11:32.640000
 I know they're on the
 same wire as me.

0:11:32.640000 --> 0:11:35.460000
 I know that when I put my electrical
 energy on this wire to represent

0:11:35.460000 --> 0:11:39.000000
 1s and 0s, they will see it, because
 they're in the same broadcast domain

0:11:39.000000 --> 0:11:43.600000
 as I am. But if I need to create a packet
 going to a destination that's

0:11:43.600000 --> 0:11:49.680000
 not 129.1, that's anything else, they
 are not in my broadcast domain,

0:11:49.680000 --> 0:11:53.160000
 which means I need to send it to my router
 to get it to wherever it needs

0:11:53.160000 --> 0:12:00.440000
 to go. So it says, okay, of my particular
 network, my network is 129.1

0:12:00.440000 --> 0:12:10.220000
.0.0. And if I ever need to send a broadcast,
 well, my group is 129.1,

0:12:10.220000 --> 0:12:13.160000
 and I'll send all the
 host bits to 1s.

0:12:13.160000 --> 0:12:19.920000
 So the broadcast address for this particular
 network is 129.1.255.2.55.

0:12:19.920000 --> 0:12:27.940000
 Okay, now we go into subnet masks.


0:12:27.940000 --> 0:12:33.200000
 So now on my laptop or my PC or my tablet,
 I have to provide it two pieces

0:12:33.200000 --> 0:12:39.060000
 of information. The IP address, and
 right next to that, another 32-bit

0:12:39.060000 --> 0:12:41.840000
 number in binary, which
 is called a subnet mask.

0:12:41.840000 --> 0:12:44.940000
 And the two are used to compare
 against each other.

0:12:44.940000 --> 0:12:48.720000
 Now here I put them one on top of
 each other to make it real clear.

0:12:48.720000 --> 0:12:52.260000
 I said, okay, here's your 32-bit
 number, which is your IP address.

0:12:52.260000 --> 0:12:56.100000
 And just below that
 is your subnet mask.

0:12:56.100000 --> 0:13:00.880000
 And the way that your laptop or smartphone
 or tablet looks at this, it

0:13:00.880000 --> 0:13:03.660000
 says, okay, I'm going to do
 a one-for-one comparison.

0:13:03.660000 --> 0:13:08.920000
 For every bit in my subnet mask that's
 a one, that means the corresponding

0:13:08.920000 --> 0:13:14.160000
 bit in the IP address belongs to my network,
 belongs to my group, my broadcast

0:13:14.160000 --> 0:13:19.660000
 domain. And for a bit in my subnet
 mask that's a zero, that means the

0:13:19.660000 --> 0:13:25.680000
 corresponding bit in my IP address belongs
 to my own unique host identifier.

0:13:25.680000 --> 0:13:29.760000
 So now here with this subnet mask, I'm
 telling it, okay, don't worry about

0:13:29.760000 --> 0:13:31.000000
 the class anymore.

0:13:31.000000 --> 0:13:33.840000
 Forget about the fact that it says
 one zero at the beginning.

0:13:33.840000 --> 0:13:34.800000
 That's irrelevant.

0:13:34.800000 --> 0:13:40.560000
 Instead, the subnet mask says of your
 32-bit number, the first 24 bits,

0:13:40.560000 --> 0:13:48.280000
 the first 24 bits represent your specific
 group, your broadcast domain.

0:13:48.280000 --> 0:13:53.480000
 So now the laptop says, okay, based
 on that, anybody else I want to talk

0:13:53.480000 --> 0:13:57.060000
 to who's in my broadcast domain, who's
 on my wire should also have the

0:13:57.060000 --> 0:14:03.900000
 exact same 24-bit pattern
 as me, which is 129.1.1.

0:14:03.900000 --> 0:14:09.000000
 And so now if I need to send a packet
 to anybody that does not match those

0:14:09.000000 --> 0:14:14.520000
 first 24 bits, that means they're
 in a different broadcast domain.

0:14:14.520000 --> 0:14:17.240000
 And I'll need to use
 my default gateway.

0:14:17.240000 --> 0:14:21.620000
 So now my network has
 changed a little bit.

0:14:21.620000 --> 0:14:24.860000
 My network is still
 the same, 129.1.0.

0:14:24.860000 --> 0:14:28.300000
 Remember, previously, he said, oh, my
 network is only the first half of

0:14:28.300000 --> 0:14:32.480000
 the address on class
 B, so it's 129.1.

0:14:32.480000 --> 0:14:37.080000
 Now he's saying, oh, the subnet
 mask is telling me it's 129.1.0.

0:14:37.080000 --> 0:14:40.440000
 I got to include that zero as
 part of my network address.

0:14:40.440000 --> 0:14:51.360000
 And if I want to send a broadcast,
 that'd be 129.1.1.255.

0:14:51.360000 --> 0:14:53.640000
 So this is the purpose
 of the subnet mask.

0:14:53.640000 --> 0:14:57.420000
 It's a comparison tool to help the
 device with the IP address to know

0:14:57.420000 --> 0:15:02.880000
 specifically of those 32 bits
 where the dividing line ends.

0:15:02.880000 --> 0:15:06.740000
 Which portion of the 32 bits are the
 network and which portion are unique

0:15:06.740000 --> 0:15:11.700000
 host bits? And we represent subnet masks
 in one of three different ways.

0:15:11.700000 --> 0:15:14.780000
 Typically you won't see it in binary,
 but this is how your laptop sees

0:15:14.780000 --> 0:15:19.760000
 it. It's just a string
 of binary bits.

0:15:19.760000 --> 0:15:23.720000
 But typically we convert, just like
 we convert a 32 bit IP address into

0:15:23.720000 --> 0:15:26.660000
 dotted decimal, we do the same
 thing with the subnet mask.

0:15:26.660000 --> 0:15:31.120000
 We take that entire 32 bit binary number
 and convert it into dotted decimal.

0:15:31.120000 --> 0:15:36.180000
 So this would be a common representation,
 255, 255, 0.0.

0:15:36.180000 --> 0:15:40.400000
 And a lot of times in papers and books
 and stuff, they'll shorten it even

0:15:40.400000 --> 0:15:44.600000
 further. They'll say, okay, well, in
 this combination here, I'm seeing

0:15:44.600000 --> 0:15:47.480000
 that the first 16
 bits are all ones.

0:15:47.480000 --> 0:15:51.400000
 So that's telling me of my 32 bit number,
 the first 16 bits are the network

0:15:51.400000 --> 0:15:57.040000
 portion. So shorthand notation
 would be slash 16.

0:15:57.040000 --> 0:15:59.380000
 Well, guess what?

0:15:59.380000 --> 0:16:01.740000
 I have some more questions
 for you.

0:16:01.740000 --> 0:16:04.140000
 So here we go. Let me expand
 this a little bit.

0:16:04.140000 --> 0:16:05.780000
 A few more quiz questions.

0:16:05.780000 --> 0:16:12.120000
 Same thing. I will give you guys
 30 seconds to think about it.

0:16:12.120000 --> 0:16:14.140000
 And then I will show
 you the answer.

0:16:14.140000 --> 0:16:18.520000
 So here we go. Quiz number three.

0:16:18.520000 --> 0:16:23.400000
 Given the following subnet mask in binary,
 what is the equivalent representation

0:16:23.400000 --> 0:16:27.480000
 in dotted decimal and shorthand?

0:16:27.480000 --> 0:16:31.760000
 Okay, time's up.

0:16:31.760000 --> 0:16:34.960000
 So here is our answer.

0:16:34.960000 --> 0:16:38.680000
 So if you take a look at all the ones,
 and remember that your ones represent

0:16:38.680000 --> 0:16:43.240000
 your networking bits, if you just add
 them up, we've got eight, plus eight,

0:16:43.240000 --> 0:16:44.620000
 plus four, and four.

0:16:44.620000 --> 0:16:49.680000
 Which says of the 32 bits, the first
 20 of them are networking bits.

0:16:49.680000 --> 0:16:52.580000
 So that gives us our shorthand
 answer of slash 20.

0:16:52.580000 --> 0:16:57.240000
 And if you convert this into a dotted
 decimal number, all ones is 255,

0:16:57.240000 --> 0:17:02.820000
 255, and the first four ones, if you
 add those up, 128 plus 64 plus 32

0:17:02.820000 --> 0:17:06.020000
 plus 16 gives you 240.

0:17:06.020000 --> 0:17:10.780000
 So that's why answer D is
 the correct answer also.

0:17:10.780000 --> 0:17:12.940000
 Let's do a couple more of these.

0:17:12.940000 --> 0:17:17.880000
 If the following subnet mask were to
 be applied to a PC's NIC, how many

0:17:17.880000 --> 0:17:24.740000
 bits of the IP address would be
 interpreted as networking bits?

0:17:24.740000 --> 0:17:31.260000
 All right, and the answer to this, 29
 of those bits would be considered

0:17:31.260000 --> 0:17:33.760000
 networking bits.

0:17:33.760000 --> 0:17:36.900000
 So let's do that one on the
 whiteboard real quick.

0:17:36.900000 --> 0:17:47.060000
 So we had 255, so let's just make
 this a little bit larger.

0:17:47.060000 --> 0:17:53.800000
 We had 255, 255, 255.248.

0:17:53.800000 --> 0:17:59.800000
 So if we take a look at that, we
 know the number 255 is that.

0:17:59.800000 --> 0:18:03.960000
 So that tells me that all eight bits
 of the first octet are networking

0:18:03.960000 --> 0:18:08.220000
 bits, all eight bits of the second octet,
 and all eight bits of the third

0:18:08.220000 --> 0:18:17.260000
 octet. And if we take a look at the
 number 248, that's the first five

0:18:17.260000 --> 0:18:22.080000
 bits as being networking bits.

0:18:22.080000 --> 0:18:27.740000
 So if you add all those up, eight plus
 eight plus eight is 24, 24 plus

0:18:27.740000 --> 0:18:33.680000
 five gives us. What subnet mask would
 be appropriate and dotted decimal

0:18:33.680000 --> 0:18:39.280000
 to indicate to a host that the first
 26 bits of its IP address should

0:18:39.280000 --> 0:18:43.700000
 be considered as the network.

0:18:43.700000 --> 0:18:51.020000
 All right, the correct answer for this
 one was answer B, the first 26

0:18:51.020000 --> 0:18:53.240000
 bits of the IP address.

0:18:53.240000 --> 0:19:08.080000
 So if we're looking at the first
 26 bits, that looks like this.

0:19:08.080000 --> 0:19:13.020000
 The first 24 bits, one two, there's
 26, three, four, five, six, seven,

0:19:13.020000 --> 0:19:22.240000
 eight. And when you convert those numbers,
 you've got 255.255.255.192.

0:19:22.240000 --> 0:19:32.800000
 Given the following IP address and subnet
 mask, identify the subnetwork

0:19:32.800000 --> 0:19:35.300000
 address of this host.

0:19:35.300000 --> 0:19:39.800000
 So what you have here is a full
 32-bit host IP address.

0:19:39.800000 --> 0:19:44.140000
 When the host IP address, when that
 host looks at that IP address that

0:19:44.140000 --> 0:19:48.560000
 he's got, as well as his corresponding
 subnet mask, what is the network

0:19:48.560000 --> 0:19:51.680000
 that he will assume that he
 is on that he's sitting on?

0:19:51.680000 --> 0:19:56.340000
 Remember, the key thing here about
 this is, in a 32-bit IP address, if

0:19:56.340000 --> 0:20:01.280000
 all the host bits are zeros,
 that is your network number.

0:20:01.280000 --> 0:20:05.960000
 So you're trying to extract from this
 what the network is where all the

0:20:05.960000 --> 0:20:08.340000
 host bits are zeroed out.

0:20:08.340000 --> 0:20:16.780000
 Okay, the answer to this
 one is answer A.

0:20:16.780000 --> 0:20:22.600000
 So let's work through the logic
 of how this one works.

0:20:22.600000 --> 0:20:33.500000
 So here we had 137.54.101.77.

0:20:33.500000 --> 0:20:47.860000
 And the corresponding subnet
 mask was 255.255.224.0.

0:20:47.860000 --> 0:20:52.860000
 Now, whenever you see a within a subnet
 mask, if an entire byte is the

0:20:52.860000 --> 0:20:56.020000
 number 255, remember, that's
 real easy, right?

0:20:56.020000 --> 0:21:02.380000
 That means that all 8 bits of that byte
 in the corresponding IP address

0:21:02.380000 --> 0:21:04.440000
 belong to the network.

0:21:04.440000 --> 0:21:09.200000
 So that means that this entire byte
 of 137 belongs to the network.

0:21:09.200000 --> 0:21:13.400000
 And this entire byte of 54
 belongs to the network.

0:21:13.400000 --> 0:21:16.200000
 Now, where it may have gotten a little
 difficult for you was in the third

0:21:16.200000 --> 0:21:19.000000
 byte, because we don't
 have all 8 bits.

0:21:19.000000 --> 0:21:21.820000
 224 is this number.

0:21:21.820000 --> 0:21:29.880000
 That's 224, which tells me that of the
 number 101, only the first 3 bits

0:21:29.880000 --> 0:21:32.040000
 belong to the network.

0:21:32.040000 --> 0:21:37.160000
 And then everything else to the right
 needs to be zeroed out as host bits.

0:21:37.160000 --> 0:21:41.020000
 So to do this, we had to convert the
 number 101, just the first 3 bits

0:21:41.020000 --> 0:21:43.660000
 of it, into binary.

0:21:43.660000 --> 0:21:48.500000
 So with 101, the 128 bit is off.

0:21:48.500000 --> 0:21:53.460000
 64 bit is on. 32 bit is on.

0:21:53.460000 --> 0:21:55.460000
 64 plus 32 is 96.

0:21:55.460000 --> 0:21:58.820000
 At this point, we can't go any further,
 because if we turned on the 16

0:21:58.820000 --> 0:22:02.940000
 bit, that would be too high.

0:22:02.940000 --> 0:22:10.140000
 And then everything else
 needs to be zeroed out.

0:22:10.140000 --> 0:22:15.600000
 1, 2, 3, 4, 5, 6, 7, 8.

0:22:15.600000 --> 0:22:23.980000
 So this is telling us here that these
 bits here in the pink boxes all

0:22:23.980000 --> 0:22:25.520000
 belong to the network.

0:22:25.520000 --> 0:22:28.880000
 Everything else are host bits.

0:22:28.880000 --> 0:22:33.740000
 So when you convert that entire thing
 into a dotted decimal number, that's

0:22:33.740000 --> 0:22:42.760000
 what gave you your final
 answer of 137.54.96.0.

0:22:42.760000 --> 0:22:46.000000
 Because remember, to identify the network,
 that means all the host bits

0:22:46.000000 --> 0:22:49.960000
 have to be zeroed out.

0:22:49.960000 --> 0:22:56.800000
 What if I were to ask you, using the
 same IP address and same subnet mask,

0:22:56.800000 --> 0:23:01.440000
 to identify the broadcast
 address of this network?

0:23:01.440000 --> 0:23:06.180000
 Remember, what makes the network address
 different than the broadcast

0:23:06.180000 --> 0:23:10.400000
 address? And the network address, all
 the host bits are zero, because

0:23:10.400000 --> 0:23:15.040000
 you're referring to the wire itself,
 not any particular host on that wire.

0:23:15.040000 --> 0:23:17.620000
 You're referring to the broadcast
 domain in general.

0:23:17.620000 --> 0:23:22.400000
 Well, in a broadcast, you're saying,
 I'm sending it to all the hosts.

0:23:22.400000 --> 0:23:25.060000
 Every single host there is.

0:23:25.060000 --> 0:23:28.640000
 So 011 ends my network.

0:23:28.640000 --> 0:23:35.320000
 And if I'm sending it to all
 my hosts, it looks like that.

0:23:35.320000 --> 0:23:39.760000
 Because all my host bits
 are set to ones.

0:23:39.760000 --> 0:23:46.940000
 So to identify the broadcast
 address, it would be 137.54.

0:23:46.940000 --> 0:23:49.920000
 And then what's this entire
 byte right here?

0:23:49.920000 --> 0:23:51.260000
 Well, that entire
 byte, what is it?

0:23:51.260000 --> 0:23:55.180000
 That's one number shy of
 the number 128, isn't it?

0:23:55.180000 --> 0:24:00.880000
 Because the next binary pattern bigger
 than that would be 1,000,000,000,

0:24:00.880000 --> 0:24:09.020000
 which is 128. So that means
 that number is 127.254.

0:24:09.020000 --> 0:24:12.880000
 So using that one IP address and subnet
 mask, we were able to extract

0:24:12.880000 --> 0:24:15.980000
 from that. And this is exactly
 the way your laptop does it.

0:24:15.980000 --> 0:24:18.620000
 It extracts from that
 the network address.

0:24:18.620000 --> 0:24:23.500000
 It says, OK, once my networking bits end,
 I'm just going to zero out everything.

0:24:23.500000 --> 0:24:24.320000
 That's the network.

0:24:24.320000 --> 0:24:25.260000
 That's the broadcast domain.

0:24:25.260000 --> 0:24:26.560000
 That's my group.

0:24:26.560000 --> 0:24:31.040000
 And it says, OK, and if I turn all
 those host bits to ones, that's how

0:24:31.040000 --> 0:24:34.680000
 I send a broadcast to
 everyone in my group.

0:24:34.680000 --> 0:24:38.520000
 Let's do another one.

0:24:38.520000 --> 0:24:44.020000
 Given the following IP address and subnet
 mask in binary, identify which

0:24:44.020000 --> 0:24:48.040000
 of the answers below provide for the
 broadcast address of this network.

0:24:48.040000 --> 0:24:49.480000
 We just did that.

0:24:49.480000 --> 0:24:54.100000
 So let's see if you can
 do that for yourself.

0:24:54.100000 --> 0:24:59.740000
 OK, times up. So if we take a look at
 this, according to the subnet mask,

0:24:59.740000 --> 0:25:05.860000
 this right here belongs
 to the network.

0:25:05.860000 --> 0:25:10.880000
 To our network, because the subnet mask
 has the first 16 bits belong to

0:25:10.880000 --> 0:25:15.420000
 the network. So what
 is that number?

0:25:15.420000 --> 0:25:19.200000
 Well, that's just by process
 of elimination.

0:25:19.200000 --> 0:25:22.100000
 You can pretty much assume
 it's 67 to begin with.

0:25:22.100000 --> 0:25:25.000000
 And then the second number is 3.

0:25:25.000000 --> 0:25:26.980000
 So that eliminates answer D.

0:25:26.980000 --> 0:25:28.920000
 That can't be right.

0:25:28.920000 --> 0:25:34.160000
 So 67.3. And we're being asked to
 identify the broadcast address.

0:25:34.160000 --> 0:25:37.880000
 So that means that all of the host
 bits have to be set to ones.

0:25:37.880000 --> 0:25:44.960000
 So that means it would
 be 67.3.255.

0:25:44.960000 --> 0:25:51.060000
 And that gives us our answer.

0:25:51.060000 --> 0:25:53.300000
 Let's do a couple more.

0:25:53.300000 --> 0:25:55.360000
 Want to make sure you
 really have this.

0:25:55.360000 --> 0:26:00.820000
 Different permutations
 of the same question.

0:26:00.820000 --> 0:26:05.180000
 Given the following IP address and
 subnet mask, identify which of the

0:26:05.180000 --> 0:26:08.200000
 answers below provide for the broadcast
 address of this network.

0:26:08.200000 --> 0:26:10.700000
 It's very similar, but
 a little bit different.

0:26:10.700000 --> 0:26:14.560000
 It can be 30 seconds for this one.


0:26:14.560000 --> 0:26:16.340000
 All right, time's up.

0:26:16.340000 --> 0:26:20.260000
 So in this particular case, the
 subnet mask was real easy.

0:26:20.260000 --> 0:26:26.560000
 It tells us the first three octets
 belong to the network.

0:26:26.560000 --> 0:26:31.560000
 And so if we take our host bits and
 we set them all to the ones to make

0:26:31.560000 --> 0:26:40.480000
 a broadcast, that gives us our
 correct answer of 130.54.6.255.

0:26:40.480000 --> 0:26:55.760000
 Let's do another one.

0:26:55.760000 --> 0:27:00.100000
 Which is below provides for the broadcast
 address of this network.

0:27:00.100000 --> 0:27:02.760000
 30 seconds beginning now.

0:27:02.760000 --> 0:27:17.220000
 Okay, so in this one right here, we've
 got all of this belongs to the

0:27:17.220000 --> 0:27:22.580000
 network. Because that's what matches
 our subnet mask pattern.

0:27:22.580000 --> 0:27:25.700000
 And so if we're going to identify the
 broadcast address, that means all

0:27:25.700000 --> 0:27:29.360000
 these remaining host bits
 have to be set to ones.

0:27:29.360000 --> 0:27:35.260000
 All right, so this right
 here, that's easy.

0:27:35.260000 --> 0:27:39.340000
 If that's all set to
 ones, that's 255.

0:27:39.340000 --> 0:27:43.160000
 So we've got 67.3.

0:27:43.160000 --> 0:27:47.160000
 And then in the third octet, if we have
 011 and then we set the rest of

0:27:47.160000 --> 0:27:51.440000
 it to all ones, that
 would give us 67.3.

0:27:51.440000 --> 0:28:00.660000
 Up, I made a mistake here.

0:28:00.660000 --> 0:28:02.640000
 It's not just the
 first three bits.

0:28:02.640000 --> 0:28:05.260000
 Not just the first three bits.

0:28:05.260000 --> 0:28:09.240000
 It's the first four bits.

0:28:09.240000 --> 0:28:13.540000
 The network mask did not
 quite line up underneath.

0:28:13.540000 --> 0:28:15.780000
 That's where we ended.

0:28:15.780000 --> 0:28:17.940000
 First four bits there.

0:28:17.940000 --> 0:28:23.200000
 So now if we set the remaining stuff
 to ones, that third octet, if we

0:28:23.200000 --> 0:28:32.280000
 convert that into got a decimal,
 we'll give us the number 111.

0:28:32.280000 --> 0:28:42.820000
 011, 011, 11. One more
 quiz question.

0:28:42.820000 --> 0:28:45.620000
 One more and then we'll
 keep going on.

0:28:45.620000 --> 0:28:48.080000
 Same type of thing.

0:28:48.080000 --> 0:28:54.080000
 Identify the broadcast address
 for this network.

0:28:54.080000 --> 0:29:00.280000
 Times up. Correct answer
 was the bottom one.

0:29:00.280000 --> 0:29:06.280000
 In this particular case,
 255, 255, 224.

0:29:06.280000 --> 0:29:13.980000
 That tells us that all of 77, all of
 42, and then of the number 200, the

0:29:13.980000 --> 0:29:18.340000
 first three bits, because
 224 is 111.

0:29:18.340000 --> 0:29:20.520000
 And then all five zeros.

0:29:20.520000 --> 0:29:21.760000
 Kind of hard for me
 to draw it here.

0:29:21.760000 --> 0:29:25.580000
 So forgive my sloppy drawing.

0:29:25.580000 --> 0:29:30.720000
 That's 224. So the number 200, we've got
 the first three bits we're concerned

0:29:30.720000 --> 0:29:40.920000
 with. 32 bit is off.

0:29:40.920000 --> 0:29:43.140000
 That gives us the number 192.

0:29:43.140000 --> 0:29:46.440000
 Everything else is host bits.

0:29:46.440000 --> 0:29:50.780000
 So if we're trying to identify the broadcast
 address, we have five more

0:29:50.780000 --> 0:29:58.420000
 bits here. So let's go ahead
 and draw those in.

0:29:58.420000 --> 0:30:03.860000
 1234.5. And then 1234.5.

0:30:03.860000 --> 0:30:14.400000
 678. So 77.42. This is
 the number 223.255.

0:30:14.400000 --> 0:30:16.500000
 That is the broadcast address
 of that network.

