]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - ripd/rip_zebra.c
New upstream version 1.2.4
[quagga-debian.git] / ripd / 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  */
21
22 #include <zebra.h>
23
24 #include "command.h"
25 #include "prefix.h"
26 #include "table.h"
27 #include "stream.h"
28 #include "memory.h"
29 #include "routemap.h"
30 #include "zclient.h"
31 #include "log.h"
32 #include "vrf.h"
33 #include "ripd/ripd.h"
34 #include "ripd/rip_debug.h"
35 #include "ripd/rip_interface.h"
36
37 /* All information about zebra. */
38 struct zclient *zclient = NULL;
39
40 /* Send ECMP routes to zebra. */
41 static void
42 rip_zebra_ipv4_send (struct route_node *rp, u_char cmd)
43 {
44   static struct in_addr **nexthops = NULL;
45   static unsigned int nexthops_len = 0;
46
47   struct list *list = (struct list *)rp->info;
48   struct zapi_ipv4 api;
49   struct listnode *listnode = NULL;
50   struct rip_info *rinfo = NULL;
51   int count = 0;
52
53   if (vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_RIP], VRF_DEFAULT))
54     {
55       api.vrf_id = VRF_DEFAULT;
56       api.type = ZEBRA_ROUTE_RIP;
57       api.flags = 0;
58       api.message = 0;
59       api.safi = SAFI_UNICAST;
60
61       if (nexthops_len < listcount (list))
62         {
63           nexthops_len = listcount (list);
64           nexthops = XREALLOC (MTYPE_TMP, nexthops,
65                                nexthops_len * sizeof (struct in_addr *));
66         }
67
68       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
69       for (ALL_LIST_ELEMENTS_RO (list, listnode, rinfo))
70         {
71           nexthops[count++] = &rinfo->nexthop;
72           if (cmd == ZEBRA_IPV4_ROUTE_ADD)
73             SET_FLAG (rinfo->flags, RIP_RTF_FIB);
74           else
75             UNSET_FLAG (rinfo->flags, RIP_RTF_FIB);
76         }
77
78       api.nexthop = nexthops;
79       api.nexthop_num = count;
80       api.ifindex_num = 0;
81
82       rinfo = listgetdata (listhead (list));
83
84       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
85       api.metric = rinfo->metric;
86
87       if (rinfo->distance && rinfo->distance != ZEBRA_RIP_DISTANCE_DEFAULT)
88         {
89           SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
90           api.distance = rinfo->distance;
91         }
92
93       if (rinfo->tag)
94         {
95           SET_FLAG (api.message, ZAPI_MESSAGE_TAG);
96           api.tag = rinfo->tag;
97         }
98
99       zapi_ipv4_route (cmd, zclient,
100                        (struct prefix_ipv4 *)&rp->p, &api);
101
102       if (IS_RIP_DEBUG_ZEBRA)
103         {
104           if (rip->ecmp)
105             zlog_debug ("%s: %s/%d nexthops %d",
106                         (cmd == ZEBRA_IPV4_ROUTE_ADD) ? \
107                             "Install into zebra" : "Delete from zebra",
108                         inet_ntoa (rp->p.u.prefix4), rp->p.prefixlen, count);
109           else
110             zlog_debug ("%s: %s/%d",
111                         (cmd == ZEBRA_IPV4_ROUTE_ADD) ? \
112                             "Install into zebra" : "Delete from zebra",
113                         inet_ntoa (rp->p.u.prefix4), rp->p.prefixlen);
114         }
115
116       rip_global_route_changes++;
117     }
118 }
119
120 /* Add/update ECMP routes to zebra. */
121 void
122 rip_zebra_ipv4_add (struct route_node *rp)
123 {
124   rip_zebra_ipv4_send (rp, ZEBRA_IPV4_ROUTE_ADD);
125 }
126
127 /* Delete ECMP routes from zebra. */
128 void
129 rip_zebra_ipv4_delete (struct route_node *rp)
130 {
131   rip_zebra_ipv4_send (rp, ZEBRA_IPV4_ROUTE_DELETE);
132 }
133
134 /* Zebra route add and delete treatment. */
135 static int
136 rip_zebra_read_ipv4 (int command, struct zclient *zclient, zebra_size_t length,
137     vrf_id_t vrf_id)
138 {
139   struct stream *s;
140   struct zapi_ipv4 api;
141   unsigned long ifindex;
142   struct in_addr nexthop;
143   struct prefix_ipv4 p;
144   unsigned char plength = 0;
145
146   s = zclient->ibuf;
147   ifindex = 0;
148   nexthop.s_addr = 0;
149
150   /* Type, flags, message. */
151   api.type = stream_getc (s);
152   api.flags = stream_getc (s);
153   api.message = stream_getc (s);
154
155   /* IPv4 prefix. */
156   memset (&p, 0, sizeof (struct prefix_ipv4));
157   p.family = AF_INET;
158   plength = stream_getc (s);
159   p.prefixlen = MIN(IPV4_MAX_PREFIXLEN, plength);
160   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
161
162   /* Nexthop, ifindex, distance, metric. */
163   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
164     {
165       api.nexthop_num = stream_getc (s);
166       nexthop.s_addr = stream_get_ipv4 (s);
167     }
168   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
169     {
170       api.ifindex_num = stream_getc (s);
171       ifindex = stream_getl (s);
172     }
173   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
174     api.distance = stream_getc (s);
175   else
176     api.distance = 255;
177   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
178     api.metric = stream_getl (s);
179   else
180     api.metric = 0;
181
182   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_TAG))
183     api.tag = stream_getl (s);
184   else
185     api.tag = 0;
186
187   /* Then fetch IPv4 prefixes. */
188   if (command == ZEBRA_IPV4_ROUTE_ADD)
189     rip_redistribute_add (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex, 
190                           &nexthop, api.metric, api.distance, api.tag);
191   else
192     rip_redistribute_delete (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex);
193
194   return 0;
195 }
196
197 void
198 rip_zclient_reset (void)
199 {
200   zclient_reset (zclient);
201 }
202
203 /* RIP route-map set for redistribution */
204 static void
205 rip_routemap_set (int type, const char *name)
206 {
207   if (rip->route_map[type].name)
208     free(rip->route_map[type].name);
209
210   rip->route_map[type].name = strdup (name);
211   rip->route_map[type].map = route_map_lookup_by_name (name);
212 }
213
214 static void
215 rip_redistribute_metric_set (int type, unsigned int metric)
216 {
217   rip->route_map[type].metric_config = 1;
218   rip->route_map[type].metric = metric;
219 }
220
221 static int
222 rip_metric_unset (int type, unsigned int metric)
223 {
224 #define DONT_CARE_METRIC_RIP 17  
225   if (metric != DONT_CARE_METRIC_RIP &&
226       rip->route_map[type].metric != metric)
227     return 1;
228   rip->route_map[type].metric_config = 0;
229   rip->route_map[type].metric = 0;
230   return 0;
231 }
232
233 /* RIP route-map unset for redistribution */
234 static int
235 rip_routemap_unset (int type, const char *name)
236 {
237   if (! rip->route_map[type].name ||
238       (name != NULL && strcmp(rip->route_map[type].name,name)))
239     return 1;
240
241   free (rip->route_map[type].name);
242   rip->route_map[type].name = NULL;
243   rip->route_map[type].map = NULL;
244
245   return 0;
246 }
247
248 /* Redistribution types */
249 static struct {
250   int type;
251   int str_min_len;
252   const char *str;
253 } redist_type[] = {
254   {ZEBRA_ROUTE_KERNEL,  1, "kernel"},
255   {ZEBRA_ROUTE_CONNECT, 1, "connected"},
256   {ZEBRA_ROUTE_STATIC,  1, "static"},
257   {ZEBRA_ROUTE_OSPF,    1, "ospf"},
258   {ZEBRA_ROUTE_BGP,     2, "bgp"},
259   {ZEBRA_ROUTE_BABEL,   2, "babel"},
260   {0, 0, NULL}
261 };
262
263 DEFUN (router_zebra,
264        router_zebra_cmd,
265        "router zebra",
266        "Enable a routing process\n"
267        "Make connection to zebra daemon\n")
268 {
269   vty->node = ZEBRA_NODE;
270   zclient->enable = 1;
271   zclient_start (zclient);
272   return CMD_SUCCESS;
273 }
274
275 DEFUN (no_router_zebra,
276        no_router_zebra_cmd,
277        "no router zebra",
278        NO_STR
279        "Enable a routing process\n"
280        "Make connection to zebra daemon\n")
281 {
282   zclient->enable = 0;
283   zclient_stop (zclient);
284   return CMD_SUCCESS;
285 }
286
287 #if 0
288 static int
289 rip_redistribute_set (int type)
290 {
291   if (vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT))
292     return CMD_SUCCESS;
293
294   vrf_bitmap_set (zclient->redist[type], VRF_DEFAULT);
295
296   if (zclient->sock > 0)
297     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
298
299   return CMD_SUCCESS;
300 }
301 #endif
302
303 static int
304 rip_redistribute_unset (int type)
305 {
306   if (! vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT))
307     return CMD_SUCCESS;
308
309   vrf_bitmap_unset (zclient->redist[type], VRF_DEFAULT);
310
311   if (zclient->sock > 0)
312     zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type,
313                              VRF_DEFAULT);
314
315   /* Remove the routes from RIP table. */
316   rip_redistribute_withdraw (type);
317
318   return CMD_SUCCESS;
319 }
320
321 int
322 rip_redistribute_check (int type)
323 {
324   return vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT);
325 }
326
327 void
328 rip_redistribute_clean (void)
329 {
330   int i;
331
332   for (i = 0; redist_type[i].str; i++)
333     {
334       if (vrf_bitmap_check (zclient->redist[redist_type[i].type], VRF_DEFAULT))
335         {
336           if (zclient->sock > 0)
337             zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
338                                      zclient, redist_type[i].type,
339                                      VRF_DEFAULT);
340
341           vrf_bitmap_unset (zclient->redist[redist_type[i].type], VRF_DEFAULT);
342
343           /* Remove the routes from RIP table. */
344           rip_redistribute_withdraw (redist_type[i].type);
345         }
346     }
347 }
348
349 DEFUN (rip_redistribute_rip,
350        rip_redistribute_rip_cmd,
351        "redistribute rip",
352        "Redistribute information from another routing protocol\n"
353        "Routing Information Protocol (RIP)\n")
354 {
355   vrf_bitmap_set (zclient->redist[ZEBRA_ROUTE_RIP], VRF_DEFAULT);
356   return CMD_SUCCESS;
357 }
358
359 DEFUN (no_rip_redistribute_rip,
360        no_rip_redistribute_rip_cmd,
361        "no redistribute rip",
362        NO_STR
363        "Redistribute information from another routing protocol\n"
364        "Routing Information Protocol (RIP)\n")
365 {
366   vrf_bitmap_unset (zclient->redist[ZEBRA_ROUTE_RIP], VRF_DEFAULT);
367   return CMD_SUCCESS;
368 }
369
370 DEFUN (rip_redistribute_type,
371        rip_redistribute_type_cmd,
372        "redistribute " QUAGGA_REDIST_STR_RIPD,
373        REDIST_STR
374        QUAGGA_REDIST_HELP_STR_RIPD)
375 {
376   int i;
377
378   for(i = 0; redist_type[i].str; i++) 
379     {
380       if (strncmp (redist_type[i].str, argv[0], 
381                    redist_type[i].str_min_len) == 0) 
382         {
383           zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, 
384                                 redist_type[i].type, VRF_DEFAULT);
385           return CMD_SUCCESS;
386         }
387     }
388
389   vty_out(vty, "Invalid type %s%s", argv[0],
390           VTY_NEWLINE);
391
392   return CMD_WARNING;
393 }
394
395 DEFUN (no_rip_redistribute_type,
396        no_rip_redistribute_type_cmd,
397        "no redistribute " QUAGGA_REDIST_STR_RIPD,
398        NO_STR
399        REDIST_STR
400        QUAGGA_REDIST_HELP_STR_RIPD)
401 {
402   int i;
403
404   for (i = 0; redist_type[i].str; i++) 
405     {
406       if (strncmp(redist_type[i].str, argv[0], 
407                   redist_type[i].str_min_len) == 0) 
408         {
409           rip_metric_unset (redist_type[i].type, DONT_CARE_METRIC_RIP);
410           rip_routemap_unset (redist_type[i].type,NULL);
411           rip_redistribute_unset (redist_type[i].type);
412           return CMD_SUCCESS;
413         }
414     }
415
416   vty_out(vty, "Invalid type %s%s", argv[0],
417           VTY_NEWLINE);
418
419   return CMD_WARNING;
420 }
421
422 DEFUN (rip_redistribute_type_routemap,
423        rip_redistribute_type_routemap_cmd,
424        "redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
425        REDIST_STR
426        QUAGGA_REDIST_HELP_STR_RIPD
427        "Route map reference\n"
428        "Pointer to route-map entries\n")
429 {
430   int i;
431
432   for (i = 0; redist_type[i].str; i++) {
433     if (strncmp(redist_type[i].str, argv[0],
434                 redist_type[i].str_min_len) == 0) 
435       {
436         rip_routemap_set (redist_type[i].type, argv[1]);
437         zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type,
438                               VRF_DEFAULT);
439         return CMD_SUCCESS;
440       }
441   }
442
443   vty_out(vty, "Invalid type %s%s", argv[0],
444           VTY_NEWLINE);
445
446   return CMD_WARNING;
447 }
448
449 DEFUN (no_rip_redistribute_type_routemap,
450        no_rip_redistribute_type_routemap_cmd,
451        "no redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
452        NO_STR
453        REDIST_STR
454        QUAGGA_REDIST_HELP_STR_RIPD
455        "Route map reference\n"
456        "Pointer to route-map entries\n")
457 {
458   int i;
459
460   for (i = 0; redist_type[i].str; i++) 
461     {
462       if (strncmp(redist_type[i].str, argv[0], 
463                   redist_type[i].str_min_len) == 0) 
464         {
465           if (rip_routemap_unset (redist_type[i].type,argv[1]))
466             return CMD_WARNING;
467           rip_redistribute_unset (redist_type[i].type);
468           return CMD_SUCCESS;
469         }
470     }
471
472   vty_out(vty, "Invalid type %s%s", argv[0],
473           VTY_NEWLINE);
474
475   return CMD_WARNING;
476 }
477
478 DEFUN (rip_redistribute_type_metric,
479        rip_redistribute_type_metric_cmd,
480        "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
481        REDIST_STR
482        QUAGGA_REDIST_HELP_STR_RIPD
483        "Metric\n"
484        "Metric value\n")
485 {
486   int i;
487   int metric;
488
489   metric = atoi (argv[1]);
490
491   for (i = 0; redist_type[i].str; i++) {
492     if (strncmp(redist_type[i].str, argv[0],
493                 redist_type[i].str_min_len) == 0) 
494       {
495         rip_redistribute_metric_set (redist_type[i].type, metric);
496         zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type,
497                               VRF_DEFAULT);
498         return CMD_SUCCESS;
499       }
500   }
501
502   vty_out(vty, "Invalid type %s%s", argv[0],
503           VTY_NEWLINE);
504
505   return CMD_WARNING;
506 }
507
508 DEFUN (no_rip_redistribute_type_metric,
509        no_rip_redistribute_type_metric_cmd,
510        "no redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
511        NO_STR
512        REDIST_STR
513        QUAGGA_REDIST_HELP_STR_RIPD
514        "Metric\n"
515        "Metric value\n")
516 {
517   int i;
518
519   for (i = 0; redist_type[i].str; i++) 
520     {
521       if (strncmp(redist_type[i].str, argv[0], 
522                   redist_type[i].str_min_len) == 0) 
523         {
524           if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
525             return CMD_WARNING;
526           rip_redistribute_unset (redist_type[i].type);
527           return CMD_SUCCESS;
528         }
529     }
530
531   vty_out(vty, "Invalid type %s%s", argv[0],
532           VTY_NEWLINE);
533
534   return CMD_WARNING;
535 }
536
537 DEFUN (rip_redistribute_type_metric_routemap,
538        rip_redistribute_type_metric_routemap_cmd,
539        "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16> route-map WORD",
540        REDIST_STR
541        QUAGGA_REDIST_HELP_STR_RIPD
542        "Metric\n"
543        "Metric value\n"
544        "Route map reference\n"
545        "Pointer to route-map entries\n")
546 {
547   int i;
548   int metric;
549
550   metric = atoi (argv[1]);
551
552   for (i = 0; redist_type[i].str; i++) {
553     if (strncmp(redist_type[i].str, argv[0],
554                 redist_type[i].str_min_len) == 0) 
555       {
556         rip_redistribute_metric_set (redist_type[i].type, metric);
557         rip_routemap_set (redist_type[i].type, argv[2]);
558         zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type,
559                               VRF_DEFAULT);
560         return CMD_SUCCESS;
561       }
562   }
563
564   vty_out(vty, "Invalid type %s%s", argv[0],
565           VTY_NEWLINE);
566
567   return CMD_WARNING;
568 }
569
570
571 DEFUN (no_rip_redistribute_type_metric_routemap,
572        no_rip_redistribute_type_metric_routemap_cmd,
573        "no redistribute " QUAGGA_REDIST_STR_RIPD
574        " metric <0-16> route-map WORD",
575        NO_STR
576        REDIST_STR
577        QUAGGA_REDIST_HELP_STR_RIPD
578        "Metric\n"
579        "Metric value\n"
580        "Route map reference\n"
581        "Pointer to route-map entries\n")
582 {
583   int i;
584
585   for (i = 0; redist_type[i].str; i++) 
586     {
587       if (strncmp(redist_type[i].str, argv[0], 
588                   redist_type[i].str_min_len) == 0) 
589         {
590           if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
591             return CMD_WARNING;
592           if (rip_routemap_unset (redist_type[i].type, argv[2]))
593             {
594               rip_redistribute_metric_set(redist_type[i].type, atoi(argv[1]));   
595               return CMD_WARNING;
596             }
597           rip_redistribute_unset (redist_type[i].type);
598           return CMD_SUCCESS;
599         }
600     }
601
602   vty_out(vty, "Invalid type %s%s", argv[0],
603           VTY_NEWLINE);
604
605   return CMD_WARNING;
606 }
607
608 /* Default information originate. */
609
610 DEFUN (rip_default_information_originate,
611        rip_default_information_originate_cmd,
612        "default-information originate",
613        "Control distribution of default route\n"
614        "Distribute a default route\n")
615 {
616   struct prefix_ipv4 p;
617
618   if (! rip->default_information)
619     {
620       memset (&p, 0, sizeof (struct prefix_ipv4));
621       p.family = AF_INET;
622
623       rip->default_information = 1;
624   
625       rip_redistribute_add (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0, 
626                             NULL, 0, 0, 0);
627     }
628
629   return CMD_SUCCESS;
630 }
631
632 DEFUN (no_rip_default_information_originate,
633        no_rip_default_information_originate_cmd,
634        "no default-information originate",
635        NO_STR
636        "Control distribution of default route\n"
637        "Distribute a default route\n")
638 {
639   struct prefix_ipv4 p;
640
641   if (rip->default_information)
642     {
643       memset (&p, 0, sizeof (struct prefix_ipv4));
644       p.family = AF_INET;
645
646       rip->default_information = 0;
647   
648       rip_redistribute_delete (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0);
649     }
650
651   return CMD_SUCCESS;
652 }
653
654 /* RIP configuration write function. */
655 static int
656 config_write_zebra (struct vty *vty)
657 {
658   if (! zclient->enable)
659     {
660       vty_out (vty, "no router zebra%s", VTY_NEWLINE);
661       return 1;
662     }
663   else if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_RIP], VRF_DEFAULT))
664     {
665       vty_out (vty, "router zebra%s", VTY_NEWLINE);
666       vty_out (vty, " no redistribute rip%s", VTY_NEWLINE);
667       return 1;
668     }
669   return 0;
670 }
671
672 int
673 config_write_rip_redistribute (struct vty *vty, int config_mode)
674 {
675   int i;
676
677   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
678     if (i != zclient->redist_default &&
679         vrf_bitmap_check (zclient->redist[i], VRF_DEFAULT))
680       {
681         if (config_mode)
682           {
683             if (rip->route_map[i].metric_config)
684               {
685                 if (rip->route_map[i].name)
686                   vty_out (vty, " redistribute %s metric %d route-map %s%s",
687                            zebra_route_string(i), rip->route_map[i].metric,
688                            rip->route_map[i].name,
689                            VTY_NEWLINE);
690                 else
691                   vty_out (vty, " redistribute %s metric %d%s",
692                            zebra_route_string(i), rip->route_map[i].metric,
693                            VTY_NEWLINE);
694               }
695             else
696               {
697                 if (rip->route_map[i].name)
698                   vty_out (vty, " redistribute %s route-map %s%s",
699                            zebra_route_string(i), rip->route_map[i].name,
700                            VTY_NEWLINE);
701                 else
702                   vty_out (vty, " redistribute %s%s", zebra_route_string(i),
703                            VTY_NEWLINE);
704               }
705           }
706         else
707           vty_out (vty, " %s", zebra_route_string(i));
708       }
709   return 0;
710 }
711
712 /* Zebra node structure. */
713 static struct cmd_node zebra_node =
714 {
715   ZEBRA_NODE,
716   "%s(config-router)# ",
717 };
718
719 static void
720 rip_zebra_connected (struct zclient *zclient)
721 {
722   zclient_send_requests (zclient, VRF_DEFAULT);
723 }
724
725 void
726 rip_zclient_init (struct thread_master *master)
727 {
728   /* Set default value to the zebra client structure. */
729   zclient = zclient_new (master);
730   zclient_init (zclient, ZEBRA_ROUTE_RIP);
731   zclient->zebra_connected = rip_zebra_connected;
732   zclient->interface_add = rip_interface_add;
733   zclient->interface_delete = rip_interface_delete;
734   zclient->interface_address_add = rip_interface_address_add;
735   zclient->interface_address_delete = rip_interface_address_delete;
736   zclient->ipv4_route_add = rip_zebra_read_ipv4;
737   zclient->ipv4_route_delete = rip_zebra_read_ipv4;
738   zclient->interface_up = rip_interface_up;
739   zclient->interface_down = rip_interface_down;
740   
741   /* Install zebra node. */
742   install_node (&zebra_node, config_write_zebra);
743
744   /* Install command elements to zebra node. */ 
745   install_element (CONFIG_NODE, &router_zebra_cmd);
746   install_element (CONFIG_NODE, &no_router_zebra_cmd);
747   install_default (ZEBRA_NODE);
748   install_element (ZEBRA_NODE, &rip_redistribute_rip_cmd);
749   install_element (ZEBRA_NODE, &no_rip_redistribute_rip_cmd);
750
751   /* Install command elements to rip node. */
752   install_element (RIP_NODE, &rip_redistribute_type_cmd);
753   install_element (RIP_NODE, &rip_redistribute_type_routemap_cmd);
754   install_element (RIP_NODE, &rip_redistribute_type_metric_cmd);
755   install_element (RIP_NODE, &rip_redistribute_type_metric_routemap_cmd);
756   install_element (RIP_NODE, &no_rip_redistribute_type_cmd);
757   install_element (RIP_NODE, &no_rip_redistribute_type_routemap_cmd);
758   install_element (RIP_NODE, &no_rip_redistribute_type_metric_cmd);
759   install_element (RIP_NODE, &no_rip_redistribute_type_metric_routemap_cmd);
760   install_element (RIP_NODE, &rip_default_information_originate_cmd);
761   install_element (RIP_NODE, &no_rip_default_information_originate_cmd);
762 }