1. Routers and the IP Addressing Principle
Each router is assigned two or more IP addresses
one address for each network to which the router attaches
To understand why, recall two facts:
A router has connections to multiple physical networks
Each IP address contains a prefix that specifies a physical network
A single IP address does not suffice for a router
because each router connects to multiple networks
and each network has a unique prefix
The IP scheme can be explained by a principle:
An IP address does not identify a specific computer
each address identifies a connection between a computer and a network
A computer with multiple network connections (e.g., a router) must be assigned one IP address for each connection 1 1

2. Multi-homed Hosts: Routers and the IP Addressing Principle2 2

3. The Internet Control Message Protocol (ICMP)
Provides control messaging among the routers to monitor the operation of the Internet
Messages are encapsulated in IP packets
DESTINATION UNREACHABLE
TIME EXCEEDED
PARAMETER PROBLEM
SOURCE QUENCH (reduce speed)
REDIRECT
ECHO REQUEST
ECHO REPLY
TIMESTAMP REQUEST
TIMESTAMP REPLY 3

4. Internet Control Message Protocol
The principal ICMP message types.
5-61 4

5. IP Routing A packet does not know how to get to its destination
Must rely on the routers to send it in the right direction
So how do the routers do that?

6. Routing Information Exchange
A router can't possibly know where everything in the world is: it is only connected to a handful of neighbour routers
How can a router in Izmir know that to send a packet to Tokyo it might have to forward it to America first?
Routers exchange information with each other to find the best possible route to a destination

7. Complexity of Routing Architecture
Two types of routing structures
Autonomous System (AS): Local routing within an organisation (requiring an interior gateway protocol)‏
Global (non-local) routing between organisations (AS’s) (requiring an exterior gateway protocol)‏

8. Autonomous Network Architecture

9. Static Routing within an AS
Interior Gateway Protocols
Requires static route added by hand, e.g., the route command
route add default gw
adds a default route to a gateway with IP address
Routing tables on most non-routers are trivial and set up manually by the operating system at boot time

10. Problem with static route entry
ICMP Redirect
Sometimes routing tables are not perfectly set up
H1 wants to send to H2 but H1's routing table tells it to route via R2

11. ICMP Redirect cont’d
When the packet reaches R2, it sees it should be routed out on the interface it came in on: so R2 knows H1's table need improving
R2 forwards the packet and send an ICMP redirect to H1

12. ICMP Redirect cont’d
H1 gets the redirect and uses it to update its routing table. Next time H1 will be able to route directly to R1

13. Dynamic Routing Protocols
ICMP redirects are OK for small fixes, but in general routers need something more substantial
Could let administrators to set up the tables?
Better to get the routers to do it themselves
Dynamic routing is the passing of routing information between routers

14. Implemented Protocols
Several protocols are used
Routing Information Protocol (RIP)‏
Open Shortest Path First (OSPF)‏
Border Gateway Protocol (BGP)‏
Many more
Each protocol is suited to a certain purpose, no single protocol fits all

15. Dynamic Routing Protocols
Internet is managed as a collection of Autonomous Systems (AS), each administered by a single entity, e.g., a University or company
Each AS chooses a routing protocol to direct packets within the AS: these are interior gateway protocols (IGP), e.g., RIP or OSPF
Between ASs run exterior gateway protocols (EGP), e.g., BGP

16. Router Structure

17. Distance-Vector and Link-State
Routing Algorithms
Distance-Vector and Link-State
Routers can collect all kinds of information about who is connected to whom and in what manner: this must be condensed down to something that can be put in a routing table
Two main algorithms are used:
distance-vector protocols
link-state protocols

18. Routing Algorithms
Distance-vector gathers collections (vectors) of hop counts (distances) from its neighbouring routers to selected destinations. From this it computes its own vector of distances. RIP is an example
Link-state gathers maps of connectivity from all the routers in the AS (or some subset) and uses this to compute its own map. OSPF is an example

19. Distance-Vector vs Link-State
Routing Algorithms
Distance-Vector vs Link-State
Distance-vector is simple, but has problems
Link-state is more complex, but has advantages

20. Routing Information Protocol: RIP
When a router starts it broadcasts a RIP request on all its interfaces with address family 0 and metric 16: this is a “send me all your routes” request
A router receiving such a request replies with its vector of distances

21. RIP
Otherwise a request is for a route to a particular address or addresses
A reply is a metric for a route, or 16 to indicate infinity or “no route”
Given a reply we can update our routing table: our metric is the received metric plus 1 for the hop to the router that replied

22. RIP
If a new route with a smaller metric than an existing route we can update our table to use the new route: RIP always deems shorter paths to be better
RIP also sends a chunk of the routing table every 30 seconds to its neighbours: routes are timed out if they are not confirmed within x minutes

23. RIP
A timed-out route is set to metric 16, but not deleted for 60 seconds: this ensures the invalidation is propagated

24. RIP R3 knows a route to H with metric 1
R3 sends a RIP message to R2, R2 learns a route to H via R3 with metric 2
R2 sends a message to R1, R1 learns a route to H via R2 with metric 3

25. RIP
Note that R2 sends a message to R3, too, so R3 learns there is a route to H via R2 with metric 3
But R3 can ignore this as it already knows a better route

26. Updating of Vector
Distance tables

27. RIP Problems
RIP has problems, in particular the long time (several minutes) it takes to readjust after a route is added or removed somewhere: the slow convergence, or count to infinity problem

28. Link up Propagation
A is initially down and comes up. The good news spreads relatively quickly.
A is down

29. The count-to-infinity problem: Link Down Propagation
A is up
Bad news spread slowly.

30. RIP Problems Cont’d
Another problem is that RIP is not suitable for use between ASs as it is ignorant of subnetting and possibly discloses too much about the internal structure of the AS
As RIP uses broadcast a router only gets information from its immediate neighbours and this makes getting a global view of the network difficult

31. RIP Problems Cont’d
The metric limit of 15 is not big enough for larger networks: making it bigger only makes the count to infinity worse
The only criterion for choice of route is the metric: this is much too simplistic. Other considerations including network speed, bandwidth and cost should be taken into account

32. Open Shortest Path First:OSPF
The Open Shortest Path First protocol is mainly based on the Dijkstra's shortest path first Algorithm

33. Dijkstra’s Algorithm
This is a method for finding best paths through a network, where “best” means “shortest” or “lowest cost” or whatever you want to measure
It is used in several routing protocols

34. Dijkstra's Algorithm
We want to find the shortest/cheapest path between V and Z, where costs are as given
We make a table of paths, containing a predecessor to a node and a cost to get to that node. Also mark each node determined or undetermined

35. Dijkstra's Algorithm
Initialise all costs to ∞, predecessors to blank and all nodes undetermined
Initialise the cost of the starting node V to 0
While there are any undetermined nodes:
pick an undetermined node of lowest cost; call it C
mark C determined
for each undetermined neighbour N of C
if cost to C + cost N to C < cost to N we have found a shorter path to N via C; make the cost of N be cost to C + cost N to C and the predecessor of N to be C

36. Dijkstra's Algorithm
Determined nodes are those for which we definitely know the best route;
Undetermined nodes are those for which we need to find a better (shorter/cheaper) route

37. Dijkstra's Algorithm Pick cheapest undetermined node: V
Make it determined and consider its neighbours W, X and Z
All have infinite cost, so make their predecessors V and adjust their costs

38. Dijkstra's Algorithm Pick cheapest undetermined node: W
Make it determined, and consider its undetermined neighbours X and Y
Cost to X via W is 2+1<4, so revalue X; cost to Y via W is 2+1<∞, so revalue Y

39. Dijkstra's Algorithm Pick cheapest undetermined node: X (or Y)‏
Make it determined and consider its undetermined neighbour Z
Cost to Z via X is 3+2<7 so revalue Z

40. Dijkstra's Algorithm Pick cheapest undetermined node: Y
Make it determined and consider its undetermined neighbour Z
Cost to Z via Y is 3+3>5 so don't revalue Z

41. Dijkstra's Algorithm Pick cheapest undetermined node: Z
Make it determined. It has no undetermined neighbours so we are done

42. Dijkstra's Algorithm Final costs:
So cheapest path from V to Z is of cost 5
Also have computed cheapest paths from V to every other node

43. ROUTING ALGORITHMS
Software responsible for deciding which output line an incoming packet should be transmitted on
Datagram
Routing decision at every node VC
Routing decision at the setup phase
Computer Networks 1
TANENBAUM

44. Routing Algorithms The Optimality Principle Shortest Path Routing
Flooding
Distance Vector Routing
Link State Routing
Hierarchical Routing
Broadcast Routing
Multicast Routing
Routing for Mobile Hosts
Routing in Ad Hoc Networks
Computer Networks 1
TANENBAUM

45. Routing Algorithm Properties
Correctness
Simplicity
Robustness
What happens if the topology changes?
Stability
Must converge to an equilibrium
Fairness
Optimality
Minimize mean packet delay
Maximize total network throughput
Computer Networks 1
TANENBAUM

46. Classes of Routing Algorithms
Nonadaptive algorithms
Route is computed in advance and stored in the router
This is called static routing
Adaptive algorithms
Base their decision on current measurement of traffic and topology
Computer Networks 1
TANENBAUM

47. Shortest Path Routing Treat routers as nodes Assign weights to links
E.g.
Fix all weight to 1 to minimize the number of hops crossed
Use distance in kilometers as weight to minimize delay
Use Dijkstra’s algorithm to determine the shortest path
Computer Networks 1
TANENBAUM

48. Dijkstra’s Algorithm 1
Computer Networks 1
TANENBAUM

49. Dijkstra’s Algorithm 2 Update least cost paths Initialize
T = {s} set of nodes incorporated (s source)
L(n)=w(i,j) for ns initial path costs to neighbors
Get next node
Add the neighbor x not in T that has least cost L(x) to s.
Add the edge from this neighbor to old T that contributes to the path
Update least cost paths
For all nT, update costs by L(n)=min[L(n),L(x)+w(x,n)]
Computer Networks 1
TANENBAUM

50. Dijkstra’s Algorithm 1
5-8 top
Computer Networks 1
TANENBAUM

51. Dijkstra’s Algorithm 2
5-8 bottom
Computer Networks 1
TANENBAUM

52. Flow-Based Routing Takes load into account Needs
Topology
Load on the lines
Capacity of the lines
Given the load and capacity, delay of the line can be computed via queueing theory
T = 1 / (C - ) where
1/ is mean packet size in bits
C is line capacity in bps
 mean flow in packets per second
Computer Networks 1
TANENBAUM

53. Link State Routing Distance vector routing
Did not take line bandwidth into account
Took too long to converge
Link state routing: Each router
Discovers its neighbors.
Measures the delay or cost to each of its neighbors.
Constructs a packet telling all it has just learned.
Sends this packet to all other routers in the vicinity.
Computes the shortest path to every other router.

54. Learning about the Neighbors
When a rooter is booted, it sends HELLO packet to all of its neighbors
Neighbors reply by sending their globally unique names.

55. Measuring Line Cost
Each router should know an estimate of delay to each of its neighbors
To estimate the delay, a router can send an echo packet to its neighbor and measure the time when it receives it back
While measuring time, it is possible to include or exclude the time the echo packet spends on the queues which corresponds to consider load on the line
Including load may cause oscillations in the algorithm

56. A subnet in which the East and West parts are connected by two lines.
Measuring Line Cost
A subnet in which the East and West parts are connected by two lines.
Computer Networks 1
TANENBAUM

57. Building Link State Packets
Packets contain
Identity of the sender
Sequence number
Age
List of neighbors and delays delays to them
Packets canbe issued
Periodically or
When a significant event occurs

58. Building Link State Packets 2
(a) A subnet. (b) The link state packets for this subnet.
Computer Networks 1
TANENBAUM

59. Distributing the Link State Packets
Flooding is used
Packet sequence numbers are used to discard duplicates or old packets by holding packets for a short while before flooding them
32-bit sequence numbers are used to prevent wrap-arounds
For each packet, in addition to sequence number, age is used and decremented every second to solve
Router crash problem
Corrupted sequence number problem

60. Flooding
Every incoming packet is sent out on every outgoing line except the one it arrived on
Generates vast number of duplicate packets
Solutions
Put a hop counter to every packet
Avoid flooding the same packet second time
Needs packet sequence numbers
Use selective flooding
Do not put the packet to every outgoing line, instead put the packet to certain outgoing lines

61. Distributing the Link State Packets 2
The packet buffer for router B shown in slide 58

62. Computing the New Routes
When a router accumulates a full set of link state packets, it can construct the entire network graph
It then runs Dijkstra’s algorithm to construct shortest paths to all possible destinations
Even for a large subnet, the memory requirements are reasonable
Protocols using link state routing
OSPF and IS-IS

63. Link-state Data Structure
// Link-state packet header: The basic data structure of link-state
// routing algo rithm
// ACK of sender is set, SEND of receiver flag is set!
typedef struct lsp {
char ip[15];
char in_ip[15];
char out_ip[15];
bool SEND, ACK;
long seqNo;
int age;
int dist;
struct lsp* next;
struct lsp* komsu;
} linkState;

64. Link-state Append Incoming Packet
// Needed for building link-state packet tables
void appendNewcomer(linkState *ls){
if(inList == NULL){
inList = ls;
ls_tail = ls;
}else{
ls_tail->next = ls; }
ls_tail->next = NULL;

65. Handle Incoming Packet
void newComer(linkState *nc) {
linkState *p = inList; // inList points head of the incoming packets
while (p != NULL ) {
// First handle duplicated link state packets: discrad the older one
// keep the younger packets in the newcomer list.
if (strcmp(nc->ip,p->ip) && (nc->seqNo == p->seqNo)) {
// Age near zero is considered older and will be discarded
if (nc->age >= p->age);
// The greater the age the younger the packet!
p->age = nc->age;
// copy the new comer's age and keep the older. }
else appendNewcomer(nc);
// The new comer is added to the incoming list
p = p->next;

66. Flooding Algorithm void flood(linkState *new_comer){
// inList-> head of the incoming packets
linkState *inList, *np;
inList = ls_major;
removeOldies(); // Delete aged packets
if (inList !=NULL) { // If list is not empty
np = inList->komsu;
while (np != NULL) {
//Incoming packet is from neighbor's source
if (checkFlooder(new_comer, np) == false) {
// Sender is not the same as the np!
if (isUp(np->ip) == true) {
// Neighbor is up, now set the SEND flag for it
// before flooding to it
np->SEND=true;
forward(new_comer,np); // Forward) this packet to neighbor }
np = np->next;

67. Removing Old Links State Packets
void removeOldies(){
linkState *tp; linkState *p = inList;
// Age zero is considered old and packets with zero age will be discarded
while (p !=NULL) {
if (p->age <= 0) {
tp = p;
p = p->next; // Goto next PACKET to check
delete (tp); // delete the old packet }
else p = p->next;

68. Is the floder One of the Neighbor?
/*************************************************************
* Before flooding to neighbors we need to make sure
* not to send the same packet back to its sender
************************************************************/
bool checkFlooder(linkState *new_comer, linkState *that) {
// that points to the neighbor of the sender.
// new_comer is the packet just arrived
if (strcmp(new_comer->ip,that->ip)) {
new_comer->ACK = true;
Acknowledge(new_comer->ip) // Ack the sender
return true; }
return false;