Annotation of embedaddon/quagga/ospfd/ospf_zebra.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Zebra connect library for OSPFd
3: * Copyright (C) 1997, 98, 99, 2000 Kunihiro Ishiguro, Toshiaki Takada
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
19: * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20: * Boston, MA 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "thread.h"
26: #include "command.h"
27: #include "network.h"
28: #include "prefix.h"
29: #include "routemap.h"
30: #include "table.h"
31: #include "stream.h"
32: #include "memory.h"
33: #include "zclient.h"
34: #include "filter.h"
35: #include "plist.h"
36: #include "log.h"
37:
38: #include "ospfd/ospfd.h"
39: #include "ospfd/ospf_interface.h"
40: #include "ospfd/ospf_ism.h"
41: #include "ospfd/ospf_asbr.h"
42: #include "ospfd/ospf_asbr.h"
43: #include "ospfd/ospf_abr.h"
44: #include "ospfd/ospf_lsa.h"
45: #include "ospfd/ospf_dump.h"
46: #include "ospfd/ospf_route.h"
47: #include "ospfd/ospf_zebra.h"
48: #ifdef HAVE_SNMP
49: #include "ospfd/ospf_snmp.h"
50: #endif /* HAVE_SNMP */
51:
52: /* Zebra structure to hold current status. */
53: struct zclient *zclient = NULL;
54:
55: /* For registering threads. */
56: extern struct thread_master *master;
57: struct in_addr router_id_zebra;
58:
59: /* Router-id update message from zebra. */
60: static int
61: ospf_router_id_update_zebra (int command, struct zclient *zclient,
62: zebra_size_t length)
63: {
64: struct ospf *ospf;
65: struct prefix router_id;
66: zebra_router_id_update_read(zclient->ibuf,&router_id);
67:
68: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
69: {
70: char buf[128];
71: prefix2str(&router_id, buf, sizeof(buf));
72: zlog_debug("Zebra rcvd: router id update %s", buf);
73: }
74:
75: router_id_zebra = router_id.u.prefix4;
76:
77: ospf = ospf_lookup ();
78:
79: if (ospf != NULL)
80: ospf_router_id_update (ospf);
81:
82: return 0;
83: }
84:
85: /* Inteface addition message from zebra. */
86: static int
87: ospf_interface_add (int command, struct zclient *zclient, zebra_size_t length)
88: {
89: struct interface *ifp;
90:
91: ifp = zebra_interface_add_read (zclient->ibuf);
92:
93: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
94: zlog_debug ("Zebra: interface add %s index %d flags %llx metric %d mtu %d",
95: ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
96: ifp->metric, ifp->mtu);
97:
98: assert (ifp->info);
99:
100: if (!OSPF_IF_PARAM_CONFIGURED (IF_DEF_PARAMS (ifp), type))
101: {
102: SET_IF_PARAM (IF_DEF_PARAMS (ifp), type);
103: IF_DEF_PARAMS (ifp)->type = ospf_default_iftype(ifp);
104: }
105:
106: ospf_if_update (NULL, ifp);
107:
108: #ifdef HAVE_SNMP
109: ospf_snmp_if_update (ifp);
110: #endif /* HAVE_SNMP */
111:
112: return 0;
113: }
114:
115: static int
116: ospf_interface_delete (int command, struct zclient *zclient,
117: zebra_size_t length)
118: {
119: struct interface *ifp;
120: struct stream *s;
121: struct route_node *rn;
122:
123: s = zclient->ibuf;
124: /* zebra_interface_state_read() updates interface structure in iflist */
125: ifp = zebra_interface_state_read (s);
126:
127: if (ifp == NULL)
128: return 0;
129:
130: if (if_is_up (ifp))
131: zlog_warn ("Zebra: got delete of %s, but interface is still up",
132: ifp->name);
133:
134: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
135: zlog_debug
136: ("Zebra: interface delete %s index %d flags %lld metric %d mtu %d",
137: ifp->name, ifp->ifindex, ifp->flags, ifp->metric, ifp->mtu);
138:
139: #ifdef HAVE_SNMP
140: ospf_snmp_if_delete (ifp);
141: #endif /* HAVE_SNMP */
142:
143: for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
144: if (rn->info)
145: ospf_if_free ((struct ospf_interface *) rn->info);
146:
147: ifp->ifindex = IFINDEX_INTERNAL;
148: return 0;
149: }
150:
151: static struct interface *
152: zebra_interface_if_lookup (struct stream *s)
153: {
154: char ifname_tmp[INTERFACE_NAMSIZ];
155:
156: /* Read interface name. */
157: stream_get (ifname_tmp, s, INTERFACE_NAMSIZ);
158:
159: /* And look it up. */
160: return if_lookup_by_name_len(ifname_tmp,
161: strnlen(ifname_tmp, INTERFACE_NAMSIZ));
162: }
163:
164: static int
165: ospf_interface_state_up (int command, struct zclient *zclient,
166: zebra_size_t length)
167: {
168: struct interface *ifp;
169: struct ospf_interface *oi;
170: struct route_node *rn;
171:
172: ifp = zebra_interface_if_lookup (zclient->ibuf);
173:
174: if (ifp == NULL)
175: return 0;
176:
177: /* Interface is already up. */
178: if (if_is_operative (ifp))
179: {
180: /* Temporarily keep ifp values. */
181: struct interface if_tmp;
182: memcpy (&if_tmp, ifp, sizeof (struct interface));
183:
184: zebra_interface_if_set_value (zclient->ibuf, ifp);
185:
186: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
187: zlog_debug ("Zebra: Interface[%s] state update.", ifp->name);
188:
189: if (if_tmp.bandwidth != ifp->bandwidth)
190: {
191: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
192: zlog_debug ("Zebra: Interface[%s] bandwidth change %d -> %d.",
193: ifp->name, if_tmp.bandwidth, ifp->bandwidth);
194:
195: ospf_if_recalculate_output_cost (ifp);
196: }
197:
198: if (if_tmp.mtu != ifp->mtu)
199: {
200: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
201: zlog_debug ("Zebra: Interface[%s] MTU change %u -> %u.",
202: ifp->name, if_tmp.mtu, ifp->mtu);
203:
204: /* Must reset the interface (simulate down/up) when MTU changes. */
205: ospf_if_reset(ifp);
206: }
207: return 0;
208: }
209:
210: zebra_interface_if_set_value (zclient->ibuf, ifp);
211:
212: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
213: zlog_debug ("Zebra: Interface[%s] state change to up.", ifp->name);
214:
215: for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
216: {
217: if ((oi = rn->info) == NULL)
218: continue;
219:
220: ospf_if_up (oi);
221: }
222:
223: return 0;
224: }
225:
226: static int
227: ospf_interface_state_down (int command, struct zclient *zclient,
228: zebra_size_t length)
229: {
230: struct interface *ifp;
231: struct ospf_interface *oi;
232: struct route_node *node;
233:
234: ifp = zebra_interface_state_read (zclient->ibuf);
235:
236: if (ifp == NULL)
237: return 0;
238:
239: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
240: zlog_debug ("Zebra: Interface[%s] state change to down.", ifp->name);
241:
242: for (node = route_top (IF_OIFS (ifp)); node; node = route_next (node))
243: {
244: if ((oi = node->info) == NULL)
245: continue;
246: ospf_if_down (oi);
247: }
248:
249: return 0;
250: }
251:
252: static int
253: ospf_interface_address_add (int command, struct zclient *zclient,
254: zebra_size_t length)
255: {
256: struct connected *c;
257:
258: c = zebra_interface_address_read (command, zclient->ibuf);
259:
260: if (c == NULL)
261: return 0;
262:
263: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
264: {
265: char buf[128];
266: prefix2str(c->address, buf, sizeof(buf));
267: zlog_debug("Zebra: interface %s address add %s", c->ifp->name, buf);
268: }
269:
270: ospf_if_update (NULL, c->ifp);
271:
272: #ifdef HAVE_SNMP
273: ospf_snmp_if_update (c->ifp);
274: #endif /* HAVE_SNMP */
275:
276: return 0;
277: }
278:
279: static int
280: ospf_interface_address_delete (int command, struct zclient *zclient,
281: zebra_size_t length)
282: {
283: struct connected *c;
284: struct interface *ifp;
285: struct ospf_interface *oi;
286: struct route_node *rn;
287: struct prefix p;
288:
289: c = zebra_interface_address_read (command, zclient->ibuf);
290:
291: if (c == NULL)
292: return 0;
293:
294: if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
295: {
296: char buf[128];
297: prefix2str(c->address, buf, sizeof(buf));
298: zlog_debug("Zebra: interface %s address delete %s", c->ifp->name, buf);
299: }
300:
301: ifp = c->ifp;
302: p = *c->address;
303: p.prefixlen = IPV4_MAX_PREFIXLEN;
304:
305: rn = route_node_lookup (IF_OIFS (ifp), &p);
306: if (!rn)
307: {
308: connected_free (c);
309: return 0;
310: }
311:
312: assert (rn->info);
313: oi = rn->info;
314:
315: /* Call interface hook functions to clean up */
316: ospf_if_free (oi);
317:
318: #ifdef HAVE_SNMP
319: ospf_snmp_if_update (c->ifp);
320: #endif /* HAVE_SNMP */
321:
322: connected_free (c);
323:
324: return 0;
325: }
326:
327: void
328: ospf_zebra_add (struct prefix_ipv4 *p, struct ospf_route *or)
329: {
330: u_char message;
331: u_char distance;
332: u_char flags;
333: int psize;
334: struct stream *s;
335: struct ospf_path *path;
336: struct listnode *node;
337:
338: if (zclient->redist[ZEBRA_ROUTE_OSPF])
339: {
340: message = 0;
341: flags = 0;
342:
343: /* OSPF pass nexthop and metric */
344: SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
345: SET_FLAG (message, ZAPI_MESSAGE_METRIC);
346:
347: /* Distance value. */
348: distance = ospf_distance_apply (p, or);
349: if (distance)
350: SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
351:
352: /* Make packet. */
353: s = zclient->obuf;
354: stream_reset (s);
355:
356: /* Put command, type, flags, message. */
357: zclient_create_header (s, ZEBRA_IPV4_ROUTE_ADD);
358: stream_putc (s, ZEBRA_ROUTE_OSPF);
359: stream_putc (s, flags);
360: stream_putc (s, message);
361:
362: /* Put prefix information. */
363: psize = PSIZE (p->prefixlen);
364: stream_putc (s, p->prefixlen);
365: stream_write (s, (u_char *) & p->prefix, psize);
366:
367: /* Nexthop count. */
368: stream_putc (s, or->paths->count);
369:
370: /* Nexthop, ifindex, distance and metric information. */
371: for (ALL_LIST_ELEMENTS_RO (or->paths, node, path))
372: {
373: if (path->nexthop.s_addr != INADDR_ANY)
374: {
375: stream_putc (s, ZEBRA_NEXTHOP_IPV4);
376: stream_put_in_addr (s, &path->nexthop);
377: }
378: else
379: {
380: stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
381: if (path->ifindex)
382: stream_putl (s, path->ifindex);
383: else
384: stream_putl (s, 0);
385: }
386:
387: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
388: {
389: char buf[2][INET_ADDRSTRLEN];
390: zlog_debug("Zebra: Route add %s/%d nexthop %s",
391: inet_ntop(AF_INET, &p->prefix,
392: buf[0], sizeof(buf[0])),
393: p->prefixlen,
394: inet_ntop(AF_INET, &path->nexthop,
395: buf[1], sizeof(buf[1])));
396: }
397: }
398:
399: if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
400: stream_putc (s, distance);
401: if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
402: {
403: if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
404: stream_putl (s, or->cost + or->u.ext.type2_cost);
405: else if (or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
406: stream_putl (s, or->u.ext.type2_cost);
407: else
408: stream_putl (s, or->cost);
409: }
410:
411: stream_putw_at (s, 0, stream_get_endp (s));
412:
413: zclient_send_message(zclient);
414: }
415: }
416:
417: void
418: ospf_zebra_delete (struct prefix_ipv4 *p, struct ospf_route *or)
419: {
420: struct zapi_ipv4 api;
421: struct ospf_path *path;
422: struct in_addr *nexthop;
423: struct listnode *node, *nnode;
424:
425: if (zclient->redist[ZEBRA_ROUTE_OSPF])
426: {
427: api.type = ZEBRA_ROUTE_OSPF;
428: api.flags = 0;
429: api.message = 0;
430: api.ifindex_num = 0;
431: api.nexthop_num = 0;
432:
433: for (ALL_LIST_ELEMENTS (or->paths, node, nnode, path))
434: {
435: if (path->nexthop.s_addr != INADDR_ANY)
436: {
437: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
438: api.nexthop_num = 1;
439: nexthop = &path->nexthop;
440: api.nexthop = &nexthop;
441: }
442: else if (if_lookup_by_index(path->ifindex))
443: {
444: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
445: api.ifindex_num = 1;
446: api.ifindex = &path->ifindex;
447: }
448: else if ( IS_DEBUG_OSPF(zebra,ZEBRA_REDISTRIBUTE) )
449: {
450: zlog_debug("Zebra: no ifp %s %d",
451: inet_ntoa(p->prefix),
452: p->prefixlen);
453: }
454:
455: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
456:
457: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE) && api.nexthop_num)
458: {
459: char buf[2][INET_ADDRSTRLEN];
460: zlog_debug("Zebra: Route delete %s/%d nexthop %s",
461: inet_ntop(AF_INET, &p->prefix, buf[0], sizeof(buf[0])),
462: p->prefixlen,
463: inet_ntop(AF_INET, *api.nexthop,
464: buf[1], sizeof(buf[1])));
465: }
466: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE) && api.ifindex_num)
467: {
468: zlog_debug ("Zebra: Route delete %s/%d ifindex %d",
469: inet_ntoa (p->prefix),
470: p->prefixlen, *api.ifindex);
471: }
472: }
473: }
474: }
475:
476: void
477: ospf_zebra_add_discard (struct prefix_ipv4 *p)
478: {
479: struct zapi_ipv4 api;
480:
481: if (zclient->redist[ZEBRA_ROUTE_OSPF])
482: {
483: api.type = ZEBRA_ROUTE_OSPF;
484: api.flags = ZEBRA_FLAG_BLACKHOLE;
485: api.message = 0;
486: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
487: api.nexthop_num = 0;
488: api.ifindex_num = 0;
489:
490: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient, p, &api);
491:
492: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
493: zlog_debug ("Zebra: Route add discard %s/%d",
494: inet_ntoa (p->prefix), p->prefixlen);
495: }
496: }
497:
498: void
499: ospf_zebra_delete_discard (struct prefix_ipv4 *p)
500: {
501: struct zapi_ipv4 api;
502:
503: if (zclient->redist[ZEBRA_ROUTE_OSPF])
504: {
505: api.type = ZEBRA_ROUTE_OSPF;
506: api.flags = ZEBRA_FLAG_BLACKHOLE;
507: api.message = 0;
508: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
509: api.nexthop_num = 0;
510: api.ifindex_num = 0;
511:
512: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
513:
514: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
515: zlog_debug ("Zebra: Route delete discard %s/%d",
516: inet_ntoa (p->prefix), p->prefixlen);
517:
518: }
519: }
520:
521: int
522: ospf_is_type_redistributed (int type)
523: {
524: return (DEFAULT_ROUTE_TYPE (type)) ?
525: zclient->default_information : zclient->redist[type];
526: }
527:
528: int
529: ospf_redistribute_set (struct ospf *ospf, int type, int mtype, int mvalue)
530: {
531: int force = 0;
532:
533: if (ospf_is_type_redistributed (type))
534: {
535: if (mtype != ospf->dmetric[type].type)
536: {
537: ospf->dmetric[type].type = mtype;
538: force = LSA_REFRESH_FORCE;
539: }
540: if (mvalue != ospf->dmetric[type].value)
541: {
542: ospf->dmetric[type].value = mvalue;
543: force = LSA_REFRESH_FORCE;
544: }
545:
546: ospf_external_lsa_refresh_type (ospf, type, force);
547:
548: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
549: zlog_debug ("Redistribute[%s]: Refresh Type[%d], Metric[%d]",
550: ospf_redist_string(type),
551: metric_type (ospf, type), metric_value (ospf, type));
552:
553: return CMD_SUCCESS;
554: }
555:
556: ospf->dmetric[type].type = mtype;
557: ospf->dmetric[type].value = mvalue;
558:
559: zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
560:
561: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
562: zlog_debug ("Redistribute[%s]: Start Type[%d], Metric[%d]",
563: ospf_redist_string(type),
564: metric_type (ospf, type), metric_value (ospf, type));
565:
566: ospf_asbr_status_update (ospf, ++ospf->redistribute);
567:
568: return CMD_SUCCESS;
569: }
570:
571: int
572: ospf_redistribute_unset (struct ospf *ospf, int type)
573: {
574: if (type == zclient->redist_default)
575: return CMD_SUCCESS;
576:
577: if (!ospf_is_type_redistributed (type))
578: return CMD_SUCCESS;
579:
580: zclient_redistribute (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
581:
582: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
583: zlog_debug ("Redistribute[%s]: Stop",
584: ospf_redist_string(type));
585:
586: ospf->dmetric[type].type = -1;
587: ospf->dmetric[type].value = -1;
588:
589: /* Remove the routes from OSPF table. */
590: ospf_redistribute_withdraw (ospf, type);
591:
592: ospf_asbr_status_update (ospf, --ospf->redistribute);
593:
594: return CMD_SUCCESS;
595: }
596:
597: int
598: ospf_redistribute_default_set (struct ospf *ospf, int originate,
599: int mtype, int mvalue)
600: {
601: ospf->default_originate = originate;
602: ospf->dmetric[DEFAULT_ROUTE].type = mtype;
603: ospf->dmetric[DEFAULT_ROUTE].value = mvalue;
604:
605: if (ospf_is_type_redistributed (DEFAULT_ROUTE))
606: {
607: /* if ospf->default_originate changes value, is calling
608: ospf_external_lsa_refresh_default sufficient to implement
609: the change? */
610: ospf_external_lsa_refresh_default (ospf);
611:
612: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
613: zlog_debug ("Redistribute[%s]: Refresh Type[%d], Metric[%d]",
614: ospf_redist_string(DEFAULT_ROUTE),
615: metric_type (ospf, DEFAULT_ROUTE),
616: metric_value (ospf, DEFAULT_ROUTE));
617: return CMD_SUCCESS;
618: }
619:
620: zclient_redistribute_default (ZEBRA_REDISTRIBUTE_DEFAULT_ADD, zclient);
621:
622: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
623: zlog_debug ("Redistribute[DEFAULT]: Start Type[%d], Metric[%d]",
624: metric_type (ospf, DEFAULT_ROUTE),
625: metric_value (ospf, DEFAULT_ROUTE));
626:
627: if (ospf->router_id.s_addr == 0)
628: ospf->external_origin |= (1 << DEFAULT_ROUTE);
629: else
630: thread_add_timer (master, ospf_default_originate_timer, ospf, 1);
631:
632: ospf_asbr_status_update (ospf, ++ospf->redistribute);
633:
634: return CMD_SUCCESS;
635: }
636:
637: int
638: ospf_redistribute_default_unset (struct ospf *ospf)
639: {
640: if (!ospf_is_type_redistributed (DEFAULT_ROUTE))
641: return CMD_SUCCESS;
642:
643: ospf->default_originate = DEFAULT_ORIGINATE_NONE;
644: ospf->dmetric[DEFAULT_ROUTE].type = -1;
645: ospf->dmetric[DEFAULT_ROUTE].value = -1;
646:
647: zclient_redistribute_default (ZEBRA_REDISTRIBUTE_DEFAULT_DELETE, zclient);
648:
649: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
650: zlog_debug ("Redistribute[DEFAULT]: Stop");
651:
652: ospf_asbr_status_update (ospf, --ospf->redistribute);
653:
654: return CMD_SUCCESS;
655: }
656:
657: static int
658: ospf_external_lsa_originate_check (struct ospf *ospf,
659: struct external_info *ei)
660: {
661: /* If prefix is multicast, then do not originate LSA. */
662: if (IN_MULTICAST (htonl (ei->p.prefix.s_addr)))
663: {
664: zlog_info ("LSA[Type5:%s]: Not originate AS-external-LSA, "
665: "Prefix belongs multicast", inet_ntoa (ei->p.prefix));
666: return 0;
667: }
668:
669: /* Take care of default-originate. */
670: if (is_prefix_default (&ei->p))
671: if (ospf->default_originate == DEFAULT_ORIGINATE_NONE)
672: {
673: zlog_info ("LSA[Type5:0.0.0.0]: Not originate AS-external-LSA "
674: "for default");
675: return 0;
676: }
677:
678: return 1;
679: }
680:
681: /* If connected prefix is OSPF enable interface, then do not announce. */
682: int
683: ospf_distribute_check_connected (struct ospf *ospf, struct external_info *ei)
684: {
685: struct listnode *node;
686: struct ospf_interface *oi;
687:
688:
689: for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
690: if (prefix_match (oi->address, (struct prefix *) &ei->p))
691: return 0;
692: return 1;
693: }
694:
695: /* return 1 if external LSA must be originated, 0 otherwise */
696: int
697: ospf_redistribute_check (struct ospf *ospf,
698: struct external_info *ei, int *changed)
699: {
700: struct route_map_set_values save_values;
701: struct prefix_ipv4 *p = &ei->p;
702: u_char type = is_prefix_default (&ei->p) ? DEFAULT_ROUTE : ei->type;
703:
704: if (changed)
705: *changed = 0;
706:
707: if (!ospf_external_lsa_originate_check (ospf, ei))
708: return 0;
709:
710: /* Take care connected route. */
711: if (type == ZEBRA_ROUTE_CONNECT &&
712: !ospf_distribute_check_connected (ospf, ei))
713: return 0;
714:
715: if (!DEFAULT_ROUTE_TYPE (type) && DISTRIBUTE_NAME (ospf, type))
716: /* distirbute-list exists, but access-list may not? */
717: if (DISTRIBUTE_LIST (ospf, type))
718: if (access_list_apply (DISTRIBUTE_LIST (ospf, type), p) == FILTER_DENY)
719: {
720: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
721: zlog_debug ("Redistribute[%s]: %s/%d filtered by ditribute-list.",
722: ospf_redist_string(type),
723: inet_ntoa (p->prefix), p->prefixlen);
724: return 0;
725: }
726:
727: save_values = ei->route_map_set;
728: ospf_reset_route_map_set_values (&ei->route_map_set);
729:
730: /* apply route-map if needed */
731: if (ROUTEMAP_NAME (ospf, type))
732: {
733: int ret;
734:
735: ret = route_map_apply (ROUTEMAP (ospf, type), (struct prefix *) p,
736: RMAP_OSPF, ei);
737:
738: if (ret == RMAP_DENYMATCH)
739: {
740: ei->route_map_set = save_values;
741: if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
742: zlog_debug ("Redistribute[%s]: %s/%d filtered by route-map.",
743: ospf_redist_string(type),
744: inet_ntoa (p->prefix), p->prefixlen);
745: return 0;
746: }
747:
748: /* check if 'route-map set' changed something */
749: if (changed)
750: *changed = !ospf_route_map_set_compare (&ei->route_map_set,
751: &save_values);
752: }
753:
754: return 1;
755: }
756:
757: /* OSPF route-map set for redistribution */
758: void
759: ospf_routemap_set (struct ospf *ospf, int type, const char *name)
760: {
761: if (ROUTEMAP_NAME (ospf, type))
762: free (ROUTEMAP_NAME (ospf, type));
763:
764: ROUTEMAP_NAME (ospf, type) = strdup (name);
765: ROUTEMAP (ospf, type) = route_map_lookup_by_name (name);
766: }
767:
768: void
769: ospf_routemap_unset (struct ospf *ospf, int type)
770: {
771: if (ROUTEMAP_NAME (ospf, type))
772: free (ROUTEMAP_NAME (ospf, type));
773:
774: ROUTEMAP_NAME (ospf, type) = NULL;
775: ROUTEMAP (ospf, type) = NULL;
776: }
777:
778: /* Zebra route add and delete treatment. */
779: static int
780: ospf_zebra_read_ipv4 (int command, struct zclient *zclient,
781: zebra_size_t length)
782: {
783: struct stream *s;
784: struct zapi_ipv4 api;
785: unsigned long ifindex;
786: struct in_addr nexthop;
787: struct prefix_ipv4 p;
788: struct external_info *ei;
789: struct ospf *ospf;
790:
791: s = zclient->ibuf;
792: ifindex = 0;
793: nexthop.s_addr = 0;
794:
795: /* Type, flags, message. */
796: api.type = stream_getc (s);
797: api.flags = stream_getc (s);
798: api.message = stream_getc (s);
799:
800: /* IPv4 prefix. */
801: memset (&p, 0, sizeof (struct prefix_ipv4));
802: p.family = AF_INET;
803: p.prefixlen = stream_getc (s);
804: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
805:
806: if (IPV4_NET127(ntohl(p.prefix.s_addr)))
807: return 0;
808:
809: /* Nexthop, ifindex, distance, metric. */
810: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
811: {
812: api.nexthop_num = stream_getc (s);
813: nexthop.s_addr = stream_get_ipv4 (s);
814: }
815: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
816: {
817: api.ifindex_num = stream_getc (s);
818: /* XXX assert(api.ifindex_num == 1); */
819: ifindex = stream_getl (s);
820: }
821: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
822: api.distance = stream_getc (s);
823: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
824: api.metric = stream_getl (s);
825:
826: ospf = ospf_lookup ();
827: if (ospf == NULL)
828: return 0;
829:
830: if (command == ZEBRA_IPV4_ROUTE_ADD)
831: {
832: /* XXX|HACK|TODO|FIXME:
833: * Maybe we should ignore reject/blackhole routes? Testing shows that
834: * there is no problems though and this is only way to "summarize"
835: * routes in ASBR at the moment. Maybe we need just a better generalised
836: * solution for these types?
837: *
838: * if ( CHECK_FLAG (api.flags, ZEBRA_FLAG_BLACKHOLE)
839: * || CHECK_FLAG (api.flags, ZEBRA_FLAG_REJECT))
840: * return 0;
841: */
842:
843: ei = ospf_external_info_add (api.type, p, ifindex, nexthop);
844:
845: if (ospf->router_id.s_addr == 0)
846: /* Set flags to generate AS-external-LSA originate event
847: for each redistributed protocols later. */
848: ospf->external_origin |= (1 << api.type);
849: else
850: {
851: if (ei)
852: {
853: if (is_prefix_default (&p))
854: ospf_external_lsa_refresh_default (ospf);
855: else
856: {
857: struct ospf_lsa *current;
858:
859: current = ospf_external_info_find_lsa (ospf, &ei->p);
860: if (!current)
861: ospf_external_lsa_originate (ospf, ei);
862: else if (IS_LSA_MAXAGE (current))
863: ospf_external_lsa_refresh (ospf, current,
864: ei, LSA_REFRESH_FORCE);
865: else
866: zlog_warn ("ospf_zebra_read_ipv4() : %s already exists",
867: inet_ntoa (p.prefix));
868: }
869: }
870: }
871: }
872: else /* if (command == ZEBRA_IPV4_ROUTE_DELETE) */
873: {
874: ospf_external_info_delete (api.type, p);
875: if (is_prefix_default (&p))
876: ospf_external_lsa_refresh_default (ospf);
877: else
878: ospf_external_lsa_flush (ospf, api.type, &p, ifindex /*, nexthop */);
879: }
880:
881: return 0;
882: }
883:
884:
885: int
886: ospf_distribute_list_out_set (struct ospf *ospf, int type, const char *name)
887: {
888: /* Lookup access-list for distribute-list. */
889: DISTRIBUTE_LIST (ospf, type) = access_list_lookup (AFI_IP, name);
890:
891: /* Clear previous distribute-name. */
892: if (DISTRIBUTE_NAME (ospf, type))
893: free (DISTRIBUTE_NAME (ospf, type));
894:
895: /* Set distribute-name. */
896: DISTRIBUTE_NAME (ospf, type) = strdup (name);
897:
898: /* If access-list have been set, schedule update timer. */
899: if (DISTRIBUTE_LIST (ospf, type))
900: ospf_distribute_list_update (ospf, type);
901:
902: return CMD_SUCCESS;
903: }
904:
905: int
906: ospf_distribute_list_out_unset (struct ospf *ospf, int type, const char *name)
907: {
908: /* Schedule update timer. */
909: if (DISTRIBUTE_LIST (ospf, type))
910: ospf_distribute_list_update (ospf, type);
911:
912: /* Unset distribute-list. */
913: DISTRIBUTE_LIST (ospf, type) = NULL;
914:
915: /* Clear distribute-name. */
916: if (DISTRIBUTE_NAME (ospf, type))
917: free (DISTRIBUTE_NAME (ospf, type));
918:
919: DISTRIBUTE_NAME (ospf, type) = NULL;
920:
921: return CMD_SUCCESS;
922: }
923:
924: /* distribute-list update timer. */
925: static int
926: ospf_distribute_list_update_timer (struct thread *thread)
927: {
928: struct route_node *rn;
929: struct external_info *ei;
930: struct route_table *rt;
931: struct ospf_lsa *lsa;
932: int type, default_refresh = 0;
933: struct ospf *ospf;
934:
935: ospf = ospf_lookup ();
936: if (ospf == NULL)
937: return 0;
938:
939: ospf->t_distribute_update = NULL;
940:
941: zlog_info ("Zebra[Redistribute]: distribute-list update timer fired!");
942:
943: /* foreach all external info. */
944: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
945: {
946: rt = EXTERNAL_INFO (type);
947: if (!rt)
948: continue;
949: for (rn = route_top (rt); rn; rn = route_next (rn))
950: if ((ei = rn->info) != NULL)
951: {
952: if (is_prefix_default (&ei->p))
953: default_refresh = 1;
954: else if ((lsa = ospf_external_info_find_lsa (ospf, &ei->p)))
955: ospf_external_lsa_refresh (ospf, lsa, ei, LSA_REFRESH_IF_CHANGED);
956: else
957: ospf_external_lsa_originate (ospf, ei);
958: }
959: }
960: if (default_refresh)
961: ospf_external_lsa_refresh_default (ospf);
962: return 0;
963: }
964:
965: #define OSPF_DISTRIBUTE_UPDATE_DELAY 5
966:
967: /* Update distribute-list and set timer to apply access-list. */
968: void
969: ospf_distribute_list_update (struct ospf *ospf, int type)
970: {
971: struct route_table *rt;
972:
973: /* External info does not exist. */
974: if (!(rt = EXTERNAL_INFO (type)))
975: return;
976:
977: /* If exists previously invoked thread, then let it continue. */
978: if (ospf->t_distribute_update)
979: return;
980:
981: /* Set timer. */
982: ospf->t_distribute_update =
983: thread_add_timer (master, ospf_distribute_list_update_timer,
984: (void *) type, OSPF_DISTRIBUTE_UPDATE_DELAY);
985: }
986:
987: /* If access-list is updated, apply some check. */
988: static void
989: ospf_filter_update (struct access_list *access)
990: {
991: struct ospf *ospf;
992: int type;
993: int abr_inv = 0;
994: struct ospf_area *area;
995: struct listnode *node;
996:
997: /* If OSPF instatnce does not exist, return right now. */
998: ospf = ospf_lookup ();
999: if (ospf == NULL)
1000: return;
1001:
1002: /* Update distribute-list, and apply filter. */
1003: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
1004: {
1005: if (ROUTEMAP (ospf, type) != NULL)
1006: {
1007: /* if route-map is not NULL it may be using this access list */
1008: ospf_distribute_list_update (ospf, type);
1009: continue;
1010: }
1011:
1012: /* There is place for route-map for default-information (ZEBRA_ROUTE_MAX),
1013: * but no distribute list. */
1014: if (type == ZEBRA_ROUTE_MAX)
1015: break;
1016:
1017: if (DISTRIBUTE_NAME (ospf, type))
1018: {
1019: /* Keep old access-list for distribute-list. */
1020: struct access_list *old = DISTRIBUTE_LIST (ospf, type);
1021:
1022: /* Update access-list for distribute-list. */
1023: DISTRIBUTE_LIST (ospf, type) =
1024: access_list_lookup (AFI_IP, DISTRIBUTE_NAME (ospf, type));
1025:
1026: /* No update for this distribute type. */
1027: if (old == NULL && DISTRIBUTE_LIST (ospf, type) == NULL)
1028: continue;
1029:
1030: /* Schedule distribute-list update timer. */
1031: if (DISTRIBUTE_LIST (ospf, type) == NULL ||
1032: strcmp (DISTRIBUTE_NAME (ospf, type), access->name) == 0)
1033: ospf_distribute_list_update (ospf, type);
1034: }
1035: }
1036:
1037: /* Update Area access-list. */
1038: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1039: {
1040: if (EXPORT_NAME (area))
1041: {
1042: EXPORT_LIST (area) = NULL;
1043: abr_inv++;
1044: }
1045:
1046: if (IMPORT_NAME (area))
1047: {
1048: IMPORT_LIST (area) = NULL;
1049: abr_inv++;
1050: }
1051: }
1052:
1053: /* Schedule ABR tasks -- this will be changed -- takada. */
1054: if (IS_OSPF_ABR (ospf) && abr_inv)
1055: ospf_schedule_abr_task (ospf);
1056: }
1057:
1058: /* If prefix-list is updated, do some updates. */
1059: void
1060: ospf_prefix_list_update (struct prefix_list *plist)
1061: {
1062: struct ospf *ospf;
1063: int type;
1064: int abr_inv = 0;
1065: struct ospf_area *area;
1066: struct listnode *node;
1067:
1068: /* If OSPF instatnce does not exist, return right now. */
1069: ospf = ospf_lookup ();
1070: if (ospf == NULL)
1071: return;
1072:
1073: /* Update all route-maps which are used as redistribution filters.
1074: * They might use prefix-list.
1075: */
1076: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
1077: {
1078: if (ROUTEMAP (ospf, type) != NULL)
1079: {
1080: /* If route-map is not NULL it may be using this prefix list */
1081: ospf_distribute_list_update (ospf, type);
1082: continue;
1083: }
1084: }
1085:
1086: /* Update area filter-lists. */
1087: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1088: {
1089: /* Update filter-list in. */
1090: if (PREFIX_NAME_IN (area))
1091: if (strcmp (PREFIX_NAME_IN (area), plist->name) == 0)
1092: {
1093: PREFIX_LIST_IN (area) =
1094: prefix_list_lookup (AFI_IP, PREFIX_NAME_IN (area));
1095: abr_inv++;
1096: }
1097:
1098: /* Update filter-list out. */
1099: if (PREFIX_NAME_OUT (area))
1100: if (strcmp (PREFIX_NAME_OUT (area), plist->name) == 0)
1101: {
1102: PREFIX_LIST_IN (area) =
1103: prefix_list_lookup (AFI_IP, PREFIX_NAME_OUT (area));
1104: abr_inv++;
1105: }
1106: }
1107:
1108: /* Schedule ABR task. */
1109: if (IS_OSPF_ABR (ospf) && abr_inv)
1110: ospf_schedule_abr_task (ospf);
1111: }
1112:
1113: static struct ospf_distance *
1114: ospf_distance_new (void)
1115: {
1116: return XCALLOC (MTYPE_OSPF_DISTANCE, sizeof (struct ospf_distance));
1117: }
1118:
1119: static void
1120: ospf_distance_free (struct ospf_distance *odistance)
1121: {
1122: XFREE (MTYPE_OSPF_DISTANCE, odistance);
1123: }
1124:
1125: int
1126: ospf_distance_set (struct vty *vty, struct ospf *ospf,
1127: const char *distance_str,
1128: const char *ip_str,
1129: const char *access_list_str)
1130: {
1131: int ret;
1132: struct prefix_ipv4 p;
1133: u_char distance;
1134: struct route_node *rn;
1135: struct ospf_distance *odistance;
1136:
1137: ret = str2prefix_ipv4 (ip_str, &p);
1138: if (ret == 0)
1139: {
1140: vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
1141: return CMD_WARNING;
1142: }
1143:
1144: distance = atoi (distance_str);
1145:
1146: /* Get OSPF distance node. */
1147: rn = route_node_get (ospf->distance_table, (struct prefix *) &p);
1148: if (rn->info)
1149: {
1150: odistance = rn->info;
1151: route_unlock_node (rn);
1152: }
1153: else
1154: {
1155: odistance = ospf_distance_new ();
1156: rn->info = odistance;
1157: }
1158:
1159: /* Set distance value. */
1160: odistance->distance = distance;
1161:
1162: /* Reset access-list configuration. */
1163: if (odistance->access_list)
1164: {
1165: free (odistance->access_list);
1166: odistance->access_list = NULL;
1167: }
1168: if (access_list_str)
1169: odistance->access_list = strdup (access_list_str);
1170:
1171: return CMD_SUCCESS;
1172: }
1173:
1174: int
1175: ospf_distance_unset (struct vty *vty, struct ospf *ospf,
1176: const char *distance_str,
1177: const char *ip_str, char
1178: const *access_list_str)
1179: {
1180: int ret;
1181: struct prefix_ipv4 p;
1182: u_char distance;
1183: struct route_node *rn;
1184: struct ospf_distance *odistance;
1185:
1186: ret = str2prefix_ipv4 (ip_str, &p);
1187: if (ret == 0)
1188: {
1189: vty_out (vty, "Malformed prefix%s", VTY_NEWLINE);
1190: return CMD_WARNING;
1191: }
1192:
1193: distance = atoi (distance_str);
1194:
1195: rn = route_node_lookup (ospf->distance_table, (struct prefix *) &p);
1196: if (!rn)
1197: {
1198: vty_out (vty, "Can't find specified prefix%s", VTY_NEWLINE);
1199: return CMD_WARNING;
1200: }
1201:
1202: odistance = rn->info;
1203:
1204: if (odistance->access_list)
1205: free (odistance->access_list);
1206: ospf_distance_free (odistance);
1207:
1208: rn->info = NULL;
1209: route_unlock_node (rn);
1210: route_unlock_node (rn);
1211:
1212: return CMD_SUCCESS;
1213: }
1214:
1215: void
1216: ospf_distance_reset (struct ospf *ospf)
1217: {
1218: struct route_node *rn;
1219: struct ospf_distance *odistance;
1220:
1221: for (rn = route_top (ospf->distance_table); rn; rn = route_next (rn))
1222: if ((odistance = rn->info) != NULL)
1223: {
1224: if (odistance->access_list)
1225: free (odistance->access_list);
1226: ospf_distance_free (odistance);
1227: rn->info = NULL;
1228: route_unlock_node (rn);
1229: }
1230: }
1231:
1232: u_char
1233: ospf_distance_apply (struct prefix_ipv4 *p, struct ospf_route *or)
1234: {
1235: struct ospf *ospf;
1236:
1237: ospf = ospf_lookup ();
1238: if (ospf == NULL)
1239: return 0;
1240:
1241: if (ospf->distance_intra)
1242: if (or->path_type == OSPF_PATH_INTRA_AREA)
1243: return ospf->distance_intra;
1244:
1245: if (ospf->distance_inter)
1246: if (or->path_type == OSPF_PATH_INTER_AREA)
1247: return ospf->distance_inter;
1248:
1249: if (ospf->distance_external)
1250: if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL
1251: || or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
1252: return ospf->distance_external;
1253:
1254: if (ospf->distance_all)
1255: return ospf->distance_all;
1256:
1257: return 0;
1258: }
1259:
1260: void
1261: ospf_zebra_init ()
1262: {
1263: /* Allocate zebra structure. */
1264: zclient = zclient_new ();
1265: zclient_init (zclient, ZEBRA_ROUTE_OSPF);
1266: zclient->router_id_update = ospf_router_id_update_zebra;
1267: zclient->interface_add = ospf_interface_add;
1268: zclient->interface_delete = ospf_interface_delete;
1269: zclient->interface_up = ospf_interface_state_up;
1270: zclient->interface_down = ospf_interface_state_down;
1271: zclient->interface_address_add = ospf_interface_address_add;
1272: zclient->interface_address_delete = ospf_interface_address_delete;
1273: zclient->ipv4_route_add = ospf_zebra_read_ipv4;
1274: zclient->ipv4_route_delete = ospf_zebra_read_ipv4;
1275:
1276: access_list_add_hook (ospf_filter_update);
1277: access_list_delete_hook (ospf_filter_update);
1278: prefix_list_add_hook (ospf_prefix_list_update);
1279: prefix_list_delete_hook (ospf_prefix_list_update);
1280: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_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 / ospfd