Nicholas Morrison - Networking Specialist

S1E8 - Routing Protocols

What is Routing?

  • moving layer 3 packets from one network to another
  • .. by choosing an outgoing interface
  • .. by referencing the routing table (show ip route)

A router making a decision

CIDR: Classless Inter-Domain Routing

  • CIDR: Classless Inter-Domain Routing
  • Notation xxx.xxx.xxx.xxx/yy - 192.168.100.100/24
  • /yy = the number of bits that represent the “network”
    • called “mask” (or “netmask” or “network mask” or “subnet mask”)
  • remaining bits = the number of bits that represent the “host”

CIDR examples: /24

An IP address with a 24-bit network mask

  • the first 24 bits define the network
  • 192.168.20.0 (zero out all the other bits) == network address
  • last 8 bits (192.168.20.20) == host part
  • 8 bits == max 254 host addresses
  • we can say:
    • the host with the address 192.168.20.20/24 is in the 192.168.20.0/24 network
    • 192.168.20.0/24 contains up to 254 hosts

CIDR examples: /16

An IP address with a 16-bit network mask

  • the first 16 bits define the network
  • 192.168.0.0 (zero out all the other bits) == network address
  • last 16 bits (192.168.20.20) == host part
  • we can say:
    • the host with the address 192.168.20.20/16 is in the 192.168.20.0/16 network
    • 192.168.0.0/16 contains up to 65,534 hosts

CIDR examples: /8

An IP address with a 8-bit network mask

  • the first 8 bits define the network
  • 192.0.0.0 (zero out all the other bits) == network address
  • last 24 bits (192.168.20.20) == host part
  • we can say:
    • the host with the address 192.168.20.20/8 is in the 192.0.0.0/8 network
    • 192.0.0.0/8 contains up to 16,777,214 hosts

… what is routing?

  • moving packets between different Layer 3 networks!

Two different networks

  • pc1 wants to send a packet to pc2
  • eth1: 192.168.10.1/24
  • eth2: 192.168.20.1/24
  • enough information to route!

More routers

Two networks with three routers between them

  • r1 knows 192.168.10.0/24
  • r1 knows 10.0.0.0/24
  • r1 does not know where 192.168.20.0/24 is! ??? OwO ???

Static routes

Two networks with three routers between them

We can help the routers with static routes to get to 192.168.20.0/24:

r1: ip route 192.168.20.0/24 10.0.0.2
r2: ip route 192.168.20.0/24 10.1.1.2

.. and for the way back to 192.168.10.0/24:

r3: ip route 192.168.10.0/24 10.1.1.1
r2: ip route 192.168.10.0/24 10.0.0.1

The problem with static routes

  • they don’t scale
  • they are prone to error
  • it’s a mostly manual proces
  • totally ok for very small networks
  • very difficult for any other network

The solution: Routing Protocols!

Lots of routers

  • share reachability information
  • provides loop-free paths
  • every router runs the same protocol
  • every router sees the network from its own perspective
  • answers the question: which interface to send this packet through?

So many protocols

  • RIP, OSPF, EIGRP, ISIS, BGP…
  • do essentially the same thing
  • with vastly different levels of:
    • scalability
    • security
    • complexity
    • awesomeness

AS (Autonomous System)

  • a network controlled by a single organisational entity
  • eg a university, a business, a government
  • maybe your organisation needs an assigned “AS Number”
  • AS numbers are globally unique
  • assigned by globally-cooperating RIRs (Regional Internet Registry)

RIP (the Routing Information Protocol)

  • distance vector
  • used within a single AS
  • simple code, simple configuration, low CPU usage
  • good for small networks

RIP path selection

Lots of routers

  • decides the best path based purely on hop-count (distance)
r1 r2       = 2 hops   <- RIP chooses this path
r1 r3 r4 r2 = 4 hops
r1 r5 r6 r2 = 4 hops

OSPF (Open Shortest Path First), ISIS (Intermediate System to Intermediate System)

  • link state vector
  • used within a single AS
  • much less simple code
  • much more scalable than RIP

OSPF, ISIS path selection

Lots of routers

  • routers assign a “cost” to their interfaces, for example:
    • 100 Gbps cost 1
    • 10 Gbps costs 10
    • 1 Gbps costs 100
    • 100 Mbps costs 1000
  • path is chosen by lowest cost (link state)
r1 r2       = 1000
r1 r3 r4 r2 = 3      <- OSPF chooses this path 
r1 r5 r6 r2 = 12

BGP (the Border Gateway Protocol)

  • path vector
  • used globally between multiple ASs
  • requires global collaboration to function
  • complex code, very memory-intensive
  • can store reachability information for the entire Internet

BGP path selection

BGP networks

  • path is chosen by AS path length
    • with a long list of tie-breakers
100 800 1000    = 3   <- BGP chooses this path
100 420 69 1000 = 4
  • my personal favourite protocol

Which one to choose?

  • tiny networks: RIP or OSPF
  • small-large networks: OSPF
  • global networks: OSPF and BGP
  • the internet: BGP

We are going to learn all of these protocols.

Questions?