RIP is a surprisingly simple protocol that, in the right (or wrong) circumstances, can make your network do a complete 180.
Imagine this: a router is trying to figure out the best path to reach another network. It shouts out, "Hey, I can get to network X in 3 hops!" Another router hears this and thinks, "Okay, and I can get to that other router in 1 hop. So, I can get to network X in 1 + 3 = 4 hops." This is the core of RIP: it tells its neighbors how many hops it thinks it takes to reach every network it knows about. The "best" path is simply the one with the fewest hops.
Let’s see it in action. We’ll set up a tiny network with two routers, R1 and R2, connected directly.
R1:
interface GigabitEthernet0/0
ip address 192.168.1.1 255.255.255.0
!
router rip
version 2
network 192.168.1.0
no auto-summary
!
R2:
interface GigabitEthernet0/0
ip address 192.168.1.2 255.255.255.0
!
router rip
version 2
network 192.168.1.0
no auto-summary
!
Now, let’s add a third network, 10.0.0.0/24, connected to R2.
R2:
interface GigabitEthernet0/1
ip address 10.0.0.1 255.255.255.0
!
router rip
version 2
network 192.168.1.0
network 10.0.0.0
no auto-summary
!
Because network 10.0.0.0 is configured on R2, RIP will advertise this network. R1, receiving this advertisement from R2, will see that it can reach 10.0.0.0/24 via R2 with a metric of 1 hop. R1 will then add this to its routing table.
On R1, you’d see something like this in its routing table:
Gateway of last resort is not set
10.0.0.0/24 is variably subnetted, 2 databases not in table
O 10.0.0.0/24 [110/1] via 192.168.1.2, 00:00:20, GigabitEthernet0/0
The O indicates an external route (if we were using OSPF, but here it signifies a learned RIP route). [110/1] means administrative distance of 110 (RIP’s default) and a metric of 1 hop. via 192.168.1.2 tells us R1 learned this route from the router at that IP address.
The problem RIP solves is dynamic routing in small, stable networks. When you add or remove a link, or a router goes down, the network can automatically adjust without manual intervention. It’s like a group of people trying to find the quickest way to a party: "I’m two blocks away," "I’m three blocks away from him," and so on. Eventually, everyone agrees on the shortest path.
Internally, RIP routers exchange their entire routing tables with their direct neighbors every 30 seconds. This is called a "periodic update." If a router doesn’t hear from a neighbor for 180 seconds (the "inactivity timer"), it assumes that neighbor is down and invalidates the routes learned from it. After 240 seconds (the "garbage collection timer"), the routes are removed from the table. This periodic, full table exchange is what makes it a "distance-vector" protocol – it knows the "distance" (hop count) and the "vector" (the next hop router) to each destination.
The "no auto-summary" command is crucial. By default, RIP will try to summarize routes at classful network boundaries (like Class A, B, or C). If you have a network like 192.168.1.0/24 and 192.168.2.0/24, RIP would try to advertise them as a single 192.168.0.0/16 route. This can lead to routing loops and lost connectivity, especially in networks with subnets that don’t align with classful boundaries. no auto-summary tells RIP to advertise each network exactly as it’s configured, preserving subnet information.
The biggest quirk of RIP is its hop count limit. A route is considered unreachable if it’s more than 15 hops away. This is a deliberate design to prevent routing loops from persisting indefinitely. However, it also severely limits the size of networks RIP can effectively manage. If a network grows beyond 15 hops, those destinations simply become unreachable, and RIP silently fails to route traffic.
A common pitfall is relying on RIP in anything but the smallest, most controlled environments. Its slow convergence time and susceptibility to routing loops, especially when "auto-summary" is left on or when dealing with network topology changes, make it unsuitable for most modern networks. The 15-hop count limit is another hard ceiling.
The next thing you’ll likely grapple with is how to handle larger or more complex networks, which will lead you to protocols like OSPF or EIGRP.