Network Layer_ Routing

Document Sample
Network Layer_ Routing Powered By Docstoc
					                Chapter 5
              Network Layer:
                 Routing



Ch.2: Link Layer               1
&LAN
   Network Layer: Protocols
    Network layer functions:

                                   Transport layer
           Routing protocols         Control protocols             Control protocols
                                     •error reporting              - router “signaling”
           •path selection
           •e.g., RIP, OSPF, BGP     e.g. ICMP                     e.g. RSVP


Network
   layer
                                                         Network layer protocol (e.g., IP)
                                   forwarding            •addressing conventions
                                                         •packet format
                                                         •packet handling conventions


                                       Link layer
                                     physical layer
                                                     Chapter 5: Network Layer: Routing       #2
Control: ROUTING algorithms




                Chapter 5: Network Layer: Routing   #3
Control Plane: Routing
       Routing
  Goal: determine “good” paths
  (sequences of routers) thru
 network from sources to dest.

Graph abstraction for the
  routing problem:
                                               5
 graph nodes are routers                      B     3      C
 graph edges are physical                 2                       5
                                       A        2                      F
  links                                                3     1
       links have properties: delay,       1   D                   2
                                                           E
       capacity, $ cost, policy                        1
                                       Chapter 5: Network Layer: Routing   #4
Key Desired Properties of a Routing
Algorithm

 Robustness


 Optimality
   find good path
    (for user/provider)


 Simplicity



                           Chapter 5: Network Layer: Routing   #5
                                                                 - Robustness

Routing Design Space
                                                                 - Optimality
                                                                 - Simplicity


 Routing has a large design space
    who decides routing?
       • source routing: end hosts make decision
       • network routing: networks make decision
           – centralized control : one node builds tables for all routers
           – distributed control : each router builds own routing table
     how many paths from source s to destination d?
       • multi-path routing (several alternatives available)
       • single path routing
     will routing adapt to network traffic demand or
      to topology changes?
       • dynamic routing : tables adapt to state changes
       • static routing : tables configured manually
     …
                                             Chapter 5: Network Layer: Routing   #6
   Routing Algorithm classification
            (distributed control network)
                                    Global or decentralized
Centralized of                        information?
  distributed control?              Global information:
Centralized control:
                                     all routers have complete
 one central node in the              topology, link-cost info
  network builds tables for
                                     “link state” algorithms
  all routers and sends to
  them                              Decentralized information:
      collects data from routers    router knows physically-
                                      connected neighbors, link
Distributed control:
                                      costs to neighbors
 every router builds its own
                                     iterative process of
   table
                                      computation, exchange of
      based on information
                                      info with neighbors
       exchange with other
       routers                       “distance vector” algorithms

                                        Chapter 5: Network Layer: Routing   #7
A Link-State Routing Algorithm
Dijkstra’s algorithm            Notation:
 net topology, link costs       c(i,j): link cost from node i
  known to all nodes               to j. cost infinite if not
    accomplished via “link        direct neighbors
      state broadcast”
                                 D(v): current value of cost
    all nodes have same info     of path from source to
 computes least cost paths       dest. V
  from one node (“source”) to
                                 p(v): immediate
  all other nodes
                                  predecessor node along
    gives routing table for
                                  path from source to v,
      that node
                                 N: set of nodes whose
 iterative: after k
                                  least cost path definitively
  iterations, know least cost
                                  known
  path to k destinations
                                      Chapter 5: Network Layer: Routing   #8
Dijsktra’s Algorithm
  1 Initialization:
  2 N = {A}
  3 for all nodes v
  4    if v adjacent to A
  5      then D(v) = c(A,v) , p(v)=A
  6      else D(v) = ∞
  7
  8 Loop
  9 find w not in N such that D(w) is a minimum
  10 add w to N
  11 update D(v) for all v adjacent to w and not in N:
  12 D(v) = min( D(v), D(w) + c(w,v) ) , adjust p(v)
  13 /* new cost to v is either old cost to v or known
  14 shortest path cost to w plus cost from w to v */
  15 until all nodes in N

                                      Chapter 5: Network Layer: Routing   #9
  Dijkstra’s algorithm: example
Step     start N   D(B),p(B) D(C),p(C) D(D),p(D) D(E),p(E) D(F),p(F)
   0           A         2,A       5,A       1,A    infinity infinity
   1         AD          2,A       4,D                  2,D  infinity
   2       ADE           2,A       3,E                           4,E
   3     ADEB                      3,E                           4,E
   4    ADEBC                                                    4,E
   5   ADEBCF


                                  5

                                  B   3       C
                              2                    5
                      A           2                    F
                                              1
                                          3
                          1                        2
                                  D           E
                                      1
                                                  Chapter 5: Network Layer: Routing   #10
Dijkstra’s algorithm, discussion
Algorithm complexity: n nodes
 each iteration: need to check all nodes, w, not in N
 n(n+1)/2 comparisons: O(n2)
      more efficient implementations possible: O(nlogn)




                                       Chapter 5: Network Layer: Routing   #11
Distance Vector Routing Algorithms
iterative:
                            Distance Table data structure
 continues until no
  change in node info.       each node has its own table

 self-terminating: no       row for each possible destination
  “signal” to stop           column for each directly-
                              attached neighbor to node
asynchronous:
                             example: in node X, for dest. Y
 nodes need   not
                              via neighbor Z:
   exchange info/iterate
   in lock step!
distributed:                            distance from X to
                              X       = Y, via Z as next hop
 each node
                            D (Y,Z)
   communicates only with
   directly-attached                  = c(X,Z) + min {DZ(Y,w)}
                                                         w
   neighbors
                                    Chapter 5: Network Layer: Routing   #12
Distance Vector Routing

 Basis of RIP, IGRP, EIGRP routing
 protocols

 Based on the Bellman-Ford
 algorithm (BFA)

 Conceptually, runs for each
 destination separately

                     Chapter 5: Network Layer: Routing   #13
Distance Vector Routing: Basic Idea
 At node i, the basic update rule
                                                      reported by j

         d i  min    jN ( i )   (d ij  d j )                destination
where
- di denotes the distance
  estimation from i to the
  destination,
- N(i) is set of neighbors of                            di          j
  node i, and                                                 d ij
- dij is the distance of                                             dj
  the direct link from i to j;                           i
  assumed positive

                                        Chapter 5: Network Layer: Routing   #14
                                                                  B     1       C
Distance Table: Example                                   A
                                                              7
Table below shows just one step done by E                          8                2
The algorithm repeats forever!                          10
                                                  E’s             E             D
       dist. tables recv’d  computation        computed                  2
        from neighbors          at E           distance              distance
                                                  table           table E sends
dE ()    A   B    D         A   B     D                           to its neighbors

   A     0   7            10 15                 A: 10                 A: 10

   B     7   0             17 8                 B: 8                  B: 8

  C          1   2            9    4             C: 4                 C: 4

  D              0               2             D: 2                 D: 2

  E      10 8      2                                                    E: 0
                                            Chapter 5: Network Layer: Routing   #15
Distance Table: example
                                                                 cost to destination via
                  B    1     C
             7                                          DE ()      A       B       D
     A             8             2
         1                                                   A     1      14       5
                  E          D
                       2

 E
                                                             B     7        8      5
D (C,D) = c(E,D) + min {DD(C,w)}
                                     w
                 = 2+2 = 4                                   C     6        9      4
 E
D (A,D) = c(E,D) + min {DD(A,w)}
                              w                              D     4      11       2
                 = 2+3 = 5
 E                         loop!
D (A,B) = c(E,B) + min {D B(A,w)}
                                     w
                 = 8+6 = 14
                                     (why not 15?)
                                                     Chapter 5: Network Layer: Routing   #16
Distance table gives routing table
       cost to destination via
   E                                  Outgoing link
  D ()      A     B      D
                                      to use, cost to dest

       A     1   14       5      A         A,1

       B     7     8      5      B         D,5

       C     6     9      4      C         D,4

       D     4   11       2      D         D,2

           Distance table        Routing table

                                 Chapter 5: Network Layer: Routing   #17
Distance Vector Routing: overview
Iterative, asynchronous:         Each node:
   each local iteration caused
   by:
 local link cost change           wait for (change in local link
 message from neighbor: its       cost or msg from neighbor)
   least cost path change
   from neighbor
Distributed:                       recompute distance table
 each node notifies
   neighbors only when its
   least cost path to any          if least cost path to any dest
   destination changes             has changed, notify all
      neighbors then notify       neighbors
       their neighbors if
       necessary
                                   Chapter 5: Network Layer: Routing   #18
Distance Vector Algorithm:

    At all nodes, X:
1 Initialization:
2 for all adjacent nodes v:
3    DX(*,v) = ∞       /* “*” means "for all rows" */
4    DX(v,v) = c(X,v)
5 for all destinations, y
6    send minw DX(y,w) to each neighbor /* w over all X's neighbors */




                                         Chapter 5: Network Layer: Routing   #19
Distance Vector Algorithm (cont.):
   8 loop
   9 wait (until a link cost C(X,V) change to neighbor V
   10      or until receive update from neighbor V)
   11
   12 if (c(X,V) changes by d)
   13 /* change cost to all dest's via neighbor v by adding d */
   14 /* note: d could be positive or negative */
   15 for all destinations y: DX(y,V) = DX(y,V) + d
   16
   17 else if (update received from V wrt destination Y)
   18 /* shortest path from V to some Y has changed */
   19 /* V has sent a new value for its minw DV(Y,w) */
   20 /* call this received new value is "newval" */
   21 for the single destination Y, D X(Y,V) = c(X,V) + newval
   22
   23 if minw DX(Y,w) for any destination Y changed,
   24    send new value of minw DX(Y,w) to all neighbors
   25
   26 forever                             Chapter 5: Network Layer: Routing   #20
Distance Vector Algorithm: example



        Y
    2       1
X               Z     X                              Z
        7            D (Y,Z) = c(X,Z) + minw{D (Y,w)}
                            = 7+1 = 8

                      X                              Y
                     D (Z,Y) = c(X,Y) + minw {D (Z,w)}
                            = 2+1 = 3




                          Chapter 5: Network Layer: Routing   #21
Distance Vector Algorithm: example



        Y
    2       1
X               Z
        7




                       Chapter 5: Network Layer: Routing   #22
 Distance Vector: link cost changes
 Link cost changes:
  node detects local link cost change
                                                  1
  updates distance table (line 15)                       Y
                                                      4        1
  if cost change in least cost path,            X                 Z
    notify neighbors (lines 23,24)                        50
  we show distance to X only
                                                                   algorithm
                                                                   terminates
“good
news                        report 1      report 2
travels
fast”



                                         Chapter 5: Network Layer: Routing   #23
Distance Vector: link cost changes
  Link cost changes:
   good news travels fast                            60
   bad news travels slow -
                                                              Y
                                                          4        1
    “count to infinity” problem!                      X                Z
   we show distance to X only                                50

            Y              Y              Y
                                                                           algorithm
                                                                           continues
                                                                                  on!
                report 6
                               report 7




                                              Chapter 5: Network Layer: Routing     #24
Distance Vector: poisoned reverse
If Z routes through Y to get to X
  (= Z learned its best dist. to X from Y):        60
                                                              Y
 Z tells Y its (Z’s) distance to X is                4            1
  infinite (so Y won’t route to X via Z)          X                    Z
                                                              50
 will this completely solve count to
  infinity problem?
                                                                           algorithm
                  Y          Y           Y                Y
                                                                           terminates




                                       Chapter 5: Network Layer: Routing        #25
Comparison of LS and DV algorithms
Message complexity               Robustness: what happens
 LS: with n nodes, E links,       if router malfunctions?
  O(nE) msgs sent                LS:
 DV: exchange between
                                       node can advertise
  neighbors only
                                        incorrect link cost
    but larger msgs
                                       each node computes only
Speed of Convergence                    its own table
 LS: requires O(nE) msgs        DV:
    may have oscillations             DV node can advertise
 DV: convergence time varies           incorrect path cost
    may have routing loops
                                       each node’s table used by
                                        others
    count-to-infinity problem
                                         • error propagates thru
                                           network
                                    Chapter 5: Network Layer: Routing   #26
Broadcast and Multicast Routing




                  Chapter 5: Network Layer: Routing   #27
   Broadcast Routing
 Deliver packets from source to all other nodes
 Source duplication is inefficient:

                                  duplicate
      duplicate    R1       creation/transmission   R1
                                                              duplicate
                   R2                               R2


             R3         R4                    R3         R4

                source                              in-network
              duplication                           duplication

 Source duplication: how does source
  determine recipient addresses
                                                         Chapter 5: Network Layer: Routing   #28
In-network duplication
 Flooding: when node receives brdcst pckt,
  sends copy to all neighbors
     Problems: cycles & broadcast storm
 Controlled flooding: node only brdcsts pkt
  if it hasn’t brdcst same packet before
   Node keeps track of pckt ids already brdcsted
   Or reverse path forwarding (RPF): A only
    forwards a packet if it arrived on shortest path
    between from source to A
 Spanning tree
   No redundant packets received by any node


                                Chapter 5: Network Layer: Routing   #29
Spanning Tree
 First construct a spanning tree
 Nodes forward copies only along spanning
  tree
              A                               A

                     B                                B
          c                               c

                         D                                D
     F         E                  F            E

                             G                                G
   (a) Broadcast initiated at A   (b) Broadcast initiated at D


                                      Chapter 5: Network Layer: Routing   #30
Spanning Tree: Creation
 Center node
 Each node sends unicast join message to center
  node
      Message forwarded until it arrives at a node already
       belonging to spanning tree

               A                                        A
                       3
                               B                                B
           c                                        c
               4
                           2
                                   D                                 D
       F           E                         F           E
           1                       5
                                       G                                 G
  (a) Stepwise construction                (b) Constructed spanning
      of spanning tree                         tree
                                                 Chapter 5: Network Layer: Routing   #31
Multicast Routing: Problem Statement
 Goal: find a tree (or trees) connecting
  routers having local mcast group members
 tree: not all paths between routers used
  a)   source-based: different tree from each sender to receivers
  b)   shared-tree: same tree used by all group members




          Shared tree          Source-based trees
                                        Chapter 5: Network Layer: Routing   #32
Approaches for building mcast trees
Approaches:
1. source-based tree: one tree per source
   a)   shortest path trees
   b)   reverse path forwarding
2. group-shared tree: group uses one tree
   a) minimal spanning (Steiner)
   b) center-based trees


…we first look at the basic approaches


                                  Chapter 5: Network Layer: Routing   #33
Shortest Path Tree
 mcast forwarding tree: tree of shortest
 path routes from source to all receivers
     Dijkstra’s algorithm

  S: source                               LEGEND
              R1        2
               1            R4                 router with attached
                                               group member
        R2                       5
                                               router with no attached
         3         4
                                     R5        group member
   R3                        6             i   link used for forwarding,
                   R6       R7                 i indicates order link
                                               added by algorithm

                                           Chapter 5: Network Layer: Routing   #34
Reverse Path Forwarding
 rely on router’s knowledge of unicast
  shortest path from it to sender
 each router has simple forwarding behavior:

   if (mcast datagram received on incoming link
    of shortest path from the center)
     then flood datagram onto all outgoing links
    else ignore datagram

 gives broadcastbehavior

                              Chapter 5: Network Layer: Routing   #35
Reverse Path Forwarding: example
S: source
                                LEGEND
            R1
                      R4                router with attached
                                        group member
      R2
                                        router with no attached
                           R5           group member
 R3                                     datagram will be
                 R6   R7                forwarded
                                        datagram will not be
                                        forwarded

• result is a source-specific reverse SPT
   – may be a bad choice with asymmetric links


                                Chapter 5: Network Layer: Routing   #36
Reverse Path Forwarding: pruning
 forwarding tree contains subtrees with no mcast
   group members
     no need to forward datagrams down subtree
     “prune” msgs sent upstream by router with no
      downstream group members

S: source                           LEGEND

            R1                            router with attached
                          R4
                                          group member

      R2                                   router with no attached
                      P                    group member
                                     P
                               R5          prune message
 R3                    P                  links with multicast
                 R6   R7                  forwarding

                                         Chapter 5: Network Layer: Routing   #37
Shared-Tree: Steiner Tree

 Steiner Tree: minimum cost tree
  connecting all routers with attached group
  members
 problem is NP-complete
 excellent heuristics exists
 not used in practice:
   computational complexity
   information about entire network needed
   monolithic: rerun algorithm whenever a router
    needs to join/leave
                               Chapter 5: Network Layer: Routing   #38
Center-based trees
 single delivery tree shared by all
 one router identified as   “center” of tree
 to join:
   edge  router sends unicast join-msg addressed
    to center router
   join-msg “processed” by intermediate routers
    and forwarded towards center
   join-msg either hits existing tree branch for
    this center, or arrives at center
   path taken by join-msg becomes new branch of
    tree for this router
                              Chapter 5: Network Layer: Routing   #39
Center-based trees: an example

Suppose R6 chosen as center:

                                       LEGEND

           R1                                  router with attached
                             R4
                    3                          group member

      R2                                        router with no attached
                         2                      group member
                                        1
                                  R5            path order in which join
                                                messages generated
 R3
                1   R6   R7




                                            Chapter 5: Network Layer: Routing   #40
Hierarchical Routing




           Chapter 5: Network Layer: Routing   #41
Hierarchical Routing
             Our routing study thus far - idealization
              all routers identical
              network “flat”
             … not true in practice

scale: with 200 million       administrative autonomy
  destinations:                internet = network of
 can’t store all dest’s in     networks
  routing tables!              each network admin may
 routing algorithm info        want to control routing in its
  exchange would swamp          own network
  links!

                                    Chapter 5: Network Layer: Routing   #42
Hierarchical Routing
 aggregate routers into         Gateway router
  regions, “autonomous
                                  Direct link to router in
  systems” (AS)
                                   another AS
 routers in same AS run
  same routing protocol
      “intra-AS” routing
       protocol
      routers in different AS
       can run different
       intra-AS routing
       protocols




                                      Chapter 5: Network Layer: Routing   #43
Interconnected ASes

 3c
     3a                                        2c
3b                                        2a
   AS3                                               2b
               1c                              AS2
          1a              1b
               1d               AS1
                                                 Forwarding table is
                                                     configured by both
                                                     intra- and inter-AS
                    Intra-AS
                    Routing
                                  Inter-AS
                                  Routing            routing algorithm
                                                          Intra-AS sets entries
                    algorithm     algorithm
                                                     
                         Forwarding                       for internal dest’s
                                                          Inter-AS & Intra-As
                            table
                                                     
                                                          sets entries for
                                                          external dest’s
                                                Chapter 5: Network Layer: Routing   #44
Inter-AS tasks                       AS1 needs:
  Suppose router in AS1             1. to learn which dests
   receives datagram for                are reachable through
   which dest is outside                AS2 and which
   of AS1                               through AS3
      Router should forward         2. to propagate this
       packet towards one of
                                        reachability info to all
       the gateway routers,
       but which one?                   routers in AS1
                                     Job of inter-AS routing!


           3c
                 3a                              2c
          3b                               2a
               AS3                                    2b
                           1c                   AS2
                      1a        1b
                           1d        AS1
                                           Chapter 5: Network Layer: Routing   #45
Example: Setting forwarding table
in router 1d

 Suppose AS1 learns from the inter-AS
  protocol that subnet x is reachable from
  AS3 (gateway 1c) but not from AS2.
 Inter-AS protocol propagates reachability
  info to all internal routers.
 Router 1d determines from intra-AS
  routing info that its interface I leads to
  the least cost path to 1c.
 Puts in forwarding table the entry (x,I).


                           Chapter 5: Network Layer: Routing   #46
Example: Choosing among multiple ASes
   Now suppose AS1 learns from the inter-AS protocol
    that subnet x is reachable from AS3 and from AS2.
   To configure forwarding table, router 1d must
    determine towards which gateway it should forward
    packets for dest x.
   This is also the job on inter-AS routing protocol !
   Hot potato routing: send packet towards closest of
    two routers.

                          Use routing info                                   Determine from
Learn from inter-AS                             Hot potato routing:       forwarding table the
                           from intra-AS
protocol that subnet                           Choose the gateway        interface I that leads
                       protocol to determine
 x is reachable via                                that has the         to least-cost gateway.
                        costs of least-cost
 multiple gateways                              smallest least cost           Enter (x,I) in
                           paths to each
                          of the gateways                                   forwarding table



                                                       Chapter 5: Network Layer: Routing      #47
Intra-AS and Inter-AS routing
         C.b                                      Gateways:
                                B.a
                                                    •perform inter-AS
                    A.a                             routing amongst
          b               A.c             c         themselves
a    C                           a
                                              b     •perform intra-AS
                     a                B
                                                    routers with other
                d          c                        routers in their
               A     b
                                                    AS
                                          CPU

                                                      network layer
    inter-AS, intra-AS                                link layer
             routing in
           gateway A.c                                  physical layer




                          NIC         Chapter 5: Network Layer: Routing   #48
Intra-AS and Inter-AS routing
                                Inter-AS
               C.b               routing
                                between       B.a
                        A.a     A and B                         Host
                b               A.c                     c         h2
    a      C                                   a
                                                            b
                          a                         B
    Host              d          c             Intra-AS routing
    h1                     b
                     A                         within AS B
                     Intra-AS routing
                     within AS A


   We’ll examine specific inter-AS and intra-AS
    Internet routing protocols shortly

                                           Chapter 5: Network Layer: Routing   #49
                                                          AS D

    Routing: Example                                       d
E
                                 AS A
                                 (OSPF)

                                     a2

    No Export                   a1
F                      i
    to F
                                                               AS C


                                           AS B
                                           (OSPF intra
                                            routing)
                           i2
                                             b




                AS I             Chapter 5: Network Layer: Routing    #50
                                                         AS D

    Routing: Example                                      d
                                                                     d1

E                                                                          d2
                               AS A
                               (OSPF)

                                   a2


F          i
                  How to specify? a1                          AS C


                                          AS B
                                          (OSPF intra
                                           routing)


                                            b




           AS I                 Chapter 5: Network Layer: Routing    #51
Routing in the Internet

 The Global Internet consists of Autonomous Systems
  (AS) interconnected with each other:
      Stub AS: small corporation (single Inter-AS link)
      Multihomed AS: large corporation
                       (several Inter-AS links, no transit)
      Transit AS: service provider


 Two-level routing:
    Intra-AS: administrator is responsible for choice
    Inter-AS: unique standard




                                        Chapter 5: Network Layer: Routing   #52
Internet AS Hierarchy
  Inter-AS : border (exterior gateway) routers




Intra-AS : interior (gateway) routers

                                 Chapter 5: Network Layer: Routing   #53
Intra-AS Routing

 Also known as Interior Gateway Protocols (IGP)
 Most common IGPs:

      RIP: Routing Information Protocol
      OSPF: Open Shortest Path First

      IGRP: Interior Gateway Routing Protocol (Cisco
       proprietary)




                                  Chapter 5: Network Layer: Routing   #54
RIP ( Routing Information Protocol)

 Distance vector algorithm
 RIP messages sent using UDP
 Included in BSD-UNIX Distribution in 1982
 Distance metric: # of hops (max = 15 hops)
    why?



 Distance vectors: exchanged every 30 sec via
  Response Message (also called advertisement)
 Each advertisement: route to up to 25 destination
  nets
      may need several advertisements to each neighbor

                                      Chapter 5: Network Layer: Routing   #55
RIP (Routing Information Protocol)

                                                                        z
w               x                              y
          A            D             B

                       C
Destination Network   Next Router         Num. of hops to dest.
      w                    A                           2
      y                    B                           2
      z                    B                           7
      x                    --                          1
      ….                   ….                          ....
                      Routing table in D
                                    Chapter 5: Network Layer: Routing   #56
RIP: Link Failure and Recovery

If no advertisement heard after 180 sec -->
  neighbor/link declared dead
    routes via neighbor invalidated
    new advertisements sent to neighbors
    neighbors in turn send out new advertisements (if
     tables changed)
    link failure info quickly propagates to entire net
    poison reverse used to prevent ping-pong loops
     (infinite distance = 16 hops)




                                 Chapter 5: Network Layer: Routing   #57
OSPF (Open Shortest Path First)

 “open”: publicly available
 Uses Link State algorithm
    LS packet dissemination
    Topology map at each node
    Routes computed locally, using Dijkstra’s algorithm

 OSPF advertisement messages:
   Hello looks for active OSPF routers on a link (sent to
    neighbors only)
   DB Description shows whole AS topology; sent to new router
   Link State Update shows changes of link costs local to
    sender;
 LSU Advertisements flooded to all routers in AS
 Sent on status change or every 30 min.
                                      Chapter 5: Network Layer: Routing   #58
OSPF “advanced” features (not in RIP)

 Security: all OSPF messages authenticated (to
  prevent malicious intrusion); TCP connections used
 Multiple same-cost paths allowed
      only one path in RIP
 For each link, multiple cost metrics for different
  ToS (eg, satellite link cost set “low” for best effort;
  high for real time)
 Integrated uni- and multicast support:
      Multicast OSPF (MOSPF) uses same topology data base as
       OSPF
 Hierarchical OSPF in large domains.


                                     Chapter 5: Network Layer: Routing   #59
Hierarchical OSPF




                    Chapter 5: Network Layer: Routing   #60
Hierarchical OSPF
 Two-level hierarchy: local area, backbone area.
      link-state advertisements only inside area
   Internal routers: have detailed topology each of its
    own area only
   Area border routers: “summarize” distances to nets
    in own area, advertise to other Area Border routers;
    hold condensed DB of all local areas, detailed DB of
    the backbone area.
   Backbone routers: run OSPF routing limited to
    backbone.
   Boundary routers: connect to other ASs.

                                  Chapter 5: Network Layer: Routing   #61
IGRP (Interior Gateway Routing Protocol)

 CISCO proprietary; successor of RIP (mid 80s)
 Distance Vector, like RIP
 several cost metrics (delay, bandwidth, reliability,
  load etc)
 uses TCP to exchange routing updates
 Loop-free routing via Distributed Updating Alg.
  (DUAL) based on diffused computation




                                  Chapter 5: Network Layer: Routing   #62
Inter-AS routing




                   Chapter 5: Network Layer: Routing   #63
Internet inter-AS routing: BGP

 BGP (Border Gateway Protocol):   the de facto
  standard
 Path Vector protocol:
    similar to Distance Vector protocol
    each Border Gateway broadcast to neighbors
     (peers) entire path (i.e., sequence of ASs) to
     destination
    E.g., Gateway X may send its path to dest. Z:


            Path (X,Z) = X,Y1,Y2,Y3,…,Z


                                 Chapter 5: Network Layer: Routing   #64
Internet inter-AS routing: BGP
Suppose: gateway X sends its path to peer gateway W
 W may or may not select path offered by X
    cost, policy (don’t route via competitor’s AS), loop
     prevention reasons.
 If W selects path advertised by X, then:
                 Path(W,Z) = W, Path(X,Z)
 Note: X can control incoming traffic by controlling its
  route advertisements to peers:
    e.g., don’t want to route traffic to Z -> don’t
     advertise any routes to Z


                                 Chapter 5: Network Layer: Routing   #65
Internet inter-AS routing: BGP
 BGP messages exchanged using TCP.
 BGP messages:
   OPEN: opens TCP connection to peer and
    authenticates sender
   UPDATE: advertises new path (or withdraws old)
   KEEPALIVE indicates that a connection is alive in
    absence of UPDATES; also ACKs OPEN request
   NOTIFICATION: reports errors in received msg;
    also used to close connection



                               Chapter 5: Network Layer: Routing   #66
Why different Intra- and Inter-AS routing ?

Policy:
 Inter-AS: admin wants control over how its traffic
  routed, who routes through its net
      due to e.g. commercial, political, price concerns
 Intra-AS: single admin, so no policy decisions needed
Scale:
 hierarchical routing saves table size, reduced update
  traffic
Performance:
 Intra-AS: can focus on performance
 Inter-AS: policy may dominate over performance
                                         Chapter 5: Network Layer: Routing   #67

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:2
posted:10/25/2012
language:English
pages:67