ospfd: Tighten up the connected check for redistribution
[jleu-quagga.git] / ripd / rip_zebra.c
blob7729d9b472679e7261cc51df362627ef4b4853e1
1 /* RIPd and zebra interface.
2 * Copyright (C) 1997, 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
4 * This file is part of GNU Zebra.
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.
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.
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.
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"
32 #include "ripd/rip_interface.h"
34 /* All information about zebra. */
35 struct zclient *zclient = NULL;
37 /* RIPd to zebra command interface. */
38 void
39 rip_zebra_ipv4_add (struct prefix_ipv4 *p, struct in_addr *nexthop,
40 u_int32_t metric, u_char distance)
42 struct zapi_ipv4 api;
44 if (zclient->redist[ZEBRA_ROUTE_RIP])
46 api.type = ZEBRA_ROUTE_RIP;
47 api.flags = 0;
48 api.message = 0;
49 SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
50 api.nexthop_num = 1;
51 api.nexthop = &nexthop;
52 api.ifindex_num = 0;
53 SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
54 api.metric = metric;
56 if (distance && distance != ZEBRA_RIP_DISTANCE_DEFAULT)
58 SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
59 api.distance = distance;
62 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient, p, &api);
64 rip_global_route_changes++;
68 void
69 rip_zebra_ipv4_delete (struct prefix_ipv4 *p, struct in_addr *nexthop,
70 u_int32_t metric)
72 struct zapi_ipv4 api;
74 if (zclient->redist[ZEBRA_ROUTE_RIP])
76 api.type = ZEBRA_ROUTE_RIP;
77 api.flags = 0;
78 api.message = 0;
79 SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
80 api.nexthop_num = 1;
81 api.nexthop = &nexthop;
82 api.ifindex_num = 0;
83 SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
84 api.metric = metric;
86 zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
88 rip_global_route_changes++;
92 /* Zebra route add and delete treatment. */
93 static int
94 rip_zebra_read_ipv4 (int command, struct zclient *zclient, zebra_size_t length)
96 struct stream *s;
97 struct zapi_ipv4 api;
98 unsigned long ifindex;
99 struct in_addr nexthop;
100 struct prefix_ipv4 p;
102 s = zclient->ibuf;
103 ifindex = 0;
104 nexthop.s_addr = 0;
106 /* Type, flags, message. */
107 api.type = stream_getc (s);
108 api.flags = stream_getc (s);
109 api.message = stream_getc (s);
111 /* IPv4 prefix. */
112 memset (&p, 0, sizeof (struct prefix_ipv4));
113 p.family = AF_INET;
114 p.prefixlen = stream_getc (s);
115 stream_get (&p.prefix, s, PSIZE (p.prefixlen));
117 /* Nexthop, ifindex, distance, metric. */
118 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
120 api.nexthop_num = stream_getc (s);
121 nexthop.s_addr = stream_get_ipv4 (s);
123 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
125 api.ifindex_num = stream_getc (s);
126 ifindex = stream_getl (s);
128 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
129 api.distance = stream_getc (s);
130 else
131 api.distance = 255;
132 if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
133 api.metric = stream_getl (s);
134 else
135 api.metric = 0;
137 /* Then fetch IPv4 prefixes. */
138 if (command == ZEBRA_IPV4_ROUTE_ADD)
139 rip_redistribute_add (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex,
140 &nexthop, api.metric, api.distance);
141 else
142 rip_redistribute_delete (api.type, RIP_ROUTE_REDISTRIBUTE, &p, ifindex);
144 return 0;
147 void
148 rip_zclient_reset (void)
150 zclient_reset (zclient);
153 /* RIP route-map set for redistribution */
154 static void
155 rip_routemap_set (int type, const char *name)
157 if (rip->route_map[type].name)
158 free(rip->route_map[type].name);
160 rip->route_map[type].name = strdup (name);
161 rip->route_map[type].map = route_map_lookup_by_name (name);
164 static void
165 rip_redistribute_metric_set (int type, unsigned int metric)
167 rip->route_map[type].metric_config = 1;
168 rip->route_map[type].metric = metric;
171 static int
172 rip_metric_unset (int type, unsigned int metric)
174 #define DONT_CARE_METRIC_RIP 17
175 if (metric != DONT_CARE_METRIC_RIP &&
176 rip->route_map[type].metric != metric)
177 return 1;
178 rip->route_map[type].metric_config = 0;
179 rip->route_map[type].metric = 0;
180 return 0;
183 /* RIP route-map unset for redistribution */
184 static int
185 rip_routemap_unset (int type, const char *name)
187 if (! rip->route_map[type].name ||
188 (name != NULL && strcmp(rip->route_map[type].name,name)))
189 return 1;
191 free (rip->route_map[type].name);
192 rip->route_map[type].name = NULL;
193 rip->route_map[type].map = NULL;
195 return 0;
198 /* Redistribution types */
199 static struct {
200 int type;
201 int str_min_len;
202 const char *str;
203 } redist_type[] = {
204 {ZEBRA_ROUTE_KERNEL, 1, "kernel"},
205 {ZEBRA_ROUTE_CONNECT, 1, "connected"},
206 {ZEBRA_ROUTE_STATIC, 1, "static"},
207 {ZEBRA_ROUTE_OSPF, 1, "ospf"},
208 {ZEBRA_ROUTE_BGP, 1, "bgp"},
209 {0, 0, NULL}
212 DEFUN (router_zebra,
213 router_zebra_cmd,
214 "router zebra",
215 "Enable a routing process\n"
216 "Make connection to zebra daemon\n")
218 vty->node = ZEBRA_NODE;
219 zclient->enable = 1;
220 zclient_start (zclient);
221 return CMD_SUCCESS;
224 DEFUN (no_router_zebra,
225 no_router_zebra_cmd,
226 "no router zebra",
227 NO_STR
228 "Enable a routing process\n"
229 "Make connection to zebra daemon\n")
231 zclient->enable = 0;
232 zclient_stop (zclient);
233 return CMD_SUCCESS;
236 static int
237 rip_redistribute_set (int type)
239 if (zclient->redist[type])
240 return CMD_SUCCESS;
242 zclient->redist[type] = 1;
244 if (zclient->sock > 0)
245 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
247 return CMD_SUCCESS;
250 static int
251 rip_redistribute_unset (int type)
253 if (! zclient->redist[type])
254 return CMD_SUCCESS;
256 zclient->redist[type] = 0;
258 if (zclient->sock > 0)
259 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
261 /* Remove the routes from RIP table. */
262 rip_redistribute_withdraw (type);
264 return CMD_SUCCESS;
268 rip_redistribute_check (int type)
270 return (zclient->redist[type]);
273 void
274 rip_redistribute_clean (void)
276 int i;
278 for (i = 0; redist_type[i].str; i++)
280 if (zclient->redist[redist_type[i].type])
282 if (zclient->sock > 0)
283 zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
284 zclient, redist_type[i].type);
286 zclient->redist[redist_type[i].type] = 0;
288 /* Remove the routes from RIP table. */
289 rip_redistribute_withdraw (redist_type[i].type);
294 DEFUN (rip_redistribute_rip,
295 rip_redistribute_rip_cmd,
296 "redistribute rip",
297 "Redistribute information from another routing protocol\n"
298 "Routing Information Protocol (RIP)\n")
300 zclient->redist[ZEBRA_ROUTE_RIP] = 1;
301 return CMD_SUCCESS;
304 DEFUN (no_rip_redistribute_rip,
305 no_rip_redistribute_rip_cmd,
306 "no redistribute rip",
307 NO_STR
308 "Redistribute information from another routing protocol\n"
309 "Routing Information Protocol (RIP)\n")
311 zclient->redist[ZEBRA_ROUTE_RIP] = 0;
312 return CMD_SUCCESS;
315 DEFUN (rip_redistribute_type,
316 rip_redistribute_type_cmd,
317 "redistribute " QUAGGA_REDIST_STR_RIPD,
318 REDIST_STR
319 QUAGGA_REDIST_HELP_STR_RIPD)
321 int i;
323 for(i = 0; redist_type[i].str; i++)
325 if (strncmp (redist_type[i].str, argv[0],
326 redist_type[i].str_min_len) == 0)
328 zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient,
329 redist_type[i].type);
330 return CMD_SUCCESS;
334 vty_out(vty, "Invalid type %s%s", argv[0],
335 VTY_NEWLINE);
337 return CMD_WARNING;
340 DEFUN (no_rip_redistribute_type,
341 no_rip_redistribute_type_cmd,
342 "no redistribute " QUAGGA_REDIST_STR_RIPD,
343 NO_STR
344 REDIST_STR
345 QUAGGA_REDIST_HELP_STR_RIPD)
347 int i;
349 for (i = 0; redist_type[i].str; i++)
351 if (strncmp(redist_type[i].str, argv[0],
352 redist_type[i].str_min_len) == 0)
354 rip_metric_unset (redist_type[i].type, DONT_CARE_METRIC_RIP);
355 rip_routemap_unset (redist_type[i].type,NULL);
356 rip_redistribute_unset (redist_type[i].type);
357 return CMD_SUCCESS;
361 vty_out(vty, "Invalid type %s%s", argv[0],
362 VTY_NEWLINE);
364 return CMD_WARNING;
367 DEFUN (rip_redistribute_type_routemap,
368 rip_redistribute_type_routemap_cmd,
369 "redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
370 REDIST_STR
371 QUAGGA_REDIST_HELP_STR_RIPD
372 "Route map reference\n"
373 "Pointer to route-map entries\n")
375 int i;
377 for (i = 0; redist_type[i].str; i++) {
378 if (strncmp(redist_type[i].str, argv[0],
379 redist_type[i].str_min_len) == 0)
381 rip_routemap_set (redist_type[i].type, argv[1]);
382 zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
383 return CMD_SUCCESS;
387 vty_out(vty, "Invalid type %s%s", argv[0],
388 VTY_NEWLINE);
390 return CMD_WARNING;
393 DEFUN (no_rip_redistribute_type_routemap,
394 no_rip_redistribute_type_routemap_cmd,
395 "no redistribute " QUAGGA_REDIST_STR_RIPD " route-map WORD",
396 NO_STR
397 REDIST_STR
398 QUAGGA_REDIST_HELP_STR_RIPD
399 "Route map reference\n"
400 "Pointer to route-map entries\n")
402 int i;
404 for (i = 0; redist_type[i].str; i++)
406 if (strncmp(redist_type[i].str, argv[0],
407 redist_type[i].str_min_len) == 0)
409 if (rip_routemap_unset (redist_type[i].type,argv[1]))
410 return CMD_WARNING;
411 rip_redistribute_unset (redist_type[i].type);
412 return CMD_SUCCESS;
416 vty_out(vty, "Invalid type %s%s", argv[0],
417 VTY_NEWLINE);
419 return CMD_WARNING;
422 DEFUN (rip_redistribute_type_metric,
423 rip_redistribute_type_metric_cmd,
424 "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
425 REDIST_STR
426 QUAGGA_REDIST_HELP_STR_RIPD
427 "Metric\n"
428 "Metric value\n")
430 int i;
431 int metric;
433 metric = atoi (argv[1]);
435 for (i = 0; redist_type[i].str; i++) {
436 if (strncmp(redist_type[i].str, argv[0],
437 redist_type[i].str_min_len) == 0)
439 rip_redistribute_metric_set (redist_type[i].type, metric);
440 zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
441 return CMD_SUCCESS;
445 vty_out(vty, "Invalid type %s%s", argv[0],
446 VTY_NEWLINE);
448 return CMD_WARNING;
451 DEFUN (no_rip_redistribute_type_metric,
452 no_rip_redistribute_type_metric_cmd,
453 "no redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16>",
454 NO_STR
455 REDIST_STR
456 QUAGGA_REDIST_HELP_STR_RIPD
457 "Metric\n"
458 "Metric value\n")
460 int i;
462 for (i = 0; redist_type[i].str; i++)
464 if (strncmp(redist_type[i].str, argv[0],
465 redist_type[i].str_min_len) == 0)
467 if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
468 return CMD_WARNING;
469 rip_redistribute_unset (redist_type[i].type);
470 return CMD_SUCCESS;
474 vty_out(vty, "Invalid type %s%s", argv[0],
475 VTY_NEWLINE);
477 return CMD_WARNING;
480 DEFUN (rip_redistribute_type_metric_routemap,
481 rip_redistribute_type_metric_routemap_cmd,
482 "redistribute " QUAGGA_REDIST_STR_RIPD " metric <0-16> route-map WORD",
483 REDIST_STR
484 QUAGGA_REDIST_HELP_STR_RIPD
485 "Metric\n"
486 "Metric value\n"
487 "Route map reference\n"
488 "Pointer to route-map entries\n")
490 int i;
491 int metric;
493 metric = atoi (argv[1]);
495 for (i = 0; redist_type[i].str; i++) {
496 if (strncmp(redist_type[i].str, argv[0],
497 redist_type[i].str_min_len) == 0)
499 rip_redistribute_metric_set (redist_type[i].type, metric);
500 rip_routemap_set (redist_type[i].type, argv[2]);
501 zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, redist_type[i].type);
502 return CMD_SUCCESS;
506 vty_out(vty, "Invalid type %s%s", argv[0],
507 VTY_NEWLINE);
509 return CMD_WARNING;
513 DEFUN (no_rip_redistribute_type_metric_routemap,
514 no_rip_redistribute_type_metric_routemap_cmd,
515 "no redistribute " QUAGGA_REDIST_STR_RIPD
516 " metric <0-16> route-map WORD",
517 NO_STR
518 REDIST_STR
519 QUAGGA_REDIST_HELP_STR_RIPD
520 "Metric\n"
521 "Metric value\n"
522 "Route map reference\n"
523 "Pointer to route-map entries\n")
525 int i;
527 for (i = 0; redist_type[i].str; i++)
529 if (strncmp(redist_type[i].str, argv[0],
530 redist_type[i].str_min_len) == 0)
532 if (rip_metric_unset (redist_type[i].type, atoi(argv[1])))
533 return CMD_WARNING;
534 if (rip_routemap_unset (redist_type[i].type, argv[2]))
536 rip_redistribute_metric_set(redist_type[i].type, atoi(argv[1]));
537 return CMD_WARNING;
539 rip_redistribute_unset (redist_type[i].type);
540 return CMD_SUCCESS;
544 vty_out(vty, "Invalid type %s%s", argv[0],
545 VTY_NEWLINE);
547 return CMD_WARNING;
550 /* Default information originate. */
552 DEFUN (rip_default_information_originate,
553 rip_default_information_originate_cmd,
554 "default-information originate",
555 "Control distribution of default route\n"
556 "Distribute a default route\n")
558 struct prefix_ipv4 p;
560 if (! rip->default_information)
562 memset (&p, 0, sizeof (struct prefix_ipv4));
563 p.family = AF_INET;
565 rip->default_information = 1;
567 rip_redistribute_add (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0,
568 NULL, 0, 0);
571 return CMD_SUCCESS;
574 DEFUN (no_rip_default_information_originate,
575 no_rip_default_information_originate_cmd,
576 "no default-information originate",
577 NO_STR
578 "Control distribution of default route\n"
579 "Distribute a default route\n")
581 struct prefix_ipv4 p;
583 if (rip->default_information)
585 memset (&p, 0, sizeof (struct prefix_ipv4));
586 p.family = AF_INET;
588 rip->default_information = 0;
590 rip_redistribute_delete (ZEBRA_ROUTE_RIP, RIP_ROUTE_DEFAULT, &p, 0);
593 return CMD_SUCCESS;
596 /* RIP configuration write function. */
597 static int
598 config_write_zebra (struct vty *vty)
600 if (! zclient->enable)
602 vty_out (vty, "no router zebra%s", VTY_NEWLINE);
603 return 1;
605 else if (! zclient->redist[ZEBRA_ROUTE_RIP])
607 vty_out (vty, "router zebra%s", VTY_NEWLINE);
608 vty_out (vty, " no redistribute rip%s", VTY_NEWLINE);
609 return 1;
611 return 0;
615 config_write_rip_redistribute (struct vty *vty, int config_mode)
617 int i;
619 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
620 if (i != zclient->redist_default && zclient->redist[i])
622 if (config_mode)
624 if (rip->route_map[i].metric_config)
626 if (rip->route_map[i].name)
627 vty_out (vty, " redistribute %s metric %d route-map %s%s",
628 zebra_route_string(i), rip->route_map[i].metric,
629 rip->route_map[i].name,
630 VTY_NEWLINE);
631 else
632 vty_out (vty, " redistribute %s metric %d%s",
633 zebra_route_string(i), rip->route_map[i].metric,
634 VTY_NEWLINE);
636 else
638 if (rip->route_map[i].name)
639 vty_out (vty, " redistribute %s route-map %s%s",
640 zebra_route_string(i), rip->route_map[i].name,
641 VTY_NEWLINE);
642 else
643 vty_out (vty, " redistribute %s%s", zebra_route_string(i),
644 VTY_NEWLINE);
647 else
648 vty_out (vty, " %s", zebra_route_string(i));
650 return 0;
653 /* Zebra node structure. */
654 static struct cmd_node zebra_node =
656 ZEBRA_NODE,
657 "%s(config-router)# ",
660 void
661 rip_zclient_init ()
663 /* Set default value to the zebra client structure. */
664 zclient = zclient_new ();
665 zclient_init (zclient, ZEBRA_ROUTE_RIP);
666 zclient->interface_add = rip_interface_add;
667 zclient->interface_delete = rip_interface_delete;
668 zclient->interface_address_add = rip_interface_address_add;
669 zclient->interface_address_delete = rip_interface_address_delete;
670 zclient->ipv4_route_add = rip_zebra_read_ipv4;
671 zclient->ipv4_route_delete = rip_zebra_read_ipv4;
672 zclient->interface_up = rip_interface_up;
673 zclient->interface_down = rip_interface_down;
675 /* Install zebra node. */
676 install_node (&zebra_node, config_write_zebra);
678 /* Install command elements to zebra node. */
679 install_element (CONFIG_NODE, &router_zebra_cmd);
680 install_element (CONFIG_NODE, &no_router_zebra_cmd);
681 install_default (ZEBRA_NODE);
682 install_element (ZEBRA_NODE, &rip_redistribute_rip_cmd);
683 install_element (ZEBRA_NODE, &no_rip_redistribute_rip_cmd);
685 /* Install command elements to rip node. */
686 install_element (RIP_NODE, &rip_redistribute_type_cmd);
687 install_element (RIP_NODE, &rip_redistribute_type_routemap_cmd);
688 install_element (RIP_NODE, &rip_redistribute_type_metric_cmd);
689 install_element (RIP_NODE, &rip_redistribute_type_metric_routemap_cmd);
690 install_element (RIP_NODE, &no_rip_redistribute_type_cmd);
691 install_element (RIP_NODE, &no_rip_redistribute_type_routemap_cmd);
692 install_element (RIP_NODE, &no_rip_redistribute_type_metric_cmd);
693 install_element (RIP_NODE, &no_rip_redistribute_type_metric_routemap_cmd);
694 install_element (RIP_NODE, &rip_default_information_originate_cmd);
695 install_element (RIP_NODE, &no_rip_default_information_originate_cmd);