1: /*
2: * RIPngd and zebra interface.
3: * Copyright (C) 1998, 1999 Kunihiro Ishiguro
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2, or (at your option) any
10: * later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "command.h"
26: #include "prefix.h"
27: #include "table.h"
28: #include "stream.h"
29: #include "memory.h"
30: #include "routemap.h"
31: #include "zclient.h"
32: #include "log.h"
33:
34: #include "ripngd/ripngd.h"
35: #include "ripngd/ripng_debug.h"
36:
37: /* All information about zebra. */
38: struct zclient *zclient = NULL;
39:
40: /* Send ECMP routes to zebra. */
41: static void
42: ripng_zebra_ipv6_send (struct route_node *rp, u_char cmd)
43: {
44: static struct in6_addr **nexthops = NULL;
45: static ifindex_t *ifindexes = NULL;
46: static unsigned int nexthops_len = 0;
47:
48: struct list *list = (struct list *)rp->info;
49: struct zapi_ipv6 api;
50: struct listnode *listnode = NULL;
51: struct ripng_info *rinfo = NULL;
52: int count = 0;
53:
54: if (vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_RIPNG], VRF_DEFAULT))
55: {
56: api.vrf_id = VRF_DEFAULT;
57: api.type = ZEBRA_ROUTE_RIPNG;
58: api.flags = 0;
59: api.message = 0;
60: api.safi = SAFI_UNICAST;
61:
62: if (nexthops_len < listcount (list))
63: {
64: nexthops_len = listcount (list);
65: nexthops = XREALLOC (MTYPE_TMP, nexthops,
66: nexthops_len * sizeof (struct in6_addr *));
67: ifindexes = XREALLOC (MTYPE_TMP, ifindexes,
68: nexthops_len * sizeof (unsigned int));
69: }
70:
71: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
72: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
73: for (ALL_LIST_ELEMENTS_RO (list, listnode, rinfo))
74: {
75: nexthops[count] = &rinfo->nexthop;
76: ifindexes[count] = rinfo->ifindex;
77: count++;
78: if (cmd == ZEBRA_IPV6_ROUTE_ADD)
79: SET_FLAG (rinfo->flags, RIPNG_RTF_FIB);
80: else
81: UNSET_FLAG (rinfo->flags, RIPNG_RTF_FIB);
82: }
83:
84: api.nexthop = nexthops;
85: api.nexthop_num = count;
86: api.ifindex = ifindexes;
87: api.ifindex_num = count;
88:
89: rinfo = listgetdata (listhead (list));
90:
91: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
92: api.metric = rinfo->metric;
93:
94: zapi_ipv6_route (cmd, zclient,
95: (struct prefix_ipv6 *)&rp->p, &api);
96:
97: if (IS_RIPNG_DEBUG_ZEBRA)
98: {
99: if (ripng->ecmp)
100: zlog_debug ("%s: %s/%d nexthops %d",
101: (cmd == ZEBRA_IPV6_ROUTE_ADD) ? \
102: "Install into zebra" : "Delete from zebra",
103: inet6_ntoa (rp->p.u.prefix6), rp->p.prefixlen, count);
104: else
105: zlog_debug ("%s: %s/%d",
106: (cmd == ZEBRA_IPV6_ROUTE_ADD) ? \
107: "Install into zebra" : "Delete from zebra",
108: inet6_ntoa (rp->p.u.prefix6), rp->p.prefixlen);
109: }
110: }
111: }
112:
113: /* Add/update ECMP routes to zebra. */
114: void
115: ripng_zebra_ipv6_add (struct route_node *rp)
116: {
117: ripng_zebra_ipv6_send (rp, ZEBRA_IPV6_ROUTE_ADD);
118: }
119:
120: /* Delete ECMP routes from zebra. */
121: void
122: ripng_zebra_ipv6_delete (struct route_node *rp)
123: {
124: ripng_zebra_ipv6_send (rp, ZEBRA_IPV6_ROUTE_DELETE);
125: }
126:
127: /* Zebra route add and delete treatment. */
128: static int
129: ripng_zebra_read_ipv6 (int command, struct zclient *zclient,
130: zebra_size_t length, vrf_id_t vrf_id)
131: {
132: struct stream *s;
133: struct zapi_ipv6 api;
134: unsigned long ifindex;
135: struct in6_addr nexthop;
136: struct prefix_ipv6 p;
137: unsigned char plength = 0;
138:
139: s = zclient->ibuf;
140: ifindex = 0;
141: memset (&nexthop, 0, sizeof (struct in6_addr));
142:
143: /* Type, flags, message. */
144: api.type = stream_getc (s);
145: api.flags = stream_getc (s);
146: api.message = stream_getc (s);
147:
148: /* IPv6 prefix. */
149: memset (&p, 0, sizeof (struct prefix_ipv6));
150: p.family = AF_INET6;
151: plength = stream_getc (s);
152: p.prefixlen = MIN(IPV6_MAX_PREFIXLEN, plength);
153: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
154:
155: /* Nexthop, ifindex, distance, metric. */
156: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
157: {
158: api.nexthop_num = stream_getc (s);
159: stream_get (&nexthop, s, 16);
160: }
161: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
162: {
163: api.ifindex_num = stream_getc (s);
164: ifindex = stream_getl (s);
165: }
166: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
167: api.distance = stream_getc (s);
168: else
169: api.distance = 0;
170: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
171: api.metric = stream_getl (s);
172: else
173: api.metric = 0;
174:
175: if (command == ZEBRA_IPV6_ROUTE_ADD)
176: ripng_redistribute_add (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex, &nexthop);
177: else
178: ripng_redistribute_delete (api.type, RIPNG_ROUTE_REDISTRIBUTE, &p, ifindex);
179:
180: return 0;
181: }
182:
183: void
184: ripng_zclient_reset (void)
185: {
186: zclient_reset (zclient);
187: }
188:
189: static int
190: ripng_redistribute_unset (int type)
191: {
192: if (! vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT))
193: return CMD_SUCCESS;
194:
195: vrf_bitmap_set (zclient->redist[type], VRF_DEFAULT);
196:
197: if (zclient->sock > 0)
198: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type,
199: VRF_DEFAULT);
200:
201: ripng_redistribute_withdraw (type);
202:
203: return CMD_SUCCESS;
204: }
205:
206: int
207: ripng_redistribute_check (int type)
208: {
209: return vrf_bitmap_check (zclient->redist[type], VRF_DEFAULT);
210: }
211:
212: static void
213: ripng_redistribute_metric_set (int type, int metric)
214: {
215: ripng->route_map[type].metric_config = 1;
216: ripng->route_map[type].metric = metric;
217: }
218:
219: static int
220: ripng_redistribute_metric_unset (int type)
221: {
222: ripng->route_map[type].metric_config = 0;
223: ripng->route_map[type].metric = 0;
224: return 0;
225: }
226:
227: static void
228: ripng_redistribute_routemap_set (int type, const char *name)
229: {
230: if (ripng->route_map[type].name)
231: free (ripng->route_map[type].name);
232:
233: ripng->route_map[type].name = strdup (name);
234: ripng->route_map[type].map = route_map_lookup_by_name (name);
235: }
236:
237: static void
238: ripng_redistribute_routemap_unset (int type)
239: {
240: if (ripng->route_map[type].name)
241: free (ripng->route_map[type].name);
242:
243: ripng->route_map[type].name = NULL;
244: ripng->route_map[type].map = NULL;
245: }
246:
247: /* Redistribution types */
248: static struct {
249: int type;
250: int str_min_len;
251: const char *str;
252: } redist_type[] = {
253: {ZEBRA_ROUTE_KERNEL, 1, "kernel"},
254: {ZEBRA_ROUTE_CONNECT, 1, "connected"},
255: {ZEBRA_ROUTE_STATIC, 1, "static"},
256: {ZEBRA_ROUTE_OSPF6, 1, "ospf6"},
257: {ZEBRA_ROUTE_BGP, 2, "bgp"},
258: {ZEBRA_ROUTE_BABEL, 2, "babel"},
259: {0, 0, NULL}
260: };
261:
262: void
263: ripng_redistribute_clean ()
264: {
265: int i;
266:
267: for (i = 0; redist_type[i].str; i++)
268: {
269: if (vrf_bitmap_check (zclient->redist[redist_type[i].type], VRF_DEFAULT))
270: {
271: if (zclient->sock > 0)
272: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE,
273: zclient, redist_type[i].type,
274: VRF_DEFAULT);
275:
276: vrf_bitmap_unset (zclient->redist[redist_type[i].type], VRF_DEFAULT);
277:
278: /* Remove the routes from RIPng table. */
279: ripng_redistribute_withdraw (redist_type[i].type);
280: }
281: }
282: }
283:
284: DEFUN (router_zebra,
285: router_zebra_cmd,
286: "router zebra",
287: "Enable a routing process\n"
288: "Make connection to zebra daemon\n")
289: {
290: vty->node = ZEBRA_NODE;
291: zclient->enable = 1;
292: zclient_start (zclient);
293: return CMD_SUCCESS;
294: }
295:
296: DEFUN (no_router_zebra,
297: no_router_zebra_cmd,
298: "no router zebra",
299: NO_STR
300: "Disable a routing process\n"
301: "Stop connection to zebra daemon\n")
302: {
303: zclient->enable = 0;
304: zclient_stop (zclient);
305: return CMD_SUCCESS;
306: }
307:
308: DEFUN (ripng_redistribute_ripng,
309: ripng_redistribute_ripng_cmd,
310: "redistribute ripng",
311: "Redistribute information from another routing protocol\n"
312: "RIPng route\n")
313: {
314: vrf_bitmap_set (zclient->redist[ZEBRA_ROUTE_RIPNG], VRF_DEFAULT);
315: return CMD_SUCCESS;
316: }
317:
318: DEFUN (no_ripng_redistribute_ripng,
319: no_ripng_redistribute_ripng_cmd,
320: "no redistribute ripng",
321: NO_STR
322: "Redistribute information from another routing protocol\n"
323: "RIPng route\n")
324: {
325: vrf_bitmap_unset (zclient->redist[ZEBRA_ROUTE_RIPNG], VRF_DEFAULT);
326: return CMD_SUCCESS;
327: }
328:
329: DEFUN (ripng_redistribute_type,
330: ripng_redistribute_type_cmd,
331: "redistribute " QUAGGA_REDIST_STR_RIPNGD,
332: "Redistribute\n"
333: QUAGGA_REDIST_HELP_STR_RIPNGD)
334: {
335: int type;
336:
337: type = proto_redistnum(AFI_IP6, argv[0]);
338:
339: if (type < 0)
340: {
341: vty_out(vty, "Invalid type %s%s", argv[0], VTY_NEWLINE);
342: return CMD_WARNING;
343: }
344:
345: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type, VRF_DEFAULT);
346: return CMD_SUCCESS;
347: }
348:
349: DEFUN (no_ripng_redistribute_type,
350: no_ripng_redistribute_type_cmd,
351: "no redistribute " QUAGGA_REDIST_STR_RIPNGD,
352: NO_STR
353: "Redistribute\n"
354: QUAGGA_REDIST_HELP_STR_RIPNGD)
355: {
356: int type;
357:
358: type = proto_redistnum(AFI_IP6, argv[0]);
359:
360: if (type < 0)
361: {
362: vty_out(vty, "Invalid type %s%s", argv[0], VTY_NEWLINE);
363: return CMD_WARNING;
364: }
365:
366: ripng_redistribute_metric_unset (type);
367: ripng_redistribute_routemap_unset (type);
368: return ripng_redistribute_unset (type);
369: }
370:
371:
372: DEFUN (ripng_redistribute_type_metric,
373: ripng_redistribute_type_metric_cmd,
374: "redistribute " QUAGGA_REDIST_STR_RIPNGD " metric <0-16>",
375: "Redistribute\n"
376: QUAGGA_REDIST_HELP_STR_RIPNGD
377: "Metric\n"
378: "Metric value\n")
379: {
380: int type;
381: int metric;
382:
383: metric = atoi (argv[1]);
384: type = proto_redistnum(AFI_IP6, argv[0]);
385:
386: if (type < 0)
387: {
388: vty_out(vty, "Invalid type %s%s", argv[0], VTY_NEWLINE);
389: return CMD_WARNING;
390: }
391:
392: ripng_redistribute_metric_set (type, metric);
393: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type, VRF_DEFAULT);
394: return CMD_SUCCESS;
395: }
396:
397: ALIAS (no_ripng_redistribute_type,
398: no_ripng_redistribute_type_metric_cmd,
399: "no redistribute " QUAGGA_REDIST_STR_RIPNGD " metric <0-16>",
400: NO_STR
401: "Redistribute\n"
402: QUAGGA_REDIST_HELP_STR_RIPNGD
403: "Metric\n"
404: "Metric value\n")
405:
406: DEFUN (ripng_redistribute_type_routemap,
407: ripng_redistribute_type_routemap_cmd,
408: "redistribute " QUAGGA_REDIST_STR_RIPNGD " route-map WORD",
409: "Redistribute\n"
410: QUAGGA_REDIST_HELP_STR_RIPNGD
411: "Route map reference\n"
412: "Pointer to route-map entries\n")
413: {
414: int type;
415:
416: type = proto_redistnum(AFI_IP6, argv[0]);
417:
418: if (type < 0)
419: {
420: vty_out(vty, "Invalid type %s%s", argv[0], VTY_NEWLINE);
421: return CMD_WARNING;
422: }
423:
424: ripng_redistribute_routemap_set (type, argv[1]);
425: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type, VRF_DEFAULT);
426: return CMD_SUCCESS;
427: }
428:
429: ALIAS (no_ripng_redistribute_type,
430: no_ripng_redistribute_type_routemap_cmd,
431: "no redistribute " QUAGGA_REDIST_STR_RIPNGD " route-map WORD",
432: NO_STR
433: "Redistribute\n"
434: QUAGGA_REDIST_HELP_STR_RIPNGD
435: "Route map reference\n"
436: "Pointer to route-map entries\n")
437:
438: DEFUN (ripng_redistribute_type_metric_routemap,
439: ripng_redistribute_type_metric_routemap_cmd,
440: "redistribute " QUAGGA_REDIST_STR_RIPNGD " metric <0-16> route-map WORD",
441: "Redistribute\n"
442: QUAGGA_REDIST_HELP_STR_RIPNGD
443: "Metric\n"
444: "Metric value\n"
445: "Route map reference\n"
446: "Pointer to route-map entries\n")
447: {
448: int type;
449: int metric;
450:
451: type = proto_redistnum(AFI_IP6, argv[0]);
452: metric = atoi (argv[1]);
453:
454: if (type < 0)
455: {
456: vty_out(vty, "Invalid type %s%s", argv[0], VTY_NEWLINE);
457: return CMD_WARNING;
458: }
459:
460: ripng_redistribute_metric_set (type, metric);
461: ripng_redistribute_routemap_set (type, argv[2]);
462: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type, VRF_DEFAULT);
463: return CMD_SUCCESS;
464: }
465:
466: ALIAS (no_ripng_redistribute_type,
467: no_ripng_redistribute_type_metric_routemap_cmd,
468: "no redistribute " QUAGGA_REDIST_STR_RIPNGD " metric <0-16> route-map WORD",
469: NO_STR
470: "Redistribute\n"
471: QUAGGA_REDIST_HELP_STR_RIPNGD
472: "Route map reference\n"
473: "Pointer to route-map entries\n")
474:
475: void
476: ripng_redistribute_write (struct vty *vty, int config_mode)
477: {
478: int i;
479:
480: for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
481: if (i != zclient->redist_default &&
482: vrf_bitmap_check (zclient->redist[i], VRF_DEFAULT))
483: {
484: if (config_mode)
485: {
486: if (ripng->route_map[i].metric_config)
487: {
488: if (ripng->route_map[i].name)
489: vty_out (vty, " redistribute %s metric %d route-map %s%s",
490: zebra_route_string(i), ripng->route_map[i].metric,
491: ripng->route_map[i].name, VTY_NEWLINE);
492: else
493: vty_out (vty, " redistribute %s metric %d%s",
494: zebra_route_string(i), ripng->route_map[i].metric,
495: VTY_NEWLINE);
496: }
497: else
498: {
499: if (ripng->route_map[i].name)
500: vty_out (vty, " redistribute %s route-map %s%s",
501: zebra_route_string(i), ripng->route_map[i].name,
502: VTY_NEWLINE);
503: else
504: vty_out (vty, " redistribute %s%s", zebra_route_string(i),
505: VTY_NEWLINE);
506: }
507: }
508: else
509: vty_out (vty, " %s", zebra_route_string(i));
510: }
511: }
512:
513: /* RIPng configuration write function. */
514: static int
515: zebra_config_write (struct vty *vty)
516: {
517: if (! zclient->enable)
518: {
519: vty_out (vty, "no router zebra%s", VTY_NEWLINE);
520: return 1;
521: }
522: else if (! vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_RIPNG], VRF_DEFAULT))
523: {
524: vty_out (vty, "router zebra%s", VTY_NEWLINE);
525: vty_out (vty, " no redistribute ripng%s", VTY_NEWLINE);
526: return 1;
527: }
528: return 0;
529: }
530:
531: /* Zebra node structure. */
532: static struct cmd_node zebra_node =
533: {
534: ZEBRA_NODE,
535: "%s(config-router)# ",
536: };
537:
538: static void
539: ripng_zebra_connected (struct zclient *zclient)
540: {
541: zclient_send_requests (zclient, VRF_DEFAULT);
542: }
543:
544: /* Initialize zebra structure and it's commands. */
545: void
546: zebra_init (struct thread_master *master)
547: {
548: /* Allocate zebra structure. */
549: zclient = zclient_new (master);
550: zclient_init (zclient, ZEBRA_ROUTE_RIPNG);
551:
552: zclient->zebra_connected = ripng_zebra_connected;
553: zclient->interface_up = ripng_interface_up;
554: zclient->interface_down = ripng_interface_down;
555: zclient->interface_add = ripng_interface_add;
556: zclient->interface_delete = ripng_interface_delete;
557: zclient->interface_address_add = ripng_interface_address_add;
558: zclient->interface_address_delete = ripng_interface_address_delete;
559: zclient->ipv6_route_add = ripng_zebra_read_ipv6;
560: zclient->ipv6_route_delete = ripng_zebra_read_ipv6;
561:
562: /* Install zebra node. */
563: install_node (&zebra_node, zebra_config_write);
564:
565: /* Install command element for zebra node. */
566: install_element (CONFIG_NODE, &router_zebra_cmd);
567: install_element (CONFIG_NODE, &no_router_zebra_cmd);
568: install_default (ZEBRA_NODE);
569: install_element (ZEBRA_NODE, &ripng_redistribute_ripng_cmd);
570: install_element (ZEBRA_NODE, &no_ripng_redistribute_ripng_cmd);
571:
572: /* Install command elements to ripng node */
573: install_element (RIPNG_NODE, &ripng_redistribute_type_cmd);
574: install_element (RIPNG_NODE, &ripng_redistribute_type_routemap_cmd);
575: install_element (RIPNG_NODE, &ripng_redistribute_type_metric_cmd);
576: install_element (RIPNG_NODE, &ripng_redistribute_type_metric_routemap_cmd);
577: install_element (RIPNG_NODE, &no_ripng_redistribute_type_cmd);
578: install_element (RIPNG_NODE, &no_ripng_redistribute_type_routemap_cmd);
579: install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_cmd);
580: install_element (RIPNG_NODE, &no_ripng_redistribute_type_metric_routemap_cmd);
581: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ripng_zebra.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ripngd