View source for Distance-vector routing protocol

{{short description|Class of routing protocols}}
{{Multiple issues|
{{More footnotes needed|date=September 2010}}
{{technical|date=November 2013}}
}}

A '''distance-vector routing protocol''' in [[data networks]] determines the best route for data packets based on distance. Distance-vector routing protocols measure the distance by the number of [[Router (computing)|routers]] a packet has to pass; one router counts as one hop. Some distance-vector protocols also take into account [[network latency]] and other factors that influence traffic on a given route. To determine the best route across a network, routers using a distance-vector protocol exchange information with one another, usually [[routing tables]] plus hop counts for destination networks and possibly other traffic information. Distance-vector routing protocols also require that a router inform its neighbours of [[network topology]] changes periodically.

Distance-vector routing protocols use the [[Bellman–Ford algorithm]] to calculate the best route. Another way of calculating the best route across a network is based on link cost, and is implemented through [[link-state routing protocol]]s.

The term ''distance vector'' refers to the fact that the protocol manipulates ''vectors'' ([[Array data structure|arrays]]) of distances to other nodes in the network.  The distance vector algorithm was the original [[ARPANET]] routing algorithm and was implemented more widely in [[local area networks]] with the [[Routing Information Protocol]] (RIP).

==Overview==
Distance-vector routing protocols use the [[Bellman–Ford algorithm]]. In these protocols, each router does not possess information about the full [[network topology]]. It advertises its distance value (DV) calculated to other routers and receives similar advertisements from other routers unless changes are done in the local network or by neighbours (routers). Using these routing advertisements each router populates its routing table. In the next advertisement cycle, a router advertises updated information from its routing table. This process continues until the routing tables of each router [[Convergence (routing)|converge]] to stable values.

Some of these protocols have the disadvantage of slow convergence.

Examples of distance-vector routing protocols:
* [[Routing Information Protocol]] (RIP)
* [[Routing Information Protocol#RIP version 2|Routing Information Protocol Version 2]] (RIPv2)
* [[Routing Information Protocol#RIPng|Routing Information Protocol Next Generation]] (RIPng), an extension of RIP version 2 with support for [[IPv6]]
* [[Interior Gateway Routing Protocol]] (IGRP)
* [[Enhanced Interior Gateway Routing Protocol]] (EIGRP)

==Methodology==
Routers that use distance-vector protocol determine the distance between themselves and a destination. The best route for [[data]] through a [[data network]] is measured in terms of the numbers of [[Router (computing)|routers]] (hops) a packet has to pass through to reach its destination network. Additionally, some distance-vector protocols take into account other traffic information, such as [[network latency]]. To establish the best route, routers regularly exchange information with neighbouring routers, usually their [[routing table]], hop count for a destination network and possibly other traffic related information. Routers that implement distance-vector protocol rely purely on the information provided to them by other routers, and do not assess the [[network topology]].<ref>{{Cite book|title= Network+ Guide to Networks|url= https://archive.org/details/networkguidetone00dean_142|url-access= limited|author =Tamara Dean |publisher= Cengage Learning|year=2009 |isbn=  9781423902454|pages=[https://archive.org/details/networkguidetone00dean_142/page/n294 274]}}</ref>

Distance-vector protocols update the routing tables of routers and determine the route on which a packet will be sent by the ''next hop'' which is the exit interface of the router and the IP address of the interface of the receiving router. Distance is a measure of the cost to reach a certain node. The least cost route between any two nodes is the route with minimum distance.

Updates are performed periodically in a distance-vector protocol where all or part of a router's routing table is sent to all its neighbours that are configured to use the same distance-vector routing protocol. Once a router has this information it is able to amend its own routing table to reflect the changes and then inform its neighbours of the changes. This process has been described as ‘routing by rumour’ because routers are relying on the information they receive from other routers and cannot determine if the information is actually valid and true. There are a number of features which can be used to help with instability and inaccurate routing information.

== Development of distance-vector routing ==
The oldest [[routing protocol]], and the oldest distance-vector protocol, is version 1 of the [[Routing Information Protocol]] (RIPv1). RIPv1 was formally standardised in 1988.{{Ref RFC|1058}} It establishes the shortest path across a network purely on the basis of the hops, that is numbers of routers that need to be passed to reach the destination network. RIP is an [[interior gateway protocol]], so it can be used in [[local area networks]] (LANs) on interior or border routers. Routers with RIPv1 implementation exchange their routing tables with neighbouring routers by [[Broadcasting (networking)|broadcasting]] a RIPv1 packet every 30 second into all connected networks. RIPv1 is not suitable for large networks as it limits the number of hops to 15. This hop limit was introduced to avoid routing loops, but also means that networks that are connected through more than 15 routers are unreachable.<ref>{{Cite book|title= Network+ Guide to Networks|url= https://archive.org/details/networkguidetone00dean_142|url-access= limited|author =Tamara Dean |publisher= Cengage Learning|year=2009 |isbn=  9781423902454|pages=[https://archive.org/details/networkguidetone00dean_142/page/n294 274]}}</ref>

<!--I don't think BGP is a distance-vector protocol but rather a path-vector protocol. Otherwise it would should be listed as solution to the count-to-infinity problem, because BGP uses paths and can therefore detect loops intrinsically-->
The distance-vector protocol designed for use in [[wide area network]]s (WANs) is the [[Border Gateway Protocol]] (BGP). BGP is an [[exterior gateway protocol]] and therefore implemented on border and exterior routers on the [[Internet]]. It exchanges information between routers through a [[Transmission Control Protocol]] (TCP) session. Routers with BGP implementation determine the shortest path across a network based on a range of factors other than hops. BGP can also be configured by administrators so that certain routes are preferred or avoided. BGP is used by [[internet service providers]] (ISPs) and telecommunication companies.<ref>{{Cite book|title= Network+ Guide to Networks|url= https://archive.org/details/networkguidetone00dean_142|url-access= limited|author =Tamara Dean |publisher= Cengage Learning|year=2009 |isbn=  9781423902454|pages=[https://archive.org/details/networkguidetone00dean_142/page/n294 274]–275}}</ref>

Among the distance-vector protocols that have been described as a hybrid, because it uses routing methods associated with [[link-state routing protocol]]s, is the proprietary [[Enhanced Interior Gateway Routing Protocol]] (EIGRP). It was developed by [[Cisco]] in the 1980s and was designed to offer better convergence and cause less network traffic between routers than the link-state routing protocol [[Open Shortest Path First]] (OSPF).<ref>{{Cite book|title= Network+ Guide to Networks|url= https://archive.org/details/networkguidetone00dean_142|url-access= limited|author =Tamara Dean |publisher= Cengage Learning|year=2009 |isbn=  9781423902454|pages=[https://archive.org/details/networkguidetone00dean_142/page/n295 275]}}</ref>

Another example of a distance-vector routing protocol is [[Babel (protocol)|Babel]].

==Count to infinity problem==
The [[Bellman–Ford algorithm]] does not prevent [[routing loop]]s from happening and suffers from the '''count to infinity problem'''. The core of the count-to-infinity problem is that if A tells B that it has a path somewhere, there is no way for B to know if the path has B as a part of it.  To see the problem, imagine a subnet connected like A–B–C–D–E–F, and let the metric between the routers be "number of jumps". Now suppose that A is taken offline. In the vector-update-process B notices that the route to A, which was distance 1, is down – B does not receive the vector update from A. The problem is, B also gets an update from C, and C is still not aware of the fact that A is down – so it tells B that A is only two jumps from C (C to B to A). Since B doesn't know that the path from C to A is through itself (B), it updates its table with the new value "B to A =  2 + 1". Later on, B forwards the update to C and due to the fact that A is reachable through B (From C's point of view), C decides to update its table to "C to A = 3 + 1". This slowly propagates through the network until it becomes infinity (in which case the algorithm corrects itself, due to the relaxation property of Bellman-Ford).

===Workarounds and solutions===
[[Routing Information Protocol|RIP]] uses the [[Split horizon route advertisement|split horizon]] with poison reverse technique to reduce the chance of forming loops and uses a maximum number of hops to counter the 'count to infinity' problem. These measures avoid the formation of routing loops in some, but not all, cases.{{Ref RFC|1058|section=2.2.2}}  The addition of a ''hold time'' (refusing route updates for a few minutes after a route retraction) avoids loop formation in virtually all cases, but causes a significant increase in convergence times.

More recently, a number of loop-free distance vector protocols have been developed — notable examples are [[EIGRP]], [[DSDV]] and [[Babel (protocol)|Babel]].  These avoid loop formation in all cases, but suffer from increased complexity, and their deployment has been slowed down by the success of [[link state routing protocol]]s such as [[OSPF]].

==Example==
In this network we have 4 routers A, B, C and D:

[[File:networkabcd.svg|300px]]

We mark the current time (or iteration) in the algorithm with T, and begin (at time 0, or T=0) by creating distance matrices for each router to its immediate neighbours. As we build the routing tables below, the shortest path is highlighted in green, and a new shortest path is highlighted in yellow. Grey columns indicate nodes that are not neighbors of the current node, and are therefore not considered as a valid direction in its table. Red indicates invalid entries in the table since they refer to distances from a node to itself, or via itself.

{|
|-
| T=0
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from A
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|3
|
|bgcolor="#C0C0C0"|
|---
!to C
|bgcolor="#DD5555"|
|
|bgcolor="#D0FF00"|23
|bgcolor="#C0C0C0"|
|---
!to D
|bgcolor="#DD5555"|
|
|
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#DD5555" | from B
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#D0FF00"|3
|bgcolor="#DD5555"|
|
|bgcolor="#C0C0C0"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to C
|
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|2
|bgcolor="#C0C0C0"|
|---
!to D
|
|bgcolor="#DD5555"|
|
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#DD5555" | from C
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#D0FF00"|23
|
|bgcolor="#DD5555"|
|
|---
!to B
|
|bgcolor="#D0FF00"|2
|bgcolor="#DD5555"|
|
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to D
|
|
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|5
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from D
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|
|bgcolor="#DD5555"|
|---
!to C
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#D0FF00"|5
|bgcolor="#DD5555"|
|---
!to D
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|}
|-
|colspan=5| At this point, all the routers (A, B, C, D) have new "shortest-paths" for their DV (the list of distances that are from them to another router via a neighbor). They each broadcast this new DV to all their neighbors: A to B and C, B to C and A, C to A, B, and D, and D to C. As each of these neighbors receives this information, they now recalculate the shortest path using it.

For example: A receives a DV from C that tells A there is a path via C to D, with a distance (or cost) of 5. Since the current "shortest-path" to C is 23, then A knows it has a path to D that costs 23+5=28. As there are no other shorter paths that A knows about, it puts this as its current estimate for the shortest-path from itself (A) to D, via C.
|
|-
| T=1
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from A
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|3
|25
|bgcolor="#C0C0C0"|
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|5
|23
|bgcolor="#C0C0C0"|
|---
!to D
|bgcolor="#DD5555"|
|
|bgcolor="#D0FF00"|28
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from B
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#80FF80"|3
|bgcolor="#DD5555"|
|25
|bgcolor="#C0C0C0"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to C
|26
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|2
|bgcolor="#C0C0C0"|
|---
!to D
|
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|7
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from C
!via A
!via B
!via C
!via D
|---
!to A
|23
|bgcolor="#D0FF00"|5
|bgcolor="#DD5555"|
|
|---
!to B
|26
|bgcolor="#80FF80"|2
|bgcolor="#DD5555"|
|
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to D
|
|
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|5
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from D
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#D0FF00"|28
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#D0FF00"|7
|bgcolor="#DD5555"|
|---
!to C
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|5
|bgcolor="#DD5555"|
|---
!to D
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|}
|-
|colspan=5| Again, all the routers have gained in the last iteration (at T=1) new "shortest-paths", so they all broadcast their  DVs to their neighbors; This prompts each neighbor to re-calculate their shortest distances again.

For instance: A receives a DV from B that tells A there is a path via B to D, with a distance (or cost) of 7. Since the current "shortest-path" to B is 3, then A knows it has a path to D that costs 7+3=10. This path to D of length 10 (via B) is shorter than the existing "shortest-path" to D of length 28 (via C), so it becomes the new "shortest-path" to D.
|
|-
| T=2
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from A
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|3
|25
|bgcolor="#C0C0C0"|
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|5
|23
|bgcolor="#C0C0C0"|
|---
!to D
|bgcolor="#DD5555"|
|bgcolor="#D0FF00"|10
|28
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from B
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#80FF80"|3
|bgcolor="#DD5555"|
|7
|bgcolor="#C0C0C0"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to C
|8
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|2
|bgcolor="#C0C0C0"|
|---
!to D
|31
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|7
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from C
!via A
!via B
!via C
!via D
|---
!to A
|23
|bgcolor="#80FF80"|5
|bgcolor="#DD5555"|
|33
|---
!to B
|26
|bgcolor="#80FF80"|2
|bgcolor="#DD5555"|
|12
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to D
|51
|9
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|5
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from D
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#D0FF00"|10
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|7
|bgcolor="#DD5555"|
|---
!to C
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|5
|bgcolor="#DD5555"|
|---
!to D
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|}
|-
|colspan=5| This time, only routers A and D have new shortest-paths for their DVs. So they broadcast their new DVs to their neighbors: A broadcasts to B and C, and D broadcasts to C. This causes each of the neighbors receiving the new DVs to re-calculate their shortest paths. However, since the information from the DVs doesn't yield any shorter paths than they already have in their routing tables, then there are no changes to the routing tables.
|
|-
| T=3
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from A
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|3
|25
|bgcolor="#C0C0C0"|
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|5
|23
|bgcolor="#C0C0C0"|
|---
!to D
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|10
|28
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from B
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#80FF80"|3
|bgcolor="#DD5555"|
|7
|bgcolor="#C0C0C0"|
|---
!to B
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to C
|8
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|2
|bgcolor="#C0C0C0"|
|---
!to D
|13
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|7
|bgcolor="#C0C0C0"|
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from C
!via A
!via B
!via C
!via D
|---
!to A
|23
|bgcolor="#80FF80"|5
|bgcolor="#DD5555"|
|15
|---
!to B
|26
|bgcolor="#80FF80"|2
|bgcolor="#DD5555"|
|12
|---
!to C
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|---
!to D
|33
|9
|bgcolor="#DD5555"|
|bgcolor="#80FF80"|5
|}
|
{| class="wikitable"
!bgcolor="#C0C0C0" | from D
!via A
!via B
!via C
!via D
|---
!to A
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|10
|bgcolor="#DD5555"|
|---
!to B
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|7
|bgcolor="#DD5555"|
|---
!to C
|bgcolor="#C0C0C0"|
|bgcolor="#C0C0C0"|
|bgcolor="#80FF80"|5
|bgcolor="#DD5555"|
|---
!to D
|bgcolor="#EE5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|bgcolor="#DD5555"|
|}
|-
|colspan=5| None of the routers have any new shortest-paths to broadcast. Therefore, none of the routers ''receive'' any new information that might change their routing tables. The algorithm comes to a stop.
|
|}

==References==
{{Reflist}}
* {{Ref RFC|2453|ref=no}}
* "A Path-Finding Algorithm for Loop-Free Routing'',  J.J. Garcia-Luna-Aceves and S. Murthy,  IEEE/ACM Transactions on Networking, February 1997
* "Detection of Invalid Routing Announcements in the RIP Protocol", D. Pei, D. Massey, and L. Zhang, IEEE Global Communications Conference (Globecom), December, 2003

==Further reading==
* [http://docwiki.cisco.com/wiki/Routing_Basics#Link-State_Versus_Distance_Vector Section "Link-State Versus Distance Vector"] {{Webarchive|url=https://web.archive.org/web/20101214043441/http://docwiki.cisco.com/wiki/Routing_Basics#Link-State_Versus_Distance_Vector |date=2010-12-14 }} in the Chapter "Routing Basics" in the [[Cisco Systems|Cisco]] "Internetworking Technology Handbook"
* [http://authors.phptr.com/tanenbaumcn4/ Section 5.2 "Routing Algorithms"] in Chapter "5 THE NETWORK LAYER" from "Computer Networks" 4th. Edition by Andrew S. Tanenbaum

{{DEFAULTSORT:Distance-Vector Routing Protocol}}
[[Category:Routing protocols]]
[[Category:Routing algorithms]]