WEBVTT

0:00:05.160000 --> 0:00:09.760000
 Okay, so in these last few very short
 videos, I'm going to dedicate a

0:00:09.760000 --> 0:00:13.540000
 short video for Distance Vector, one
 for Link State, one for Advanced

0:00:13.540000 --> 0:00:16.800000
 Distance Vector, and then we'll
 finish up with Path Vector.

0:00:16.800000 --> 0:00:21.620000
 And for each one of these, I'm going
 to answer the same questions.

0:00:21.620000 --> 0:00:25.160000
 Is a neighbor relationship
 required or not?

0:00:25.160000 --> 0:00:26.860000
 How is a route maintained?

0:00:26.860000 --> 0:00:31.080000
 In other words, once a route is learned,
 how do we know an hour from now,

0:00:31.080000 --> 0:00:33.880000
 a day from now, it's still believable,
 it's still good?

0:00:33.880000 --> 0:00:36.540000
 How do all four of them
 answer that question?

0:00:36.540000 --> 0:00:40.700000
 What type of visibility into the network
 topology does each of the four

0:00:40.700000 --> 0:00:43.740000
 have? Do they only know about their
 directly connected neighbors or do

0:00:43.740000 --> 0:00:45.180000
 they know about everything?

0:00:45.180000 --> 0:00:49.440000
 What type of data structures
 do they create?

0:00:49.440000 --> 0:00:54.200000
 They all feed into the routing table,
 but do they also maintain additional

0:00:54.200000 --> 0:00:57.700000
 tables and in order
 to do their job?

0:00:57.700000 --> 0:01:01.760000
 And if so, what are their names
 and what are they called?

0:01:01.760000 --> 0:01:05.020000
 And then lastly, I'll give you actual
 examples of routing protocols that

0:01:05.020000 --> 0:01:07.680000
 fall into each of the
 four categories.

0:01:07.680000 --> 0:01:12.020000
 So let's start with
 Distance Vector.

0:01:12.020000 --> 0:01:16.280000
 So Distance Vector, no neighbor
 relationship is required.

0:01:16.280000 --> 0:01:19.320000
 If I tell you I'm running a Distance
 Vector routing protocol, that means

0:01:19.320000 --> 0:01:23.100000
 the routers are not doing any kind of
 sanity checks, they're not making

0:01:23.100000 --> 0:01:26.800000
 sure that there's any ground rules
 that have to be met first, they're

0:01:26.800000 --> 0:01:30.520000
 just blindly sending out their routing
 updates and they don't even care

0:01:30.520000 --> 0:01:33.340000
 if anybody is out there
 to get them or not.

0:01:33.340000 --> 0:01:37.560000
 And they're just listening if they receive
 in an incoming routing update,

0:01:37.560000 --> 0:01:39.460000
 they don't care who it came from.

0:01:39.460000 --> 0:01:44.380000
 They'll just accept it blindly,
 no neighbor relationships.

0:01:44.380000 --> 0:01:46.660000
 How is the route still believable?


0:01:46.660000 --> 0:01:50.900000
 Well, Distance Vector
 does periodic updates.

0:01:50.900000 --> 0:01:54.780000
 In other words, we're going to resend
 the same routes over and over and

0:01:54.780000 --> 0:01:58.060000
 over again for infinity,
 just keep on doing it.

0:01:58.060000 --> 0:02:02.280000
 Even if nothing changes in the network
 for the next six months, a router

0:02:02.280000 --> 0:02:06.100000
 running a Distance Vector protocol will
 resend its entire routing table

0:02:06.100000 --> 0:02:08.720000
 over and over and over again.

0:02:08.720000 --> 0:02:11.880000
 And so all the routers around it know
 the routes are still believable

0:02:11.880000 --> 0:02:14.860000
 because they know after a few seconds
 they're going to get those same

0:02:14.860000 --> 0:02:16.900000
 routes all over again.

0:02:16.900000 --> 0:02:19.680000
 Visibility into the
 network topology.

0:02:19.680000 --> 0:02:24.000000
 In a Distance Vector routing protocol,
 all the router knows about is itself

0:02:24.000000 --> 0:02:26.900000
 and is directly connected
 neighbors.

0:02:26.900000 --> 0:02:31.200000
 That's it. It knows about routes that are
 out there, but beyond it's directly

0:02:31.200000 --> 0:02:35.340000
 connected next hops, everything
 else is a cloud.

0:02:35.340000 --> 0:02:38.980000
 It knows there's routes beyond the
 next hop, but it doesn't know what

0:02:38.980000 --> 0:02:40.780000
 the network structure looks like.

0:02:40.780000 --> 0:02:42.420000
 It can't see that.

0:02:42.420000 --> 0:02:44.280000
 And what type of data
 structure is used?

0:02:44.280000 --> 0:02:48.360000
 Well, you just have the routing
 table and then a database.

0:02:48.360000 --> 0:02:52.080000
 So a Distance Vector routing protocol,
 all the routes that it learns are

0:02:52.080000 --> 0:02:54.400000
 placed into a database.

0:02:54.400000 --> 0:02:59.180000
 And then those routes may or may
 not feed into the routing table.

0:02:59.180000 --> 0:03:02.240000
 Once again, just because they're in
 the database, the next hop might not

0:03:02.240000 --> 0:03:06.560000
 be reachable. Maybe we learned about
 those routes via some other method

0:03:06.560000 --> 0:03:09.440000
 that has a better administrative
 distance.

0:03:09.440000 --> 0:03:14.280000
 So only the best routes make it into the
 routing table itself, but a Distance

0:03:14.280000 --> 0:03:18.000000
 Vector protocol stores everything
 it learns about in its database.

0:03:18.000000 --> 0:03:21.920000
 And it assumes after a periodic interval
 has elapsed, those routes will

0:03:21.920000 --> 0:03:25.940000
 be gone and it'll relearn them
 in the database again.

0:03:25.940000 --> 0:03:31.040000
 And examples of this are RIP
 version one and version two.

0:03:31.040000 --> 0:03:34.880000
 And an older Cisco proprietary protocol
 that's not used anymore called

0:03:34.880000 --> 0:03:38.280000
 the Interior Gateway routing
 protocol, IGRP.

0:03:38.280000 --> 0:03:40.220000
 And that has been deprecated.

0:03:40.220000 --> 0:03:43.140000
 So that concludes this short
 video on Distance Vector.

0:03:43.140000 --> 0:03:47.560000
 So we're going to compare these exact
 same things against link state routing

0:03:47.560000 --> 0:03:49.100000
 protocols in the next video.