2. cnp3-ebook
3. principles/network
4. English
5. Zen

154 ../../principles/dv.rst:301
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Routers `A` and `D` exchange distance vectors with increasing costs until these costs reach :math:`\infty`. This problem may occur in other scenarios than the one depicted in the above figure. In fact, distance vector routing may suffer from count to infinity problems as soon as there is a cycle in the network. Unfortunately, cycles are widely used in networks since they provide the required redundancy to deal with link and router failures. To mitigate the impact of counting to infinity, some distance vector protocols consider that :math:`16=\infty`. Unfortunately, this limits the metrics that network operators can use and the diameter of the networks using distance vectors. 683/10000 · 683
155 ../../principles/dv.rst:306
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This count to infinity problem occurs because router `A` advertises to router `D` a route that it has learned via router `D`. A possible solution to avoid this problem could be to change how a router creates its distance vector. Instead of computing one distance vector and sending it to all its neighbors, a router could create a distance vector that is specific to each neighbor and only contains the routes that have not been learned via this neighbor. This could be implemented by the following pseudocode. 510/10000 · 510
156 ../../principles/dv.rst:323
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This technique is called `split-horizon`. With this technique, the count to infinity problem would not have happened in the above scenario, as router `A` would have advertised :math:`[A=0]` after the failure, since it learned all its other routes via router `D`. Another variant called `split-horizon with poison reverse` is also possible. Routers using this variant advertise a cost of :math:`\infty` for the destinations that they reach via the router to which they send the distance vector. This can be implemented by using the pseudo-code below. 550/10000 · 550
157 ../../principles/dv.rst:341
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Unfortunately, split-horizon is not sufficient to avoid all count to infinity problems with distance vector routing. Consider the failure of link `A-B` in the four routers network shown below. 192/10000 · 192
158 ../../principles/dv.rst:407
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — After having detected the failure, router `B` sends its distance vectors: 73/10000 · 73
159 ../../principles/dv.rst:409
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — :math:`[A=\infty,B=0,C=\infty,E=1]` to router `C` 49/10000 · 49
160 ../../principles/dv.rst:410
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — :math:`[A=\infty,B=0,C=1,E=\infty]` to router `E` 49/10000 · 49
161 ../../principles/dv.rst:412
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — If, unfortunately, the distance vector sent to router `C` is lost due to a transmission error or because router `C` is overloaded, a new count to infinity problem can occur. If router `C` sends its distance vector :math:`[A=2,B=1,C=0,E=\infty]` to router `E`, this router installs a route of distance `3` to reach `A` via `C`. Router `E` sends its distance vectors :math:`[A=3,B=\infty,C=1,E=1]` to router `B` and :math:`[A=\infty,B=1,C=\infty,E=0]` to router `C`. This distance vector allows `B` to recover a route of distance `4` to reach `A`. 545/10000 · 545
162 ../../principles/dv.rst:417
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Forwarding tables versus routing tables 39/10000 · 39
163 ../../principles/dv.rst:419
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Routers usually maintain at least two data structures that contain information about the reachable destinations. The first data structure is the `routing table`. The `routing table` is a data structure that associates a destination to an outgoing interface or a nexthop router and a set of additional attributes. Different routing protocols can associate different attributes for each destination. Distance vector routing protocols will store the cost to reach the destination along the shortest path. Other routing protocols may store information about the number of hops of the best path, its lifetime or the number of sub paths. A `routing table` may store different paths towards a given destination and flag one of them as the best one. 741/10000 · 741
164 ../../principles/dv.rst:421
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The `routing table` is a software data structure which is updated by (one or more) routing protocols. The `routing table` is usually not directly used when forwarding packets. Packet forwarding relies on a more compact data structure which is the `forwarding table`. On high-end routers, the `forwarding table` is implemented directly in hardware while lower performance routers will use a software implementation. A `forwarding table` contains a subset of the information found in the `routing table`. It only contains the nexthops towards each destination that are used to forward packets and no attributes. A `forwarding table` will typically associate each destination to one or more outgoing interface or nexthop router. 725/10000 · 725
165 ../../principles/linkstate.rst:9
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Link state routing 18/10000 · 18
166 ../../principles/linkstate.rst:11
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Link state routing is the second family of routing protocols. While distance vector routers use a distributed algorithm to compute their routing tables, link-state routers exchange messages to allow each router to learn the entire network topology. Based on this learned topology, each router is then able to compute its routing table by using a shortest path computation such as Dijkstra's algorithm [Dijkstra1959]_. A detailed description of this shortest path algorithm may be found in [Wikipedia:Dijkstra]_. 511/10000 · 511
167 ../../principles/linkstate.rst:13
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — For link-state routing, a network is modeled as a `directed weighted graph`. Each router is a node, and the links between routers are the edges in the graph. A positive weight is associated to each directed edge and routers use the shortest path to reach each destination. In practice, different types of weights can be associated to each directed edge : 354/10000 · 354
168 ../../principles/linkstate.rst:15
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — unit weight. If all links have a unit weight, shortest path routing prefers the paths with the least number of intermediate routers. 132/10000 · 132
169 ../../principles/linkstate.rst:16
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — weight proportional to the propagation delay on the link. If all link weights are configured this way, shortest path routing uses the paths with the smallest propagation delay. 176/10000 · 176
170 ../../principles/linkstate.rst:17
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — :math:`weight=\frac{C}{bandwidth}` where `C` is a constant larger than the highest link bandwidth in the network. If all link weights are configured this way, shortest path routing prefers higher bandwidth paths over lower bandwidth paths. 239/10000 · 239
171 ../../principles/linkstate.rst:19
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Usually, the same weight is associated to the two directed edges that correspond to a physical link (i.e. :math:`R1 \rightarrow R2` and :math:`R2 \rightarrow R1`). However, nothing in the link state protocols requires this. For example, if the weight is set in function of the link bandwidth, then an asymmetric ADSL link could have a different weight for the upstream and downstream directions. Other variants are possible. Some networks use optimization algorithms to find the best set of weights to minimize congestion inside the network for a given traffic demand [FRT2002]_. 579/10000 · 579
172 ../../principles/linkstate.rst:24
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — When a link-state router boots, it first needs to discover to which routers it is directly connected. For this, each router sends a HELLO message every `N` seconds on all its interfaces. This message contains the router's address. Each router has a unique address. As its neighboring routers also send HELLO messages, the router automatically discovers to which neighbors it is connected. These HELLO messages are only sent to neighbors that are directly connected to a router, and a router never forwards the HELLO messages that it receives. HELLO messages are also used to detect link and router failures. A link is considered to have failed if no HELLO message has been received from a neighboring router for a period of :math:`k \times N` seconds. 751/10000 · 751
173 ../../principles/linkstate.rst:52
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Once a router has discovered its neighbors, it must reliably distribute all its outgoing edges to all routers in the network to allow them to compute their local view of the network topology. For this, each router builds a `link-state packet` (LSP) containing the following information: 286/10000 · 286