Enhanced Interior Gateway Routing Protocol (EIGRP) is, as the name says, an enhancement of the Interior Gateway Routing Protocol (IGRP). EIGRP is a Cisco proprietary distance vector routing protocol that, while retaining some concepts introduced with IGRP, is distinctly different from IGRP. This article should serve as a concise introduction to EIGRP for Cisco certification candidates as well as network administrators dealing with EIGRP at work. We start out by introducing the main features of EIGRP. We then present you with a simple topology consisting of three routers. You will learn how to configure and verify EIGRP in that topology, from scratch, with the goal of achieving end-to-end reachability.
CCNA Training – Resources (Intense)
EIGRP is an Interior Gateway Protocol (IGP) designed for routing within a single administrative domain or autonomous system (AS). It is a classless protocol which means each route entry in an update includes a subnet mask as well. The subnet masks sent with each route in updates may be of different length. This feature is called variable-length subnet masking and it allows for subnetting as well as address aggregation or summarization. EIGRP packets can also be optionally authenticated using an MD5 checksum, if authentication is configured.
EIGRP uses the Diffusing Update ALgorithm (DUAL) to achieve fast convergence while remaining loop-free at all times. EIGRP updates are not sent at regular intervals; rather, updates are sent only when a metric or topology change takes place. Also, the updates will include only routes that have changed and not every entry in the routing table. In other words, EIGRP updates are both non-periodic and partial in contrast to other distance vector protocols like Routing Information Protocol (RIP). You may recall that RIP sends updates at regular intervals and includes all routes in the routing table in every update. These characteristics mean that EIGRP uses much less bandwidth than other distance vector protocols, a feature that is especially useful on low-bandwidth Wide Area Network (WAN) links.
EIGRP uses special packets to run its operations. The Reliable Transport Protocol (RTP) is used to send and receive EIGRP packets. RTP ensures that packets not only get delivered but are delivered in order. We will go into a bit of detail about multiple EIGRP packet types which are all identified by protocol number 88 in the IP packet header.
- Hellos are used for neighbor discovery and recovery after a neighbor is lost. Hello packets are sent as multicasts to 22.214.171.124. Hellos use unreliable delivery which means they are not acknowledged.
- Acknowledgements (ACKs) are actually Hello packets but without any data in them. ACKs are sent as unicasts and use unreliable delivery like Hellos.
- Updates contain the route information including subnets and masks. Unlike RIP and IGRP updates, these packets contain only the routes that actually change, and are sent only when there are metric or topology changes to routers that require the information. Updates always use reliable delivery which means they are always acknowledged using ACKs.
- Queries and Replies are used to ask neighbors about lost routes. Queries can be multicast or unicast, but replies are always unicast. Queries and replies both use reliable delivery which means both are separately acknowledged.
If a Query or Update is reliably multicast but an ACK is not received from a neighbor, the packet will be retransmitted as a unicast only to the neighbor that failed to respond. If an ACK is not received even after 16 of these unicast retransmissions, the neighbor will be declared dead.
EIGRP Neighbor Discovery
EIGRP Hello packets are used to discover and track other EIGRP speaking routers on directly connected networks. On most networks, Hellos are multicast every five seconds, minus a very small random time to prevent synchronization. On multipoint Frame Relay interfaces with access link speeds of T1 or slower, Hellos are unicast every 60 seconds. You can change the default Hello interval, on a per interface basis, with the command ip hello-interval eigrp.
Each Hello packet includes a hold time. When a router receives a Hello packet from a neighbor, the hold time in the packet tells the router the maximum time it should wait to receive subsequent Hellos. If the hold timer expires before a Hello is received, the neighbor is declared unreachable. By default, the hold time is three times the Hello interval. This makes the default value of hold time either 15, or 180 seconds depending on the type of interface. The default can be changed, on a per interface basis, with the command ip hold-time eigrp.
EIGRP records information about each neighbor in a neighbor table. The neighbor table contains the IP address of the neighbor and the interface on which the neighbor’s Hellos are received. The neighbor table can be viewed using the show ip eigrp neighbor command.
Feasible Distance (FD) and Feasibility Condition
An EIGRP-speaking router uses Hellos to discover neighbors and to identify itself to them. When a neighbor is discovered, EIGRP will attempt to form an adjacency with that neighbor. An adjacency is a logical association between two neighbors over which route information can actually be exchanged.
When EIGRP adjacencies have been established, updates will be exchanged with neighbors. The updates will contain all routes known by the router sending an update and the metrics of those routes as well. The router receiving EIGRP update will calculate a metric or distance based on the distance advertised by the neighbor and the cost of the link to that neighbor.
The lowest distance calculated by a router for each destination will become the feasible distance (FD) of that destination. For example, a router may learn three different routes to subnet 192.168.73.0 and may calculate metrics of 360832, 886028, and 12348428 for the three routes. 360832 will become the FD because it is the lowest calculated distance for 192.168.73.0.
The feasibility condition (FC) is something you would encounter pretty often in any discussion on EIGRP. It is a condition that is met if the distance advertised by a neighbor for a destination is lower than the router’s FD to that same destination. If a neighbor’s advertised distance to a destination meets the FC, the neighbor becomes a feasible successor for that destination.
For example, if the FD to subnet 192.168.23.0 is 360832 and a neighbor advertises a route to that subnet with a distance of 355042, the neighbor will become a feasible successor. If the same neighbor advertises a distance of 370289, it will not satisfy the feasibility condition and will not become a feasible successor. These concepts are central to loop avoidance in EIGRP because installing a route in the routing table with a reported distance higher than the FD may indicate a route that points back to the router receiving the route.
The EIGRP topology table contains every destination known to the router for which one or more feasible successors exist. The topology table contains the following information:
- FD of the destination
- All feasible successors
- Advertised distance of each feasible successor to the destination
- The distance calculated locally to the destination via each feasible successor
- The local interface connected to the network on which each feasible successor is found
You can view the EIGRP topology table using the show ip eigrp topology command.
The ultimate goal of every dynamic routing protocol is to place routes in the routing table. It is after all the IP routing table that is used by the router to route packets. For every destination listed in the EIGRP topology table, the route with the lowest metric is picked up and placed in the routing table. The neighbor that advertised that route becomes the successor to which packets for that destination are sent.
EIGRP operation, as you may have realized, is quite complex but the complexity is handled by the Cisco IOS Software behind the scene. As a result, EIGRP configuration is not that complex. We present to you a scenario that consists of three routers R1, R2, and R3 interconnected as shown in Figure 1. We will configure EIGRP on these three routers in order to achieve reachability from any subnet to any other subnet in the given topology.
Figure 1 Configuring EIGRP
We start by configuring interface IP addresses on R1.
R1>enable R1#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R1(config)#interface Loopback0 R1(config-if)#ip address 10.10.1.1 255.255.255.0 R1(config-if)#exit R1(config)#interface FastEthernet0/0 R1(config-if)#ip address 192.168.12.1 255.255.255.0 R1(config-if)#no shutdown R1(config-if)#end R1#
Let’s now configure IP addresses on R2.
R2>enable R2#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R2(config)#interface Loopback0 R2(config-if)#ip address 10.10.2.2 255.255.255.0 R2(config-if)#exit R2(config)#interface FastEthernet0/0 R2(config-if)#ip address 192.168.12.2 255.255.255.0 R2(config-if)#no shutdown R2(config-if)#exit R2(config)#interface Serial0/0 R2(config-if)#ip address 192.168.23.1 255.255.255.252 R2(config-if)#no shutdown R2(config-if)#end R2#
We finally configure R3 to complete IP address configuration.
R3>enable R3#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R3(config)#interface Loopback0 R3(config-if)#ip address 10.10.3.3 255.255.255.0 R3(config-if)#exit R3(config)#interface Serial0/0 R3(config-if)#ip address 192.168.23.2 255.255.255.252 R3(config-if)#no shutdown R3(config-if)#end R3#
At this point, IP addresses have all been configured. Let’s go to router R1 and try to ping the directly connected interface of R2.
R1#ping 192.168.12.2 Type escape sequence to abort. Sending 5, 100-byte ICMP Echos to 192.168.12.2, timeout is 2 seconds: !!!!! Success rate is 100 percent (5/5), round-trip min/avg/max = 16/29/56 ms R1#
That’s a success, but what if we try to ping the Loopback interface of R2 from R1?
R1#ping 10.10.2.2 Type escape sequence to abort. Sending 5, 100-byte ICMP Echos to 10.10.2.2, timeout is 2 seconds: ..... Success rate is 0 percent (0/5) R1#
That doesn’t look very good. Let’s have a look at the routing table of R1.
R1#show ip route Codes: C - connected, S - static, R - RIP, M - mobile, B - BGP D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2 E1 - OSPF external type 1, E2 - OSPF external type 2 i - IS-IS, su - IS-IS summary, L1 - IS-IS level-1, L2 - IS-IS level-2 ia - IS-IS inter area, * - candidate default, U - per-user static route o - ODR, P - periodic downloaded static route Gateway of last resort is not set C 192.168.12.0/24 is directly connected, FastEthernet0/0 10.0.0.0/24 is subnetted, 1 subnets C 10.10.1.0 is directly connected, Loopback0
As you can see in the output of show ip route command above, R1 knows only about its directly connected subnets. It has no knowledge whatsoever about what lies beyond. In order to achieve end-to-end reachability in our topology, we will use EIGRP to propagate routing information dynamically.
Let’s configure EIGRP on the three routers one by one. The router eigrp command entered in global configuration mode with autonomous-system-number argument creates an EIGRP routing instance. It is the first step in configuring EIGRP on a router as shown here for R1.
R1>enable R1#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R1(config)#router eigrp 10 R1(config-router)#no auto-summary R1(config-router)#
The command no auto-summary is needed to disable automatic route summarization at classful network boundaries. The next step in configuring EIGRP is to specify which router interfaces are included in EIGRP using the network command. The router will send EIGRP messages and try to establish adjacencies with other EIGRP speaking routers off these interfaces. We will enable EIGRP on Loopback0 and FastEthernet0/0 on R1. You should carefully note the inverse mask used with the network command.
R1#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R1(config)#router eigrp 10 R1(config-router)#no auto-summary R1(config-router)#network 10.10.1.0 0.0.0.255 R1(config-router)#network 192.168.12.0 0.0.0.255 R1(config-router)#end R1#
And that completes our EIGRP configuration on R1. Wasn’t that simple? Let’s proceed and configure EIGRP on R2 and R3 following the same pattern.
R2#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R2(config)#router eigrp 10 R2(config-router)#no auto-summary R2(config-router)#network 10.10.2.0 0.0.0.255 R2(config-router)#network 192.168.12.0 0.0.0.255 R2(config-router)#network 192.168.23.0 0.0.0.3 R2(config-router)#end R2# R3#configure terminal Enter configuration commands, one per line. End with CNTL/Z. R3(config)#router eigrp 10 R3(config-router)#no auto-summary R3(config-router)#network 10.10.3.0 0.0.0.255 R3(config-router)#network 192.168.23.2 0.0.0.3 R3(config-router)#end R3#
That completes our EIGRP configuration on R1, R2, and R3 and it’s time to verify if our configuration works as expected. If we configured EIGRP correctly, EIGRP adjacencies should have been established between R1 and R2, as well as, R2 and R3. Let’s see if that’s the case using the show ip eigrp neighbor command on R1.
R1#show ip eigrp neighbor IP-EIGRP neighbors for process 10 H Address Interface Hold Uptime SRTT RTO Q Seq (sec) (ms) Cnt Num 0 192.168.12.2 Fa0/0 12 00:00:35 32 450 0 10
You can see that R1 has established adjacency with 192.168.12.2, which happens to be the IP address on the R2 interface connected directly to R1. Let’s now check if R2 has established an EIGRP adjacency with R3.
R2#show ip eigrp neighbor IP-EIGRP neighbors for process 10 H Address Interface Hold Uptime SRTT RTO Q Seq (sec) (ms) Cnt Num 1 192.168.23.2 Se0/0 11 00:08:01 44 396 0 3 0 192.168.12.1 Fa0/0 14 00:09:29 52 312 0 3
You actually see two EIGRP neighbors on R2 indicating that it has established EIGRP adjacencies with both R1 and R3.
Now that EIGRP adjacencies have been established, we can hope that some routing information would also have been exchanged between routers. Let’s first examine the EIGRP topology table on R1 using the show ip eigrp topology command.
R1#show ip eigrp topology IP-EIGRP Topology Table for AS(10)/ID(10.10.1.1) Codes: P - Passive, A - Active, U - Update, Q - Query, R - Reply, r - reply Status, s - sia Status P 10.10.1.0/24, 1 successors, FD is 128256 via Connected, Loopback0 P 10.10.2.0/24, 1 successors, FD is 156160 via 192.168.12.2 (409600/128256), FastEthernet0/0 P 10.10.3.0/24, 1 successors, FD is 2300416 via 192.168.12.2 (2323456/2297856), FastEthernet0/0 P 192.168.12.0/24, 1 successors, FD is 281600 via Connected, FastEthernet0/0 P 192.168.23.0/30, 1 successors, FD is 2172416 via 192.168.12.2 (2195456/2169856), FastEthernet0/0
We can see several entries with their successors listed along with the FD for each. Let’s examine the routing table on R1 using the good old show ip route command.
R1#show ip route C 192.168.12.0/24 is directly connected, FastEthernet0/0 10.0.0.0/24 is subnetted, 3 subnets C 10.10.1.0 is directly connected, Loopback0 D 10.10.2.0 [90/409600] via 192.168.12.2, 00:12:10, FastEthernet0/0 D 10.10.3.0 [90/2323456] via 192.168.12.2, 00:10:42, FastEthernet0/0 192.168.23.0/30 is subnetted, 1 subnets D 192.168.23.0 [90/2195456] via 192.168.12.2, 00:11:56, FastEthernet0/0
In addition to the two directly connected subnets, R1 has also learned three subnets through EIGRP. These three subnets correspond to the Loopback0 of R2, Loopback0 of R3, and the interconnection of R2 and R3. In fact, R1 now has information about all subnets in our topology. Let’s try to ping Loopback0 of R3 from R1.
R1#ping 10.10.3.3 Type escape sequence to abort. Sending 5, 100-byte ICMP Echos to 10.10.3.3, timeout is 2 seconds: !!!!! Success rate is 100 percent (5/5), round-trip min/avg/max = 20/26/36 ms
In fact, you will be able to ping any subnet from any router in the topology at this point. We would strongly urge you to implement this topology in a lab environment. When you implement this topology, you should use the show commands seen in this article on all your routers, closely examining the output. This would be fun and a great way to have a better understanding of EIGRP.