开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
rip_zebra.c
资源名称：zebra-0.95a.tar.gz　[点击查看]
上传用户：xiaozhuqw
上传日期：2009-11-15
资源大小：1338k
文件大小：18k
源码类别：

网络

开发平台：

Unix_Linux

rip_zebra.c：源码内容
  1. /* RIPd and zebra interface.
  2.  * Copyright (C) 1997, 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
  3.  *
  4.  * This file is part of GNU Zebra.
  5.  *
  6.  * GNU Zebra is free software; you can redistribute it and/or modify it
  7.  * under the terms of the GNU General Public License as published by the
  8.  * Free Software Foundation; either version 2, or (at your option) any
  9.  * later version.
  10.  *
  11.  * GNU Zebra is distributed in the hope that it will be useful, but
  12.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18.  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19.  * 02111-1307, USA.  
  20.  */
  22. #include <zebra.h>
  24. #include "command.h"
  25. #include "prefix.h"
  26. #include "stream.h"
  27. #include "routemap.h"
  28. #include "zclient.h"
  29. #include "log.h"
  30. #include "ripd/ripd.h"
  31. #include "ripd/rip_debug.h"
  33. /* All information about zebra. */
  34. struct zclient *zclient = NULL;
  36. /* Callback prototypes for zebra client service. */
  37. int rip_interface_add (int, struct zclient *, zebra_size_t);
  38. int rip_interface_delete (int, struct zclient *, zebra_size_t);
  39. int rip_interface_address_add (int, struct zclient *, zebra_size_t);
  40. int rip_interface_address_delete (int, struct zclient *, zebra_size_t);
  41. int rip_interface_up (int, struct zclient *, zebra_size_t);
  42. int rip_interface_down (int, struct zclient *, zebra_size_t);
  44. /* RIPd to zebra command interface. */
  45. void
  46. rip_zebra_ipv4_add (struct prefix_ipv4 *p, struct in_addr *nexthop, 
  47.     u_int32_t metric, u_char distance)
  48. {
  49.   struct zapi_ipv4 api;
  51.   if (zclient->redist[ZEBRA_ROUTE_RIP])
  52.     {
  53.       api.type = ZEBRA_ROUTE_RIP;
  54.       api.flags = 0;
  55.       api.message = 0;
  56.       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
  57.       api.nexthop_num = 1;
  58.       api.nexthop = &nexthop;
  59.       api.ifindex_num = 0;
  60.       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
  61.       api.metric = metric;
  63.       if (distance && distance != ZEBRA_RIP_DISTANCE_DEFAULT)
  64. {
  65.   SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
  66.   api.distance = distance;
  67. }
  69.       zapi_ipv4_add (zclient, p, &api);
  71.       rip_global_route_changes++;
  72.     }
  73. }
  75. void
  76. rip_zebra_ipv4_delete (struct prefix_ipv4 *p, struct in_addr *nexthop, 
  77.        u_int32_t metric)
  78. {
  79.   struct zapi_ipv4 api;
  81.   if (zclient->redist[ZEBRA_ROUTE_RIP])
  82.     {
  83.       api.type = ZEBRA_ROUTE_RIP;
  84.       api.flags = 0;
  85.       api.message = 0;
  86.       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
  87.       api.nexthop_num = 1;
  88.       api.nexthop = &nexthop;
  89.       api.ifindex_num = 0;
  90.       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
  91.       api.metric = metric;
  93.       zapi_ipv4_delete (zclient, p, &api);
  95.       rip_global_route_changes++;
  96.     }
  97. }
  99. /* Zebra route add and delete treatment. */
  100. int
  101. rip_zebra_read_ipv4 (int command, struct zclient *zclient, zebra_size_t length)
  102. {
  103.   struct stream *s;
  104.   struct zapi_ipv4 api;
  105.   unsigned long ifindex;
  106.   struct in_addr nexthop;
  107.   struct prefix_ipv4 p;
  108.   
  109.   s = zclient->ibuf;
  110.   ifindex = 0;
  111.   nexthop.s_addr = 0;
  113.   /* Type, flags, message. */
  114.   api.type = stream_getc (s);
  115.   api.flags = stream_getc (s);
  116.   api.message = stream_getc (s);
  118.   /* IPv4 prefix. */
  119.   memset (&p, 0, sizeof (struct prefix_ipv4));
  120.   p.family = AF_INET;
  121.   p.prefixlen = stream_getc (s);
  122.   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
  124.   /* Nexthop, ifindex, distance, metric. */
  125.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
  126.     {
  127.       api.nexthop_num = stream_getc (s);
  128.       nexthop.s_addr = stream_get_ipv4 (s);
  129.     }
  130.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
  131.     {
  132.       api.ifindex_num = stream_getc (s);
  133.       ifindex = stream_getl (s);
  134.     }
  135.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
  136.     api.distance = stream_getc (s);
  137.   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
  138.     api.metric = stream_getl (s);
  140.   /* Then fetch IPv4 prefixes. */
  141.   if (command == ZEBRA_IPV4_ROUTE_ADD)
  142.     rip_redistribute_add (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex, &nexthop);
  143.   else 
  144.     rip_redistribute_delete (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex);
  146.   return 0;
  147. }
  149. void
  150. rip_zclient_reset ()
  151. {
  152.   zclient_reset (zclient);
  153. }
  155. /* RIP route-map set for redistribution */
  156. void
  157. rip_routemap_set (int type, char *name)
  158. {
  159.   if (rip->route_map[type].name)
  160.     free(rip->route_map[type].name);
  162.   rip->route_map[type].name = strdup (name);
  163.   rip->route_map[type].map = route_map_lookup_by_name (name);
  164. }
  166. void
  167. rip_redistribute_metric_set (int type, int metric)
  168. {
  169.   rip->route_map[type].metric_config = 1;
  170.   rip->route_map[type].metric = metric;
  171. }
  173. int
  174. rip_metric_unset (int type,int metric)
  175. {
  176. #define DONT_CARE_METRIC_RIP 17  
  177.   if (metric != DONT_CARE_METRIC_RIP &&
  178.       rip->route_map[type].metric != metric)
  179.     return 1;
  180.   rip->route_map[type].metric_config = 0;
  181.   rip->route_map[type].metric = 0;
  182.   return 0;
  183. }
  185. /* RIP route-map unset for redistribution */
  186. int
  187. rip_routemap_unset (int type,char *name)
  188. {
  189.   if (! rip->route_map[type].name ||
  190.       (name != NULL && strcmp(rip->route_map[type].name,name)))
  191.     return 1;
  193.   free (rip->route_map[type].name);
  194.   rip->route_map[type].name = NULL;
  195.   rip->route_map[type].map = NULL;
  197.   return 0;
  198. }
  200. /* Redistribution types */
  201. static struct {
  202.   int type;
  203.   int str_min_len;
  204.   char *str;
  205. } redist_type[] = {
  206.   {ZEBRA_ROUTE_KERNEL,  1, "kernel"},
  207.   {ZEBRA_ROUTE_CONNECT, 1, "connected"},
  208.   {ZEBRA_ROUTE_STATIC,  1, "static"},
  209.   {ZEBRA_ROUTE_OSPF,    1, "ospf"},
  210.   {ZEBRA_ROUTE_BGP,     1, "bgp"},
  211.   {0, 0, NULL}
  212. };
  214. DEFUN (router_zebra,
  215.        router_zebra_cmd,
  216.        "router zebra",
  217.        "Enable a routing processn"
  218.        "Make connection to zebra daemonn")
  219. {
  220.   vty->node = ZEBRA_NODE;
  221.   zclient->enable = 1;
  222.   zclient_start (zclient);
  223.   return CMD_SUCCESS;
  224. }
  226. DEFUN (no_router_zebra,
  227.        no_router_zebra_cmd,
  228.        "no router zebra",
  229.        NO_STR
  230.        "Enable a routing processn"
  231.        "Make connection to zebra daemonn")
  232. {
  233.   zclient->enable = 0;
  234.   zclient_stop (zclient);
  235.   return CMD_SUCCESS;
  236. }
  238. int
  239. rip_redistribute_set (int type)
  240. {
  241.   if (zclient->redist[type])
  242.     return CMD_SUCCESS;
  244.   zclient->redist[type] = 1;
  246.   if (zclient->sock > 0)
  247.     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient->sock, type);
  249.   return CMD_SUCCESS;
  250. }
  252. int
  253. rip_redistribute_unset (int type)
  254. {
  255.   if (! zclient->redist[type])
  256.     return CMD_SUCCESS;
  258.   zclient->redist[type] = 0;
  260.   if (zclient->sock > 0)
  261.     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient->sock, type);
  263.   /* Remove the routes from RIP table. */
  264.   rip_redistribute_withdraw (type);
  266.   return CMD_SUCCESS;
  267. }
  269. int
  270. rip_redistribute_check (int type)
  271. {
  272.   return (zclient->redist[type]);
  273. }
  275. void
  276. rip_redistribute_clean ()
  277. {
  278.   int i;
  280.   for (i = 0; redist_type[i].str; i++)
  281.     {
  282.       if (zclient->redist[redist_type[i].type])
  283. {
  284.   if (zclient->sock > 0)
  285.     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
  286.      zclient->sock, redist_type[i].type);
  288.   zclient->redist[redist_type[i].type] = 0;
  290.   /* Remove the routes from RIP table. */
  291.   rip_redistribute_withdraw (redist_type[i].type);
  292. }
  293.     }
  294. }
  296. DEFUN (rip_redistribute_rip,
  297.        rip_redistribute_rip_cmd,
  298.        "redistribute rip",
  299.        "Redistribute information from another routing protocoln"
  300.        "Routing Information Protocol (RIP)n")
  301. {
  302.   zclient->redist[ZEBRA_ROUTE_RIP] = 1;
  303.   return CMD_SUCCESS;
  304. }
  306. DEFUN (no_rip_redistribute_rip,
  307.        no_rip_redistribute_rip_cmd,
  308.        "no redistribute rip",
  309.        NO_STR
  310.        "Redistribute information from another routing protocoln"
  311.        "Routing Information Protocol (RIP)n")
  312. {
  313.   zclient->redist[ZEBRA_ROUTE_RIP] = 0;
  314.   return CMD_SUCCESS;
  315. }
  317. DEFUN (rip_redistribute_type,
  318.        rip_redistribute_type_cmd,
  319.        "redistribute (kernel|connected|static|ospf|bgp)",
  320.        "Redistribute information from another routing protocoln"
  321.        "Kernel routesn"
  322.        "Connectedn"
  323.        "Static routesn"
  324.        "Open Shortest Path First (OSPF)n"
  325.        "Border Gateway Protocol (BGP)n")
  326. {
  327.   int i;
  329.   for(i = 0; redist_type[i].str; i++) 
  330.     {
  331.       if (strncmp (redist_type[i].str, argv[0], 
  332.    redist_type[i].str_min_len) == 0) 
  333. {
  334.   zclient_redistribute_set (zclient, redist_type[i].type);
  335.   return CMD_SUCCESS;
  336. }
  337.     }
  339.   vty_out(vty, "Invalid type %s%s", argv[0],
  340.   VTY_NEWLINE);
  342.   return CMD_WARNING;
  343. }
  345. DEFUN (no_rip_redistribute_type,
  346.        no_rip_redistribute_type_cmd,
  347.        "no redistribute (kernel|connected|static|ospf|bgp)",
  348.        NO_STR
  349.        "Redistribute information from another routing protocoln"
  350.        "Kernel routesn"
  351.        "Connectedn"
  352.        "Static routesn"
  353.        "Open Shortest Path First (OSPF)n"
  354.        "Border Gateway Protocol (BGP)n")
  355. {
  356.   int i;
  358.   for (i = 0; redist_type[i].str; i++) 
  359.     {
  360.       if (strncmp(redist_type[i].str, argv[0], 
  361.   redist_type[i].str_min_len) == 0) 
  362. {
  363.   rip_metric_unset (redist_type[i].type, DONT_CARE_METRIC_RIP);
  364.   rip_routemap_unset (redist_type[i].type,NULL);
  365.   rip_redistribute_unset (redist_type[i].type);
  366.   return CMD_SUCCESS;
  367.         }
  368.     }
  370.   vty_out(vty, "Invalid type %s%s", argv[0],
  371.   VTY_NEWLINE);
  373.   return CMD_WARNING;
  374. }
  376. DEFUN (rip_redistribute_type_routemap,
  377.        rip_redistribute_type_routemap_cmd,
  378.        "redistribute (kernel|connected|static|ospf|bgp) route-map WORD",
  379.        "Redistribute information from another routing protocoln"
  380.        "Kernel routesn"
  381.        "Connectedn"
  382.        "Static routesn"
  383.        "Open Shortest Path First (OSPF)n"
  384.        "Border Gateway Protocol (BGP)n"
  385.        "Route map referencen"
  386.        "Pointer to route-map entriesn")
  387. {
  388.   int i;
  390.   for (i = 0; redist_type[i].str; i++) {
  391.     if (strncmp(redist_type[i].str, argv[0],
  392. redist_type[i].str_min_len) == 0) 
  393.       {
  394. rip_routemap_set (redist_type[i].type, argv[1]);
  395. zclient_redistribute_set (zclient, redist_type[i].type);
  396. return CMD_SUCCESS;
  397.       }
  398.   }
  400.   vty_out(vty, "Invalid type %s%s", argv[0],
  401.   VTY_NEWLINE);
  403.   return CMD_WARNING;
  404. }
  406. DEFUN (no_rip_redistribute_type_routemap,
  407.        no_rip_redistribute_type_routemap_cmd,
  408.        "no redistribute (kernel|connected|static|ospf|bgp) route-map WORD",
  409.        NO_STR
  410.        "Redistribute information from another routing protocoln"
  411.        "Kernel routesn"
  412.        "Connectedn"
  413.        "Static routesn"
  414.        "Open Shortest Path First (OSPF)n"
  415.        "Border Gateway Protocol (BGP)n"
  416.        "Route map referencen"
  417.        "Pointer to route-map entriesn")
  418. {
  419.   int i;
  421.   for (i = 0; redist_type[i].str; i++) 
  422.     {
  423.       if (strncmp(redist_type[i].str, argv[0], 
  424.   redist_type[i].str_min_len) == 0) 
  425. {
  426.   if (rip_routemap_unset (redist_type[i].type,argv[1]))
  427.     return CMD_WARNING;
  428.   rip_redistribute_unset (redist_type[i].type);
  429.   return CMD_SUCCESS;
  430.         }
  431.     }
  433.   vty_out(vty, "Invalid type %s%s", argv[0],
  434.   VTY_NEWLINE);
  436.   return CMD_WARNING;
  437. }
  439. DEFUN (rip_redistribute_type_metric,
  440.        rip_redistribute_type_metric_cmd,
  441.        "redistribute (kernel|connected|static|ospf|bgp) metric <0-16>",
  442.        "Redistribute information from another routing protocoln"
  443.        "Kernel routesn"
  444.        "Connectedn"
  445.        "Static routesn"
  446.        "Open Shortest Path First (OSPF)n"
  447.        "Border Gateway Protocol (BGP)n"
  448.        "Metricn"
  449.        "Metric valuen")
  450. {
  451.   int i;
  452.   int metric;
  454.   metric = atoi (argv[1]);
  456.   for (i = 0; redist_type[i].str; i++) {
  457.     if (strncmp(redist_type[i].str, argv[0],
  458. redist_type[i].str_min_len) == 0) 
  459.       {
  460. rip_redistribute_metric_set (redist_type[i].type, metric);
  461. zclient_redistribute_set (zclient, redist_type[i].type);
  462. return CMD_SUCCESS;
  463.       }
  464.   }
  466.   vty_out(vty, "Invalid type %s%s", argv[0],
  467.   VTY_NEWLINE);
  469.   return CMD_WARNING;
  470. }
  472. DEFUN (no_rip_redistribute_type_metric,
  473.        no_rip_redistribute_type_metric_cmd,
  474.        "no redistribute (kernel|connected|static|ospf|bgp) metric <0-16>",
  475.        NO_STR
  476.        "Redistribute information from another routing protocoln"
  477.        "Kernel routesn"
  478.        "Connectedn"
  479.        "Static routesn"
  480.        "Open Shortest Path First (OSPF)n"
  481.        "Border Gateway Protocol (BGP)n"
  482.        "Metricn"
  483.        "Metric valuen")
  484. {
  485.   int i;
  487.   for (i = 0; redist_type[i].str; i++) 
  488.     {
  489.       if (strncmp(redist_type[i].str, argv[0], 
  490.   redist_type[i].str_min_len) == 0) 
  491. {
  492.   if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
  493.     return CMD_WARNING;
  494.   rip_redistribute_unset (redist_type[i].type);
  495.   return CMD_SUCCESS;
  496.         }
  497.     }
  499.   vty_out(vty, "Invalid type %s%s", argv[0],
  500.   VTY_NEWLINE);
  502.   return CMD_WARNING;
  503. }
  505. DEFUN (no_rip_redistribute_type_metric_routemap,
  506.        no_rip_redistribute_type_metric_routemap_cmd,
  507.        "no redistribute (kernel|connected|static|ospf|bgp) metric <0-16> route-map WORD",
  508.        NO_STR
  509.        "Redistribute information from another routing protocoln"
  510.        "Kernel routesn"
  511.        "Connectedn"
  512.        "Static routesn"
  513.        "Open Shortest Path First (OSPF)n"
  514.        "Border Gateway Protocol (BGP)n"
  515.        "Metricn"
  516.        "Metric valuen"
  517.        "Route map referencen"
  518.        "Pointer to route-map entriesn")
  519. {
  520.   int i;
  522.   for (i = 0; redist_type[i].str; i++) 
  523.     {
  524.       if (strncmp(redist_type[i].str, argv[0], 
  525.   redist_type[i].str_min_len) == 0) 
  526. {
  527.   if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
  528.     return CMD_WARNING;
  529.   if (rip_routemap_unset (redist_type[i].type, argv[2]))
  530.     {
  531.       rip_redistribute_metric_set(redist_type[i].type, atoi(argv[1]));   
  532.       return CMD_WARNING;
  533.     }
  534.   rip_redistribute_unset (redist_type[i].type);
  535.   return CMD_SUCCESS;
  536.         }
  537.     }
  539.   vty_out(vty, "Invalid type %s%s", argv[0],
  540.   VTY_NEWLINE);
  542.   return CMD_WARNING;
  543. }
  545. /* Default information originate. */
  547. DEFUN (rip_default_information_originate,
  548.        rip_default_information_originate_cmd,
  549.        "default-information originate",
  550.        "Control distribution of default routen"
  551.        "Distribute a default routen")
  552. {
  553.   struct prefix_ipv4 p;
  555.   if (! rip->default_information)
  556.     {
  557.       memset (&p, 0, sizeof (struct prefix_ipv4));
  558.       p.family = AF_INET;
  560.       rip->default_information = 1;
  561.   
  562.       rip_redistribute_add (ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, 0, NULL);
  563.     }
  565.   return CMD_SUCCESS;
  566. }
  568. DEFUN (no_rip_default_information_originate,
  569.        no_rip_default_information_originate_cmd,
  570.        "no default-information originate",
  571.        NO_STR
  572.        "Control distribution of default routen"
  573.        "Distribute a default routen")
  574. {
  575.   struct prefix_ipv4 p;
  577.   if (rip->default_information)
  578.     {
  579.       memset (&p, 0, sizeof (struct prefix_ipv4));
  580.       p.family = AF_INET;
  582.       rip->default_information = 0;
  583.   
  584.       rip_redistribute_delete (ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, 0);
  585.     }
  587.   return CMD_SUCCESS;
  588. }
  590. /* RIP configuration write function. */
  591. int
  592. config_write_zebra (struct vty *vty)
  593. {
  594.   if (! zclient->enable)
  595.     {
  596.       vty_out (vty, "no router zebra%s", VTY_NEWLINE);
  597.       return 1;
  598.     }
  599.   else if (! zclient->redist[ZEBRA_ROUTE_RIP])
  600.     {
  601.       vty_out (vty, "router zebra%s", VTY_NEWLINE);
  602.       vty_out (vty, " no redistribute rip%s", VTY_NEWLINE);
  603.       return 1;
  604.     }
  605.   return 0;
  606. }
  608. int
  609. config_write_rip_redistribute (struct vty *vty, int config_mode)
  610. {
  611.   int i;
  612.   char *str[] = { "system", "kernel", "connected", "static", "rip",
  613.   "ripng", "ospf", "ospf6", "bgp"};
  615.   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
  616.     if (i != zclient->redist_default && zclient->redist[i])
  617.       {
  618. if (config_mode)
  619.   {
  620.     if (rip->route_map[i].metric_config)
  621.       {
  622. if (rip->route_map[i].name)
  623.   vty_out (vty, " redistribute %s metric %d route-map %s%s",
  624.    str[i], rip->route_map[i].metric,
  625.    rip->route_map[i].name,
  626.    VTY_NEWLINE);
  627. else
  628.   vty_out (vty, " redistribute %s metric %d%s",
  629.    str[i], rip->route_map[i].metric,
  630.    VTY_NEWLINE);
  631.       }
  632.     else
  633.       {
  634. if (rip->route_map[i].name)
  635.   vty_out (vty, " redistribute %s route-map %s%s",
  636.    str[i], rip->route_map[i].name,
  637.    VTY_NEWLINE);
  638. else
  639.   vty_out (vty, " redistribute %s%s", str[i],
  640.    VTY_NEWLINE);
  641.       }
  642.   }
  643. else
  644.   vty_out (vty, " %s", str[i]);
  645.       }
  646.   return 0;
  647. }
  649. /* Zebra node structure. */
  650. struct cmd_node zebra_node =
  651. {
  652.   ZEBRA_NODE,
  653.   "%s(config-router)# ",
  654. };
  656. void
  657. rip_zclient_init ()
  658. {
  659.   /* Set default value to the zebra client structure. */
  660.   zclient = zclient_new ();
  661.   zclient_init (zclient, ZEBRA_ROUTE_RIP);
  662.   zclient->interface_add = rip_interface_add;
  663.   zclient->interface_delete = rip_interface_delete;
  664.   zclient->interface_address_add = rip_interface_address_add;
  665.   zclient->interface_address_delete = rip_interface_address_delete;
  666.   zclient->ipv4_route_add = rip_zebra_read_ipv4;
  667.   zclient->ipv4_route_delete = rip_zebra_read_ipv4;
  668.   zclient->interface_up = rip_interface_up;
  669.   zclient->interface_down = rip_interface_down;
  670.   
  671.   /* Install zebra node. */
  672.   install_node (&zebra_node, config_write_zebra);
  674.   /* Install command elements to zebra node. */ 
  675.   install_element (CONFIG_NODE, &router_zebra_cmd);
  676.   install_element (CONFIG_NODE, &no_router_zebra_cmd);
  677.   install_default (ZEBRA_NODE);
  678.   install_element (ZEBRA_NODE, &rip_redistribute_rip_cmd);
  679.   install_element (ZEBRA_NODE, &no_rip_redistribute_rip_cmd);
  681.   /* Install command elements to rip node. */
  682.   install_element (RIP_NODE, &rip_redistribute_type_cmd);
  683.   install_element (RIP_NODE, &rip_redistribute_type_routemap_cmd);
  684.   install_element (RIP_NODE, &rip_redistribute_type_metric_cmd);
  685.   install_element (RIP_NODE, &no_rip_redistribute_type_cmd);
  686.   install_element (RIP_NODE, &no_rip_redistribute_type_routemap_cmd);
  687.   install_element (RIP_NODE, &no_rip_redistribute_type_metric_cmd);
  688.   install_element (RIP_NODE, &no_rip_redistribute_type_metric_routemap_cmd);
  689.   install_element (RIP_NODE, &rip_default_information_originate_cmd);
  690.   install_element (RIP_NODE, &no_rip_default_information_originate_cmd);
  691. }