Distance Vector vs Link-State Routing

Routing protocols are classified into two main categories based on how they learn and maintain routing information: distance vector and link-state. A third category, path-vector (used by BGP), is beyond CCNA scope. Distance vector protocols operate on the principle of 'routing by rumor'—each router only knows the direction (vector) and distance (metric) to a destination, as reported by its directly connected neighbors. There is no global view of the network topology. Examples include Routing Information Protocol (RIP) and Enhanced Interior Gateway Routing Protocol (EIGRP), though EIGRP is technically an advanced distance vector protocol (also called a hybrid) because it includes features like Diffusing Update Algorithm (DUAL) for fast convergence and loop prevention.

Link-state protocols, on the other hand, give every router a complete picture of the network topology. Each router independently constructs a Link-State Database (LSDB) containing all routers and their links, then runs the Shortest Path First (SPF) algorithm (Dijkstra's algorithm) to compute the best path to every destination. Examples include Open Shortest Path First (OSPF) and Intermediate System-to-Intermediate System (IS-IS).

Distance vector protocols use the Bellman-Ford algorithm to compute routes. Each router maintains a routing table with entries containing the destination network, the metric (e.g., hop count for RIP, composite metric for EIGRP), and the next-hop router. Routers periodically send their entire routing table (or updates) to directly connected neighbors. When a router receives an update, it compares the received metric plus the cost to reach the neighbor against its current best metric. If the new path is better, it updates the routing table.

Key characteristics: - Periodic updates: RIP sends its full routing table every 30 seconds, even if nothing changed. EIGRP uses triggered updates (partial updates only when changes occur) but also sends hello packets every 5 seconds (default on LAN) to maintain neighbor relationships. - Hop count limit: RIP has a maximum hop count of 15 (16 is considered infinite/unreachable) to prevent routing loops. EIGRP uses a more sophisticated metric (bandwidth, delay, load, reliability) and has no hard hop limit. - Slow convergence: Because updates are periodic and only propagate neighbor-to-neighbor, convergence can take minutes. RIP uses hold-down timers (180 seconds) to prevent flapping routes from causing loops. - Routing loops: Distance vector protocols are susceptible to loops, mitigated by mechanisms like split horizon, route poisoning, and hold-down timers. For example, split horizon prevents a router from advertising a route back out the interface from which it was learned.

Link-state protocols build a complete topology map. The process has three main phases: 1. Neighbor Discovery: Routers send hello packets to discover neighbors and form adjacencies. For OSPF, hello packets are sent every 10 seconds on broadcast networks (default), and the dead interval is 40 seconds. Neighbors must agree on certain parameters (e.g., area ID, hello/dead intervals, authentication) to become fully adjacent. 2. Link-State Advertisement (LSA) Flooding: Each router creates Link-State Advertisements (LSAs) describing its directly connected links, the state of those links (up/down), and the cost (metric). LSAs are flooded to all routers in the same area (OSPF) or level (IS-IS). Flooding is reliable—each LSA is acknowledged. The collection of LSAs forms the Link-State Database (LSDB). 3. SPF Calculation: Each router runs the Dijkstra algorithm on the LSDB to compute the shortest path tree (SPT) with itself as the root. The result is the routing table. SPF is recalculated whenever the LSDB changes (e.g., a link goes down).

Key characteristics: - Fast convergence: Changes are detected quickly (via hello failures or link down events) and flooded immediately, so all routers recalculate within seconds. - Loop-free by design: Because every router has the same topology map, the SPF algorithm guarantees loop-free paths (as long as the LSDB is consistent). - Resource-intensive: The LSDB can be large in big networks, and SPF calculations consume CPU. OSPF uses areas to limit the scope of LSAs and reduce the LSDB size. - No hop count limit: OSPF uses cost (default based on bandwidth: cost = 10^8 / bandwidth in bps). EIGRP uses a composite metric (bandwidth, delay, load, reliability).

| Protocol | Hello Timer | Dead Timer | Update Timer | Hold-Down Timer | |----------|-------------|------------|--------------|-----------------| | RIP | N/A (no hellos) | N/A | 30s (full table) | 180s | | EIGRP | 5s (LAN), 60s (WAN) | 15s (LAN), 180s (WAN) | Triggered (partial) | Active timer: 3min | | OSPF | 10s (broadcast), 30s (non-broadcast) | 40s (broadcast), 120s (non-broadcast) | N/A (LSA flooding) | N/A |

For distance vector (RIP example):

R1# show ip route
R1# show ip rip database
R1# debug ip rip

For link-state (OSPF example):

R1# show ip ospf neighbor
R1# show ip ospf interface
R1# show ip ospf database
R1# show ip route ospf

Example output for show ip ospf neighbor:

Neighbor ID     Pri   State           Dead Time   Address         Interface
10.1.1.2         1   FULL/DR         00:00:35    10.1.12.2       GigabitEthernet0/0

The State field shows the adjacency state (FULL means fully adjacent), and the Dead Time counts down from 40 seconds.

Both types interact with the routing table (RIB) and forwarding table (FIB). Administrative distance (AD) is used to select between routes learned from different protocols. For example, OSPF has AD 110, EIGRP internal AD 90, RIP AD 120. If a router learns the same prefix from both OSPF and EIGRP, it prefers EIGRP because of lower AD. Redistribution between protocols is possible but requires careful metric translation (e.g., setting a seed metric for RIP).

In an enterprise campus network with hundreds of routers and thousands of subnets, a routing protocol's scalability is paramount. I once worked on a network that originally used RIP—convergence after a link failure took over two minutes, causing widespread timeouts. We migrated to OSPF, and convergence dropped to under 10 seconds. The trade-off was that we needed to design OSPF areas (backbone area 0, standard areas, stub areas) to keep the LSDB manageable. For example, we placed all core routers in area 0 and each building's distribution routers in separate areas. This reduced SPF calculation scope and memory usage.

Another scenario: a service provider connecting customer sites. Here, EIGRP is often used because it supports unequal-cost load balancing and converges fast using DUAL. However, if the network includes non-Cisco devices, OSPF is mandatory. I've seen misconfiguration where someone set an OSPF hello timer to 30 seconds on one end and left default 10 on the other—neighbors never formed. The fix was to ensure timer consistency.

A common production issue: redistribution between OSPF and EIGRP. Without proper metric conversion, routes may not be advertised or may have incorrect costs. For instance, redistributing OSPF into EIGRP requires setting a default metric (e.g., bandwidth, delay). If forgotten, EIGRP won't advertise the redistributed routes because it views them as having an infinite metric. This is a classic CCNA troubleshooting scenario.

Scale considerations: OSPF in a single area with 500 routers will cause huge LSDBs and frequent SPF recalculations. The solution is to segment into multiple areas. For EIGRP, the main scaling limit is the number of neighbors; EIGRP can handle hundreds of neighbors per router if tuned, but the query process during network convergence can be CPU-intensive.

When misconfigured, both protocol types can cause black holes or routing loops. For distance vector, a missing split horizon can cause a loop that takes minutes to break. For link-state, a mismatched area ID or MTU mismatch can prevent adjacency formation. I once spent hours troubleshooting OSPF neighbors stuck in EXSTART state due to an MTU mismatch on a serial link—the fix was to set the interface MTU to 1500 on both sides.