Cisco CCNA ICND2 640-816

Advanced TCP/IP: IP Subnetting, Part 1

by Jeremy Cioara

Start your 7-day free trial today.

This video is only available to subscribers.

A free trial includes:

  • Unlimited 24/7 access to our entire IT training video library.
  • Ability to train on the go with our mobile website and iOS/Android apps.
  • Note-taking, bookmarking, speed control, and closed captioning features.
Video Title Duration

Review: Rebuilding the Small Office Network, Part 1

Review: Rebuilding the Small Office Network, Part 2

Review: Rebuilding the Small Office Network, Part 3

Switch VLANs: Understanding VLANs

Switch VLANs: Understanding Trunks and VTP

Switch VLANs: Configuring VLANs and VTP, Part 1

Switch VLANs: Configuring VLANs and VTP, Part 2

Switch STP: Understanding the Spanning-Tree Protocol

Switch STP: Configuring Basic STP

Switch STP: Enhancements to STP

General Switching: Troubleshooting and Security Best Practices

Subnetting: Understanding VLSM

Routing Protocols: Distance Vector vs. Link State

Routing Protocols: OSPF Concepts

Routing Protocols: OSPF Configuration and Troubleshooting

Routing Protocols: EIGRP Concepts and Configuration

Access-Lists: The Rules of the ACL

Access-Lists: Configuring ACLs

Access-Lists: Configuring ACLs, Part 2

NAT: Understanding the Three Styles of NAT

NAT: Command-line NAT Configuration

WAN Connections: Concepts of VPN Technology

WAN Connections: Implementing PPP Authentication

WAN Connections: Understanding Frame Relay

WAN Connections: Configuring Frame Relay

IPv6: Understanding Basic Concepts and Addressing

IPv6: Configuring, Routing, and Interoperating

Certification: Some Last Words for Test Takers

Advanced TCP/IP: Working with Binary

Advanced TCP/IP: IP Subnetting, Part 1

00:00:00 - Ahhhhh. All right, are you ready for it? We have arrived at advanced
00:00:09 - TCP/IP: IP Subnetting, part one.
00:00:14 - If you haven't looked at the bottom of the window yet, this video
00:00:17 - will take a little extra time because I'm going to fully walk
00:00:21 - through multiple examples of subnetting based on network
00:00:25 - requirements. Four different ones to be exact and then leave
00:00:28 - you with a bunch of practice to do on your own. Now, one of
00:00:32 - the things that I've found is the best way to teach subnetting
00:00:36 - is not just to start talking about the -- the advanced pieces
00:00:39 - of it right away and -- and say oh this is, you know, this is what
00:00:43 - subnetting does and binary addition and all that. It's more so to apply
00:00:47 - it to the real world. So you can see that we have four separate
00:00:51 - scenarios, four different network requirements that we're going
00:00:54 - to walk through one by one as we determine how to break a
00:00:59 - network into multiple sub-networks one by one. Let's get going.
00:01:05 - Let's start off with network scenario number one. We have an
00:01:08 - organization, this organization has purchased a Class C address
00:01:12 -, so they've purchased
00:01:16 - that from the powers that be, the Internet, and they now want
00:01:19 - to use it to address this network. And this is a picture of
00:01:23 - their network. Now here's the trouble and this is why we need
00:01:27 - subnetting. They purchased a Class C network and let me just write it over
00:01:30 - here,
00:01:37 - Now, when they bought that, it's a Class C network so the subnet
00:01:40 - mask is this. The question I have is how many networks do they
00:01:44 - get from that?
00:01:47 - Well, looking at it, it's just one. We draw our line boundary right
00:01:50 - there and 216.21.5 represents the
00:01:54 - one network they get; that's their network. And this over here
00:01:57 - represents the host. It goes from 0 to 255 maximum
00:02:01 - where you can't use zero and you can't use 255. You
00:02:04 - get everything in between; you can't use the first and last address
00:02:06 - from -- from the network range. So we have 254
00:02:10 - hosts on one network. Now look at their network diagram. How
00:02:14 - many networks do they need? Well, let's number them, one, two,
00:02:22 - three; and a lot of people forget these -- four and five. Remember
00:02:30 - every interface of a router is a network. So we need a network
00:02:35 - address or a sub-network -- a network -- for every single one of
00:02:38 - these locations. Here's maybe an office with an ethernet switch
00:02:42 - maybe that's in Arizona. We have an office across the WAN link
00:02:46 - to California. The WAN link to get there is considered a network
00:02:49 - and the office itself. Now we have a WAN link over from California to
00:02:53 - Florida, which we have an office right here and the WAN link
00:02:57 - itself to get there. So we have one network that we purchased
00:03:01 - but we need to break it in to five.
00:03:04 - So we know our network requirements now. Now here are the
00:03:08 - three steps of subnetting.
00:03:11 - Before we start working through this, let me give you a little disclaimer.
00:03:14 - First off, I wrote our network requirements up here. This
00:03:17 - was our Class C subnet mask that we needed and we know that we needed
00:03:20 - five networks or sub-networks based on what we saw on the
00:03:24 - previous slide. Now the disclaimer that I have is that there
00:03:28 - are more ways to subnet than there probably are grains of sand
00:03:32 - on the sea shore. I mean, literally I, even myself over the
00:03:36 - twelve years of teaching that I have been in, have taught this
00:03:38 - probably six or seven different ways. About five years ago, I
00:03:42 - came up with this little three step process that will work
00:03:45 - for just about any subnetting scenario you can throw at it. And you'll
00:03:49 - be able to -- to figure out the answer. Now the first time we work
00:03:53 - through this together, it's going to look a little weird and
00:03:57 - you're going to go, ah,
00:03:58 - I don't know about that. But I'm telling you after about the third or
00:04:02 - fourth example of this, you're gonna start going, oh, I see how this
00:04:05 - is working. And between this and the following video I hope to
00:04:09 - give you enough examples and practice that you can work on
00:04:12 - yourself, so that you'll be able to master the skill and master
00:04:15 - it quickly. So our first step in this subnetting scenario is
00:04:21 - to determine the number of networks and convert it to binary.
00:04:25 - We need to use this skill that we learned previously in the
00:04:27 - previous video, of binary conversion. So we know that we need
00:04:31 - five networks, let me write up our binary chart. 128,64,32,
00:04:35 - 8, 4, 2, 1. So five is a binary
00:04:41 - number is no, no, no, no, no, yes; there's our first one -- four
00:04:47 - zero one. So we know that five is zero, zero, zero, zero, zero -- five
00:04:52 - zeros -- 101; that's our binary equivalent. That's all there
00:04:55 - is to step one.
00:04:57 - The second step is the big one. Reserve the bits in the subnet
00:05:01 - mask and find your increment. Now I am going to show you something
00:05:06 - and I want to make sure that when you start working on this
00:05:09 - you don't skip this, this step or this part of the step. It
00:05:13 - may seem tedious at first, but you will greatly appreciate
00:05:17 - this after a little bit. We need to write our regional subnet mask
00:05:22 - right here, in all binary. So
00:05:26 - is Class C. Now what's 255 in binary? All ones;
00:05:31 - that's the biggest number we can have, right? So 8 ones
00:05:34 - dot -- this is the whole subnet mask; eight ones, one two three four five six
00:05:39 - seven, eight dot eight more ones; one, two, three, four, five, six,
00:05:43 - seven eight dot and now zero in binary is just all zeros. One
00:05:47 - two, three, four, five, six, seven, eight.
00:05:51 - Now I need to have you make a mental leap with me; a transition.
00:05:56 - We've been looking at subnet masks, like this, up till this
00:06:00 - point and we've been looking at them in decimal format. Everywhere
00:06:05 - we see 255, we go oh, well, that represents the network. So
00:06:08 - we know 216 represents part of the network. 255, oh 21
00:06:12 - is part of the network. So we've been relating 255
00:06:15 - equals network and wherever we see the zero, that represents
00:06:20 - the hosts. But here's the leap I need you to make. We need to
00:06:23 - start thinking in terms of binary, so can I say wherever I see ones
00:06:28 - as binary numbers that represents the network. And wherever
00:06:32 - I see zeros as binary numbers, that represents the host. Is
00:06:37 - that an okay leap to make? Good, so what -- the beauty of
00:06:42 - of video recordings as I can say, good; we're all on the same page
00:06:46 - and we are. So we have right here our -- our 24 ones that
00:06:51 - represent the network and our 8 zeros. Now what's our goal
00:06:55 - here? Our goal is to create more networks. Meaning, we only have
00:07:00 - one network and I need to create more, five of them to be exact.
00:07:04 - Now how many bits does it take to get the number five?
00:07:10 - Three of them. Three bits, right? You can't get the number five
00:07:15 - with any less than three bits. Now, when I asked that question,
00:07:18 - I know you may have been thinking, well, two bits, right? Because there's
00:07:22 - only two ones there. But if you look at this, if you only have
00:07:25 - two bits, what's the biggest number you can get?
00:07:28 - Three, right? If two plus one -- you can't -- you can't get the number
00:07:31 - five. So I'm not looking when I asked that question for how many
00:07:34 - ones do I have, I literally want to know how many bits does
00:07:37 - it take to get the number five and that is three bits;
00:07:40 - three bits total. So transition that back over. Our goal in this
00:07:44 - step is to reserve the bits in the subnet mask and find your increments.
00:07:48 - So when I say reserve the bits in the mask, what I mean is I
00:07:52 - know that I can't get the number five with any less than three
00:07:55 - bits. And I know that network bits are ones so what I need
00:08:00 - to do when I'm making this reservation is give myself three
00:08:04 - more network bits. So I pick up where the ones leave off and go
00:08:08 - one, two, three.
00:08:12 - Zero, zero, zero, zero, zero. Now I know, you're looking at this
00:08:16 - going whoa, wait a sec, that was a little weird. I'm not sure if I
00:08:20 - follow that the whole way. Don't worry, we'll get used to this as we go
00:08:23 - through it again and again and again. But let me just reiterate
00:08:27 - our goal is to create more networks because we only have
00:08:31 - one. And we know that it takes three bits to get our five networks
00:08:37 - that we needed and then partner that with we know that network
00:08:40 - bits are one bits it doesn't really matter that five was one
00:08:43 - zero one. I'm looking for three more network bits. So with that
00:08:47 - in mind I just add three more right where my network bits
00:08:51 - leave off left to right; one, two, three. At this point in the
00:08:55 - problem we already know what our subnet mask will be for
00:08:59 - the entire organization. It is
00:09:03 - 255 -- convert this back to decimal -- dot 255; that's what
00:09:07 - this one is -- dot --.255; that's the third one. That's
00:09:11 - what we had originally, dot and then we need to convert this
00:09:15 - last octet right here back to decimal. Now again using those
00:09:19 - skills from before if we line that back up to the binary chart
00:09:22 - that says we've got one 128; one 64; one 32;
00:09:26 - zero, zero, zero, zero, zero. So if I wanted to find
00:09:30 - out what this, right there, is in a decimal number, I would just
00:09:34 - take 128 plus 64 plus 32
00:09:40 - and that, if we add that all together, will be 224.
00:09:43 - So our subnet mask that we get for our entire organization is
00:09:48 -
00:09:54 - Now that's fantastic. We know what every single PC, what
00:09:58 - every single router, what every single switch, every single device
00:10:02 - in our organization that is on the network will use this subnet
00:10:06 - mask. Woo hoo, you know, do the happy dance. But we don't know what
00:10:09 - that means yet, you know? Great we've got a subnet mask that's a key
00:10:13 - part of the equation, but we need to figure out what that subnet
00:10:16 - mask means and that's the second half of step two. Says reserve
00:10:20 - the bits in the subnet mask -- we just did that, and find your
00:10:24 - increment. The increment, this is the other weird part, is going to
00:10:28 - be the lowest network bit that you have
00:10:33 - converted back to a decimal number. So look at our network bits.
00:10:37 - Right here, this is a 128, right? 64 and a decimal
00:10:41 - 32, that is our lowest network bit converted back
00:10:46 - to a decimal number, 32.
00:10:49 - That is our increment. So with that in mind, we can move to
00:10:54 - step three, which says use the increment to find your network
00:10:59 - ranges. This is where the subnet mask becomes meaningful to
00:11:03 - us. So
00:11:05 - I just change my pen color here. Step three I'm gonna take what I started
00:11:08 - off with, meaning, the address that I purchased,
00:11:13 - And then just begin adding
00:11:18 - my increment. Now my increment, right here, this 32 is
00:11:22 - in the fourth octet, so that's where I do my addition. 216.21
00:11:26 - .5.32.
00:11:31 - You
00:11:36 - can see all I'm doing here is adding my increment.
00:11:40 - that's 64 plus
00:11:45 - 32. And so on and so on and so on we go. What this is
00:11:50 - when I'm looking at this, is the beginning of each network range.
00:11:54 - Now, all I have to do is fill in the end. What's the last IP
00:11:58 - address before I get,
00:12:02 - which is this one right here.
00:12:05 - Now it's not a trick question -- 31 just taken one away from
00:12:08 - 32. Put this through, 216.21.5.
00:12:12 - -- last IP address before 64 is 63.
00:12:18 - and
00:12:23 - so on and so on and so on we would go; down and down and down until we found
00:12:26 - enough network ranges to fit our organization. These are actual
00:12:30 - reality to us. Meaning, let me -- let me do a quick sketch
00:12:34 - of that network diagram. The network diagram that organization
00:12:37 - had looks something like this, where we had three different
00:12:42 - networks that we were trying to address. Now what I can do
00:12:46 - is I can start assigning these network ranges to that organization.
00:12:49 - This one we'll address, I think this was Arizona that I put -- the Arizona
00:12:53 - router and they will use that range for this network
00:12:57 - right here. You can see what we've done is sacrificed the total
00:13:01 - number of hosts we have
00:13:03 - or to -- to get more networks. We originally had 254
00:13:06 - hosts with our Class C address up here. And now we've
00:13:10 - sacrificed that and said, well, I'll have less hosts, but more networks.
00:13:15 - The second network range can go ahead and address, I believe
00:13:18 - this was California down here and the third network range
00:13:22 - we'll address Florida up there in the upper right-hand corner.
00:13:25 - I won't draw the arrow across, just so it doesn't get too messy. The fourth
00:13:28 - network range would address the WAN link. And the fifth network range -- I didn't
00:13:32 - go that far because I ran out of space down here, but the fifth network
00:13:36 - range would address that WAN link right there. Those are the network
00:13:39 - ranges that I can assign to the devices. I would then assign
00:13:42 - IP addresses from these ranges to the computers in Arizona and
00:13:46 - assign IP addresses from this range to the computers in California. This
00:13:51 - is the meaning of subnetting; breaking our one network into
00:13:55 - multiple networks. We've got our new subnet mask that we use
00:13:58 - and our network ranges that can be assigned to the different
00:14:01 - devices. With that in place, I know, at this point it's like, okay,
00:14:06 - I'm seeing that; still a little fuzzy. Let's do another example.
00:14:11 - Network scenario number two. Instead of drawing this massive
00:14:16 - network, I just put our requirements in the upper right-hand
00:14:18 - corner. We have another organization that is using
00:14:22 - It's a Class C network.
00:14:27 - And they need to break that one network; 195.5.20
00:14:30 - into 50 sub-networks or 50 smaller networks.
00:14:35 - It's a lot of networks; that's why I didn't want to draw a network diagram.
00:14:38 - So let's work through the steps again. Number one, determine
00:14:43 - the number of networks and convert that number to binary.
00:14:48 - 50 is how many networks we wanted. So I'll put our equals and
00:14:52 - let's draw up our binary chart. 128, 64, 32,
00:14:56 - 16, 8, 4, 2 and 1. So 50 networks; zero, zero,
00:15:04 - one,
00:15:06 - I can take 50 minus 32 and that would give me
00:15:10 - four -- eight --18; so, 18 left over. So I'd have a 1 and a 16
00:15:15 - that would leave me two -- 18 minus 16, so there's our
00:15:18 - two and that is our binary number. Zero, zero, one, one, zero, zero
00:15:24 - one, zero. Now let me ask you a question.
00:15:28 - How many bits does it take to get the number 50? Well,
00:15:33 - looking -- looking at this number I can just underline where the
00:15:35 - first one started and say that takes one, two, three, four, five,
00:15:41 - six bits.
00:15:44 - Good, because we're going to need that number when we do step two.
00:15:47 - So step two now says reserve the bits in the subnet mask and find your
00:15:52 - increment. Again, don't skip this first part.
00:15:57 - It may seem tedious, but that is the key to seeing what bits
00:16:02 - you have to work with. Our original subnet mask is Class C, so
00:16:06 - in binary it's 8 ones dot one, two, three, four, five, six, seven,
00:16:12 - eight ones dot one, two, three, four, five, six, seven, eight ones
00:16:17 - dot and then the most critical piece. Not all the ones, it's the zeros; one,
00:16:20 - two, three, four five, six, seven, eight because the zeros is where
00:16:25 - we can do our subnetting. We were given a Class C address so we
00:16:28 - can't change any of those first 24 ones right there.
00:16:31 - We can only play with the last eight zeros. So now we look
00:16:35 - at our requirements, it says reserve bits in the subnet mask and find
00:16:38 - your increment. Our organization wants to break this into 50
00:16:42 - sub-networks. We know that it takes six bits to get the number
00:16:46 - 50. And we know that ones are network bits. We need to change
00:16:50 - our subnet mask to where we have six more ones. So we do that;
00:16:55 - one, two, three, four, five, six. And the other two can remain zero
00:17:01 - zero, zero. We've stolen six network, or six host bits and made
00:17:06 - them network bits to meet our requirements. Just like that, poof.
00:17:10 - We know what our subnet mask will be for our whole organization.
00:17:14 - It's 255.255.255 dot, and
00:17:19 - then we need to convert this last one back to decimal. So we
00:17:23 - use our binary to decimal and decimal to binary conversion
00:17:26 - skills and I say I've got one 128; one 64;
00:17:31 - one 32; one 16; one 8; one 4; no twos no
00:17:37 - ones. So I can, by the way when you see this you can approach
00:17:41 - it one of two ways. I can either add all these numbers together
00:17:44 - 128, 64, 32, 16, 8, 4, 2
00:17:47 - or four, add all those up and I would end up, if I did that addition
00:17:51 - with the number 252. But that's a pretty long addition
00:17:55 - problem, adding all those values together. So one of the ways
00:17:59 - that I do this and find a little shortcut is I know if all of
00:18:03 - these are turned on to one, it's what number?
00:18:06 - 255; right? That's -- that's the maximum number I can get. And
00:18:10 - I can look at this and go, oh, well, there is no twos and there
00:18:13 - is no one, so I can just do 255 minus two, minus one
00:18:17 - or just add those together and just do 255 minus
00:18:20 - three and get 252. So whatever way works easier
00:18:25 - in your mind for you, either doing addition, adding all those
00:18:27 - together or knowing the maximum is 255 and just subtracting
00:18:31 - what's not turned on. That will give you your subnet mask. Now
00:18:37 - I'm trying to think should I add another piece at this point?
00:18:39 - No, I'm not going to. Let's -- let's keep working through this, I'll add it once we're
00:18:43 - done with this problem. It says reserve the bits in the mask
00:18:46 - and find your increment. So we've got the mask, we've reserved the
00:18:49 - bits, our increment is the lowest network bit,
00:18:54 - that guy, converted back to a decimal number. Now if we look in --
00:18:58 - in binary, this is or in decimal, this is one, two -- that one is a four. That is
00:19:04 - the decimal equivalent of the lowest network bit.
00:19:08 - That is our increment and that is what we need to find our
00:19:12 - network ranges. So the last step will be finding our network ranges.
00:19:17 - We start with what we were given;;
00:19:23 - that's the address that we purchased from
00:19:26 - the powers that be. And we want to use to address our whole organization.
00:19:29 - So now I just need to start adding my increment in whatever
00:19:32 - octet it's in. I notice that it's in the fourth octet right here. So I'll just
00:19:36 - do some simple math,;;
00:19:42 - and I'll just
00:19:47 - start shortening --.20.12;.20.16.
00:19:52 - You know this is the same the whole way down. That is the start of
00:19:55 - every single network range that I have. Now let's fill in the end.
00:19:59 - I'll go back to the top. The last IP address before I get
00:20:02 - to down here
00:20:06 - is.3. The last IP address before I get to
00:20:10 - is.7 and down and
00:20:16 - down I go;.11 is the last one before 12;.15, you
00:20:20 - know, same thing.;.15 and so on.
00:20:22 - I just keep on going. I think the next one would be.19
00:20:26 - because.20 would be if I added four over here. And I
00:20:29 - would just keep finding all these network ranges. Now let
00:20:33 - me fill in a little more -- a little more information here
00:20:38 - about these network ranges. We've taken one Class C network,
00:20:42 - with one network
00:20:46 - that could go all the way up to 255 and broken it into
00:20:50 - all these little sub-networks. Now there is a price to pay
00:20:55 - whenever you do subnetting. Here it is. When we had one network, we couldn't
00:20:59 - use the very first or the last IP address; right? Because the very
00:21:04 - first IP address identified the network. It's known as the network
00:21:08 - ID. You can not assign -- or
00:21:12 - .20.0 to a PC or to a router or to any device because
00:21:15 - it identifies the network. We can't assign that IP address because
00:21:19 - that's the broadcast. Meaning, if I wanted to send a broadcast to
00:21:23 - everybody in that network, I would send it to that IP address.
00:21:27 - So I can not assign this IP address to any given host. Now
00:21:32 - what we've done is taken this one network and broken it down into
00:21:36 - mini sub-networks. But when we do that we can not use the first
00:21:42 - IP address or the last IP address from every single
00:21:46 - network range. So I can not assign 20.3 to a host because
00:21:51 - it's the broadcast for this first network right here. I can
00:21:54 - not assign 20.7 to a host because that's the broadcast
00:21:58 - for the second network and the third network and the fourth
00:22:01 - network. I can not assign the first or the last IP address from
00:22:05 - every single range to a host or a router or a switch or any device
00:22:09 - on that network. So what does that mean?
00:22:12 - That means when I really look at this, I have one through two;
00:22:17 - five through six; nine through ten. I have two usable hosts per network
00:22:25 - that I can actually assign -- one and two; five and six; nine and ten -- that
00:22:29 - I can actually give to a device. Now I know you might be looking at
00:22:32 - that going, that is stupid he-he. Why would you ever have
00:22:38 - a network of two hosts? Now with that being said, I can tell
00:22:43 - you that is the second most popular subnet mask in the world.
00:22:49 - I'm not kidding. This subnet mask that you just found,
00:22:52 - which gives you two usable
00:22:55 - hosts per network is the second most popular one in the world
00:22:59 - because it's perfect
00:23:05 - for those kind of networks right there. That is considered
00:23:09 - a point-to-point WAN link, meaning, you know, this -- I
00:23:14 - mean think of the diagram we had before where we had, you know, we've
00:23:17 - had some hosts over here and some hosts over here. And I said but
00:23:19 - this is a network, too. Well, that network will never have more
00:23:24 - than two hosts per network because there's only eight points.
00:23:27 - I'll put.1,.2, to point network right here. So I
00:23:32 - can assign this first network to that point-to-point WAN
00:23:36 - link. I have another point-to-point WAN link right here. I could assign
00:23:40 - this second network, maybe.5 is assigned to that router right there.
00:23:44 - And.6 is assigned to that router interface over there. That
00:23:47 - is a very popular subnet mask and very popular way to find network
00:23:51 - ranges for your WAN links. Now
00:23:55 - with that being said, that is the second network scenario that we've
00:23:58 - gone through that is a Class C address. I'd like to add one more
00:24:02 - piece of information that we can gather from this. That
00:24:06 - is a different way to write the subnet mask. You can see that
00:24:11 - I have the Class C subnet mask right here,
00:24:14 - Now I don't know if I've written it this way
00:24:18 - in the past in this series, but you'll see this subnet mask,
00:24:23 - short-hand abbreviated, a lot of times a /24. Have you
00:24:27 - seen that before? When -- when people write a Class C subnet mask up here,
00:24:31 - they might write it 195 -- oops,,
00:24:37 - instead of actually writing
00:24:41 -; that's known, technically known
00:24:45 - as cider notation. Many people call it bit notation or slash
00:24:49 - notation. There's a lot of names for it, but all it is shorthand
00:24:53 - for writing the subnet mask. And now that we have this problem
00:24:56 - sitting right in front of us, we can explain why this shorthand
00:25:00 - notation means the same thing. When you see slash and a
00:25:04 - number, that is literally the number of ones in the subnet
00:25:08 - mask when you convert it to binary.
00:25:11 - Ha, seriously, look at this. Class C subnet mask --
00:25:14 - If you converted 255 to binary,
00:25:18 - how many ones is that?
00:25:20 - Eight, same thing here, eight, same thing there, eight. So if I take all of
00:25:25 - those ones and add them up, 8 plus 8 plus 8 is twenty four. It's
00:25:30 - shorthand. So if I were to look at a Class A subnet mask; that's
00:25:33 - 255.2 -- oops, or.0.0.0,
00:25:38 - that is abbreviated as a /8. A Class B subnet mask
00:25:43 - is abbreviated
00:25:48 - as a /16. Class C is /24; that's the bit
00:25:54 - notation. You're just looking at how many ones, 8 plus 8,
00:25:57 - or just 8 up here is in the subnet mask. And the same thing
00:26:01 - works for these custom subnet masks right here.
00:26:05 - can be shorthand notated, in
00:26:08 - cider notation or bit notation by saying, okay, we've got 8 -
00:26:12 - ones there; 8 - ones there; that's 24, 25,
00:26:16 - 26, 27, 28, 29, 30.
00:26:20 - /30 is shorthand bit notation for
00:26:25 - When you are working
00:26:28 - on a CISCO device, there are many show
00:26:31 - commands that will show you the subnet mask in that format and
00:26:35 - there are many show commands that will show you the subnet mask
00:26:37 - in that format. So you need to be comfortable working with both.
00:26:41 - Same thing if you're preparing for the CCENT or CCNA
00:26:44 - exam, there are questions that will give you the subnet mask in both
00:26:48 - formats, one or the other. So you need to be very comfortable working
00:26:52 - with either one. So what I want to do as we work through these
00:26:55 - problems, we've got two more scenarios that I've got for this
00:26:58 - video that I want to work through, I want to show you the subnet
00:27:01 - mask both in decimal and bit notation so you can get comfortable
00:27:05 - working with the either.
00:27:08 - Now before we move on to network scenario number three, I
00:27:12 - wanna make a quick point. We just did two back-to-back network
00:27:15 - scenarios that are using Class C networks. I'm about to move
00:27:20 - into a Class B example. Now don't worry it's the same thing.
00:27:24 - It's the same three steps, same process that you work through.
00:27:27 - But I want to make sure before you jump into this one that
00:27:29 - you are comfortable with the Class C examples we just talked
00:27:32 - about. So if you would like, what I would propose is to pause
00:27:37 - the video right here, if you're still feeling like you -- you wanna
00:27:39 - see those again, rewind it and do the Class C examples one more
00:27:43 - time. That's the beauty of video; just watch -- watch me work through those two
00:27:47 - Class C examples, then come into this Class B. If you're feeling
00:27:50 - comfortable and -- and you're ready for a Class B example, feel
00:27:53 - free to keep on watching. I just wanted to make sure I mentioned that
00:27:56 - we are moving into another class of problem if you will. So
00:28:01 - here's our scenario,
00:28:03 - we are given a Class B network, 150. 5.0.0
00:28:08 - and the organization that we're working for has offered
00:28:12 - us a lucrative $16.3 million contract
00:28:16 - to break that into a hundred sub-networks. As of right now, you
00:28:20 - know, Class B network;
00:28:25 - We've got one network;
00:28:29 - that's 150.5 and a whole bunch of hosts.
00:28:33 - 65,535 I believe to be exact.
00:28:36 - And that -- you know, that's way too many hosts. We want to break
00:28:39 - that into a hundred different sub-networks; that's our goal.
00:28:42 - So
00:28:43 - the process is the same. Number one determine the number of
00:28:47 - networks and convert to binary. 100 sub-networks;
00:28:51 - right? That in binary -- let me just write up our chart. 128, 64, 32, 16, 8,
00:28:56 - 4, 2, 1. So we convert it to
00:29:02 - binary; zero -- we can't subtract 128, so our first one
00:29:05 - goes right there. 100 minus 64, remember on CISCO
00:29:09 - exams there are no calculators. So that will be 9, -- six
00:29:14 - 36, right? So we can take our 32, that would leave us
00:29:18 - with four. Zero, zero, one, zero, zero. So a hundred as a binary number
00:29:23 - is 01100100.
00:29:29 - Now, let me freeze for a moment right there. I'm not all about
00:29:34 - teaching shortcuts. Meaning, you're going to find as you
00:29:37 - work through more and more examples, there's ways to -- to cut
00:29:40 - time by doing shortcuts. But there is one thing I do want to
00:29:44 - show you and that's how to save a little extra time right
00:29:47 - here. When I convert 100 to a binary number, remember I'm
00:29:51 - not so much after the binary number itself as I am after how many
00:29:56 - bits did it take to get to the number 100, right? Because that's
00:29:59 - what I'm wanting for the second step of the problem; that's why
00:30:02 - we do this binary conversion to start off with is we want to
00:30:05 - know how many bits it takes to get to the number 100.
00:30:08 - Now as soon as I find where my first one goes,
00:30:12 - do I know how many bits it's going to take? Well, sure I do. Soon
00:30:16 - as I know that my first one is 64, I know that I'm going
00:30:19 - to have one, two, three, four, five, six, seven bits. It doesn't matter
00:30:23 - what the rest of the binary, you know, comes out to. I know as soon
00:30:26 - as I know where that first one is that it takes seven bits
00:30:32 - to get the number 100. So a time saving shortcut right
00:30:36 - there, as soon as you look and find out where your first one
00:30:40 - goes in the binary equation, you can stop. You don't have to figure
00:30:44 - out and do subtraction and find the rest of it because you know, stop right
00:30:47 - there as soon as I know my first one is at 64, it takes
00:30:50 - seven bits to get to the number 100. That shortcut helps you
00:30:53 - save some time, it's great. If it confuses you, forget I ever
00:30:57 - said it. Just figure out the whole binary number. But you'll get comfortable
00:31:00 - with it as you work through it a couple more times. Here is the
00:31:03 - second set, reserve the bits in the subnet mask and find your increment.
00:31:07 - Now again, it becomes even more critical when you have a Class
00:31:12 - B example to write your subnet mask in all binary one, two, three,
00:31:16 - four, five, six, seven, eight. That's our first.255
00:31:22 - Eight, there's our second.255, now the host bits; one,
00:31:25 - two, three, four, five, six, seven, eight dot one, two, three, four,
00:31:30 - five, six, seven, eight. We have 16 network bits, it's a /16
00:31:35 - subnet mask by default and 16 host bits that are at our disposal.
00:31:39 - Now we're going back to our question. We want to take the Class
00:31:42 - B network and break it into a hundred sub-networks. We know
00:31:45 - that it takes seven or sorry, six bits to get the number 100.
00:31:50 - So we will pick up right where our ones leave off.
00:31:54 - This is the key don't -- don't start it's not a Class C example
00:31:57 - anymore. Don't start adding ones over here. We pick up where the
00:32:00 - ones leave off and say I need -- wait a sec, did I say six bits or
00:32:04 - seven bits? Seven bits; seven bits to get the number 100.
00:32:07 - Sorry; one, two, three, four, five, six, seven, zero dot and all these
00:32:14 - stay zero -- zero, zero, zero, zero, zero, zero, zero, zero. Eight zeros.
00:32:18 - There it is. Okay, 8 zeros. That is our new subnet mask when we're using
00:32:22 - a Class B example. Remember it's the same as it was before, it's
00:32:25 - just now we're working in this third octet, rather than the
00:32:28 - fourth because we started with a different subnet mask. So our
00:32:31 - new subnet mask, we now know that is 255.255. --
00:32:35 - if we were to convert this one back to decimal,
00:32:39 - we could either add all those up or just know that it's 255
00:32:42 - minus -- we don't have a one. It would be 254.0.
00:32:46 - So our new subnet mask is
00:32:50 - Or if we're writing it in slash notation, it
00:32:54 - would be a /23. We had an original 16 bits --
00:32:59 - eight and eight, right there. And we just added seven more; that's
00:33:03 - the 254 or the seven bits right here. So you can just
00:33:06 - think of that as a /23 as shorthand notation.
00:33:09 - So that's the first part of step two, reserve the bits in the
00:33:12 - subnet mask and now find our increment. Our increment
00:33:17 - is the lowest network bit converted back to a decimal. Now don't
00:33:22 - start letting your mind go wild here, because I know you
00:33:25 - might think, okay, well, 128's right there, so is
00:33:29 - this like 256 now and stuff like that? No, the increments
00:33:33 - restart every single octet. So it's very simple; this is
00:33:37 - a one. This is a two, four, eight, you know, the decimal. I'm looking
00:33:41 - for the lowest network bit converted back to decimal number,
00:33:44 - that is simply a two.
00:33:47 - Now, step three; use the increment to find our network ranges. Just
00:33:52 - like the previous example, we're gonna write
00:33:55 -; that's the network that we started
00:34:00 - with and now we just start adding our increment. But before I do, I
00:34:03 - gotta ask the question what octet is the increment in?
00:34:08 - The third, right? This -- this octet right here is where our increment
00:34:11 - is at. Before when we were doing the Class C example, our increment
00:34:14 - was over here and that's why we added the number to our fourth octet.
00:34:17 - But since now our increments in our third octet; that's where
00:34:21 - our addition takes place. So we have,
00:34:25 -;.5.6.0;
00:34:30 - .5.8.0; forgive my penmanship getting
00:34:35 - a little sloppy as I go down. It's 150.5
00:34:38 - the whole way down and so on and so on and so on. We just
00:34:41 - keep adding to -- to that number.
00:34:44 - Now we fill in our end range and this is where it gets a
00:34:46 - little tricky. You look at this what -- and ask the question, what is
00:34:49 - the last IP address before I get to
00:34:55 - Well, you look at it and go 150.5.1, and be
00:35:00 - careful right here because I know you might be thinking well,
00:35:02 - 1.0; right? Well, remember if we do
00:35:06 - through 150.5.1, if I put
00:35:10 - a zero right here, then
00:35:13 - that's where this first range ends and the next one picks up at
00:35:17 - 2.0. So let me ask the question what happens to
00:35:21 - the number or
00:35:25 -; 52; or 53? What happens to
00:35:28 - all of the 150.5.1 numbers? Well, if you go
00:35:32 - to as your end, you lose all of them.
00:35:35 - You can't -- can't do that. Think of some weird twisted
00:35:39 - math problem,; that's where our
00:35:43 - next one starts, if we were to subtract one from that, the last
00:35:46 - possible IP address before we get to 2.0 is actually
00:35:49 - 1.255.
00:35:52 - Ah-ah! This one goes through 150.5.3 --
00:35:57 - that's the last one before we get to 4.0.255.
00:36:01 - Again, last IP address before we get to four is
00:36:06 - 3.255. Last IP address before we get to 6.0,
00:36:09 - and so on
00:36:15 - and so on and so on we go.
00:36:17 - Does that make sense? It's kinda weird, but that's -- that's the last IP address
00:36:20 - before we get to two and four and six and eight and so on and
00:36:23 - so on. It is going to be the 255 because that's how the
00:36:26 - binary works out.
00:36:28 - That is the answer to the problem. Now there's a couple more
00:36:32 - pieces I want to add as we have walked through this problem. The
00:36:35 - first one is this,
00:36:38 - as you look at these network ranges, we now have a network
00:36:42 - range that shows through
00:36:45 - We know that we can't use
00:36:49 - the last IP address from that range, right? 1.255
00:36:52 - because that's the broadcast, just like we saw on the previous
00:36:55 - one. We can't use the first one from each range either because
00:36:58 - that identifies the network. So those are unusable. Now here's
00:37:03 - the question, I'm looking at that first range; that's where my arrows
00:37:06 - drawing from, somewhere within that range I'm gonna run into the
00:37:09 - IP address, right?
00:37:17 - Do you see that? It's somewhere squished in the middle of that
00:37:20 - range. Can I actually assign that to a PC? Hmm.
00:37:25 - Well, on that same token before I answer that question, I'm also
00:37:28 - going to run into somewhere
00:37:33 - in that range, you know, it's in between 0.0 and 1.255;
00:37:37 - that's -- that's an IP address in that range. Can I assign that
00:37:40 - one to a PC or to a router?
00:37:42 - The answer on both accounts is absolutely yes, you can. It's
00:37:49 - going to feel really weird when you're typing it in because
00:37:52 - we're -- we're geared in the decimal mindset. We're -- we're geared to think,
00:37:55 - oh, 255 you can't use that. That's -- that's a broadcast,
00:37:59 - right? You can't use that. And same thing with 1.0, you
00:38:02 - can't use that. You can't use zeros; that's -- that's the network.
00:38:05 - That's thinking in a decimal mindset. Those addresses are right
00:38:11 - in the middle of this range. They are completely valid addresses.
00:38:15 - Like I said it's going to feel really weird typing it in, but
00:38:18 - when you combine it with this subnet mask in your network properties
00:38:22 - field, it will work just fine. It's right in the middle. There's
00:38:26 - only one broadcast address and one network address for each
00:38:30 - range and that is it. We circled them right there on the screen.
00:38:33 - Everything that's in that squishy oreo center of that works
00:38:37 - just fine. That's something to get used to. And then I want you to already
00:38:41 - begin envisioning, if you're preparing for the certification
00:38:45 - exam a test question that says, which of the following addresses
00:38:49 - are valid and invalid; select all that apply. Well, when you see
00:38:53 - this you think, oh, that's invalid. Well, that's not true. You have
00:38:57 - to back up and say, well, what subnet mask are we working
00:39:00 - with, first of all. Based on that subnet mask, you'll be able to figure
00:39:03 - out which ones are valid and invalid. So that's the first piece
00:39:07 - I wanted to add to this is getting comfortable with those network
00:39:11 - ranges. The second piece that I want to add to this is what
00:39:15 - if -- what if somebody really wanted to know, you know? Okay, I can
00:39:19 - see that, you know, we wanted a hundred networks, but, you know,
00:39:23 - how many networks did this really give us? I mean, if we were
00:39:25 - to come up, here's one, here's two, here's three -- you know, if I wanted to
00:39:29 - know how many networks I could get using this subnet mask. Is there an
00:39:34 - easy way to do that without adding all of these up, you know,
00:39:37 - going through and writing all the ranges and then adding them up
00:39:39 - one by one? Well, the answer to that is also yes. We can figure
00:39:44 - that out by using a formula. And I know this is the first mathematical
00:39:48 - formula we've introduced here; it's known as the power formula.
00:39:52 - Two to the power of X is the formula that I want you to remember,
00:39:57 - where X is actually the number of subnet bits. Now
00:40:02 - if we look we added one, two, three, four, five, six, seven subnet bits.
00:40:07 - That's what we found right here. It takes seven bits. So if we do two
00:40:11 - to the power of seven that will tell us just how many subnets
00:40:17 - we're going to end up with if we were to count this all
00:40:20 - to the bottom. Now
00:40:22 - that's -- that's a painful equation when you're on a certification
00:40:26 - exam and don't have a calculator in front of you. So let me -- let
00:40:31 - me do this, let me show you two things. First off, I want
00:40:34 - to show you how to figure this out if you have a calculator
00:40:38 - and second, I want to show you how to figure out if you don't.
00:40:40 - If you have a calculator, let me bring this back into the screen;
00:40:45 - just clear off what we've got here, if you have a calculator
00:40:48 - the Windows calculator, all I need to do is go two, then move
00:40:52 - over here to these fuchsia numbers, x^y will do two to the
00:40:56 - power of seven and hit the equal sign
00:41:02 - and that will tell us exactly how many networks we get. If we
00:41:05 - were to follow this all the way to the bottom, we would end
00:41:08 - up with a 128 -- oops, I went out of the screen -- a 128
00:41:12 - different subnets that we could break this into.
00:41:16 - That's the way to do it with the calculator. If you don't have
00:41:19 - a calculator, the way to do it is using your binary chart.
00:41:24 - You might remember when I talked in the binary conversion video,
00:41:27 - I said these are actually the power of two. This one is two to
00:41:31 - the power of zero. Remember I said I don't know why two to the power
00:41:34 - of zero is one, but it is. Anything to the power of zero is one.
00:41:37 - So if you remember that, you can go okay, two to the power of one
00:41:40 - is two. Two to the power of two is four, three, four, five, six, seven.
00:41:46 - Ah-ha -- is 128. So I can look at two to the power of seven and
00:41:50 - say that is a hundred and 28 just by looking at my binary
00:41:54 - chart and realizing they're powers of two.
00:41:57 - Okay, are you comfortable with that? That is adding a couple of pieces
00:42:02 - to this, finding out that in between these network ranges
00:42:05 - we have some odd numbers that are valid and finding out the
00:42:08 - way that we can find how many networks we really get when we
00:42:11 - do subnetting. Using that same logic,
00:42:16 - let me just clear up some room -- I'm looking at this -- this screen right
00:42:21 - now, thinking how on earth can you learn anything from this
00:42:24 - mess? It's just a mess of numbers at this point. So let me just
00:42:27 - carve out a little extra space out for myself so I can do some
00:42:30 - writing here.
00:42:32 - I just showed you the equation, the two to the power of X equation
00:42:37 - to find the number of networks. But what if you were asked not --
00:42:41 - not for the number of networks, but how many hosts do I get
00:42:45 - in each one of those networks? Meaning, how many hosts do I get in
00:42:49 - between and
00:42:52 - Well, just looking at
00:42:55 - that, it's not very easy to just add those up and -- and figure that
00:42:58 - out. So you can use that same equation, slightly different to
00:43:02 - find the number of hosts. Two to the power of X, but this time
00:43:06 - X is how many zeros. We were using ones
00:43:11 - the find how many networks we get, so two to the power of X with
00:43:15 - zeros being the X this time will tell us how many hosts we get.
00:43:19 - But remember we have to do a minus two on there.
00:43:23 - We have to subtract two from whatever our value is because we
00:43:27 - cannot use the last nor can we use the first IP address from
00:43:30 - each range; that's why we subtract two. So in our case, two to the
00:43:34 - power of X, X is one, two, three, four, five, six, seven, eight,
00:43:40 - nine zeros. We have nine zeros left over in our subnet mask.
00:43:44 - So two to the power of nine minus two will give us that equation.
00:43:49 - Now again, if you've got your calculator that makes it a lot easier.
00:43:52 - We can go two; x^y -- this fuschia one, nine equals 512
00:43:59 - minus two, 510. So there are 510
00:44:04 - hosts per network here. If you don't have a calculator
00:44:08 - in front of you, you can say okay, well, I know two to the power of
00:44:11 - seven is 128, you know? You know where that leaves
00:44:14 - off. So two to the power of eight is 128 times two; that's
00:44:20 - 256. Two to the power of nine is 256 times two
00:44:26 - and that is 512. It will take a little extra math if
00:44:30 - you don't have a calculator, but that will be able to tell you
00:44:33 - how many hosts per subnet you have.
00:44:36 - All right. I have one more network scenario to work through with you.
00:44:39 - And after seeing the Class B one, it shouldn't be to bad, although, I've thrown in an extra
00:44:43 - little twist in here. We now have a Class A example. We
00:44:49 - have the network and we would
00:44:52 - like to break that into 500 networks. Wow.
00:44:58 - All right. Same three steps; same process, just a little bit bigger
00:45:02 - numbers. We've got step one, determine the number of networks
00:45:06 - and convert to binary. So
00:45:08 - here's my hint for this one -- 500 is let's go ahead and write
00:45:12 - our binary table. 1, 2, 4, 8,
00:45:17 - 16. 32. 64, 128. Now stop
00:45:23 - right there, because I know that -- wait a second, I -- I can't get the number
00:45:27 - 500 with eight bits. I can only get 255; right? Right.
00:45:32 - So we need to keep going, 128, 256 -- I'm running outta room here --
00:45:37 - 512. Now, immediately I look and I go, oh 512 is
00:45:43 - bigger than 500. So I at -- my first one doesn't go there,
00:45:46 - I can't subtract 512 from 500. So my first one
00:45:49 - goes erk -- right there; 256. Now I can work that out and do
00:45:54 - 500 minus 256 and -- and find the whole binary
00:45:57 - number for what 500 is. But remember I just mentioned on the
00:46:00 - last slide, we're not after that binary number and exactly what
00:46:04 - it is. We just want to know how many bits did it take to get the
00:46:06 - number 500. And when I look and I go, oh, well, my first one
00:46:09 - went right there. I immediately know it took one, two, three, four, five,
00:46:13 - six, seven, eight, nine -- nine bits to get the number 500.
00:46:21 - Good? All right, second step, reserve the bits in the subnet mask and find your
00:46:26 - increment. Again, we now have a Class A network, so I need to
00:46:31 - write that subnet mask in all binarys. One, two, three, four, five,
00:46:34 - six, seven, eight, dot one, two, three, four, five, six, seven, eight
00:46:39 - dot one, two, three, four, five, six, seven, eight
00:46:44 - dot one, two, three, four, five, six, seven, eight. Trust me, it doesn't
00:46:49 - take you this long when you're not talking as you do it. It just -- it's
00:46:52 - hard to write and talk. So we have to
00:46:56 - written in all binary. I now need to ask, am I trying to get more
00:46:59 - networks here or am I trying to get more hosts per network? Now I -- I look at
00:47:04 - that and I say, well, I want more networks. Now I asked that
00:47:07 - question because in the next video I'm gonna show you the second style of subnetting, which
00:47:11 - is host per network. So we say I wanted 500 networks.
00:47:14 - 500 networks need nine bits and I know network bits
00:47:19 - are the ones, so I'll pick up right where the ones leave off and
00:47:23 - go one, two, three, four, five, six, seven, eight -- eight bits per octet -- dot
00:47:29 - nine. One, two, three, four, five, six, seven dot and then those all stay
00:47:35 - zero. So we actually bled past our octet. We moved into
00:47:39 - another octet. So I know my new subnet mask is 255. -- second
00:47:45 - octet is now 255. -- now, if I convert that third octet to
00:47:49 - binary, what is it? Or wait, to decimal? It is 128
00:47:53 - as a decimal number. One, zero, zero, they're all zeros.
00:47:56 - If we line that back up; that's 128. So that is our
00:48:00 - new subnet mask or in bit notation it's / -- we have eight - ones; eight - ones;
00:48:04 - that's 16, 17. /17 is our subnet mask. Wow;
00:48:09 - that's new. Now, here's the unique part about it, what is
00:48:13 - our increment? Lowest network bit converted back to a decimal
00:48:17 - number. Well, that network bit is
00:48:21 - 128. Wow. weird, So our increment is the same as our
00:48:26 - subnet mask. You bet it is. So now we have all the pieces
00:48:30 - that we need to move on to step three and find our network
00:48:33 - ranges. This is where it's going to take a slightly different
00:48:36 - look, but like I'm doing it, I'm adding more pieces on every single
00:48:40 - one of these problems. This is the last piece I need to add. So we
00:48:43 - have the increment to find our network ranges. We started with
00:48:46 - hang on,
00:48:50 - let me get a different color here. I know -- I know. Colors don't matter
00:48:55 - but to me they do; they stand out better. So is
00:48:59 - what we were given and what we started with. Now we need to look back at
00:49:02 - this increment and identify what octet the increment is in.
00:49:07 - It's in octet number three. So I can just go and add 128
00:49:13 - to the third octet.
00:49:17 - 10.0. -- wait a sec,
00:49:20 - what happens if you add 128
00:49:25 - to 128? 128 plus 128,
00:49:30 - that gives you 256. You can't have 256 in an
00:49:35 - IP address. Well, here's -- here's where I want to show you. Now notice
00:49:38 - first off we added eight network bits. I know we're going to
00:49:43 - get way more than two network ranges with eight network bits. I mean,
00:49:47 - if we did two to the power of X where X is eight, we get
00:49:51 - a whole bunch of networks that are at our disposal with
00:49:54 - this; at least 500. So I know that I can't stop right here,
00:49:58 - so let's fill in the end ranges. Just kinda -- erk -- draw a line. Let's -- let's see where
00:50:02 - things end. This would go, what would be the last IP address
00:50:05 - before we got to
00:50:08 - It would be,
00:50:15 - right? This would go through 10. -- well, let -- let's
00:50:19 - do the math as if it worked, right? Let's say that this went to
00:50:23 - 256.0, right? If we were just adding like we were before,
00:50:28 - what would be the last IP address before we get to 256.0?
00:50:32 - 10.0.255;
00:50:35 - that's the last one before you get there, right?.255
00:50:38 - But we know that we can't have 256, so let's --
00:50:44 - let's make a slight correction here.
00:50:48 - Erase that. When we have 255.255, if I
00:50:53 - were to do like a plus one -- think of this as, again that weird twisted
00:50:57 - math problem. I know that I can't go to 256, so this will be
00:51:00 - that'll zero it out, right? 255 plus one and carry
00:51:03 - the one. So we have a plus one there. You can't have 256 so
00:51:07 - zero it out, carry the one and now I have like this
00:51:11 - Hmm; that's exactly what the next range starts
00:51:17 - at.
00:51:20 - and then just keep adding our increment.
00:51:23 - 10 -- instead of doing
00:51:28 - this all over again, I will now recognize it and go, well I can't have 256
00:51:31 - so we move up to Let's fill in some end
00:51:37 - ranges here. 10. -- this will be;
00:51:43 - that's the last IP address before I
00:51:46 - get to 10.1.128. This goes through
00:51:51 - Last IP address before I get to
00:51:55 - And so on and so on and so on we would go
00:51:59 - down and down and down the range; that's a tough one. I have
00:52:02 - to tell you, that's -- it takes a little logic and a little working
00:52:04 - through that to get it, but that is how you can find those network
00:52:07 - ranges is just identifying where the next one starts and subtract
00:52:11 - one to find where the last one would end up ending.
00:52:16 - Before we end this video, I want to make sure that you get
00:52:20 - some practice because doing subnetting, working through it again and again
00:52:25 - and again and again and again and again and again, is the only way that you're
00:52:28 - going to solidify this skill yourself. So what I have here
00:52:31 - is four problems to do on your own. I have two Class C examples,
00:52:35 - which are by far the most common subnetting styles. But then
00:52:38 - I have a Class B and a Class A example as well. And they do have their
00:52:42 - own little twist break into a thousand networks; break into 25
00:52:45 - networks and that sort of thing. So I want you to take some
00:52:49 - time, grab a piece of paper and work through these problems
00:52:52 - so that you can make sure you can not only observe this skill being
00:52:55 - done on the screen, but do it yourself. Now I know that
00:53:01 - examples or -- or practice problems without being able to know
00:53:04 - if you're right or not are of no use, so what I've done is I've
00:53:06 - actually worked through these problems on my own, and put up my
00:53:09 - results on You'll actually see a file there
00:53:13 - named something like CCENT support files or it'll have some
00:53:17 - identifier that you'll be able to quickly CCENT something.
00:53:20 - And you can download that and you will be able to check your
00:53:23 - work and verify your answers. When I worked these out, I worked
00:53:26 - them out on -- I just did it in a Microsoft Word document. I saved it as a PDF
00:53:30 - file, so everybody can open it. And all I did was -- was walk through the
00:53:34 - three steps. So I have the results of the three steps that you
00:53:37 - would be walking through, you can compare your answers to mine
00:53:40 - and make sure that you're on the right track. This is the first
00:53:44 - style of subnetting that we must master before you move into the next style
00:53:47 - in the next video.
00:53:49 - I know that this video has been a little extra long compared
00:53:53 - to the traditional CBTNuggets video in this series, but I couldn't
00:53:57 - think of a better way to group everything together and show
00:53:59 - you enough examples where you can see at least four different
00:54:03 - scenarios working through different classes of subnetting, based
00:54:07 - on the number of networks. The benefit is you now have the chance
00:54:10 - to just sit down, let it soak in, review this video; review just
00:54:14 - sections of this video multiple times if you need to see some
00:54:17 - examples as you work through those practice problems. I'll also mention
00:54:21 - that when I created those practice problems, I didn't pull them from
00:54:25 - the book or something or -- or what -- what should I do? I just made
00:54:29 - them up and you can do the same thing. Don't -- don't think that
00:54:31 - those four practice problems are the only ones that you can
00:54:34 - do. Just think of a -- a network that you have, you know,
00:54:38 - and then just say I want 50, 90, 100
00:54:43 - different networks and then work out that subnetting problem. And
00:54:47 - figure out what the result will be. The key is not only to master
00:54:51 - the subnetting, meaning, come up with the subnet mask and find your network
00:54:54 - ranges, but to be able to do it quickly. I'll talk more about why
00:54:59 - that's essential in the next video. For now, I hope this has
00:55:02 - been informative for you and I'd like to thank you for viewing.

Advanced TCP/IP: IP Subnetting, Part 2

Advanced TCP/IP: IP Subnetting, Part 3

Please help us improve by sharing your feedback on training courses and videos. For customer service questions, please contact our support team. The views expressed in comments reflect those of the author and not of CBT Nuggets. We reserve the right to remove comments that do not adhere to our community standards.

comments powered by Disqus

Course Features

Speed Control

Play videos at a faster or slower pace.


Pick up where you left off watching a video.


Jot down information to refer back to at a later time.

Closed Captions

Follow what the trainers are saying with ease.

Offline Training

Our mobile apps offer the ability to download videos and train anytime, anywhere offline.

Accountability Coaching

Develop and maintain a study plan with assistance from coaches.
Jeremy Cioara

Jeremy Cioara

CBT Nuggets Trainer

Cisco CCNA, CCDA, CCNA Security, CCNA Voice, CCNP, CCSP, CCVP, CCDP, CCIE R&S; Amazon Web Services CSA; Microsoft MCP, MCSE, Novell CNA, CNE; CompTIA A+, Network+, iNet+

Area Of Expertise:
Cisco network administration and development. Author or coauthor of numerous books, including: CCNA Voice 640-461 Official Cert Guide; CCNA Voice Official Exam Certification Guide (640-460 IIUC); CCENT Exam Prep (Exam 640-822); CCNA Exam Cram (Exam 640-802) 3rd Edition; and CCNA Voice 640-461 Official Cert Guide.

Stay Connected

Get the latest updates on the subjects you choose.

  © 2015 CBT Nuggets. All rights reserved. Licensing Agreement | Billing Agreement | Privacy Policy | RSS