This is another blog post in the series “One minute…” which gives the basic concepts of a topic, with enough information so that you can read other documentation, but without going too deeply.
IP networks can range in size from 2 nodes(machines), to millions of nodes(machines), and a packet can go from my machine to any available machines – and it arrives! How does this miracle work?
I’ll work with IP V6 to make it more interesting (and there is already a lot of documentation for IP V4)
- Static routing
- Routing Information Protocol(RIP)
- OSPF (Open Shortest Path First) – not a very helpful title. I would call it build a map of the network.
I have and old laptop, connected by Ethernet to my new laptop. My new laptop is connected by wireless to my server which is connected to z/OS. I can ping from the old laptop to z/OS.
- Each machine needs connectivity for example wireless, Ethernet, or both.
- Each machine has one or more interfaces where the connectivity comes in (think Ethernet port, and Wireless connection). This is sometimes known as a device.
- Each interface has one or more IP addresses.
- You can have hardware routers, or can route through software, without a hardware router. A hardware router can do more than route.
- Each machine can route traffic over an interface (or throw away the packet).
- If there is only one interface this is easy – all traffic goes down it.
- If there is more than one interface you can specify which address ranges go to which interface.
- You can have a default catch-all if none of the definitions match
- You can have the same address using different interfaces, and the system can exploit metrics to decide which will be used.
- You can have policy based routing. For example
- packets from this premier user, going to a specific IP address should use the high performance (and more expensive) interface,
- people using the free service, use the slower(and cheaper) interface.
Modern routing uses the network topology to manage the routing tables and metrics in each machine.
The administrator defines a table of “if you want get to… then use this interface, the default is to send the packet using this … interface”. For example with z/OS
BEGINRoutes ; Destination SubnetMask FirstHop LinkName Size ; ROUTE 192.168.0.0 255.255.255.0 = ETH2 MTU 1492 ROUTE 10.0.0.0 255.0.0.0 = ETH1 MTU 1492 ROUTE DEFAULT 10.1.1.1 ETH1 MTU 1492 ROUTE 10.1.0.0 255.255.255.0 10.1.1.1 ETH1 MTU 1492 ROUTE 2001:db8::/64 fe80::f8b5:3466:aa53:2f56 JFPORTCP2 MTU 5000 ROUTE fe80::17 HOST = IFPORTCP6 MTU 5000 ROUTE default6 fe80::f8b5:e4ff:fe59:2e51 IFPORTCP6 MTU 5000 ENDRoutes
- All traffic for 10.*.*.* goes via interface ETH1.
- If no rule matches (for IP V4) use the DEFAULT route via ETH1. The remote end of the connection has IP address 10.1.1.1
- All traffic for IPV6 address 2001:db8:0:* goes via interface JFPORTCP2
- If no rule matches (for IP V6) use the DEFAULT6 route via IFPORTCP6. The remote end of the connection has IP address fe80::f8b5:e4ff:fe59:2e51.
On Linux the ip route command gave
default via 192.168.1.254 dev wlxd037450ab7ac proto dhcp metric 600 10.1.0.0/24 dev eno1 proto kernel scope link src 10.1.0.3 metric 100 10.1.1.0/24 dev tap0 proto kernel scope link src 10.1.1.1
- The default is to send any traffic via device wlxd037450ab7ac.
- Any traffic for 10.1.0.* goes via device eno1
- Any traffic for 10.1.1.* goes via device tap0.
Routing Information Protocol(RIP)
Manually assigning metrics (priorities) to hint which routes are best, quickly becomes unmanageable when the number of nodes(hosts) increases.
If the 1980’s the first attempt to solve this was using RIP. It uses “hop count” of the destination from the machine as a metric. A route with a small hop count will get selected over a route with a large hop count. Of course this means that each machine needs to know the topology. RIP can support at most 15 hops.
Each node participating in RIP learns about all other nodes participating in RIP.
Every 30 seconds each node sends to adjacent nodes “I know about the following nodes and their route statements”. Given this, eventually all nodes connected to the network will know the complete topology.
For example, from the frr(Free Range Routing) trace on Linux
RIPng update timer expired! RIPng update routes on interface tap1 send interface tap1 SEND response version 1 packet size 144 2001:db8::/64 metric 1 tag 0 2001:db8:1::/64 metric 1 tag 0 2002::/64 metric 2 tag 0 2002:2::/64 metric 2 tag 0 2008::/64 metric 3 tag 0 2009::/64 metric 1 tag 0 2a00:23c5:978f:6e01::/64 metric 1 tag 0
- The 30 second timer woke up
- It sent information to interface tap1
- 2001:db8::/64 metric 1 this is on my host(1 hop)
- 2002::/64 metric 2 this is from a router directly connected to me (2 hops).
- 2008::/64 metric 3 is connected to a router connected to a router directly connected to me (3 hops.)
On z/OS the command F OMP1,RT6TABLE gave me message EZZ7979I . See OMPROUTE IPv6 main routing table for more information
DESTINATION: 2002::/64 NEXT HOP: FE80::E42D:73FF:FEB1:1AB8 TYPE: RIP COST: 3 AGE: 10 DESTINATION: 2001:DB8::/64 NEXT HOP: FE80::E42D:73FF:FEB1:1AB8 TYPE: RIP* COST: 2 AGE: 0
- To get to 2002::/64 go down interface with the IP address FE80::E42D:73FF:FEB1:1AB8.
- This route has been provided by the RIP code.
- The destination is 3 hops away (in the information sent from the server it was 2 hops away)
The fields are
- RIP – Indicates a route that was learned through the IPv6 RIP protocol.
- * An asterisk (*) after the route type indicates that the route has a directly connected backup.
- Cost 3 – this route is 3 hops away.
- Age 10 -Indicates the time that has elapsed since the routing table entry was last refreshed
OSPF (Open Shortest Path First)
OSPF was developed after RIP, as RIP had limitations – the maximum number of hops was 15, and every 30 seconds there was a deluge of information being sent around. The OSPF standard came out in 1998 10 years after RIP.
Using OSPF, when a system starts up it sends to the neighbouring systems “Hello,_ my router id is 184.108.40.206, and I have the following IP addresses and routes.” This information is propagated to all nodes in the OSPF area. When a node receives this information it updates its internal map (database) with this information. Every 10 seconds or so each node sends a “Hello Packet” to the adjacent node to say “I’m still here”. If this packet is not received, then it can broadcast “This node …. is not_responsive/dead”, and all other nodes can then update their maps.
If the configuration changes, for example an IP address is added to an interface, the node’s information is propagated throughout the network. In a stable network, the network traffic is just the “Hello packet” sent to the next node, and any configuration changes propagated.
One of the pieces of information sent out about node’s route is the metric or “cost”. When a node is deciding which interface to route a packet to, OSPF can calculate the overall “cost” and if there are a choice of routes to the destination it can decide which interface gives the best cost.
To make it easier to administer, you can have areas, so you might have an area being the UK, another area being Denmark, and another area being the USA.