WEBVTT

0:00:08.140000 --> 0:00:16.960000
 So we have spent the vast majority of
 our day today talking about taking

0:00:16.960000 --> 0:00:21.740000
 networks, a single network that you've
 leased or rented from your service

0:00:21.740000 --> 0:00:26.860000
 provider and by modifying some of the
 host bits, taking that network and

0:00:26.860000 --> 0:00:30.840000
 cutting it up into little subnets,
 cutting it up into multiple pieces

0:00:30.840000 --> 0:00:34.960000
 for place on this land over here, that
 land over here, this land over

0:00:34.960000 --> 0:00:40.840000
 here. Summarization is just
 the opposite of that.

0:00:40.840000 --> 0:00:45.180000
 Starting out with a bunch of networks
 and saying I want to shrink them

0:00:45.180000 --> 0:00:49.280000
 all down to something
 they have in common.

0:00:49.280000 --> 0:00:52.780000
 Summarization is the
 process of that.

0:00:52.780000 --> 0:01:01.760000
 So it's the process of combining multiple
 subnetworks into a single network

0:01:01.760000 --> 0:01:11.060000
 advertisement. Also we'll refer
 to this as route aggregation.

0:01:11.060000 --> 0:01:14.500000
 Efficient and large networks provides
 addressing hierarchy.

0:01:14.500000 --> 0:01:19.000000
 Okay, so let's talk a little bit about
 why would we want to do this.

0:01:19.000000 --> 0:01:20.760000
 I'm going to use my
 favorite analogy.

0:01:20.760000 --> 0:01:21.460000
 You ready? Here we go.

0:01:21.460000 --> 0:01:23.940000
 If you've seen any videos of me,
 you'll see me do this a lot.

0:01:23.940000 --> 0:01:26.640000
 I'm a router and you're a router
 and we're connected together.

0:01:26.640000 --> 0:01:28.180000
 I do that all the time.

0:01:28.180000 --> 0:01:30.340000
 So let's play along with me here.

0:01:30.340000 --> 0:01:31.820000
 I'm a router and you're a router.

0:01:31.820000 --> 0:01:33.460000
 We have a cable between us.

0:01:33.460000 --> 0:01:36.240000
 Okay? And we're running some
 kind of a routing protocol.

0:01:36.240000 --> 0:01:40.320000
 Take your pick. RIP,
 OSPF, EIGRP, BGP.

0:01:40.320000 --> 0:01:49.460000
 Doesn't have to be as high as them
 to you so that you know you can get

0:01:49.460000 --> 0:01:51.560000
 to them through me.

0:01:51.560000 --> 0:01:53.360000
 That's the whole point.

0:01:53.360000 --> 0:01:56.480000
 Now normally when you turn on a routing
 protocol, like I said, take your

0:01:56.480000 --> 0:02:01.860000
 pick, as that router learns about networks
 and doesn't matter if there's

0:02:01.860000 --> 0:02:05.700000
 subnets or classical networks, the router
 doesn't care, the router says,

0:02:05.700000 --> 0:02:08.320000
 hey, let me tell you neighbor
 about what I know.

0:02:08.320000 --> 0:02:12.240000
 So imagine if behind me there's
 a whole bunch of lands.

0:02:12.240000 --> 0:02:19.500000
 Let's say there's a land out there
 that's 1010, 0, 0, slash 16, 1010,

0:02:19.500000 --> 0:02:27.080000
 0, 0, slash 16, 1010,
 10.64.128, slash 17.

0:02:27.080000 --> 0:02:30.100000
 There's a whole but now normally as
 a routing protocol, I would send all

0:02:30.100000 --> 0:02:32.180000
 those to you. I'd say, okay,
 here's a routing update.

0:02:32.180000 --> 0:02:46.600000
 Let me tell you about 1010, 1010, 1010,
 1010, what if you are running

0:02:46.600000 --> 0:02:50.800000
 out of memory? Okay, because all these
 routes that I'm sending to you,

0:02:50.800000 --> 0:02:54.140000
 you have to store them in memory somewhere
 in a place called an IP routing

0:02:54.140000 --> 0:02:56.360000
 table, an IP before routing table.


0:02:56.360000 --> 0:03:03.460000
 Well, what if you've got so many routes
 already that if I send you, let's

0:03:03.460000 --> 0:03:08.800000
 say, oh, 500 routes, that's going to
 overwhelm you, you're going to say,

0:03:08.800000 --> 0:03:10.800000
 look, I'm busting
 at the seams here.

0:03:10.800000 --> 0:03:14.680000
 I don't have enough memory left over
 to store 500 additional routes.

0:03:14.680000 --> 0:03:16.000000
 That's going to be bad.

0:03:16.000000 --> 0:03:18.920000
 It might cause your
 router to crash.

0:03:18.920000 --> 0:03:21.900000
 Least case scenario, you're probably going
 to drop some of my routes because

0:03:21.900000 --> 0:03:24.640000
 you're just not going to
 be a place to put them.

0:03:24.640000 --> 0:03:28.400000
 And certainly when we're talking about
 service provider networks, this

0:03:28.400000 --> 0:03:29.340000
 is a big concern.

0:03:29.340000 --> 0:03:34.400000
 If we're talking about a router that's
 owned by Time Warner Cable or Comcast,

0:03:34.400000 --> 0:03:39.300000
 that router could literally, if it knows
 about everything in the internet,

0:03:39.300000 --> 0:03:45.100000
 currently in the internet, there's
 well over 400,000 networks.

0:03:45.100000 --> 0:03:48.580000
 Think about that, 400,000 networks
 in the entire world.

0:03:48.580000 --> 0:03:53.260000
 Imagine how much memory that would consume
 to store in a single routing

0:03:53.260000 --> 0:03:56.580000
 table. And that's not the only thing
 that router is keeping track of,

0:03:56.580000 --> 0:04:00.120000
 right? That router is also keeping track
 of access lists and art tables

0:04:00.120000 --> 0:04:02.020000
 and all kinds of other stuff.

0:04:02.020000 --> 0:04:04.760000
 And now it's got store
 500,000 routes.

0:04:04.760000 --> 0:04:10.180000
 Yikes. Better be a big, powerful router
 with a lot of memory to do that.

0:04:10.180000 --> 0:04:13.100000
 Well, a lot of times what service providers
 will do is they'll say, look,

0:04:13.100000 --> 0:04:19.240000
 yeah, I could send you all these 500
 routes I know about 10, 10, 10, 30,

0:04:19.240000 --> 0:04:26.020000
 10.90.128. But when I think about
 it, huh, they all begin with 10.

0:04:26.020000 --> 0:04:33.680000
 Every router I have back here begins
 with I just send you a single route

0:04:33.680000 --> 0:04:39.200000
 that says, Hey, look, any packet you
 have that starts with 10, 10 slash

0:04:39.200000 --> 0:04:41.620000
 eight, send it to me.

0:04:41.620000 --> 0:04:45.000000
 I know about all networks
 that begin with 10.

0:04:45.000000 --> 0:04:46.940000
 That'd be nice, wouldn't it?

0:04:46.940000 --> 0:04:49.880000
 Because that now conserves
 your memory.

0:04:49.880000 --> 0:04:53.440000
 You don't have to know about
 every specific little thing.

0:04:53.440000 --> 0:04:58.480000
 I'm just sending you a single aggregated
 route, a single summarized route.

0:04:58.480000 --> 0:05:01.180000
 And that's what route summarization
 is all about.

0:05:01.180000 --> 0:05:03.760000
 Now routers don't do this
 technically by default.

0:05:03.760000 --> 0:05:05.520000
 You have to get in them
 and configure them.

0:05:05.520000 --> 0:05:07.420000
 And this is something
 at the CCNP level.

0:05:07.420000 --> 0:05:09.460000
 You learn how to do that.

0:05:09.460000 --> 0:05:13.960000
 But theoretically on paper, you do
 have to know how to take a bunch of

0:05:13.960000 --> 0:05:19.660000
 subnets like 10, 1, 10, 2, 10, 50,
 10, not 98 and ask yourself, okay,

0:05:19.660000 --> 0:05:31.840000
 if I thought about these as binary
 patterns from left to right, these,

0:05:31.840000 --> 0:05:36.160000
 that's what I'll send
 to my neighbor.

0:05:36.160000 --> 0:05:39.280000
 So for example, let's look
 at an example of this.

0:05:39.280000 --> 0:05:48.500000
 Here we have two networks,
 10.10.32.0 and 10.10.48.0.

0:05:48.500000 --> 0:05:51.140000
 They both in this case have
 the exact same mask.

0:05:51.140000 --> 0:05:54.980000
 Although really, the subnet mask of
 the original network is irrelevant

0:05:54.980000 --> 0:05:57.200000
 in the case of route
 summarization.

0:05:57.200000 --> 0:05:58.700000
 We really could care less.

0:05:58.700000 --> 0:06:01.660000
 So that's just sort of like
 a a little bit more.

0:06:01.660000 --> 0:06:06.300000
 So if we convert these networks into binary,
 remember what is our objective

0:06:06.300000 --> 0:06:07.360000
 here? What's our goal?

0:06:07.360000 --> 0:06:11.360000
 We're trying to figure out from left
 to right, what do these networks

0:06:11.360000 --> 0:06:14.140000
 have in common, if anything?

0:06:14.140000 --> 0:06:18.480000
 Well, clearly they have the first 16
 bits in common because they both

0:06:18.480000 --> 0:06:19.880000
 start with 10, 10.

0:06:19.880000 --> 0:06:23.040000
 But do they have any
 more than that?

0:06:23.040000 --> 0:06:27.020000
 Well, when we go into the third octet,
 we see, oh, wait a second.

0:06:27.020000 --> 0:06:33.180000
 The number 32 and 48, when I start converting
 that into binary, sure enough,

0:06:33.180000 --> 0:06:35.980000
 those two numbers have the
 first three bits in common.

0:06:35.980000 --> 0:06:38.660000
 They both start with 001.

0:06:38.660000 --> 0:06:41.520000
 The 128 and 64 bit are off.

0:06:41.520000 --> 0:06:43.560000
 The 32 bit is on.

0:06:43.560000 --> 0:06:47.380000
 After that, I start experiencing some
 variation where they're not the

0:06:47.380000 --> 0:06:51.480000
 same. So what do these
 guys have in common?

0:06:51.480000 --> 0:06:55.620000
 What they have in common
 is the first 19 bits.

0:06:55.620000 --> 0:07:01.620000
 All 8 bits of 10, all 8 bits of 10
 in the second octet, and then three

0:07:01.620000 --> 0:07:09.000000
 bits of 001. So I can shrink that down
 to a single summarized route of

0:07:09.000000 --> 0:07:14.400000
 10, 10.32.0 slash 19.

0:07:14.400000 --> 0:07:23.060000
 And that's how you summarize
 something like that.

0:07:23.060000 --> 0:07:26.420000
 Let's do one, let's see here.

0:07:26.420000 --> 0:07:30.280000
 Actually, I've got a whiteboard prebuilt
 that we can work on this.

0:07:30.280000 --> 0:07:33.600000
 There we go. Okay.

0:07:33.600000 --> 0:07:36.400000
 Let's do a couple
 examples of this.

0:07:36.400000 --> 0:07:39.800000
 Let's start with these three
 networks right here.

0:07:39.800000 --> 0:07:47.480000
 Okay, so we can see pretty clearly right
 off the bat that all three these

0:07:47.480000 --> 0:07:51.600000
 networks start with 2020.40.

0:07:51.600000 --> 0:07:56.060000
 So their first 24 bits
 clearly are in common.

0:07:56.060000 --> 0:07:59.440000
 But let's see if we can create a summarized
 route that's even more specific

0:07:59.440000 --> 0:08:02.600000
 than that, that has
 even more in common.

0:08:02.600000 --> 0:08:10.780000
 So in the fourth octet, .90, let's see
 here, it's got the 128 bit turned

0:08:10.780000 --> 0:08:17.180000
 off. Also 82 has a 128 bit turned off
 and 88 has a 128 bit turned off.

0:08:17.180000 --> 0:08:21.400000
 So far so good. Let's keep going.

0:08:21.400000 --> 0:08:24.380000
 .90 has the 64 bit turned on.

0:08:24.380000 --> 0:08:29.380000
 82 has a 64 bit turned on.

0:08:29.380000 --> 0:08:32.780000
 And 88 has the 64 bit turned on.

0:08:32.780000 --> 0:08:37.560000
 So so far we've identified 26 bits that
 all three of these networks have

0:08:37.560000 --> 0:08:38.840000
 in common. Can we go further?

0:08:38.840000 --> 0:08:40.060000
 Can we keep going?

0:08:40.060000 --> 0:08:48.560000
 Let's see the 32 bit is off here because
 the 64 plus 32 would be 96.

0:08:48.560000 --> 0:08:52.300000
 So that's off. 32 bit is off here.


0:08:52.300000 --> 0:08:54.860000
 32 bit is off here.

0:08:54.860000 --> 0:08:55.900000
 Well, so far so good.

0:08:55.900000 --> 0:08:56.360000
 Let's keep going.

0:08:56.360000 --> 0:08:58.240000
 Can we go even further?

0:08:58.240000 --> 0:09:00.160000
 What about the 16 bit?

0:09:00.160000 --> 0:09:05.200000
 64 plus 16 is 80.

0:09:05.200000 --> 0:09:08.960000
 So yeah, 16 bit is on, on and on.

0:09:08.960000 --> 0:09:11.080000
 So we're up to 80 right now.

0:09:11.080000 --> 0:09:15.420000
 Now if I go to the 8
 bit, 80 plus 8 is 88.

0:09:15.420000 --> 0:09:17.700000
 Yeah, we've got the 8 bit on here.


0:09:17.700000 --> 0:09:23.700000
 Uh oh, the 8 bit is off there and
 the 8 bit is on right here.

0:09:23.700000 --> 0:09:25.220000
 So now I can stop.

0:09:25.220000 --> 0:09:31.420000
 I can see that all these networks in
 addition to the first 24 bits in

0:09:31.420000 --> 0:09:40.100000
 common, they actually have the
 first 28 bits in common.

0:09:40.100000 --> 0:09:49.440000
 So all these networks start with 20,
 20, 40 dot 0101 and then I have my

0:09:49.440000 --> 0:09:59.580000
 variability. So that would come up
 with 20, 20 dot 40 dot 0101, 000.

0:09:59.580000 --> 0:10:08.940000
 So my single summarized
 route is 20, 20, 40.

0:10:08.940000 --> 0:10:10.640000
 Make sure I got this right here.

0:10:10.640000 --> 0:10:16.420000
 64 and 16, you have 80 slash 28.

0:10:16.420000 --> 0:10:25.560000
 So all three of these subnets are encompassed
 or included in this one

0:10:25.560000 --> 0:10:29.640000
 aggregated or summarized route.

0:10:29.640000 --> 0:10:38.220000
 Let's do one more example of that.


0:10:38.220000 --> 0:10:50.320000
 Down here. Okay, so these clearly have
 the first two bytes in common.

0:10:50.320000 --> 0:10:56.040000
 So our variability is going to be
 somewhere in the third octet.

0:10:56.040000 --> 0:11:01.960000
 They all have the 128 turned off.

0:11:01.960000 --> 0:11:05.800000
 They all have the 64 turned off.

0:11:05.800000 --> 0:11:13.600000
 Oops. They all have
 the 32 turned off.

0:11:13.600000 --> 0:11:24.360000
 They all have the 8 on.

0:11:24.360000 --> 0:11:26.340000
 This has the 8 bit on.

0:11:26.340000 --> 0:11:28.320000
 This has the 8 bit on.

0:11:28.320000 --> 0:11:31.740000
 This has the 4 bit on.

0:11:31.740000 --> 0:11:35.900000
 8 plus 4 is 12. This
 has the 4 bit on.

0:11:35.900000 --> 0:11:39.540000
 This does not. This has
 the 4 bit turned off.

0:11:39.540000 --> 0:11:41.760000
 So now I can stop.

0:11:41.760000 --> 0:11:50.240000
 In this particular case, they all
 have this bit pattern in common.

0:11:50.240000 --> 0:11:52.520000
 So I have the 8 bit
 pattern in common.

0:11:52.520000 --> 0:12:00.120000
 This is 13,000, 130
 dot 75 dot 000 01.

0:12:00.120000 --> 0:12:07.140000
 Let's see, 1234, 5, 6, 7, 8.

0:12:07.140000 --> 0:12:30.360000
 If I convert that down, that's
 8 dot 0 slash 16 plus 5, 21.

0:12:30.360000 --> 0:12:39.260000
 So there's my single summarized
 route for these three.

0:12:39.260000 --> 0:12:46.420000
 So I've got one quiz question here to give
 you guys practice on this yourself.

0:12:46.420000 --> 0:12:48.360000
 There you go. So do
 the same thing.

0:12:48.360000 --> 0:12:53.980000
 See if you can come up with the most
 specific summarized route that will

0:12:53.980000 --> 0:12:59.080000
 collapse all three of those subnets
 down into one summarized route.

0:12:59.080000 --> 0:13:07.000000
 I'll give you 30 seconds for this.


0:13:07.000000 --> 0:13:09.380000
 Okay, time's up.

0:13:09.380000 --> 0:13:12.480000
 Here's our answer.

0:13:12.480000 --> 0:13:20.620000
 So all three of these networks had
 the first 27 bits in common.

0:13:20.620000 --> 0:13:29.920000
 135.75 dot 42. And then in the fourth
 octet, they all had 011 in common,

0:13:29.920000 --> 0:13:40.720000
 which gives us 135 dot 75 dot 42 dot
 96 with a slash 27 subnet mask.

0:13:40.720000 --> 0:13:45.460000
 All right, we have one topic left to
 go, which we'll actually get through

0:13:45.460000 --> 0:13:47.900000
 pretty quickly. One last topic.

0:13:47.900000 --> 0:13:53.100000
 That's called supernetting.

0:13:53.100000 --> 0:14:09.260000
 So supernetting is essentially exactly,
 exactly the same thing as route

0:14:09.260000 --> 0:14:12.100000
 and the same logic you used
 to do, summarization.

0:14:12.100000 --> 0:14:15.660000
 There's only one main
 differentiator.

0:14:15.660000 --> 0:14:18.620000
 With summarization, look at that
 last bullet point there.

0:14:18.620000 --> 0:14:24.900000
 Whatever the summarized route is, it does
 not break the classful boundaries.

0:14:24.900000 --> 0:14:28.700000
 What do I mean? Let's
 go back to this here.

0:14:28.700000 --> 0:14:34.280000
 135. Technically, if we were talking
 about classful addresses, what class

0:14:34.280000 --> 0:14:39.320000
 of address would 135 fall into?

0:14:39.320000 --> 0:14:42.120000
 Hopefully you said class B.

0:14:42.120000 --> 0:14:47.880000
 135 is class B, which means that if
 I'm doing summarization, whatever

0:14:47.880000 --> 0:14:51.860000
 subnet mask I come up with, remember
 my summarized route?

0:14:51.860000 --> 0:14:58.540000
 It has to be slash 16 or bigger, like
 in this case it was slash 27, slash

0:14:58.540000 --> 0:15:05.660000
 16 or bigger. Well, supernetting is coming
 up with a mask that's actually

0:15:05.660000 --> 0:15:09.920000
 smaller than your
 classful address.

0:15:09.920000 --> 0:15:15.080000
 For example, take a look at this.

0:15:15.080000 --> 0:15:22.620000
 Let's say that my router knew about
 these two class C networks.

0:15:22.620000 --> 0:15:29.060000
 192.168.1 and 192.168.2.

0:15:29.060000 --> 0:15:31.420000
 There's no way I could
 summarize this.

0:15:31.420000 --> 0:15:35.380000
 If I want to shrink this down into
 just one advertisement and send it

0:15:35.380000 --> 0:15:37.840000
 as a summarized route, I couldn't.


0:15:37.840000 --> 0:15:43.680000
 Why not? Well, because the mask is
 already at the classful boundary of

0:15:43.680000 --> 0:15:48.880000
 slash 24. Summarization means I can't
 go in less than the slash 24 if

0:15:48.880000 --> 0:15:52.680000
 what I'm starting with is
 essentially a class C.

0:15:52.680000 --> 0:15:55.320000
 This is where supernetting
 comes into play.

0:15:55.320000 --> 0:15:56.640000
 So use the exact same logic.

0:15:56.640000 --> 0:15:59.560000
 Let's look at this and say for a second,
 okay, well, from left to right,

0:15:59.560000 --> 0:16:04.060000
 if I was to convert this into binary,
 from left to right, what do these

0:16:04.060000 --> 0:16:06.960000
 two networks have in common?

0:16:06.960000 --> 0:16:17.120000
 The first two octets are the same and
 then in the third octet, oops, in

0:16:17.120000 --> 0:16:24.220000
 the third octet, they're
 the same up to here.

0:16:24.220000 --> 0:16:31.720000
 So really, these two networks both
 have in common the first 22 bits.

0:16:31.720000 --> 0:16:36.600000
 So I could collapse them
 down into one route.

0:16:36.600000 --> 0:16:44.120000
 192.168.00.22. And this
 is called a supernet.

0:16:44.120000 --> 0:16:48.580000
 Because even though, if you take a
 look at that first byte, you'd say,

0:16:48.580000 --> 0:16:51.940000
 oh, 192. Well, in binary,
 that's 110.

0:16:51.940000 --> 0:16:56.240000
 That's class C. But class
 C means slash 24.

0:16:56.240000 --> 0:16:59.060000
 And here I'm doing a slash 22.

0:16:59.060000 --> 0:17:02.120000
 That's what makes it a supernet.

0:17:02.120000 --> 0:17:05.800000
 That's what makes it a supernet.

0:17:05.800000 --> 0:17:12.720000
 Now, as far as summarization is concerned,
 some routing protocols when

0:17:12.720000 --> 0:17:15.680000
 you turn them on, and it depends on the
 version of software you're dealing

0:17:15.680000 --> 0:17:20.480000
 with and the code, some routers perform
 routes summarization by default.

0:17:20.480000 --> 0:17:24.180000
 They will take some subnets, shrink them
 down into a single route, advertise

0:17:24.180000 --> 0:17:28.360000
 it out, and the subnet mask, the mask,
 I should say, shouldn't say subnet

0:17:28.360000 --> 0:17:34.100000
 mask, the mask associated with that
 summarized route, does not break the

0:17:34.100000 --> 0:17:37.800000
 rules of classful addressing.

0:17:37.800000 --> 0:17:41.180000
 Supernetting can only
 be done manually.

0:17:41.180000 --> 0:17:44.280000
 Typically, this is something
 you would see done in BGP.

0:17:44.280000 --> 0:17:47.480000
 You wouldn't normally see it done in
 your interior gateway protocols,

0:17:47.480000 --> 0:17:49.240000
 although you can.

0:17:49.240000 --> 0:17:52.800000
 But this is usually something that
 ISPs would do to each other.

0:17:52.800000 --> 0:17:58.500000
 Right? For example, if I'm time Warner
 Cable, I might say, well, let's

0:17:58.500000 --> 0:17:59.640000
 do an example of that.

0:17:59.640000 --> 0:18:04.300000
 Let's say that we have
 here two routers.

0:18:04.300000 --> 0:18:07.880000
 This router here is owned
 by Time Warner Cable.

0:18:07.880000 --> 0:18:11.780000
 This router here is
 owned by Sprint.

0:18:11.780000 --> 0:18:14.520000
 Two different routing domains.

0:18:14.520000 --> 0:18:19.620000
 Now, Time Warner Cable as a service provider
 owns thousands and thousands,

0:18:19.620000 --> 0:18:22.840000
 tens, probably even hundreds
 of thousands of subnets.

0:18:22.840000 --> 0:18:28.140000
 And let's say they say, okay, well, I own
 every subnet from one dot anything,

0:18:28.140000 --> 0:18:34.740000
 two dot anything, three
 dot anything.

0:18:34.740000 --> 0:18:52.300000
 Let's see if I can figure out
 a nice, easy way to do this.

0:18:52.300000 --> 0:19:00.840000
 130 dot 2 dot 0 dot 0,
 130 dot 3 dot 0 dot 0.

0:19:00.840000 --> 0:19:07.940000
 Let's stick up here at the
 top, 130 dot 0 dot 0.

0:19:07.940000 --> 0:19:14.140000
 So Time Warner Cable actually owns
 the, I'm just making this up here.

0:19:14.140000 --> 0:19:19.540000
 Time Warner Cable, let's assume,
 owns these four full class B's.

0:19:19.540000 --> 0:19:22.520000
 Now, chances are they're probably not
 going to hand out these class B's

0:19:22.520000 --> 0:19:28.080000
 to their customers because each one
 of those class B's supports over 65

0:19:28.080000 --> 0:19:33.200000
,000 hosts. So if a customer goes to
 Time Warner Cable and they say, oh,

0:19:33.200000 --> 0:19:34.500000
 I need a network from you.

0:19:34.500000 --> 0:19:36.640000
 Time Warner Cable might say,
 okay, well, let's see here.

0:19:36.640000 --> 0:19:40.480000
 How many hosts does your
 network support?

0:19:40.480000 --> 0:19:45.060000
 And if the customer says, oh, well,
 my network supports 300 hosts.

0:19:45.060000 --> 0:19:48.300000
 Time Warner Cable is not going to
 give them this entire class B.

0:19:48.300000 --> 0:19:53.100000
 They'll probably carve out a subnet
 of that class B and sell that to the

0:19:53.100000 --> 0:19:56.560000
 customer. But Time Warner Cable as
 a whole as a company is responsible

0:19:56.560000 --> 0:19:59.080000
 for these four class B's.

0:19:59.080000 --> 0:20:03.920000
 They've been allocated these from
 the regional internet registry.

0:20:03.920000 --> 0:20:14.140000
 Well, using BGP or something, they could
 send all four of these to Sprint.

0:20:14.140000 --> 0:20:16.680000
 Or they could say, let's
 do supernetting here.

0:20:16.680000 --> 0:20:18.440000
 What do these guys have in common?


0:20:18.440000 --> 0:20:27.220000
 Well, they all start out with 130 and
 then in the second octet, 128, 64,

0:20:27.220000 --> 0:20:31.640000
 32, 16, 8, and 4.

0:20:31.640000 --> 0:20:34.660000
 Those bits are all zeroed out.

0:20:34.660000 --> 0:20:41.580000
 And the last two bits have
 various combinations.

0:20:41.580000 --> 0:20:48.380000
 So Time Warner Cable could instead send
 a supernet, which looks like this.

0:20:48.380000 --> 0:20:54.540000
 130.0.0.0. Slash 14.

0:20:54.540000 --> 0:20:59.420000
 All four of these networks have
 the first 14 bits in common.

0:20:59.420000 --> 0:21:02.160000
 130 and then 6 bits of zero.

0:21:02.160000 --> 0:21:05.000000
 This is a supernet.

0:21:05.000000 --> 0:21:13.320000
 So when performing summarization or
 supernetting, like I said, the logic

0:21:13.320000 --> 0:21:15.400000
 you've worked through
 is exactly the same.

0:21:15.400000 --> 0:21:21.560000
 Simply ask yourself, what bits from left
 to right do all of these networks

