IP Routing, Switching Paths, Static Routing.

Lessons Learned:

IP Routing Overview

Three main Steps

-Routing – find the outgoing interface

-Switching – move the packet between interfaces

-Encapsulation- Build the layer 2 header

Regardless of what you’re running the router will always go through a three step process internally when it’s moving packets between interfaces.

First, when a router receives an IP packet, it’s going to look at the destination address to find the outgoing interface.

This is the routing processes job. (RIB or CEF or FIB) – once the decision is made of where to send the packet it, it’s out of the routing processes hands.

The second of this three step process is the switching path – where the router actually moves the packet between the interfaces.

Note: there is  separation between the routing process and the switching process. The switching process is controlled by the CEF or fast switching process, this is where you could define load-balancing, etc. Also where the router has use its general CPU to move traffic between interfaces or where we use the forwarding table globally or line card/ port.

Third – the encapsulation process. This is where the router will actually build the layer 2 header. Then main diff between L2 switching process and L3 – for a layer 3 routing process is  - for a layer 3 router we are rebuilding the L2 encapsulation in a hop by hop basis. This process allows a packet to be received from a Frame interface and then forward to a Ethernet interface.

All devices L3 and above will be rebuilding the L2 header on a hop-by-hop basis.

 

The routing process:

-Find the longest match

When the router receives an L3 packet, it first looks at what is the destination address. It will then do a lookup against the routing table of the forwarding table to find the most number of BITS in common,  and the destination of the packet.

EX: route for network 1.2.3.4

 # s hip route

1.0.0.0/8

1.2.0.0/16

1.2.3.0/24 – Router will choose this path because it’s the longest match. The most number of Bits in common for routing entry and also destination

Note: For the longest match – a /32 host route would be the longest as compare to the default route – the last ditch effort.

Note: This is also independent of the AD distance or the metric

Recurse the to the outgoing interface.

What’s the outgoing interface and next hop value associated with the route.

Note: if the router has to look-up the destination more than one time this is a recursive lookup.

 

Once the routing process has made its decision on the longest match and the outgoing interface, the process is done.

The packet is then sent to the switching process whose job is to move the packet over to the next or exit interface.

 

Multiple longest matches:

If there’s multiple longest matches for a destination – the router needs to choose which to use. It can also use some sort of load balancing mechanism.

Where do the same lonest matches come from?

-Same protocol (EX: EIGRP)

--choose the lowest metric  - this will be used if the same longest matches are coming from the same routing protocols.

Different protocols (ex: EIGRP to OSPF)

-choose lowest administrative distance. – This will be used if the longest match is coming from different routing protocols.

Distance values:

Internal  Routes:

1.Connected Link – distance = 0. Router will ALWAYS prefer this – there’s no way to preempt a connected link for ANY destination.

2.Static route – Distance = 1

3.EIGRP Summary Route – Distance = 5 (IP summary add at the link level of a router)

4.EIGRP – Distance = 90

5. OSPF – Distance – 110

6. RIP – Distance – 120

7. EIGRP External routes – Distance = 170

Distance values:

External  Routes:

EBGP – distance = 20

iBGP – distance – 200

So a manually configured static router – will always be preferred over any Dynamically learned info.

From an external routing perspective, the router will always prefer any external BGP derived route VS any IGP’s

Note: If you’re learning the route from BGP it means the route is not part of your own autonomous system. If it was part of your own AS – the route should be learned from your own IGP.

The switching process:

Moves the packet between interfaces.

-process, fast, CEF, etc.

-where load balancing occurs.

Config:

# ip cef

# (no) ip route-cache (turns the process on or off for on the interface level)

# (no) ip mroute-cache (for multicast switching)

Verification:

#sh ip interface

#sh ip cef (address) (detail)

#Sh ip cef exact-route (source) (Destination) – can be useful for load distribution based on multiple interface, helps find the outgoing interface. If routing protocol is offering two equal cost paths.

CEF Switching should be the default switching on most all platforms. CEF is preferred because it has a faster internal lookup process.

CEF lookups are deterministic – CEF internally divides its lookups into 4 different tables. Based on the hierarchy of the IP Addressing (IPv4). This is because IPv4 has four different octets - Octets A.B.C.D.

Within the scope of the CEF process there is an internal data structure that represents each Octet.

For example:

Octet A: there is 255 child entries that go from 1 – 255. And so on for each Octet.

What this means from a CEF table’s point of view when trying to figure the outgoing interface – the process has to do 4 individual lookups under each Octet and each child object.

The CEF process the table is always pre-calculated – the cache is built from the routing protocols and longest match information. Note: the CEF or FIB table on larger scale gear like the 6500 – the table actually runs on the line card level. This means that there’s no need to forward to the routing process of SUP, it can be immediately sent and doesn’t need to reference the central copy of the CEF table.

Verifications:

# sh ip cache

R1#sh ip cache

IP routing cache 0 entries, 0 bytes

   0 adds, 0 invalidates, 0 refcounts

Minimum invalidation interval 2 seconds, maximum interval 5 seconds,

   quiet interval 3 seconds, threshold 0 requests

Invalidation rate 0 in last second, 0 in last 3 seconds

Last full cache invalidation occurred 00:26:33 ago

R1#sh ip cef

Prefix              Next Hop             Interface

0.0.0.0/0           drop                 Null0 (default route handler entry)

0.0.0.0/8           drop

0.0.0.0/32          receive

127.0.0.0/8         drop

224.0.0.0/4         drop

224.0.0.0/24        receive

240.0.0.0/4         drop

255.255.255.255/32  receive

R1#

Process Switching – the entire lookup is done all at once based on a Top down perspective. Depends on how many entries in the routing table / order they’re configured in – has to look though all entries and this happens on a per packet basis.

Fast switching – once the router has found the outgoing interface, it keeps a caching table (route cache)that has the interface mappings. This is driven by the data plane because we don’t have an entry until a packet is sent to a particular destination.

Note: The router will Process switch (process uses the routers Local CPU) locally originated or locally destined traffic. Any transit traffic (packets coming in one interface and going out another) these packets will go to the CEF process by default.

The encapsulation Process:

Build the layer 2 header

Multipoint interfaces require L3 to L2 resolution. Router will ALWAYS have to do an L2 to L3 resolution.

-Ethernet # sh harp

-Frame Relay  #Sh frame-relay map

Point to point interfaces, PPP sub interfaces, PPP or HDLC links, etc. Do not have to go through the L2 to L3 link,  this because the same L2 address is used for every destination reachable out the link.

Note: By definition PPP is a point to point protocol.

 

Routing to a Next-Hop:

When you route to a next hop value, this means the router doesn’t know the outgoing interface to s destination.

If the router cannot find a next-hop, that means the route cannot be installed in the forwarding table. Once the router finds the next-hop interface it will need to do a layer 3 to Layer 2 resolution on the next-hop value.

 

Recurse to the interface –

If multipoint, resolve L2 address of next-hop

Example:

# ip route 10.0.0.0 255.0.0.0 1.2.3.4

-find interface for 1.2.3.4

-if multipoint, find L2 address of 1.2.3.4

Routing to a Multipoint interface

-recursion not required

-resolve L2 address for final destination

….Ethernet Proxy-arp

….NBMA Mappings

Example:

-ip route 10.0.0.0 255.0.0.0 Fastherthernet 0/0

- find layer 2 address of 10.0.0.1

Note: In this case he router doesn’t need to do a lookup because it already knows the exit interface is FA0/0. What it does not know is what is the L2 neighbor on the link – this is not a good idea for Multipoint interfaces.

Routing to a Point-to-Point interface

-recursion NOT required

L2 resolution not required

EX: ip route 10.0.0.0 255.0.0.0 Serial 0/0.1

Note: You should only point a route to  an interface on a P2P link. Because not Recursion or L2 lookup is required for this type link.