Annotation of embedaddon/quagga/isisd/isis_zebra.c, revision 1.1.1.1
1.1 misho 1: /*
2: * IS-IS Rout(e)ing protocol - isis_zebra.c
3: *
4: * Copyright (C) 2001,2002 Sampo Saaristo
5: * Tampere University of Technology
6: * Institute of Communications Engineering
7: *
8: * This program is free software; you can redistribute it and/or modify it
9: * under the terms of the GNU General Public Licenseas published by the Free
10: * Software Foundation; either version 2 of the License, or (at your option)
11: * any later version.
12: *
13: * This program is distributed in the hope that it will be useful,but WITHOUT
14: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16: * more details.
17:
18: * You should have received a copy of the GNU General Public License along
19: * with this program; if not, write to the Free Software Foundation, Inc.,
20: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "thread.h"
26: #include "command.h"
27: #include "memory.h"
28: #include "log.h"
29: #include "if.h"
30: #include "network.h"
31: #include "prefix.h"
32: #include "zclient.h"
33: #include "stream.h"
34: #include "linklist.h"
35:
36: #include "isisd/dict.h"
37: #include "isisd/isis_constants.h"
38: #include "isisd/isis_common.h"
39: #include "isisd/isisd.h"
40: #include "isisd/isis_circuit.h"
41: #include "isisd/isis_csm.h"
42: #include "isisd/isis_route.h"
43: #include "isisd/isis_zebra.h"
44:
45: struct zclient *zclient = NULL;
46:
47: extern struct thread_master *master;
48: extern struct isis *isis;
49:
50: struct in_addr router_id_zebra;
51:
52: /* Router-id update message from zebra. */
53: static int
54: isis_router_id_update_zebra (int command, struct zclient *zclient,
55: zebra_size_t length)
56: {
57: struct prefix router_id;
58:
59: zebra_router_id_update_read (zclient->ibuf,&router_id);
60: router_id_zebra = router_id.u.prefix4;
61:
62: /* FIXME: Do we react somehow? */
63: return 0;
64: }
65:
66: static int
67: isis_zebra_if_add (int command, struct zclient *zclient, zebra_size_t length)
68: {
69: struct interface *ifp;
70:
71: ifp = zebra_interface_add_read (zclient->ibuf);
72:
73: if (isis->debugs & DEBUG_ZEBRA)
74: zlog_debug ("Zebra I/F add: %s index %d flags %ld metric %d mtu %d",
75: ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric, ifp->mtu);
76:
77: if (if_is_operative (ifp))
78: isis_csm_state_change (IF_UP_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
79:
80: return 0;
81: }
82:
83: static int
84: isis_zebra_if_del (int command, struct zclient *zclient, zebra_size_t length)
85: {
86: struct interface *ifp;
87: struct stream *s;
88:
89: s = zclient->ibuf;
90: ifp = zebra_interface_state_read (s);
91:
92: if (!ifp)
93: return 0;
94:
95: if (if_is_operative (ifp))
96: zlog_warn ("Zebra: got delete of %s, but interface is still up",
97: ifp->name);
98:
99: if (isis->debugs & DEBUG_ZEBRA)
100: zlog_debug ("Zebra I/F delete: %s index %d flags %ld metric %d mtu %d",
101: ifp->name, ifp->ifindex, (long)ifp->flags, ifp->metric, ifp->mtu);
102:
103:
104: /* Cannot call if_delete because we should retain the pseudo interface
105: in case there is configuration info attached to it. */
106: if_delete_retain(ifp);
107:
108: isis_csm_state_change (IF_DOWN_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
109:
110: ifp->ifindex = IFINDEX_INTERNAL;
111:
112: return 0;
113: }
114:
115: static struct interface *
116: zebra_interface_if_lookup (struct stream *s)
117: {
118: char ifname_tmp[INTERFACE_NAMSIZ];
119:
120: /* Read interface name. */
121: stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
122:
123: /* And look it up. */
124: return if_lookup_by_name_len(ifname_tmp,
125: strnlen(ifname_tmp, INTERFACE_NAMSIZ));
126: }
127:
128: static int
129: isis_zebra_if_state_up (int command, struct zclient *zclient,
130: zebra_size_t length)
131: {
132: struct interface *ifp;
133:
134: ifp = zebra_interface_if_lookup (zclient->ibuf);
135:
136: if (!ifp)
137: return 0;
138:
139: if (if_is_operative (ifp))
140: {
141: zebra_interface_if_set_value (zclient->ibuf, ifp);
142: /* HT: This is wrong actually. We can't assume that circuit exist
143: * if we delete circuit during if_state_down event. Needs rethink.
144: * TODO */
145: isis_circuit_update_params (circuit_scan_by_ifp (ifp), ifp);
146: return 0;
147: }
148:
149: zebra_interface_if_set_value (zclient->ibuf, ifp);
150: isis_csm_state_change (IF_UP_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
151:
152: return 0;
153: }
154:
155: static int
156: isis_zebra_if_state_down (int command, struct zclient *zclient,
157: zebra_size_t length)
158: {
159: struct interface *ifp;
160:
161: ifp = zebra_interface_if_lookup (zclient->ibuf);
162:
163: if (ifp == NULL)
164: return 0;
165:
166: if (if_is_operative (ifp))
167: {
168: zebra_interface_if_set_value (zclient->ibuf, ifp);
169: isis_csm_state_change (IF_DOWN_FROM_Z, circuit_scan_by_ifp (ifp), ifp);
170: }
171:
172: return 0;
173: }
174:
175: static int
176: isis_zebra_if_address_add (int command, struct zclient *zclient,
177: zebra_size_t length)
178: {
179: struct connected *c;
180: struct prefix *p;
181: char buf[BUFSIZ];
182:
183: c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
184: zclient->ibuf);
185:
186: if (c == NULL)
187: return 0;
188:
189: p = c->address;
190:
191: prefix2str (p, buf, BUFSIZ);
192: #ifdef EXTREME_DEBUG
193: if (p->family == AF_INET)
194: zlog_debug ("connected IP address %s", buf);
195: #ifdef HAVE_IPV6
196: if (p->family == AF_INET6)
197: zlog_debug ("connected IPv6 address %s", buf);
198: #endif /* HAVE_IPV6 */
199: #endif /* EXTREME_DEBUG */
200: if (if_is_operative (c->ifp))
201: isis_circuit_add_addr (circuit_scan_by_ifp (c->ifp), c);
202:
203: return 0;
204: }
205:
206: static int
207: isis_zebra_if_address_del (int command, struct zclient *client,
208: zebra_size_t length)
209: {
210: struct connected *c;
211: struct interface *ifp;
212: #ifdef EXTREME_DEBUG
213: struct prefix *p;
214: u_char buf[BUFSIZ];
215: #endif /* EXTREME_DEBUG */
216:
217: c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
218: zclient->ibuf);
219:
220: if (c == NULL)
221: return 0;
222:
223: ifp = c->ifp;
224:
225: #ifdef EXTREME_DEBUG
226: p = c->address;
227: prefix2str (p, buf, BUFSIZ);
228:
229: if (p->family == AF_INET)
230: zlog_debug ("disconnected IP address %s", buf);
231: #ifdef HAVE_IPV6
232: if (p->family == AF_INET6)
233: zlog_debug ("disconnected IPv6 address %s", buf);
234: #endif /* HAVE_IPV6 */
235: #endif /* EXTREME_DEBUG */
236:
237: if (if_is_operative (ifp))
238: isis_circuit_del_addr (circuit_scan_by_ifp (ifp), c);
239: connected_free (c);
240:
241: return 0;
242: }
243:
244: static void
245: isis_zebra_route_add_ipv4 (struct prefix *prefix,
246: struct isis_route_info *route_info)
247: {
248: u_char message, flags;
249: int psize;
250: struct stream *stream;
251: struct isis_nexthop *nexthop;
252: struct listnode *node;
253:
254: if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
255: return;
256:
257: if (zclient->redist[ZEBRA_ROUTE_ISIS])
258: {
259: message = 0;
260: flags = 0;
261:
262: SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
263: SET_FLAG (message, ZAPI_MESSAGE_METRIC);
264: #if 0
265: SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
266: #endif
267:
268: stream = zclient->obuf;
269: stream_reset (stream);
270: zclient_create_header (stream, ZEBRA_IPV4_ROUTE_ADD);
271: /* type */
272: stream_putc (stream, ZEBRA_ROUTE_ISIS);
273: /* flags */
274: stream_putc (stream, flags);
275: /* message */
276: stream_putc (stream, message);
277: /* prefix information */
278: psize = PSIZE (prefix->prefixlen);
279: stream_putc (stream, prefix->prefixlen);
280: stream_write (stream, (u_char *) & prefix->u.prefix4, psize);
281:
282: stream_putc (stream, listcount (route_info->nexthops));
283:
284: /* Nexthop, ifindex, distance and metric information */
285: for (ALL_LIST_ELEMENTS_RO (route_info->nexthops, node, nexthop))
286: {
287: /* FIXME: can it be ? */
288: if (nexthop->ip.s_addr != INADDR_ANY)
289: {
290: stream_putc (stream, ZEBRA_NEXTHOP_IPV4);
291: stream_put_in_addr (stream, &nexthop->ip);
292: }
293: else
294: {
295: stream_putc (stream, ZEBRA_NEXTHOP_IFINDEX);
296: stream_putl (stream, nexthop->ifindex);
297: }
298: }
299: #if 0
300: if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
301: stream_putc (stream, route_info->depth);
302: #endif
303: if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
304: stream_putl (stream, route_info->cost);
305:
306: stream_putw_at (stream, 0, stream_get_endp (stream));
307: zclient_send_message(zclient);
308: SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
309: }
310: }
311:
312: static void
313: isis_zebra_route_del_ipv4 (struct prefix *prefix,
314: struct isis_route_info *route_info)
315: {
316: struct zapi_ipv4 api;
317: struct prefix_ipv4 prefix4;
318:
319: if (zclient->redist[ZEBRA_ROUTE_ISIS])
320: {
321: api.type = ZEBRA_ROUTE_ISIS;
322: api.flags = 0;
323: api.message = 0;
324: prefix4.family = AF_INET;
325: prefix4.prefixlen = prefix->prefixlen;
326: prefix4.prefix = prefix->u.prefix4;
327: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, &prefix4, &api);
328: }
329: UNSET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
330:
331: return;
332: }
333:
334: #ifdef HAVE_IPV6
335: void
336: isis_zebra_route_add_ipv6 (struct prefix *prefix,
337: struct isis_route_info *route_info)
338: {
339: struct zapi_ipv6 api;
340: struct in6_addr **nexthop_list;
341: unsigned int *ifindex_list;
342: struct isis_nexthop6 *nexthop6;
343: int i, size;
344: struct listnode *node;
345: struct prefix_ipv6 prefix6;
346:
347: if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
348: return;
349:
350: api.type = ZEBRA_ROUTE_ISIS;
351: api.flags = 0;
352: api.message = 0;
353: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
354: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
355: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
356: api.metric = route_info->cost;
357: #if 0
358: SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
359: api.distance = route_info->depth;
360: #endif
361: api.nexthop_num = listcount (route_info->nexthops6);
362: api.ifindex_num = listcount (route_info->nexthops6);
363:
364: /* allocate memory for nexthop_list */
365: size = sizeof (struct isis_nexthop6 *) * listcount (route_info->nexthops6);
366: nexthop_list = (struct in6_addr **) XMALLOC (MTYPE_ISIS_TMP, size);
367: if (!nexthop_list)
368: {
369: zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
370: return;
371: }
372:
373: /* allocate memory for ifindex_list */
374: size = sizeof (unsigned int) * listcount (route_info->nexthops6);
375: ifindex_list = (unsigned int *) XMALLOC (MTYPE_ISIS_TMP, size);
376: if (!ifindex_list)
377: {
378: zlog_err ("isis_zebra_add_route_ipv6: out of memory!");
379: XFREE (MTYPE_ISIS_TMP, nexthop_list);
380: return;
381: }
382:
383: /* for each nexthop */
384: i = 0;
385: for (ALL_LIST_ELEMENTS_RO (route_info->nexthops6, node, nexthop6))
386: {
387: if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
388: !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6))
389: {
390: api.nexthop_num--;
391: api.ifindex_num--;
392: continue;
393: }
394:
395: nexthop_list[i] = &nexthop6->ip6;
396: ifindex_list[i] = nexthop6->ifindex;
397: i++;
398: }
399:
400: api.nexthop = nexthop_list;
401: api.ifindex = ifindex_list;
402:
403: if (api.nexthop_num && api.ifindex_num)
404: {
405: prefix6.family = AF_INET6;
406: prefix6.prefixlen = prefix->prefixlen;
407: memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
408: zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient, &prefix6, &api);
409: SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
410: }
411:
412: XFREE (MTYPE_ISIS_TMP, nexthop_list);
413: XFREE (MTYPE_ISIS_TMP, ifindex_list);
414:
415: return;
416: }
417:
418: static void
419: isis_zebra_route_del_ipv6 (struct prefix *prefix,
420: struct isis_route_info *route_info)
421: {
422: struct zapi_ipv6 api;
423: struct in6_addr **nexthop_list;
424: unsigned int *ifindex_list;
425: struct isis_nexthop6 *nexthop6;
426: int i, size;
427: struct listnode *node;
428: struct prefix_ipv6 prefix6;
429:
430: if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
431: return;
432:
433: api.type = ZEBRA_ROUTE_ISIS;
434: api.flags = 0;
435: api.message = 0;
436: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
437: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
438: api.nexthop_num = listcount (route_info->nexthops6);
439: api.ifindex_num = listcount (route_info->nexthops6);
440:
441: /* allocate memory for nexthop_list */
442: size = sizeof (struct isis_nexthop6 *) * listcount (route_info->nexthops6);
443: nexthop_list = (struct in6_addr **) XMALLOC (MTYPE_ISIS_TMP, size);
444: if (!nexthop_list)
445: {
446: zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
447: return;
448: }
449:
450: /* allocate memory for ifindex_list */
451: size = sizeof (unsigned int) * listcount (route_info->nexthops6);
452: ifindex_list = (unsigned int *) XMALLOC (MTYPE_ISIS_TMP, size);
453: if (!ifindex_list)
454: {
455: zlog_err ("isis_zebra_route_del_ipv6: out of memory!");
456: XFREE (MTYPE_ISIS_TMP, nexthop_list);
457: return;
458: }
459:
460: /* for each nexthop */
461: i = 0;
462: for (ALL_LIST_ELEMENTS_RO (route_info->nexthops6, node, nexthop6))
463: {
464: if (!IN6_IS_ADDR_LINKLOCAL (&nexthop6->ip6) &&
465: !IN6_IS_ADDR_UNSPECIFIED (&nexthop6->ip6))
466: {
467: api.nexthop_num--;
468: api.ifindex_num--;
469: continue;
470: }
471:
472: nexthop_list[i] = &nexthop6->ip6;
473: ifindex_list[i] = nexthop6->ifindex;
474: i++;
475: }
476:
477: api.nexthop = nexthop_list;
478: api.ifindex = ifindex_list;
479:
480: if (api.nexthop_num && api.ifindex_num)
481: {
482: prefix6.family = AF_INET6;
483: prefix6.prefixlen = prefix->prefixlen;
484: memcpy (&prefix6.prefix, &prefix->u.prefix6, sizeof (struct in6_addr));
485: zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient, &prefix6, &api);
486: UNSET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
487: }
488:
489: XFREE (MTYPE_ISIS_TMP, nexthop_list);
490: XFREE (MTYPE_ISIS_TMP, ifindex_list);
491: }
492:
493: #endif /* HAVE_IPV6 */
494:
495: void
496: isis_zebra_route_update (struct prefix *prefix,
497: struct isis_route_info *route_info)
498: {
499: if (zclient->sock < 0)
500: return;
501:
502: if (!zclient->redist[ZEBRA_ROUTE_ISIS])
503: return;
504:
505: if (CHECK_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ACTIVE))
506: {
507: if (prefix->family == AF_INET)
508: isis_zebra_route_add_ipv4 (prefix, route_info);
509: #ifdef HAVE_IPV6
510: else if (prefix->family == AF_INET6)
511: isis_zebra_route_add_ipv6 (prefix, route_info);
512: #endif /* HAVE_IPV6 */
513: }
514: else
515: {
516: if (prefix->family == AF_INET)
517: isis_zebra_route_del_ipv4 (prefix, route_info);
518: #ifdef HAVE_IPV6
519: else if (prefix->family == AF_INET6)
520: isis_zebra_route_del_ipv6 (prefix, route_info);
521: #endif /* HAVE_IPV6 */
522: }
523: return;
524: }
525:
526: static int
527: isis_zebra_read_ipv4 (int command, struct zclient *zclient,
528: zebra_size_t length)
529: {
530: struct stream *stream;
531: struct zapi_ipv4 api;
532: struct prefix_ipv4 p;
533: unsigned long ifindex;
534: struct in_addr nexthop;
535:
536: stream = zclient->ibuf;
537: memset (&p, 0, sizeof (struct prefix_ipv4));
538: ifindex = 0;
539:
540: api.type = stream_getc (stream);
541: api.flags = stream_getc (stream);
542: api.message = stream_getc (stream);
543:
544: p.family = AF_INET;
545: p.prefixlen = stream_getc (stream);
546: stream_get (&p.prefix, stream, PSIZE (p.prefixlen));
547:
548: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
549: {
550: api.nexthop_num = stream_getc (stream);
551: nexthop.s_addr = stream_get_ipv4 (stream);
552: }
553: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
554: {
555: api.ifindex_num = stream_getc (stream);
556: ifindex = stream_getl (stream);
557: }
558: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
559: api.distance = stream_getc (stream);
560: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
561: api.metric = stream_getl (stream);
562: else
563: api.metric = 0;
564:
565: if (command == ZEBRA_IPV4_ROUTE_ADD)
566: {
567: if (isis->debugs & DEBUG_ZEBRA)
568: zlog_debug ("IPv4 Route add from Z");
569: }
570:
571: return 0;
572: }
573:
574: #ifdef HAVE_IPV6
575: static int
576: isis_zebra_read_ipv6 (int command, struct zclient *zclient,
577: zebra_size_t length)
578: {
579: return 0;
580: }
581: #endif
582:
583: #define ISIS_TYPE_IS_REDISTRIBUTED(T) \
584: T == ZEBRA_ROUTE_MAX ? zclient->default_information : zclient->redist[type]
585:
586: int
587: isis_distribute_list_update (int routetype)
588: {
589: return 0;
590: }
591:
592: #if 0 /* Not yet. */
593: static int
594: isis_redistribute_default_set (int routetype, int metric_type,
595: int metric_value)
596: {
597: return 0;
598: }
599: #endif /* 0 */
600:
601: void
602: isis_zebra_init ()
603: {
604: zclient = zclient_new ();
605: zclient_init (zclient, ZEBRA_ROUTE_ISIS);
606: zclient->router_id_update = isis_router_id_update_zebra;
607: zclient->interface_add = isis_zebra_if_add;
608: zclient->interface_delete = isis_zebra_if_del;
609: zclient->interface_up = isis_zebra_if_state_up;
610: zclient->interface_down = isis_zebra_if_state_down;
611: zclient->interface_address_add = isis_zebra_if_address_add;
612: zclient->interface_address_delete = isis_zebra_if_address_del;
613: zclient->ipv4_route_add = isis_zebra_read_ipv4;
614: zclient->ipv4_route_delete = isis_zebra_read_ipv4;
615: #ifdef HAVE_IPV6
616: zclient->ipv6_route_add = isis_zebra_read_ipv6;
617: zclient->ipv6_route_delete = isis_zebra_read_ipv6;
618: #endif /* HAVE_IPV6 */
619:
620: return;
621: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_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 / isisd