How to Add RIPng to IPv6

To imagine what Routing Interface Protocol (RIP) does for the internet, imagine that a friend invites you over for dinner. You've never been to their place, so they give you their address. You get directions and arrive, but it's a big apartment building. Not only did your friend not tell you their apartment number,  the apartment numbers have letters and symbols as well. Oh, and the main door is locked. The numbering doesn't make any sense at all. Even if you knew their apartment, you wouldn't know how to find the place or get in.

With networking and routing, this can sort of be how routers feel sometimes. A router knows who it's connected to, but it doesn't know what's beyond that connection. Out of the box, routers don't advertise their connections and networks to other routers just because they're connected to them. But for quite a while, there's been RIP. RIP, or Routing Interface Protocol, makes sure that all routers know where to find connections and how many hops away each one is.

RIP doesn't look very different in IPv6 compared to IPv4, but in this post, we'll explain how to implement RIP on a router in IPv6.

What is Routing Interface Protocol?

Quick Definition: Routing Interface Protocol, also known as RIP, is used to disseminate information about networks and interfaces to other routers. Not only do routers need to know what destinations can be reached, but they also need to know how far away they are and what the quickest, most efficient path there is. RIP is one of the oldest protocols for disseminating that information.

What is IPv6 RIP or RIP Next Generation (RIPng)?

Routing Interface Protocol was originally designed for the internet standard of IPv4. It's a distance vector protocol — or a protocol that determines the path to remote networks and counts the number of hops to get there. RIP eventually became replaced with RIPv2.

The IPv6 version of RIP is also known as RIP Next Generation (RIPng) or IPv6 RIP. Functionally, IPv6 RIP works the same way that RIPv2 did, it just offers more. Most importantly, it can only be run on IPv6.

Using a Virtualized Network to Demonstrate RIPng

After setting up a network, you want to make sure that the connections are working and that each router can see everything else on that network it's supposed to. Throughout this post, we're going to cover how to use IPv6 RIP to do exactly that. But before we do that, we should visualize the test network we're going to use.

We recommend using a virtualized network and practicing on your own, and to help you do so, here's a brief description of our network. We have three routers: R1, R2, and R3. Each is connected to the others on their serial interfaces. Each router also has a g2/0 interface leading off to different devices underneath them. When we set up the network, we came up with an IP addressing schema of 2001:db8:6783:X:: /64.

If this were a real-world network, we'd put our cables and connectors together. And then, virtualized or physical, we configure each s1/0 and s1/1 interface with the appropriate IP address. The central question we're asking throughout this post is this: once it's all in place, how do we test it? How do you go about checking that each connection, interface and device is operating how it should?

How to Verify a Network Connection Without RIP

One answer is with a simple ping. To demonstrate this, let's go into R1 and ping R3's address. This should verify whether R3 is responding and whether it's able to communicate with R1. If you have a virtualized network to work on, follow along with us by going into R1's console.

Once there, you have a choice. You can either type in all the characters of the IPv6 address for the subnet and host ID, but there's an alternative. Type:

show ipv6 int brief

Doing that will output a table. In it are all the serial connections this router "sees". In our case, we have addresses at Serial1/0 and Serial1/1 going out to their own networks (the two networks that R1 has to R2, and R1 to R3). All we have to do is drag, copy and paste in the address straight from the interface table you see there.

Keep in mind that the address you'll see in that table is the network ID: you'll need to replace the final digit. In our case, what we see on that table is 2001:DB8:6783:13::1. But we want to only copy everything before that final "1". We replace that 1 with the address of the router, which happens to be "3". This leaves us with:

ping 2001:DB8:6783:13::3

We wouldn't want to speak for you, but getting a successful return on a test ping is always an exciting thing — even when it's on a simple virtualized network with only a few connections. Success is success.

Our return shows that IPv6 is good between R1 and R3. We've named the network between R1 and R3 13, and what this ping tells us is that our 13 network between R1's serial s1/1 and R3's s1/1 is good.

But this only demonstrates one thing: the route between R1 and R3's serial interfaces. What about interfaces that R1 can't "see" directly? If you remember back, this is like arriving at an apartment building without an apartment number, an understanding of its numbering system, or a key.

Can You Ping Network Connections That Aren't Connected?

We named the network between R2 and R3 23. Our question now is whether R1 can see network 23 even though it's not directly connected to it. You might think that since R1 successfully pinged R3 before, it should be able to easily ping R3's serial connection to R2 as well. After all, it's pinging the exact same router, just a different interface on that router. Spoiler alert: it's not going to work. If you want to see the failure result, type:

ping 2001:DB8:6783:23::3

You'll see we changed the network ID from "13" to "23", but the ping still fails. The error message effectively says, "I don't have the ability to ping that address." You may wonder why that is. Well, routers, based on directly connected interfaces alone, don't know about remote networks. Just because it's connected to R3, R1 doesn't automatically learn all R3's other interfaces and networks. R1 doesn't even know about network 23's existence, and it certainly can't ping it.

How to Add RIPng to IPv6

RIP next generation, or IPv6 RIP, is how we'll inform R1 of R3's other connections. In IPv6, configuring RIP is easy.

RIPng in IPv6 is different in configuration than IPv4's RIP. Instead, we go to interface configuration mode and simply tell each interface, "Participate in interface configuration and the RIP-routing process." You also name the routing process and it can be whatever you want. By instructing the interfaces and naming the routing process, that route dynamically spawns and becomes created.

Because we created our hypothetical network for exactly this purpose, we have three identical physical interfaces on each of our three routers. R1, R2, and R3 each have g2/0, ser1/0, and ser1/1. It will probably never be the case in real-world networks that each router has exactly the same number of interfaces, but for our demonstration, it means all the commands will be identical.

Start by entering configuration mode in R1's console:

conf t

Then, enter interface configuration for our gigabyte interface:

int g2/0

After that, it's as easy as instructing it to be a part of a routing process. We're going to call our routing process "OurRip". We type this:

ipv6 rip OurRip enable

With that, you've added RIPng in IPv6 to R1's g2/0 interface. But that's only that interface. In our hypothetical network, there are still other connections. There's serial 1/0:

int ser1/0

ipv6 rip OurRip enable

And serial 1/1:

int ser 1/1

ipv6 rip OurRip enable

We'll also include loopback interfaces:

int loop 0

ipv6 rip OurRip enable

With that, you can leave configuration mode:

end

That's it, you've done it. We have R1's three physical interfaces, plus loopback interface, into and participating with RIP. But having RIPng in IPv6 added to R1 doesn't complete the process. You have to make sure the other routers on the network also know to broadcast their networks and connections.

Head over to R2 and repeat the process. Remember: it just so happens that we're using the same, exact interface numbers of R2 and R3 that we used on R1. Obviously, that might not always be the case. But since they're the same interface numbers, we type this on R2:

conf t
int g2/0
ipv6 rip OurRip enable
int ser1/0
ipv6 rip OurRip enable
int ser 1/1
ipv6 rip OurRip enable
int loop 0
ipv6 rip OurRip enable
end

In our hypothetical, three-router network, our last stop is at R3's console. Once there, we type:

conf t
int g2/0
ipv6 rip OurRip enable
int ser1/0
ipv6 rip OurRip enable
int ser 1/1
ipv6 rip OurRip enable
int loop 0
ipv6 rip OurRip enable
end

What happens next is all in the background. As each interface starts up RIP, it will start advertising and receiving advertisements. Whether IPv4 RIP or IPv6 RIP, neighbors send RIP messages back and forth to one another to count how far apart each node is.

An Overview of How to Add RIPng to IPv6 [VIDEO]

In this video, Keith Barker covers how to provide full connectivity in a sample network using the basic routing protocol RIPng (Next Generation) in IPv6. He'll discuss and demonstrate basic interface configuration and then demonstrate how you can verify everything is working the way you want it to.

How to Confirm Network Connections in IPv6 RIP

After getting R1, R2, and R3 participating in RIP, we should have the ability to see RIP-learned routes. Since every device is broadcasting the connections it has with its neighbors, and we have a small network to start with, this will be a small output. But we'll explain how to interpret the results.

Just a few minutes ago, R1 wasn’t able to ping the 23 network because it didn't even know it was there. But now we know that both R2 and R3 are advertising that network's existence and how to get there through the RIP-routing protocol. We should also have access to all of our loopbacks, because those are also being advertised inside of the RIP routing process.

Go back to R1 to see if we were successful. We'll type the same ping as before:

ping 2001:DB8:6783:23::3

Get excited – it's another success. And now, let's look at our routing table by typing:

show ipv6 route rip

This will output the routes that were learned via RIP. In this table, we can take a closer look at routes.

R1 is now aware of all the networks that R2 and R3 have advertised from their own G2/0 interfaces. Your hypothetical network may look different from ours, but if R2 has a server, R1 now knows about it and how to get there. In our network, R1 can leave s1/0, and then head out through R2's link-local address.

R1 also learns that R3 has a subnet called 3. To access it, R1 would leave its own S1/1 and the next hop is R3's link-local address.

Or there's that 23 network that exists between R2 and R3. In our case, network 23 is accessed through R2's s1/1 and R3's s1/0. If your network looks like ours, you should be seeing two equal-cost paths to get there.  One is through R1 s1/0 followed by R2 s1/1. The other through R1 s1/1 followed by R3 s1/0. What you should see is that both were put into the routing table, and both have the same metric of "2" (2 hops away).

One interesting note is that when R2 advertised this route to R1. And R3 did the same thing, it advertised network 23 with a hop of 1. But with IPv6, when a router receives a metric of "1" with RIP, we actually add another hop to it for the ingress interface. The result of that gets put into the routing table for that router.

What that means for our sample network is that even though network 23 is directly connected to R2 and was advertised with a hop count of 1, it shows up with a hop count of 2 in R1's routing table. That's a key difference between RIPng for IPv6 and RIP with IPv4.

The routing table will also include the loopback addresses of R2 and R3 as well. They're all showing up in the routing table, courtesy of RIP.

Wrapping Up

RIP is one of the oldest route-advertising and hop-counting protocols in use, but that doesn't make it obsolete. RIPng for IPv6 remains an easy-to-use tool for advertising available connections and their distance. Most importantly, RIPng helps to provide full connectivity in a network. If learning about RIP's different versions is important to you, this CBT Nuggets video reviews RIPv2 concepts.