动态路由协议 RIP协议（正篇）

RIP 版本 ：

                     RIPv1 ;                          RIPv2;                         RIPNG;

                #   RIP  一共三个版本  （ RIP v1 ,  RIPv2,  RIPNG ）

                #   v1,v2 主要是服务于  IPV4 协议，    RIPNG 服务于 IPV6 

                #   RIPv1  和 RIPv2 的区别 ：

                     *     RIPv1 是有类别的路由协议；  RIPv2 是无类别的路由协议 

                            有类无类上篇文章也提到过！

                            有类别 ：  就是 不携带掩码，没有掩码，按照 A类、B类、主类

                            无类别 :     就是我们主流的表示，携带掩码！！  

                 

                     *     RIPv1 不支持手工认证，      RIPv2 支持手工认证

                            我们动态路由协议不是需要路由器之间相互沟通交流，那势必存在信息的传递

                            交流，那也避免不了存在安全问题！

                            那么为了预防安全问题，我们就设置一种 “ 口令  ” 就像暗号，两边设备可以提前

                            设置一个 暗号，（只有两台设备知道的暗号） 发送信息时，就把 暗号带上，当

                            接受时便查看暗号，暗号正确了，便信任该流量包！！  

                   

                   *      RIPv1 采用广播形式发送信息，   RIPv2 以组播形式 

                           组播地址 ：  224.0.0.9 （ 224 开头的都是组播地址！）

             #     RIP 的封装 ：

                    RIP 本身是一个应用层协议，所以封装它，其传输层（ 使用的是 520 端口）

                    RIP 使用的是 UDP  520 端口进行传输信息的！！

RIP 的更新机制 ：

        先了解下  RIP 的数据包 ：

              ===>>>  

                            request 包  ：  请求包 

                         response 包  ：  应答包  （ 它则携带路由信息 ）

        RIP 在收敛完成后仍然会 每隔 30 秒 发送一个 response 包 ----  这种行为称之为 周期更新！ 

        那么，为什么要每隔 30 s 还发送一个包（ 周期更新 ）

        ===>>>  RIP 使用的是 UDP 协议 （ UDP 的特点就是 不可靠 ）

                       而我们收集路由信息是需要 可靠的！！！ 但是，RIP 使用的就是 UDP 协议（ 不可

                       靠），那怎么办 ？？

                       只能靠 RIP 协议自己去 补偿可靠性！！所以 RIP 就得不停发，不停发！

                       实际上，RIP  周期更新的目的 就是为了补偿 自身没有确认机制 和 保活机制 保证数

                       据传输的可靠性

                        保活机制 ：  就是 为了证明自己还在（ 就是这台设备 还可以进行通讯 ） 

RIP  的计时器  ： 

        更新计时器  ：   30 S 

        失效计时器  ：   180  S 

                         #       在前面讲过，RIP 周期更新有一个目的就是 保活机制 ，既然有保活机制，

                                     那么，势必就要做时效判断，（ 保活机制是不是就是如果没有收到对方给

                                     自己发来的信息就会判断对方死亡了； 但是，也不不能太草率，不能人家

                                     一没给你发信息，你就断定对方死亡，你得给人家时间呀，你得稍微多等

                                     一会儿，再确定它是否真正的死亡！！）

                           #        因此，无效计时器主要作用就是做 时效判断的！！

                                    （ 就是 什么时候判定他无效！！）

                           #         那这个计时器 是给谁计时呢？？

                                      是给 具体的路由条目 计时的！！！！（ 并不是给 路由器计时！）

                                      路由条目一旦在路由表中刷新就直接开始  180 S 倒计时！！

                                      怎么刷新？？

                                       ===>>>   BellFord 算法 里的刷新； 你路由表如果收到了新的路由条目，

                                                       不就直接记录在路由表里了嘛，那记录后一边就开始 180 S 倒

                                                       计时，另一边 你这个新的路由条目的发送者不也得 进行 30 S

                                                       的 周期更新！！ （ 周期更新的话，不就得 给路由表发路由条

                                                       目，一发路由条目就得更新，一更新就得重新 180 S 倒计时）

                             #       路由条目刷新后会启动 180 S 的计时器，若 180 S 结束，路由条目未刷

                                      新则认定该目标网段不可达（意思就是这个网段去不了了），将该路由条

                                      目从全局路由表中删除，并且COST 值 改为 16 ，将其保存在 缓存表中，

                                    （ 然后启动垃圾收集计时器，120秒倒计时） 之后周期更新时携带！！ 

                                    （ 你会发现 COST 值怎么改为 16 了，我们前面不是讲过 COST 值最大

                                      为 15）      

                                       那最大值 为 15 ，现在给你改为 16 意思就是  这个网段不可达！！

                                       保存在缓存中并且周期更新还携带着（ 那么，为什么还要携带？）

                                       因为 RIP 只有更新包，也就是说 RI 只能告诉别人能去哪儿，并不能告诉

                                       别人不能去哪，所以 它就把 COST 值改为 16 你收到后，一看现在能去一

                                       个网段，但是它的 COST 是 16，所以接受的那个设备就知道这个网段是

                                       不可达的！！！  （ 这就叫 带毒传输 ）

                                       

                                        综上 ： 180 秒到了之后，不会彻底删除这条路由，在缓存中存储，然后

                                                      进行带毒传输，（会携带一段时间）

                                         那么，带毒传输，要携带多长时间呢？？

                                                            120 秒！！

                                                                 

        垃圾收集计时器 ：   120 秒 

 同步更新 与 异步更新：

                      同步更新 ：   就是网络范围内，所有路由器都是同时开始 30 S 计时，也必然会同时

                                            发送数据！！

                                            造成的结果就是 ： 每到 30 秒的时候 网络就会特别特别卡！！

                                            所以 RIP 的周期更新 肯定不是 同步周期更新！！！

                      异步更新 ：   就是各个设备都把时间岔开了，就与 同步是个 相反的！！

                                            所以， RIP 的周期更新一定是  异步周期更新！！

RIP 成环问题 ：

                      

         就是因为 RIP  的异步更新，就使得 成环必然   ：

               

           上示 ： 就是向大家展示下 两台路由器 通过 RIP 协议 异步周期相互通讯的过程； 

                        两台 路由器 R1 ,R2    R2 有两个网段 （ 2.2.2.0/24;  3.3.3.0/24）

                        现在假设R1 的路由表里已经有 R2 的两个网段！

                        那么，现在开始推演 ：

                                    正常情况下， R2 每隔 30 S 要给 R1 发送 周期更新包，那周期更新包里肯

                                    定也会携带着 2.0/24 cost =1 , 3.0/24  cost =1  （ 这两个信息来到 R1 

                                    R1 也会把这两条信息 再重新抄一遍 -- 因为和自己路由表上的信息一样啊，

                                    其实对R1 的影响不大，只是刷新了计时器而已）

                                    那么， R1 是不是肯定也会 每隔 30 S 进行 周期更新 也会发给 R2 数据包

                                    （ 2.0/24  cost = 2, 3.0/24 cost = 2） 是的， cost 变为 2 了（ 加一 ）

                                    但是，R2 收到后，依据BellFord 算法， 发来的 cost 值  比本地的 cost 值

                                    大，所以不刷新！！ 

                                    以此往复！！！！ （ 各个设备 周期更新 30 S  相互沟通交流）

                                    

                                    现在有个特殊情况， 假设 R2 的 3.0 网段 突然断开了，当然， R2 肯定是

                                    感知最快的，那 R2 就会 把这个 3.0 网段 的路由条目 cost 值 改为 16，放

                                    到缓存中，然后周期更新携带的时候再发给其它设备，告诉其它设备 3.0 网

                                    段现在去不了了。

                                    但是，由于是 异步周期，就会存在一个情况 ：

                                     R2 的周期更新时间还没到，但是 R1 的周期更新时间却到了，也就是说，

                                     R2 想要告诉 其它设备 3.0 网段 去不了的这条消息还没发出去，R1 的周期

                                     更新包（3.0/24 cost =2, 3.0/24 cost = 2）已经传给 R2 了；

                                      那么，对于 R2 来说， R2 会咋想 ？？？

                                      由于 BellFord 算法知 ：  

                                                        其实，对于 R2 来说， 2.0 这个网段没啥好想的，cost 值没有

                                                        R2 本地的小，不刷新，但是，对于 3.0 网段来说，cost 值要

                                                        比本地 16 小，所以 R2 就会认为，它自己（R2）去不了 3.0

                                                        网段，但是 R1 可以去，所以，R2 关于 3.0 网段就会更新路由

                                                        更新为 3.0/24    cost = 2   下一跳 是 R1 

                                      那么，真要是有个数据包是要去 3.0 网段 发给了 R2 ，那么，R2 必然会

                                      把 数据发给 R1 ， 而 R1 收到后，查自己路由表看看有没有 去往 3.0 网段

                                      一查诶，还真有是去往 R2 的，又接着把数据发给了 R2 。

                                      那这不问题就出来了，出环了！！

RIP 的破环机制  ： 

                    首先，虽然 出环的根本是在 异步周期，但是，解决环路可不能通过 将 异步周期改为

                    同步周期方面去想！！

                    大家仔细想想，刚才出现环路最最前期的时候，是不是 R2 已经感知到了 自己的 3.0

                    网段已经断开了，不能用了，正准备给 其它设备通过 周期更新 说这件事儿，结果

                    R1 的周期更新时间到了，给自己（ R2 ） 发了数据包-----这其实才是 出环的最最根

                    本原因

                     

                     那我们现在就想，R2 你能不能别等了（ 你之所以没把 3.0 网段消息发出去，是因为

                     你一直在等 周期更新时间 ）  也就是说 R2 没有第一时间，没有 3.0 网段刚一出现问

                     题就第一时间告诉其它设备；   

                     所以，我们就想 当拓扑发生变化时，设备应该第一时间就将消息发出--  触发更新！ 

                     我们前面说过  一个协议的好坏是 ：

                                               1.    收敛快

                                               2.    占用资源少

                                               3.    选路佳（ 无环 ）

                      其实，触发更新就是破环的最核心机制，它就是拓扑中，那个链路或设备一出现问

                      题，就立刻，马上发消息给其它设备，让所有设备都知道（ 这就是 收敛快！！）

       

                     那么，大家再思考下，触发更新 能彻彻底底完全解决 环路嘛？？

                     ===>>>      不能！！ （ 这次的不能有点 勉强的成分 在里面 ）

                                        但是，这次不能的情况是特别特别  就是扣时间的！！

                                        就是说，当 R2 一收到 3.0 网段无法到达的消息，马上给其它设备发通知

                                        就偏偏有一种情况，就偏偏在 R2 发出去的前 万分之一秒， R2 收到了 

                                        R1 的数据包 （ 也就是说，还是没能赶上时间 ） 在 R2 发 3.0 网段断掉

                                       之前收到了 R1 的更新包！！

                                        

                                        也就是说， 触发更新 能解决大部分情况，并不能完全解决 出环问题，

                                        所以，还得几个帮手 一起 破环！！！

        水平分割 ：     从此口进的路由，不许再从此口出 

                                 在介绍水平分割前，先回想下环路产生的原因，想想那个过程！

                                 我们先不谈 拓扑发生变化时怎么样，先谈谈就正常情况下的运转 ：

                                  

                                  看上图， 三台路由器相互通讯， 当他们相互沟通后， 1 ，2,  3 的路由表就

                                  都有了 5 条路由 ，好！ 它们现在各自都有整个拓扑的网段！

                                

                                  那对于 R1 来说它的路由表有 1,2,3,4,5 个网段也就是5条路由 ，它的 1  ,2 网

                                  段是跟自己直连的， 就是自己路由表本身就有的路由条目， 那么对于 3,4,5

                                  网段来说，则是通过 R2 的 2.2 接口来传给 R1，才使得 R1 的路由表齐全了

                                  整个拓扑的所有网段！！

                                  好，现在来看看周期更新 :

                                  三台设备之间要互相传 路由表，那问题就来了 ：

                                  真的是需要把路由表里所有的内容都扔给别人嘛？？？？？

                                   你再看上面说的 R1 ， 对于 R1 说 3,4,5 是 R2 给 R1 的，当周期更新时，

                                   R1你又把 3,4,5  扔给 R2 （ 因为是整张路由表传给别人呀！） ，所以，这

                                  不就是问题嘛，3,4,5 是R2 给R1 ，的 你 R1 又把 3,4,5 扔给 R2 这就是问

                                  题！!!!      

                                  R2  都能 把 3,4,5 发给 R1 ， 人家 R2 的路由表里会没有 3,4,5？？？

                                  所以，这个行为其实本身就有问题 ！！

                                  一个 增加了链路资源，一方面 也极有可能导致出环啊！！

                                   

                                   因此，这个时候就需要 水平分割 站出来了！！（ 从此口进，不从此口出）

                                   3,4,5 是从 R2 的2.2接口发给 R1 的，所以在进行周期更新的时候，R1 只需

                                   要将 1,2 网段发给 R2 就好（ 实质上R1 都只需要将 1 这个网段发给 R2 就

                                   好，因为 2 这个网段是和R1 , R2 直连的）

                                   所以，按道理只需要将 不是你给我的和不是我和你直连的网段发给你就行!

                             

                                   那这个机制一出现还有没有坏 ？？

                                   其实，对于上示的直线型拓扑是不会再出现环路的，但是，我们所学习的拓

                                   扑类型也有很多种啊，还有 环形，多环形等等

                                   对于多环形就不行了, 还是会出环的！！

                                   因为，多环形它的路很多啊，会绕回到原点又出环了！！

                                   所以， 水平分割仅限于直线型拓扑防环！！   

                                   那水平分割就仅仅只有这一个作用嘛？？-- 就防环作用？？？

                                   其实 水平分割有一个很重要的作用 ：

                                   请看 ：

                                    

                                    上示拓扑， 1 上有一个 环回，那么 1 就会把这个环回告诉 2吧？ 2呢？

                                     2 也会把这个环回告诉 3 ，这是我们学习过的内容！！

                                     所以，我们得出一个结论 ： 就是一旦我从我的邻居A那里学到一个路由我

                                     就会把这个学来的路由再共享给我的 B 邻居！！

                                    但是呢，网络中有一种比较特殊的情况，我们叫做 MA 网络 - 多路访问网络

                                    示例  ：

                                   

                                   上示就是一个多路访问网络，就是一个网段里有多个路由器（上示就是一个

                                   广播域）

                                   上示呢， 1 上还有一个 环回，1要把环回往下发的时候会以 广播或者组播的

                                   形式往下发，那么发下来就会被交换机洪泛，也就是说 下面的2,3,4,5 路由

                                   器都会收到来自 1 的数据包，就是等于 2,3,4,5 对于 1 而言都是 邻居！

                                   好，问题来了 ：

                                   上示图呢，对于1来说 2,3,4,5 都是 1 的邻居，而对于 2 来说呢 1,3,4,5 也是

                                   2 的邻居，同理，对于3，对于4，对于5都是一个道理！！

                                   那意味着什么呢 ？？

                                   拿 2 来说， 当2自己 收到 了 来自1 的数据包，对于2来说 这就是个新的路

                                   由，2 也会 把 1 发给它 路由 再 发给 3,4,5 同理，但是，3,4,5已经收到了来

                                   自1 的数据包啊，以此类推，就会出现大量的重复性更新！！！

                                   这时， 想想 水平分割！！！！

                                   从此口进的路由不许再从此口出，也就是说当 1 发给 下面四个路由器，下面

                                   四个就没有资格再往回发了，只能往自己下面发，这样就没有重复了！！

                                   这才是 水平分割的核心意义！！

                                   水平分割 主要用于避免 MA 网段中的重复更新问题！！ 

                        

                                   

                                                                      

        毒性逆转水平分割 ：     从那个口学来的还从那个口出 ，但是必须得带毒 

                                               你刚看到这个机制，你肯定就会好奇，为什么叫 毒性逆转。。。

                                               就会觉得这个名字一定有背后的秘密！！

                                                

                                               当时在发明 RIP 协议时，仅仅只发明了更新包，就是只能发出消息

                                               告诉邻居我能到哪！！  而不能给邻居发消息说 我不能到哪！！

                                               就是没法告诉邻居 说我不能到那个网段！！

                                               所以，发明 RIP 协议这个人就想了一种方法，

                                               由于它不能表达不能到那去，举个例子就是 ： 我只能告诉你我有什

                                               么吃的，没法告诉你我没有吃的 !

                                               所以，我就告诉你我有一瓶耗子药你要不要！！！

                                               你肯定不要啊，耗子药不就有毒嘛，谁能吃耗子药呢？？？

                                               所以你收到后就会知道我其实是没有吃的！！！

                                               具体举例 ：

                                                我告诉你我能到 1.0 网段，但是要 16 跳，你要不要？？

                                                （ RIP 最大跳数才是 15 跳 ，你现在告诉我 16 跳，当我收到后自

                                                  然就明白，1.0 网段是到不了的！！）   

                                                这就叫   毒性  ！！！！

                                            那逆转是什么呢 ？？

                                             那么当收到 16 跳的这台路由器，是否收到了，给它发的路由器知不

                                             知道？？ 不知道啊！！！  又没有确认机制！！！

                                             所以 ，收到 16 跳的路由器 还会把 16 跳的这条路由再返回去，再返

                                             给发给它的路由器以此来告诉  收到了这条路由 ！！！！

                                              因为水平分割是 从此口出 不许再从此口入，但，实际上还是可以 返

                                              回一次的！！

                                             这个  行为就是 逆转水平分割！！

                                               

       

        看得出来 水平分割 和 毒性逆转 是矛盾的，一个让从口出，一个不让从口出，所以只能 二选

        一，华为设备默认开启的是水平分割，如果水平分割和毒性逆转同时开启，华为设备则按照

        毒性逆转的方式进行！！​​​​​​​