1: /*
2: * OSPF ABR functions.
3: * Copyright (C) 1999, 2000 Alex Zinin, 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 Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23:
24: #include <zebra.h>
25:
26: #include "thread.h"
27: #include "memory.h"
28: #include "linklist.h"
29: #include "prefix.h"
30: #include "if.h"
31: #include "table.h"
32: #include "vty.h"
33: #include "filter.h"
34: #include "plist.h"
35: #include "log.h"
36:
37: #include "ospfd/ospfd.h"
38: #include "ospfd/ospf_interface.h"
39: #include "ospfd/ospf_ism.h"
40: #include "ospfd/ospf_asbr.h"
41: #include "ospfd/ospf_lsa.h"
42: #include "ospfd/ospf_lsdb.h"
43: #include "ospfd/ospf_neighbor.h"
44: #include "ospfd/ospf_nsm.h"
45: #include "ospfd/ospf_spf.h"
46: #include "ospfd/ospf_route.h"
47: #include "ospfd/ospf_ia.h"
48: #include "ospfd/ospf_flood.h"
49: #include "ospfd/ospf_abr.h"
50: #include "ospfd/ospf_ase.h"
51: #include "ospfd/ospf_zebra.h"
52: #include "ospfd/ospf_dump.h"
53:
54: static struct ospf_area_range *
55: ospf_area_range_new (struct prefix_ipv4 *p)
56: {
57: struct ospf_area_range *range;
58:
59: range = XCALLOC (MTYPE_OSPF_AREA_RANGE, sizeof (struct ospf_area_range));
60: range->addr = p->prefix;
61: range->masklen = p->prefixlen;
62: range->cost_config = OSPF_AREA_RANGE_COST_UNSPEC;
63:
64: return range;
65: }
66:
67: static void
68: ospf_area_range_free (struct ospf_area_range *range)
69: {
70: XFREE (MTYPE_OSPF_AREA_RANGE, range);
71: }
72:
73: static void
74: ospf_area_range_add (struct ospf_area *area, struct ospf_area_range *range)
75: {
76: struct route_node *rn;
77: struct prefix_ipv4 p;
78:
79: p.family = AF_INET;
80: p.prefixlen = range->masklen;
81: p.prefix = range->addr;
82:
83: rn = route_node_get (area->ranges, (struct prefix *)&p);
84: if (rn->info)
85: route_unlock_node (rn);
86: else
87: rn->info = range;
88: }
89:
90: static void
91: ospf_area_range_delete (struct ospf_area *area, struct route_node *rn)
92: {
93: struct ospf_area_range *range = rn->info;
94:
95: if (range->specifics != 0)
96: ospf_delete_discard_route (area->ospf->new_table,
97: (struct prefix_ipv4 *) &rn->p);
98:
99: ospf_area_range_free (range);
100: rn->info = NULL;
101: route_unlock_node (rn);
102: route_unlock_node (rn);
103: }
104:
105: struct ospf_area_range *
106: ospf_area_range_lookup (struct ospf_area *area, struct prefix_ipv4 *p)
107: {
108: struct route_node *rn;
109:
110: rn = route_node_lookup (area->ranges, (struct prefix *)p);
111: if (rn)
112: {
113: route_unlock_node (rn);
114: return rn->info;
115: }
116: return NULL;
117: }
118:
119: struct ospf_area_range *
120: ospf_area_range_lookup_next (struct ospf_area *area,
121: struct in_addr *range_net,
122: int first)
123: {
124: struct route_node *rn;
125: struct prefix_ipv4 p;
126: struct ospf_area_range *find;
127:
128: p.family = AF_INET;
129: p.prefixlen = IPV4_MAX_BITLEN;
130: p.prefix = *range_net;
131:
132: if (first)
133: rn = route_top (area->ranges);
134: else
135: {
136: rn = route_node_get (area->ranges, (struct prefix *) &p);
137: rn = route_next (rn);
138: }
139:
140: for (; rn; rn = route_next (rn))
141: if (rn->info)
142: break;
143:
144: if (rn && rn->info)
145: {
146: find = rn->info;
147: *range_net = rn->p.u.prefix4;
148: route_unlock_node (rn);
149: return find;
150: }
151: return NULL;
152: }
153:
154: static struct ospf_area_range *
155: ospf_area_range_match (struct ospf_area *area, struct prefix_ipv4 *p)
156: {
157: struct route_node *node;
158:
159: node = route_node_match (area->ranges, (struct prefix *) p);
160: if (node)
161: {
162: route_unlock_node (node);
163: return node->info;
164: }
165: return NULL;
166: }
167:
168: struct ospf_area_range *
169: ospf_area_range_match_any (struct ospf *ospf, struct prefix_ipv4 *p)
170: {
171: struct ospf_area_range *range;
172: struct ospf_area *area;
173: struct listnode *node;
174:
175: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
176: if ((range = ospf_area_range_match (area, p)))
177: return range;
178:
179: return NULL;
180: }
181:
182: int
183: ospf_area_range_active (struct ospf_area_range *range)
184: {
185: return range->specifics;
186: }
187:
188: static int
189: ospf_area_actively_attached (struct ospf_area *area)
190: {
191: return area->act_ints;
192: }
193:
194: int
195: ospf_area_range_set (struct ospf *ospf, struct in_addr area_id,
196: struct prefix_ipv4 *p, int advertise)
197: {
198: struct ospf_area *area;
199: struct ospf_area_range *range;
200: int ret = OSPF_AREA_ID_FORMAT_ADDRESS;
201:
202: area = ospf_area_get (ospf, area_id, ret);
203: if (area == NULL)
204: return 0;
205:
206: range = ospf_area_range_lookup (area, p);
207: if (range != NULL)
208: {
209: if ((CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE)
210: && !CHECK_FLAG (advertise, OSPF_AREA_RANGE_ADVERTISE))
211: || (!CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE)
212: && CHECK_FLAG (advertise, OSPF_AREA_RANGE_ADVERTISE)))
213: ospf_schedule_abr_task (ospf);
214: }
215: else
216: {
217: range = ospf_area_range_new (p);
218: ospf_area_range_add (area, range);
219: ospf_schedule_abr_task (ospf);
220: }
221:
222: if (CHECK_FLAG (advertise, OSPF_AREA_RANGE_ADVERTISE))
223: SET_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE);
224: else
225: UNSET_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE);
226:
227: return 1;
228: }
229:
230: int
231: ospf_area_range_cost_set (struct ospf *ospf, struct in_addr area_id,
232: struct prefix_ipv4 *p, u_int32_t cost)
233: {
234: struct ospf_area *area;
235: struct ospf_area_range *range;
236: int ret = OSPF_AREA_ID_FORMAT_ADDRESS;
237:
238: area = ospf_area_get (ospf, area_id, ret);
239: if (area == NULL)
240: return 0;
241:
242: range = ospf_area_range_lookup (area, p);
243: if (range == NULL)
244: return 0;
245:
246: if (range->cost_config != cost)
247: {
248: range->cost_config = cost;
249: if (ospf_area_range_active (range))
250: ospf_schedule_abr_task (ospf);
251: }
252:
253: return 1;
254: }
255:
256: int
257: ospf_area_range_unset (struct ospf *ospf, struct in_addr area_id,
258: struct prefix_ipv4 *p)
259: {
260: struct ospf_area *area;
261: struct route_node *rn;
262:
263: area = ospf_area_lookup_by_area_id (ospf, area_id);
264: if (area == NULL)
265: return 0;
266:
267: rn = route_node_lookup (area->ranges, (struct prefix*)p);
268: if (rn == NULL)
269: return 0;
270:
271: if (ospf_area_range_active (rn->info))
272: ospf_schedule_abr_task (ospf);
273:
274: ospf_area_range_delete (area, rn);
275:
276: return 1;
277: }
278:
279: int
280: ospf_area_range_substitute_set (struct ospf *ospf, struct in_addr area_id,
281: struct prefix_ipv4 *p, struct prefix_ipv4 *s)
282: {
283: struct ospf_area *area;
284: struct ospf_area_range *range;
285: int ret = OSPF_AREA_ID_FORMAT_ADDRESS;
286:
287: area = ospf_area_get (ospf, area_id, ret);
288: range = ospf_area_range_lookup (area, p);
289:
290: if (range != NULL)
291: {
292: if (!CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE) ||
293: !CHECK_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE))
294: ospf_schedule_abr_task (ospf);
295: }
296: else
297: {
298: range = ospf_area_range_new (p);
299: ospf_area_range_add (area, range);
300: ospf_schedule_abr_task (ospf);
301: }
302:
303: SET_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE);
304: SET_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE);
305: range->subst_addr = s->prefix;
306: range->subst_masklen = s->prefixlen;
307:
308: return 1;
309: }
310:
311: int
312: ospf_area_range_substitute_unset (struct ospf *ospf, struct in_addr area_id,
313: struct prefix_ipv4 *p)
314: {
315: struct ospf_area *area;
316: struct ospf_area_range *range;
317:
318: area = ospf_area_lookup_by_area_id (ospf, area_id);
319: if (area == NULL)
320: return 0;
321:
322: range = ospf_area_range_lookup (area, p);
323: if (range == NULL)
324: return 0;
325:
326: if (CHECK_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE))
327: if (ospf_area_range_active (range))
328: ospf_schedule_abr_task (ospf);
329:
330: UNSET_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE);
331: range->subst_addr.s_addr = 0;
332: range->subst_masklen = 0;
333:
334: return 1;
335: }
336:
337: int
338: ospf_act_bb_connection (struct ospf *ospf)
339: {
340: if (ospf->backbone == NULL)
341: return 0;
342:
343: return ospf->backbone->full_nbrs;
344: }
345:
346: /* Determine whether this router is elected translator or not for area */
347: static int
348: ospf_abr_nssa_am_elected (struct ospf_area *area)
349: {
350: struct route_node *rn;
351: struct ospf_lsa *lsa;
352: struct router_lsa *rlsa;
353: struct in_addr *best = NULL;
354:
355: LSDB_LOOP ( ROUTER_LSDB (area), rn, lsa)
356: {
357: /* sanity checks */
358: if (!lsa
359: || (lsa->data->type != OSPF_ROUTER_LSA)
360: || IS_LSA_SELF (lsa))
361: continue;
362:
363: rlsa = (struct router_lsa *) lsa->data;
364:
365: /* ignore non-ABR routers */
366: if (!IS_ROUTER_LSA_BORDER (rlsa))
367: continue;
368:
369: /* Router has Nt flag - always translate */
370: if (IS_ROUTER_LSA_NT (rlsa))
371: {
372: if (IS_DEBUG_OSPF_NSSA)
373: zlog_debug ("ospf_abr_nssa_am_elected: "
374: "router %s asserts Nt",
375: inet_ntoa (lsa->data->id) );
376: return 0;
377: }
378:
379: if (best == NULL)
380: best = &lsa->data->id;
381: else
382: if (IPV4_ADDR_CMP (&best->s_addr, &lsa->data->id.s_addr) < 0)
383: best = &lsa->data->id;
384: }
385:
386: if (IS_DEBUG_OSPF_NSSA)
387: zlog_debug ("ospf_abr_nssa_am_elected: best electable ABR is: %s",
388: (best) ? inet_ntoa (*best) : "<none>" );
389:
390: if (best == NULL)
391: return 1;
392:
393: if (IPV4_ADDR_CMP (&best->s_addr, &area->ospf->router_id.s_addr) < 0)
394: return 1;
395: else
396: return 0;
397: }
398:
399: /* Check NSSA ABR status
400: * assumes there are nssa areas
401: */
402: static void
403: ospf_abr_nssa_check_status (struct ospf *ospf)
404: {
405: struct ospf_area *area;
406: struct listnode *lnode, *nnode;
407:
408: for (ALL_LIST_ELEMENTS (ospf->areas, lnode, nnode, area))
409: {
410: u_char old_state = area->NSSATranslatorState;
411:
412: if (area->external_routing != OSPF_AREA_NSSA)
413: continue;
414:
415: if (IS_DEBUG_OSPF (nssa, NSSA))
416: zlog_debug ("ospf_abr_nssa_check_status: "
417: "checking area %s",
418: inet_ntoa (area->area_id));
419:
420: if (!IS_OSPF_ABR (area->ospf))
421: {
422: if (IS_DEBUG_OSPF (nssa, NSSA))
423: zlog_debug ("ospf_abr_nssa_check_status: "
424: "not ABR");
425: area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
426: }
427: else
428: {
429: switch (area->NSSATranslatorRole)
430: {
431: case OSPF_NSSA_ROLE_NEVER:
432: /* We never Translate Type-7 LSA. */
433: /* TODO: check previous state and flush? */
434: if (IS_DEBUG_OSPF (nssa, NSSA))
435: zlog_debug ("ospf_abr_nssa_check_status: "
436: "never translate");
437: area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
438: break;
439:
440: case OSPF_NSSA_ROLE_ALWAYS:
441: /* We always translate if we are an ABR
442: * TODO: originate new LSAs if state change?
443: * or let the nssa abr task take care of it?
444: */
445: if (IS_DEBUG_OSPF (nssa, NSSA))
446: zlog_debug ("ospf_abr_nssa_check_status: "
447: "translate always");
448: area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_ENABLED;
449: break;
450:
451: case OSPF_NSSA_ROLE_CANDIDATE:
452: /* We are a candidate for Translation */
453: if (ospf_abr_nssa_am_elected (area) > 0)
454: {
455: area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_ENABLED;
456: if (IS_DEBUG_OSPF (nssa, NSSA))
457: zlog_debug ("ospf_abr_nssa_check_status: "
458: "elected translator");
459: }
460: else
461: {
462: area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
463: if (IS_DEBUG_OSPF (nssa, NSSA))
464: zlog_debug ("ospf_abr_nssa_check_status: " "not elected");
465: }
466: break;
467: }
468: }
469: /* RFC3101, 3.1:
470: * All NSSA border routers must set the E-bit in the Type-1 router-LSAs
471: * of their directly attached non-stub areas, even when they are not
472: * translating.
473: */
474: if (old_state != area->NSSATranslatorState)
475: {
476: if (old_state == OSPF_NSSA_TRANSLATE_DISABLED)
477: ospf_asbr_status_update (ospf, ++ospf->redistribute);
478: else if (area->NSSATranslatorState == OSPF_NSSA_TRANSLATE_DISABLED)
479: ospf_asbr_status_update (ospf, --ospf->redistribute);
480: }
481: }
482: }
483:
484: /* Check area border router status. */
485: void
486: ospf_check_abr_status (struct ospf *ospf)
487: {
488: struct ospf_area *area;
489: struct listnode *node, *nnode;
490: int bb_configured = 0;
491: int bb_act_attached = 0;
492: int areas_configured = 0;
493: int areas_act_attached = 0;
494: u_char new_flags = ospf->flags;
495:
496: if (IS_DEBUG_OSPF_EVENT)
497: zlog_debug ("ospf_check_abr_status(): Start");
498:
499: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
500: {
501: if (listcount (area->oiflist))
502: {
503: areas_configured++;
504:
505: if (OSPF_IS_AREA_BACKBONE (area))
506: bb_configured = 1;
507: }
508:
509: if (ospf_area_actively_attached (area))
510: {
511: areas_act_attached++;
512:
513: if (OSPF_IS_AREA_BACKBONE (area))
514: bb_act_attached = 1;
515: }
516: }
517:
518: if (IS_DEBUG_OSPF_EVENT)
519: {
520: zlog_debug ("ospf_check_abr_status(): looked through areas");
521: zlog_debug ("ospf_check_abr_status(): bb_configured: %d", bb_configured);
522: zlog_debug ("ospf_check_abr_status(): bb_act_attached: %d",
523: bb_act_attached);
524: zlog_debug ("ospf_check_abr_status(): areas_configured: %d",
525: areas_configured);
526: zlog_debug ("ospf_check_abr_status(): areas_act_attached: %d",
527: areas_act_attached);
528: }
529:
530: switch (ospf->abr_type)
531: {
532: case OSPF_ABR_SHORTCUT:
533: case OSPF_ABR_STAND:
534: if (areas_act_attached > 1)
535: SET_FLAG (new_flags, OSPF_FLAG_ABR);
536: else
537: UNSET_FLAG (new_flags, OSPF_FLAG_ABR);
538: break;
539:
540: case OSPF_ABR_IBM:
541: if ((areas_act_attached > 1) && bb_configured)
542: SET_FLAG (new_flags, OSPF_FLAG_ABR);
543: else
544: UNSET_FLAG (new_flags, OSPF_FLAG_ABR);
545: break;
546:
547: case OSPF_ABR_CISCO:
548: if ((areas_configured > 1) && bb_act_attached)
549: SET_FLAG (new_flags, OSPF_FLAG_ABR);
550: else
551: UNSET_FLAG (new_flags, OSPF_FLAG_ABR);
552: break;
553: default:
554: break;
555: }
556:
557: if (new_flags != ospf->flags)
558: {
559: ospf_spf_calculate_schedule (ospf, SPF_FLAG_ABR_STATUS_CHANGE);
560: if (IS_DEBUG_OSPF_EVENT)
561: zlog_debug ("ospf_check_abr_status(): new router flags: %x",new_flags);
562: ospf->flags = new_flags;
563: ospf_router_lsa_update (ospf);
564: }
565: }
566:
567: static void
568: ospf_abr_update_aggregate (struct ospf_area_range *range,
569: struct ospf_route *or, struct ospf_area *area)
570: {
571: if (IS_DEBUG_OSPF_EVENT)
572: zlog_debug ("ospf_abr_update_aggregate(): Start");
573:
574: if (CHECK_FLAG (area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED) &&
575: (range->cost != OSPF_STUB_MAX_METRIC_SUMMARY_COST))
576: {
577: range->cost = OSPF_STUB_MAX_METRIC_SUMMARY_COST;
578: if (IS_DEBUG_OSPF_EVENT)
579: zlog_debug ("ospf_abr_update_aggregate(): use summary max-metric 0x%08x",
580: range->cost);
581: }
582: else if (range->cost_config != OSPF_AREA_RANGE_COST_UNSPEC)
583: {
584: if (IS_DEBUG_OSPF_EVENT)
585: zlog_debug ("ospf_abr_update_aggregate(): use configured cost %d",
586: range->cost_config);
587:
588: range->cost = range->cost_config;
589: }
590: else
591: {
592: if (range->specifics == 0)
593: {
594: if (IS_DEBUG_OSPF_EVENT)
595: zlog_debug ("ospf_abr_update_aggregate(): use or->cost %d",
596: or->cost);
597:
598: range->cost = or->cost; /* 1st time get 1st cost */
599: }
600:
601: if (or->cost > range->cost)
602: {
603: if (IS_DEBUG_OSPF_EVENT)
604: zlog_debug ("ospf_abr_update_aggregate(): update to %d", or->cost);
605:
606: range->cost = or->cost;
607: }
608: }
609:
610: range->specifics++;
611: }
612:
613: static void
614: set_metric (struct ospf_lsa *lsa, u_int32_t metric)
615: {
616: struct summary_lsa *header;
617: u_char *mp;
618: metric = htonl (metric);
619: mp = (u_char *) &metric;
620: mp++;
621: header = (struct summary_lsa *) lsa->data;
622: memcpy(header->metric, mp, 3);
623: }
624:
625: /* ospf_abr_translate_nssa */
626: static int
627: ospf_abr_translate_nssa (struct ospf_area *area, struct ospf_lsa *lsa)
628: {
629: /* Incoming Type-7 or later aggregated Type-7
630: *
631: * LSA is skipped if P-bit is off.
632: * LSA is aggregated if within range.
633: *
634: * The Type-7 is translated, Installed/Approved as a Type-5 into
635: * global LSDB, then Flooded through AS
636: *
637: * Later, any Unapproved Translated Type-5's are flushed/discarded
638: */
639:
640: struct ospf_lsa *old = NULL,
641: *new = NULL;
642: struct as_external_lsa *ext7;
643: struct prefix_ipv4 p;
644:
645: if (! CHECK_FLAG (lsa->data->options, OSPF_OPTION_NP))
646: {
647: if (IS_DEBUG_OSPF_NSSA)
648: zlog_debug ("ospf_abr_translate_nssa(): LSA Id %s, P-bit off, NO Translation",
649: inet_ntoa (lsa->data->id));
650: return 1;
651: }
652:
653: if (IS_DEBUG_OSPF_NSSA)
654: zlog_debug ("ospf_abr_translate_nssa(): LSA Id %s, TRANSLATING 7 to 5",
655: inet_ntoa (lsa->data->id));
656:
657: ext7 = (struct as_external_lsa *)(lsa->data);
658: p.prefix = lsa->data->id;
659: p.prefixlen = ip_masklen (ext7->mask);
660:
661: if (ext7->e[0].fwd_addr.s_addr == OSPF_DEFAULT_DESTINATION)
662: {
663: if (IS_DEBUG_OSPF_NSSA)
664: zlog_debug ("ospf_abr_translate_nssa(): LSA Id %s, "
665: "Forward address is 0, NO Translation",
666: inet_ntoa (lsa->data->id));
667: return 1;
668: }
669:
670: /* try find existing AS-External LSA for this prefix */
671:
672: old = ospf_external_info_find_lsa (area->ospf, &p);
673:
674: if (old)
675: {
676: if (IS_DEBUG_OSPF_NSSA)
677: zlog_debug ("ospf_abr_translate_nssa(): "
678: "found old translated LSA Id %s, refreshing",
679: inet_ntoa (old->data->id));
680:
681: /* refresh */
682: new = ospf_translated_nssa_refresh (area->ospf, lsa, old);
683: if (!new)
684: {
685: if (IS_DEBUG_OSPF_NSSA)
686: zlog_debug ("ospf_abr_translate_nssa(): "
687: "could not refresh translated LSA Id %s",
688: inet_ntoa (old->data->id));
689: }
690: }
691: else
692: {
693: /* no existing external route for this LSA Id
694: * originate translated LSA
695: */
696:
697: if ((new = ospf_translated_nssa_originate (area->ospf, lsa))
698: == NULL)
699: {
700: if (IS_DEBUG_OSPF_NSSA)
701: zlog_debug ("ospf_abr_translate_nssa(): Could not translate "
702: "Type-7 for %s to Type-5",
703: inet_ntoa (lsa->data->id));
704: return 1;
705: }
706: }
707:
708: /* Area where Aggregate testing will be inserted, just like summary
709: advertisements */
710: /* ospf_abr_check_nssa_range (p_arg, lsa-> cost, lsa -> area); */
711:
712: return 0;
713: }
714:
715: static void
716: ospf_abr_translate_nssa_range (struct prefix_ipv4 *p, u_int32_t cost)
717: {
718: /* The Type-7 is created from the aggregated prefix and forwarded
719: for lsa installation and flooding... to be added... */
720: }
721:
722: void
723: ospf_abr_announce_network_to_area (struct prefix_ipv4 *p, u_int32_t cost,
724: struct ospf_area *area)
725: {
726: struct ospf_lsa *lsa, *old = NULL;
727: struct summary_lsa *sl = NULL;
728: u_int32_t full_cost;
729:
730: if (IS_DEBUG_OSPF_EVENT)
731: zlog_debug ("ospf_abr_announce_network_to_area(): Start");
732:
733: if (CHECK_FLAG (area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED))
734: full_cost = OSPF_STUB_MAX_METRIC_SUMMARY_COST;
735: else
736: full_cost = cost;
737:
738: old = ospf_lsa_lookup_by_prefix (area->lsdb, OSPF_SUMMARY_LSA,
739: (struct prefix_ipv4 *) p,
740: area->ospf->router_id);
741: if (old)
742: {
743: if (IS_DEBUG_OSPF_EVENT)
744: zlog_debug ("ospf_abr_announce_network_to_area(): old summary found");
745:
746: sl = (struct summary_lsa *) old->data;
747:
748: if (IS_DEBUG_OSPF_EVENT)
749: zlog_debug ("ospf_abr_announce_network_to_area(): "
750: "old metric: %d, new metric: %d",
751: GET_METRIC (sl->metric), cost);
752:
753: if ((GET_METRIC (sl->metric) == full_cost) &&
754: ((old->flags & OSPF_LSA_IN_MAXAGE) == 0))
755: {
756: /* unchanged. simply reapprove it */
757: if (IS_DEBUG_OSPF_EVENT)
758: zlog_debug ("ospf_abr_announce_network_to_area(): "
759: "old summary approved");
760: SET_FLAG (old->flags, OSPF_LSA_APPROVED);
761: }
762: else
763: {
764: /* LSA is changed, refresh it */
765: if (IS_DEBUG_OSPF_EVENT)
766: zlog_debug ("ospf_abr_announce_network_to_area(): "
767: "refreshing summary");
768: set_metric (old, full_cost);
769: lsa = ospf_lsa_refresh (area->ospf, old);
770:
771: if (!lsa)
772: {
773: char buf[INET_ADDRSTRLEN + 3]; /* ipv4 and /XX */
774:
775: prefix2str ((struct prefix *) p, buf, sizeof(buf));
776: zlog_warn ("%s: Could not refresh %s to %s",
777: __func__,
778: buf,
779: inet_ntoa (area->area_id));
780: return;
781: }
782:
783: SET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
784: /* This will flood through area. */
785: }
786: }
787: else
788: {
789: if (IS_DEBUG_OSPF_EVENT)
790: zlog_debug ("ospf_abr_announce_network_to_area(): "
791: "creating new summary");
792: lsa = ospf_summary_lsa_originate ( (struct prefix_ipv4 *)p, full_cost, area);
793: /* This will flood through area. */
794:
795: if (!lsa)
796: {
797: char buf[INET_ADDRSTRLEN + 3]; /* ipv4 and /XX */
798:
799: prefix2str ((struct prefix *)p, buf, sizeof(buf));
800: zlog_warn ("%s: Could not originate %s to %s",
801: __func__,
802: buf,
803: inet_ntoa (area->area_id));
804: return;
805: }
806:
807: SET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
808: if (IS_DEBUG_OSPF_EVENT)
809: zlog_debug ("ospf_abr_announce_network_to_area(): "
810: "flooding new version of summary");
811: }
812:
813: if (IS_DEBUG_OSPF_EVENT)
814: zlog_debug ("ospf_abr_announce_network_to_area(): Stop");
815: }
816:
817: static int
818: ospf_abr_nexthops_belong_to_area (struct ospf_route *or,
819: struct ospf_area *area)
820: {
821: struct listnode *node, *nnode;
822: struct ospf_path *path;
823: struct ospf_interface *oi;
824:
825: for (ALL_LIST_ELEMENTS_RO (or->paths, node, path))
826: for (ALL_LIST_ELEMENTS_RO (area->oiflist, nnode, oi))
827: if (oi->ifp && oi->ifp->ifindex == path->ifindex)
828: return 1;
829:
830: return 0;
831: }
832:
833: static int
834: ospf_abr_should_accept (struct prefix_ipv4 *p, struct ospf_area *area)
835: {
836: if (IMPORT_NAME (area))
837: {
838: if (IMPORT_LIST (area) == NULL)
839: IMPORT_LIST (area) = access_list_lookup (AFI_IP, IMPORT_NAME (area));
840:
841: if (IMPORT_LIST (area))
842: if (access_list_apply (IMPORT_LIST (area), p) == FILTER_DENY)
843: return 0;
844: }
845:
846: return 1;
847: }
848:
849: static int
850: ospf_abr_plist_in_check (struct ospf_area *area, struct ospf_route *or,
851: struct prefix_ipv4 *p)
852: {
853: if (PREFIX_NAME_IN (area))
854: {
855: if (PREFIX_LIST_IN (area) == NULL)
856: PREFIX_LIST_IN (area) = prefix_list_lookup (AFI_IP,
857: PREFIX_NAME_IN (area));
858: if (PREFIX_LIST_IN (area))
859: if (prefix_list_apply (PREFIX_LIST_IN (area), p) != PREFIX_PERMIT)
860: return 0;
861: }
862: return 1;
863: }
864:
865: static int
866: ospf_abr_plist_out_check (struct ospf_area *area, struct ospf_route *or,
867: struct prefix_ipv4 *p)
868: {
869: if (PREFIX_NAME_OUT (area))
870: {
871: if (PREFIX_LIST_OUT (area) == NULL)
872: PREFIX_LIST_OUT (area) = prefix_list_lookup (AFI_IP,
873: PREFIX_NAME_OUT (area));
874: if (PREFIX_LIST_OUT (area))
875: if (prefix_list_apply (PREFIX_LIST_OUT (area), p) != PREFIX_PERMIT)
876: return 0;
877: }
878: return 1;
879: }
880:
881: static void
882: ospf_abr_announce_network (struct ospf *ospf,
883: struct prefix_ipv4 *p, struct ospf_route *or)
884: {
885: struct ospf_area_range *range;
886: struct ospf_area *area, *or_area;
887: struct listnode *node;
888:
889: if (IS_DEBUG_OSPF_EVENT)
890: zlog_debug ("ospf_abr_announce_network(): Start");
891:
892: or_area = ospf_area_lookup_by_area_id (ospf, or->u.std.area_id);
893: assert (or_area);
894:
895: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
896: {
897: if (IS_DEBUG_OSPF_EVENT)
898: zlog_debug ("ospf_abr_announce_network(): looking at area %s",
899: inet_ntoa (area->area_id));
900:
901: if (IPV4_ADDR_SAME (&or->u.std.area_id, &area->area_id))
902: continue;
903:
904: if (ospf_abr_nexthops_belong_to_area (or, area))
905: continue;
906:
907: if (!ospf_abr_should_accept (p, area))
908: {
909: if (IS_DEBUG_OSPF_EVENT)
910: zlog_debug ("ospf_abr_announce_network(): "
911: "prefix %s/%d was denied by import-list",
912: inet_ntoa (p->prefix), p->prefixlen);
913: continue;
914: }
915:
916: if (!ospf_abr_plist_in_check (area, or, p))
917: {
918: if (IS_DEBUG_OSPF_EVENT)
919: zlog_debug ("ospf_abr_announce_network(): "
920: "prefix %s/%d was denied by prefix-list",
921: inet_ntoa (p->prefix), p->prefixlen);
922: continue;
923: }
924:
925: if (area->external_routing != OSPF_AREA_DEFAULT && area->no_summary)
926: {
927: if (IS_DEBUG_OSPF_EVENT)
928: zlog_debug ("ospf_abr_announce_network(): "
929: "area %s is stub and no_summary",
930: inet_ntoa (area->area_id));
931: continue;
932: }
933:
934: if (or->path_type == OSPF_PATH_INTER_AREA)
935: {
936: if (IS_DEBUG_OSPF_EVENT)
937: zlog_debug ("ospf_abr_announce_network(): this is "
938: "inter-area route to %s/%d",
939: inet_ntoa (p->prefix), p->prefixlen);
940:
941: if (!OSPF_IS_AREA_BACKBONE (area))
942: ospf_abr_announce_network_to_area (p, or->cost, area);
943: }
944:
945: if (or->path_type == OSPF_PATH_INTRA_AREA)
946: {
947: if (IS_DEBUG_OSPF_EVENT)
948: zlog_debug ("ospf_abr_announce_network(): "
949: "this is intra-area route to %s/%d",
950: inet_ntoa (p->prefix), p->prefixlen);
951: if ((range = ospf_area_range_match (or_area, p))
952: && !ospf_area_is_transit (area))
953: ospf_abr_update_aggregate (range, or, area);
954: else
955: ospf_abr_announce_network_to_area (p, or->cost, area);
956: }
957: }
958: }
959:
960: static int
961: ospf_abr_should_announce (struct ospf *ospf,
962: struct prefix_ipv4 *p, struct ospf_route *or)
963: {
964: struct ospf_area *area;
965:
966: area = ospf_area_lookup_by_area_id (ospf, or->u.std.area_id);
967:
968: assert (area);
969:
970: if (EXPORT_NAME (area))
971: {
972: if (EXPORT_LIST (area) == NULL)
973: EXPORT_LIST (area) = access_list_lookup (AFI_IP, EXPORT_NAME (area));
974:
975: if (EXPORT_LIST (area))
976: if (access_list_apply (EXPORT_LIST (area), p) == FILTER_DENY)
977: return 0;
978: }
979:
980: return 1;
981: }
982:
983: static void
984: ospf_abr_process_nssa_translates (struct ospf *ospf)
985: {
986: /* Scan through all NSSA_LSDB records for all areas;
987:
988: If P-bit is on, translate all Type-7's to 5's and aggregate or
989: flood install as approved in Type-5 LSDB with XLATE Flag on
990: later, do same for all aggregates... At end, DISCARD all
991: remaining UNAPPROVED Type-5's (Aggregate is for future ) */
992: struct listnode *node;
993: struct ospf_area *area;
994: struct route_node *rn;
995: struct ospf_lsa *lsa;
996:
997: if (IS_DEBUG_OSPF_NSSA)
998: zlog_debug ("ospf_abr_process_nssa_translates(): Start");
999:
1000: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1001: {
1002: if (! area->NSSATranslatorState)
1003: continue; /* skip if not translator */
1004:
1005: if (area->external_routing != OSPF_AREA_NSSA)
1006: continue; /* skip if not Nssa Area */
1007:
1008: if (IS_DEBUG_OSPF_NSSA)
1009: zlog_debug ("ospf_abr_process_nssa_translates(): "
1010: "looking at area %s", inet_ntoa (area->area_id));
1011:
1012: LSDB_LOOP (NSSA_LSDB (area), rn, lsa)
1013: ospf_abr_translate_nssa (area, lsa);
1014: }
1015:
1016: if (IS_DEBUG_OSPF_NSSA)
1017: zlog_debug ("ospf_abr_process_nssa_translates(): Stop");
1018:
1019: }
1020:
1021: static void
1022: ospf_abr_process_network_rt (struct ospf *ospf,
1023: struct route_table *rt)
1024: {
1025: struct ospf_area *area;
1026: struct ospf_route *or;
1027: struct route_node *rn;
1028:
1029: if (IS_DEBUG_OSPF_EVENT)
1030: zlog_debug ("ospf_abr_process_network_rt(): Start");
1031:
1032: for (rn = route_top (rt); rn; rn = route_next (rn))
1033: {
1034: if ((or = rn->info) == NULL)
1035: continue;
1036:
1037: if (!(area = ospf_area_lookup_by_area_id (ospf, or->u.std.area_id)))
1038: {
1039: if (IS_DEBUG_OSPF_EVENT)
1040: zlog_debug ("ospf_abr_process_network_rt(): area %s no longer exists",
1041: inet_ntoa (or->u.std.area_id));
1042: continue;
1043: }
1044:
1045: if (IS_DEBUG_OSPF_EVENT)
1046: zlog_debug ("ospf_abr_process_network_rt(): this is a route to %s/%d",
1047: inet_ntoa (rn->p.u.prefix4), rn->p.prefixlen);
1048: if (or->path_type >= OSPF_PATH_TYPE1_EXTERNAL)
1049: {
1050: if (IS_DEBUG_OSPF_EVENT)
1051: zlog_debug ("ospf_abr_process_network_rt(): "
1052: "this is an External router, skipping");
1053: continue;
1054: }
1055:
1056: if (or->cost >= OSPF_LS_INFINITY)
1057: {
1058: if (IS_DEBUG_OSPF_EVENT)
1059: zlog_debug ("ospf_abr_process_network_rt():"
1060: " this route's cost is infinity, skipping");
1061: continue;
1062: }
1063:
1064: if (or->type == OSPF_DESTINATION_DISCARD)
1065: {
1066: if (IS_DEBUG_OSPF_EVENT)
1067: zlog_debug ("ospf_abr_process_network_rt():"
1068: " this is a discard entry, skipping");
1069: continue;
1070: }
1071:
1072: if (or->path_type == OSPF_PATH_INTRA_AREA &&
1073: !ospf_abr_should_announce (ospf, (struct prefix_ipv4 *) &rn->p, or))
1074: {
1075: if (IS_DEBUG_OSPF_EVENT)
1076: zlog_debug("ospf_abr_process_network_rt(): denied by export-list");
1077: continue;
1078: }
1079:
1080: if (or->path_type == OSPF_PATH_INTRA_AREA &&
1081: !ospf_abr_plist_out_check (area, or, (struct prefix_ipv4 *) &rn->p))
1082: {
1083: if (IS_DEBUG_OSPF_EVENT)
1084: zlog_debug("ospf_abr_process_network_rt(): denied by prefix-list");
1085: continue;
1086: }
1087:
1088: if ((or->path_type == OSPF_PATH_INTER_AREA) &&
1089: !OSPF_IS_AREA_ID_BACKBONE (or->u.std.area_id))
1090: {
1091: if (IS_DEBUG_OSPF_EVENT)
1092: zlog_debug ("ospf_abr_process_network_rt():"
1093: " this is route is not backbone one, skipping");
1094: continue;
1095: }
1096:
1097:
1098: if ((ospf->abr_type == OSPF_ABR_CISCO) ||
1099: (ospf->abr_type == OSPF_ABR_IBM))
1100:
1101: if (!ospf_act_bb_connection (ospf) &&
1102: or->path_type != OSPF_PATH_INTRA_AREA)
1103: {
1104: if (IS_DEBUG_OSPF_EVENT)
1105: zlog_debug ("ospf_abr_process_network_rt(): ALT ABR: "
1106: "No BB connection, skip not intra-area routes");
1107: continue;
1108: }
1109:
1110: if (IS_DEBUG_OSPF_EVENT)
1111: zlog_debug ("ospf_abr_process_network_rt(): announcing");
1112: ospf_abr_announce_network (ospf, (struct prefix_ipv4 *)&rn->p, or);
1113: }
1114:
1115: if (IS_DEBUG_OSPF_EVENT)
1116: zlog_debug ("ospf_abr_process_network_rt(): Stop");
1117: }
1118:
1119: static void
1120: ospf_abr_announce_rtr_to_area (struct prefix_ipv4 *p, u_int32_t cost,
1121: struct ospf_area *area)
1122: {
1123: struct ospf_lsa *lsa, *old = NULL;
1124: struct summary_lsa *slsa = NULL;
1125:
1126: if (IS_DEBUG_OSPF_EVENT)
1127: zlog_debug ("ospf_abr_announce_rtr_to_area(): Start");
1128:
1129: old = ospf_lsa_lookup_by_prefix (area->lsdb, OSPF_ASBR_SUMMARY_LSA,
1130: p, area->ospf->router_id);
1131: if (old)
1132: {
1133: if (IS_DEBUG_OSPF_EVENT)
1134: zlog_debug ("ospf_abr_announce_rtr_to_area(): old summary found");
1135: slsa = (struct summary_lsa *) old->data;
1136:
1137: if (IS_DEBUG_OSPF_EVENT)
1138: zlog_debug ("ospf_abr_announce_network_to_area(): "
1139: "old metric: %d, new metric: %d",
1140: GET_METRIC (slsa->metric), cost);
1141: }
1142:
1143: if (old && (GET_METRIC (slsa->metric) == cost) &&
1144: ((old->flags & OSPF_LSA_IN_MAXAGE) == 0))
1145: {
1146: if (IS_DEBUG_OSPF_EVENT)
1147: zlog_debug ("ospf_abr_announce_rtr_to_area(): old summary approved");
1148: SET_FLAG (old->flags, OSPF_LSA_APPROVED);
1149: }
1150: else
1151: {
1152: if (IS_DEBUG_OSPF_EVENT)
1153: zlog_debug ("ospf_abr_announce_rtr_to_area(): 2.2");
1154:
1155: if (old)
1156: {
1157: set_metric (old, cost);
1158: lsa = ospf_lsa_refresh (area->ospf, old);
1159: }
1160: else
1161: lsa = ospf_summary_asbr_lsa_originate (p, cost, area);
1162: if (!lsa)
1163: {
1164: char buf[INET_ADDRSTRLEN + 3]; /* ipv4 and /XX */
1165:
1166: prefix2str ((struct prefix *)p, buf, sizeof(buf));
1167: zlog_warn ("%s: Could not refresh/originate %s to %s",
1168: __func__,
1169: buf,
1170: inet_ntoa (area->area_id));
1171: return;
1172: }
1173:
1174: if (IS_DEBUG_OSPF_EVENT)
1175: zlog_debug ("ospf_abr_announce_rtr_to_area(): "
1176: "flooding new version of summary");
1177:
1178: /*
1179: zlog_info ("ospf_abr_announce_rtr_to_area(): creating new summary");
1180: lsa = ospf_summary_asbr_lsa (p, cost, area, old); */
1181:
1182: SET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
1183: /* ospf_flood_through_area (area, NULL, lsa);*/
1184: }
1185:
1186: if (IS_DEBUG_OSPF_EVENT)
1187: zlog_debug ("ospf_abr_announce_rtr_to_area(): Stop");
1188: }
1189:
1190:
1191: static void
1192: ospf_abr_announce_rtr (struct ospf *ospf,
1193: struct prefix_ipv4 *p, struct ospf_route *or)
1194: {
1195: struct listnode *node;
1196: struct ospf_area *area;
1197:
1198: if (IS_DEBUG_OSPF_EVENT)
1199: zlog_debug ("ospf_abr_announce_rtr(): Start");
1200:
1201: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1202: {
1203: if (IS_DEBUG_OSPF_EVENT)
1204: zlog_debug ("ospf_abr_announce_rtr(): looking at area %s",
1205: inet_ntoa (area->area_id));
1206:
1207: if (IPV4_ADDR_SAME (&or->u.std.area_id, &area->area_id))
1208: continue;
1209:
1210: if (ospf_abr_nexthops_belong_to_area (or, area))
1211: continue;
1212:
1213: if (area->external_routing != OSPF_AREA_DEFAULT)
1214: {
1215: if (IS_DEBUG_OSPF_EVENT)
1216: zlog_debug ("ospf_abr_announce_rtr(): "
1217: "area %s doesn't support external routing",
1218: inet_ntoa(area->area_id));
1219: continue;
1220: }
1221:
1222: if (or->path_type == OSPF_PATH_INTER_AREA)
1223: {
1224: if (IS_DEBUG_OSPF_EVENT)
1225: zlog_debug ("ospf_abr_announce_rtr(): "
1226: "this is inter-area route to %s", inet_ntoa (p->prefix));
1227: if (!OSPF_IS_AREA_BACKBONE (area))
1228: ospf_abr_announce_rtr_to_area (p, or->cost, area);
1229: }
1230:
1231: if (or->path_type == OSPF_PATH_INTRA_AREA)
1232: {
1233: if (IS_DEBUG_OSPF_EVENT)
1234: zlog_debug ("ospf_abr_announce_rtr(): "
1235: "this is intra-area route to %s", inet_ntoa (p->prefix));
1236: ospf_abr_announce_rtr_to_area (p, or->cost, area);
1237: }
1238: }
1239:
1240: if (IS_DEBUG_OSPF_EVENT)
1241: zlog_debug ("ospf_abr_announce_rtr(): Stop");
1242: }
1243:
1244: static void
1245: ospf_abr_process_router_rt (struct ospf *ospf, struct route_table *rt)
1246: {
1247: struct ospf_route *or;
1248: struct route_node *rn;
1249: struct list *l;
1250:
1251: if (IS_DEBUG_OSPF_EVENT)
1252: zlog_debug ("ospf_abr_process_router_rt(): Start");
1253:
1254: for (rn = route_top (rt); rn; rn = route_next (rn))
1255: {
1256: struct listnode *node, *nnode;
1257: char flag = 0;
1258: struct ospf_route *best = NULL;
1259:
1260: if (rn->info == NULL)
1261: continue;
1262:
1263: l = rn->info;
1264:
1265: if (IS_DEBUG_OSPF_EVENT)
1266: zlog_debug ("ospf_abr_process_router_rt(): this is a route to %s",
1267: inet_ntoa (rn->p.u.prefix4));
1268:
1269: for (ALL_LIST_ELEMENTS (l, node, nnode, or))
1270: {
1271: if (!ospf_area_lookup_by_area_id (ospf, or->u.std.area_id))
1272: {
1273: if (IS_DEBUG_OSPF_EVENT)
1274: zlog_debug ("ospf_abr_process_router_rt(): area %s no longer exists",
1275: inet_ntoa (or->u.std.area_id));
1276: continue;
1277: }
1278:
1279:
1280: if (!CHECK_FLAG (or->u.std.flags, ROUTER_LSA_EXTERNAL))
1281: {
1282: if (IS_DEBUG_OSPF_EVENT)
1283: zlog_debug ("ospf_abr_process_router_rt(): "
1284: "This is not an ASBR, skipping");
1285: continue;
1286: }
1287:
1288: if (!flag)
1289: {
1290: best = ospf_find_asbr_route (ospf, rt,
1291: (struct prefix_ipv4 *) &rn->p);
1292: flag = 1;
1293: }
1294:
1295: if (best == NULL)
1296: continue;
1297:
1298: if (or != best)
1299: {
1300: if (IS_DEBUG_OSPF_EVENT)
1301: zlog_debug ("ospf_abr_process_router_rt(): "
1302: "This route is not the best among possible, skipping");
1303: continue;
1304: }
1305:
1306: if (or->path_type == OSPF_PATH_INTER_AREA &&
1307: !OSPF_IS_AREA_ID_BACKBONE (or->u.std.area_id))
1308: {
1309: if (IS_DEBUG_OSPF_EVENT)
1310: zlog_debug ("ospf_abr_process_router_rt(): "
1311: "This route is not a backbone one, skipping");
1312: continue;
1313: }
1314:
1315: if (or->cost >= OSPF_LS_INFINITY)
1316: {
1317: if (IS_DEBUG_OSPF_EVENT)
1318: zlog_debug ("ospf_abr_process_router_rt(): "
1319: "This route has LS_INFINITY metric, skipping");
1320: continue;
1321: }
1322:
1323: if (ospf->abr_type == OSPF_ABR_CISCO
1324: || ospf->abr_type == OSPF_ABR_IBM)
1325: if (!ospf_act_bb_connection (ospf)
1326: && or->path_type != OSPF_PATH_INTRA_AREA)
1327: {
1328: if (IS_DEBUG_OSPF_EVENT)
1329: zlog_debug("ospf_abr_process_network_rt(): ALT ABR: "
1330: "No BB connection, skip not intra-area routes");
1331: continue;
1332: }
1333:
1334: ospf_abr_announce_rtr (ospf, (struct prefix_ipv4 *) &rn->p, or);
1335:
1336: }
1337:
1338: }
1339:
1340: if (IS_DEBUG_OSPF_EVENT)
1341: zlog_debug ("ospf_abr_process_router_rt(): Stop");
1342: }
1343:
1344: static void
1345: ospf_abr_unapprove_translates (struct ospf *ospf) /* For NSSA Translations */
1346: {
1347: struct ospf_lsa *lsa;
1348: struct route_node *rn;
1349:
1350: if (IS_DEBUG_OSPF_NSSA)
1351: zlog_debug ("ospf_abr_unapprove_translates(): Start");
1352:
1353: /* NSSA Translator is not checked, because it may have gone away,
1354: and we would want to flush any residuals anyway */
1355:
1356: LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
1357: if (CHECK_FLAG (lsa->flags, OSPF_LSA_LOCAL_XLT))
1358: {
1359: UNSET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
1360: if (IS_DEBUG_OSPF_NSSA)
1361: zlog_debug ("ospf_abr_unapprove_translates(): "
1362: "approved unset on link id %s",
1363: inet_ntoa (lsa->data->id));
1364: }
1365:
1366: if (IS_DEBUG_OSPF_NSSA)
1367: zlog_debug ("ospf_abr_unapprove_translates(): Stop");
1368: }
1369:
1370: static void
1371: ospf_abr_unapprove_summaries (struct ospf *ospf)
1372: {
1373: struct listnode *node;
1374: struct ospf_area *area;
1375: struct route_node *rn;
1376: struct ospf_lsa *lsa;
1377:
1378: if (IS_DEBUG_OSPF_EVENT)
1379: zlog_debug ("ospf_abr_unapprove_summaries(): Start");
1380:
1381: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1382: {
1383: if (IS_DEBUG_OSPF_EVENT)
1384: zlog_debug ("ospf_abr_unapprove_summaries(): "
1385: "considering area %s",
1386: inet_ntoa (area->area_id));
1387: LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
1388: if (ospf_lsa_is_self_originated (ospf, lsa))
1389: {
1390: if (IS_DEBUG_OSPF_EVENT)
1391: zlog_debug ("ospf_abr_unapprove_summaries(): "
1392: "approved unset on summary link id %s",
1393: inet_ntoa (lsa->data->id));
1394: UNSET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
1395: }
1396:
1397: LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
1398: if (ospf_lsa_is_self_originated (ospf, lsa))
1399: {
1400: if (IS_DEBUG_OSPF_EVENT)
1401: zlog_debug ("ospf_abr_unapprove_summaries(): "
1402: "approved unset on asbr-summary link id %s",
1403: inet_ntoa (lsa->data->id));
1404: UNSET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
1405: }
1406: }
1407:
1408: if (IS_DEBUG_OSPF_EVENT)
1409: zlog_debug ("ospf_abr_unapprove_summaries(): Stop");
1410: }
1411:
1412: static void
1413: ospf_abr_prepare_aggregates (struct ospf *ospf)
1414: {
1415: struct listnode *node;
1416: struct route_node *rn;
1417: struct ospf_area_range *range;
1418: struct ospf_area *area;
1419:
1420: if (IS_DEBUG_OSPF_EVENT)
1421: zlog_debug ("ospf_abr_prepare_aggregates(): Start");
1422:
1423: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1424: {
1425: for (rn = route_top (area->ranges); rn; rn = route_next (rn))
1426: if ((range = rn->info) != NULL)
1427: {
1428: range->cost = 0;
1429: range->specifics = 0;
1430: }
1431: }
1432:
1433: if (IS_DEBUG_OSPF_EVENT)
1434: zlog_debug ("ospf_abr_prepare_aggregates(): Stop");
1435: }
1436:
1437: static void
1438: ospf_abr_announce_aggregates (struct ospf *ospf)
1439: {
1440: struct ospf_area *area, *ar;
1441: struct ospf_area_range *range;
1442: struct route_node *rn;
1443: struct prefix p;
1444: struct listnode *node, *n;
1445:
1446: if (IS_DEBUG_OSPF_EVENT)
1447: zlog_debug ("ospf_abr_announce_aggregates(): Start");
1448:
1449: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1450: {
1451: if (IS_DEBUG_OSPF_EVENT)
1452: zlog_debug ("ospf_abr_announce_aggregates(): looking at area %s",
1453: inet_ntoa (area->area_id));
1454:
1455: for (rn = route_top (area->ranges); rn; rn = route_next (rn))
1456: if ((range = rn->info))
1457: {
1458: if (!CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE))
1459: {
1460: if (IS_DEBUG_OSPF_EVENT)
1461: zlog_debug ("ospf_abr_announce_aggregates():"
1462: " discarding suppress-ranges");
1463: continue;
1464: }
1465:
1466: p.family = AF_INET;
1467: p.u.prefix4 = range->addr;
1468: p.prefixlen = range->masklen;
1469:
1470: if (IS_DEBUG_OSPF_EVENT)
1471: zlog_debug ("ospf_abr_announce_aggregates():"
1472: " this is range: %s/%d",
1473: inet_ntoa (p.u.prefix4), p.prefixlen);
1474:
1475: if (CHECK_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE))
1476: {
1477: p.family = AF_INET;
1478: p.u.prefix4 = range->subst_addr;
1479: p.prefixlen = range->subst_masklen;
1480: }
1481:
1482: if (range->specifics)
1483: {
1484: if (IS_DEBUG_OSPF_EVENT)
1485: zlog_debug ("ospf_abr_announce_aggregates(): active range");
1486:
1487: for (ALL_LIST_ELEMENTS_RO (ospf->areas, n, ar))
1488: {
1489: if (ar == area)
1490: continue;
1491:
1492: /* We do not check nexthops here, because
1493: intra-area routes can be associated with
1494: one area only */
1495:
1496: /* backbone routes are not summarized
1497: when announced into transit areas */
1498:
1499: if (ospf_area_is_transit (ar) &&
1500: OSPF_IS_AREA_BACKBONE (area))
1501: {
1502: if (IS_DEBUG_OSPF_EVENT)
1503: zlog_debug ("ospf_abr_announce_aggregates(): Skipping "
1504: "announcement of BB aggregate into"
1505: " a transit area");
1506: continue;
1507: }
1508: ospf_abr_announce_network_to_area ((struct prefix_ipv4 *)&p, range->cost, ar);
1509: }
1510: }
1511: }
1512: }
1513:
1514: if (IS_DEBUG_OSPF_EVENT)
1515: zlog_debug ("ospf_abr_announce_aggregates(): Stop");
1516: }
1517:
1518: static void
1519: ospf_abr_send_nssa_aggregates (struct ospf *ospf) /* temporarily turned off */
1520: {
1521: struct listnode *node; /*, n; */
1522: struct ospf_area *area; /*, *ar; */
1523: struct route_node *rn;
1524: struct ospf_area_range *range;
1525: struct prefix_ipv4 p;
1526:
1527: if (IS_DEBUG_OSPF_NSSA)
1528: zlog_debug ("ospf_abr_send_nssa_aggregates(): Start");
1529:
1530: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1531: {
1532: if (! area->NSSATranslatorState)
1533: continue;
1534:
1535: if (IS_DEBUG_OSPF_NSSA)
1536: zlog_debug ("ospf_abr_send_nssa_aggregates(): looking at area %s",
1537: inet_ntoa (area->area_id));
1538:
1539: for (rn = route_top (area->ranges); rn; rn = route_next (rn))
1540: {
1541: if (rn->info == NULL)
1542: continue;
1543:
1544: range = rn->info;
1545:
1546: if (!CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE))
1547: {
1548: if (IS_DEBUG_OSPF_NSSA)
1549: zlog_debug ("ospf_abr_send_nssa_aggregates():"
1550: " discarding suppress-ranges");
1551: continue;
1552: }
1553:
1554: p.family = AF_INET;
1555: p.prefix = range->addr;
1556: p.prefixlen = range->masklen;
1557:
1558: if (IS_DEBUG_OSPF_NSSA)
1559: zlog_debug ("ospf_abr_send_nssa_aggregates():"
1560: " this is range: %s/%d",
1561: inet_ntoa (p.prefix), p.prefixlen);
1562:
1563: if (CHECK_FLAG (range->flags, OSPF_AREA_RANGE_SUBSTITUTE))
1564: {
1565: p.family = AF_INET;
1566: p.prefix = range->subst_addr;
1567: p.prefixlen = range->subst_masklen;
1568: }
1569:
1570: if (range->specifics)
1571: {
1572: if (IS_DEBUG_OSPF_NSSA)
1573: zlog_debug ("ospf_abr_send_nssa_aggregates(): active range");
1574:
1575: /* Fetch LSA-Type-7 from aggregate prefix, and then
1576: * translate, Install (as Type-5), Approve, and Flood
1577: */
1578: ospf_abr_translate_nssa_range (&p, range->cost);
1579: }
1580: } /* all area ranges*/
1581: } /* all areas */
1582:
1583: if (IS_DEBUG_OSPF_NSSA)
1584: zlog_debug ("ospf_abr_send_nssa_aggregates(): Stop");
1585: }
1586:
1587: static void
1588: ospf_abr_announce_stub_defaults (struct ospf *ospf)
1589: {
1590: struct listnode *node;
1591: struct ospf_area *area;
1592: struct prefix_ipv4 p;
1593:
1594: if (! IS_OSPF_ABR (ospf))
1595: return;
1596:
1597: if (IS_DEBUG_OSPF_EVENT)
1598: zlog_debug ("ospf_abr_announce_stub_defaults(): Start");
1599:
1600: p.family = AF_INET;
1601: p.prefix.s_addr = OSPF_DEFAULT_DESTINATION;
1602: p.prefixlen = 0;
1603:
1604: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1605: {
1606: if (IS_DEBUG_OSPF_EVENT)
1607: zlog_debug ("ospf_abr_announce_stub_defaults(): looking at area %s",
1608: inet_ntoa (area->area_id));
1609:
1610: if ( (area->external_routing != OSPF_AREA_STUB)
1611: && (area->external_routing != OSPF_AREA_NSSA)
1612: )
1613: continue;
1614:
1615: if (OSPF_IS_AREA_BACKBONE (area))
1616: continue; /* Sanity Check */
1617:
1618: if (IS_DEBUG_OSPF_EVENT)
1619: zlog_debug ("ospf_abr_announce_stub_defaults(): "
1620: "announcing 0.0.0.0/0 to area %s",
1621: inet_ntoa (area->area_id));
1622: ospf_abr_announce_network_to_area (&p, area->default_cost, area);
1623: }
1624:
1625: if (IS_DEBUG_OSPF_EVENT)
1626: zlog_debug ("ospf_abr_announce_stub_defaults(): Stop");
1627: }
1628:
1629: static int
1630: ospf_abr_remove_unapproved_translates_apply (struct ospf *ospf,
1631: struct ospf_lsa *lsa)
1632: {
1633: if (CHECK_FLAG (lsa->flags, OSPF_LSA_LOCAL_XLT)
1634: && ! CHECK_FLAG (lsa->flags, OSPF_LSA_APPROVED))
1635: {
1636: zlog_info ("ospf_abr_remove_unapproved_translates(): "
1637: "removing unapproved translates, ID: %s",
1638: inet_ntoa (lsa->data->id));
1639:
1640: /* FLUSH THROUGHOUT AS */
1641: ospf_lsa_flush_as (ospf, lsa);
1642:
1643: /* DISCARD from LSDB */
1644: }
1645: return 0;
1646: }
1647:
1648: static void
1649: ospf_abr_remove_unapproved_translates (struct ospf *ospf)
1650: {
1651: struct route_node *rn;
1652: struct ospf_lsa *lsa;
1653:
1654: /* All AREA PROCESS should have APPROVED necessary LSAs */
1655: /* Remove any left over and not APPROVED */
1656: if (IS_DEBUG_OSPF_NSSA)
1657: zlog_debug ("ospf_abr_remove_unapproved_translates(): Start");
1658:
1659: LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
1660: ospf_abr_remove_unapproved_translates_apply (ospf, lsa);
1661:
1662: if (IS_DEBUG_OSPF_NSSA)
1663: zlog_debug ("ospf_abr_remove_unapproved_translates(): Stop");
1664: }
1665:
1666: static void
1667: ospf_abr_remove_unapproved_summaries (struct ospf *ospf)
1668: {
1669: struct listnode *node;
1670: struct ospf_area *area;
1671: struct route_node *rn;
1672: struct ospf_lsa *lsa;
1673:
1674: if (IS_DEBUG_OSPF_EVENT)
1675: zlog_debug ("ospf_abr_remove_unapproved_summaries(): Start");
1676:
1677: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
1678: {
1679: if (IS_DEBUG_OSPF_EVENT)
1680: zlog_debug ("ospf_abr_remove_unapproved_summaries(): "
1681: "looking at area %s", inet_ntoa (area->area_id));
1682:
1683: LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
1684: if (ospf_lsa_is_self_originated (ospf, lsa))
1685: if (!CHECK_FLAG (lsa->flags, OSPF_LSA_APPROVED))
1686: ospf_lsa_flush_area (lsa, area);
1687:
1688: LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
1689: if (ospf_lsa_is_self_originated (ospf, lsa))
1690: if (!CHECK_FLAG (lsa->flags, OSPF_LSA_APPROVED))
1691: ospf_lsa_flush_area (lsa, area);
1692: }
1693:
1694: if (IS_DEBUG_OSPF_EVENT)
1695: zlog_debug ("ospf_abr_remove_unapproved_summaries(): Stop");
1696: }
1697:
1698: static void
1699: ospf_abr_manage_discard_routes (struct ospf *ospf)
1700: {
1701: struct listnode *node, *nnode;
1702: struct route_node *rn;
1703: struct ospf_area *area;
1704: struct ospf_area_range *range;
1705:
1706: for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
1707: for (rn = route_top (area->ranges); rn; rn = route_next (rn))
1708: if ((range = rn->info) != NULL)
1709: if (CHECK_FLAG (range->flags, OSPF_AREA_RANGE_ADVERTISE))
1710: {
1711: if (range->specifics)
1712: ospf_add_discard_route (ospf->new_table, area,
1713: (struct prefix_ipv4 *) &rn->p);
1714: else
1715: ospf_delete_discard_route (ospf->new_table,
1716: (struct prefix_ipv4 *) &rn->p);
1717: }
1718: }
1719:
1720: /* This is the function taking care about ABR NSSA, i.e. NSSA
1721: Translator, -LSA aggregation and flooding. For all NSSAs
1722:
1723: Any SELF-AS-LSA is in the Type-5 LSDB and Type-7 LSDB. These LSA's
1724: are refreshed from the Type-5 LSDB, installed into the Type-7 LSDB
1725: with the P-bit set.
1726:
1727: Any received Type-5s are legal for an ABR, else illegal for IR.
1728: Received Type-7s are installed, by area, with incoming P-bit. They
1729: are flooded; if the Elected NSSA Translator, then P-bit off.
1730:
1731: Additionally, this ABR will place "translated type-7's" into the
1732: Type-5 LSDB in order to keep track of APPROVAL or not.
1733:
1734: It will scan through every area, looking for Type-7 LSAs with P-Bit
1735: SET. The Type-7's are either AS-FLOODED & 5-INSTALLED or
1736: AGGREGATED. Later, the AGGREGATED LSAs are AS-FLOODED &
1737: 5-INSTALLED.
1738:
1739: 5-INSTALLED is into the Type-5 LSDB; Any UNAPPROVED Type-5 LSAs
1740: left over are FLUSHED and DISCARDED.
1741:
1742: For External Calculations, any NSSA areas use the Type-7 AREA-LSDB,
1743: any ABR-non-NSSA areas use the Type-5 GLOBAL-LSDB. */
1744:
1745: static void
1746: ospf_abr_nssa_task (struct ospf *ospf) /* called only if any_nssa */
1747: {
1748: if (IS_DEBUG_OSPF_NSSA)
1749: zlog_debug ("Check for NSSA-ABR Tasks():");
1750:
1751: if (! IS_OSPF_ABR (ospf))
1752: return;
1753:
1754: if (! ospf->anyNSSA)
1755: return;
1756:
1757: /* Each area must confirm TranslatorRole */
1758: if (IS_DEBUG_OSPF_NSSA)
1759: zlog_debug ("ospf_abr_nssa_task(): Start");
1760:
1761: /* For all Global Entries flagged "local-translate", unset APPROVED */
1762: if (IS_DEBUG_OSPF_NSSA)
1763: zlog_debug ("ospf_abr_nssa_task(): unapprove translates");
1764:
1765: ospf_abr_unapprove_translates (ospf);
1766:
1767: /* RESET all Ranges in every Area, same as summaries */
1768: if (IS_DEBUG_OSPF_NSSA)
1769: zlog_debug ("ospf_abr_nssa_task(): NSSA initialize aggregates");
1770: ospf_abr_prepare_aggregates (ospf); /*TURNED OFF just for now */
1771:
1772: /* For all NSSAs, Type-7s, translate to 5's, INSTALL/FLOOD, or
1773: * Aggregate as Type-7
1774: * Install or Approve in Type-5 Global LSDB
1775: */
1776: if (IS_DEBUG_OSPF_NSSA)
1777: zlog_debug ("ospf_abr_nssa_task(): process translates");
1778: ospf_abr_process_nssa_translates (ospf);
1779:
1780: /* Translate/Send any "ranged" aggregates, and also 5-Install and
1781: * Approve
1782: * Scan Type-7's for aggregates, translate to Type-5's,
1783: * Install/Flood/Approve
1784: */
1785: if (IS_DEBUG_OSPF_NSSA)
1786: zlog_debug("ospf_abr_nssa_task(): send NSSA aggregates");
1787: ospf_abr_send_nssa_aggregates (ospf); /*TURNED OFF FOR NOW */
1788:
1789: /* Send any NSSA defaults as Type-5
1790: *if (IS_DEBUG_OSPF_NSSA)
1791: * zlog_debug ("ospf_abr_nssa_task(): announce nssa defaults");
1792: *ospf_abr_announce_nssa_defaults (ospf);
1793: * havnt a clue what above is supposed to do.
1794: */
1795:
1796: /* Flush any unapproved previous translates from Global Data Base */
1797: if (IS_DEBUG_OSPF_NSSA)
1798: zlog_debug ("ospf_abr_nssa_task(): remove unapproved translates");
1799: ospf_abr_remove_unapproved_translates (ospf);
1800:
1801: ospf_abr_manage_discard_routes (ospf); /* same as normal...discard */
1802:
1803: if (IS_DEBUG_OSPF_NSSA)
1804: zlog_debug ("ospf_abr_nssa_task(): Stop");
1805: }
1806:
1807: /* This is the function taking care about ABR stuff, i.e.
1808: summary-LSA origination and flooding. */
1809: void
1810: ospf_abr_task (struct ospf *ospf)
1811: {
1812: if (IS_DEBUG_OSPF_EVENT)
1813: zlog_debug ("ospf_abr_task(): Start");
1814:
1815: if (ospf->new_table == NULL || ospf->new_rtrs == NULL)
1816: {
1817: if (IS_DEBUG_OSPF_EVENT)
1818: zlog_debug ("ospf_abr_task(): Routing tables are not yet ready");
1819: return;
1820: }
1821:
1822: if (IS_DEBUG_OSPF_EVENT)
1823: zlog_debug ("ospf_abr_task(): unapprove summaries");
1824: ospf_abr_unapprove_summaries (ospf);
1825:
1826: if (IS_DEBUG_OSPF_EVENT)
1827: zlog_debug ("ospf_abr_task(): prepare aggregates");
1828: ospf_abr_prepare_aggregates (ospf);
1829:
1830: if (IS_OSPF_ABR (ospf))
1831: {
1832: if (IS_DEBUG_OSPF_EVENT)
1833: zlog_debug ("ospf_abr_task(): process network RT");
1834: ospf_abr_process_network_rt (ospf, ospf->new_table);
1835:
1836: if (IS_DEBUG_OSPF_EVENT)
1837: zlog_debug ("ospf_abr_task(): process router RT");
1838: ospf_abr_process_router_rt (ospf, ospf->new_rtrs);
1839:
1840: if (IS_DEBUG_OSPF_EVENT)
1841: zlog_debug ("ospf_abr_task(): announce aggregates");
1842: ospf_abr_announce_aggregates (ospf);
1843:
1844: if (IS_DEBUG_OSPF_EVENT)
1845: zlog_debug ("ospf_abr_task(): announce stub defaults");
1846: ospf_abr_announce_stub_defaults (ospf);
1847: }
1848:
1849: if (IS_DEBUG_OSPF_EVENT)
1850: zlog_debug ("ospf_abr_task(): remove unapproved summaries");
1851: ospf_abr_remove_unapproved_summaries (ospf);
1852:
1853: ospf_abr_manage_discard_routes (ospf);
1854:
1855: if (IS_DEBUG_OSPF_EVENT)
1856: zlog_debug ("ospf_abr_task(): Stop");
1857: }
1858:
1859: static int
1860: ospf_abr_task_timer (struct thread *thread)
1861: {
1862: struct ospf *ospf = THREAD_ARG (thread);
1863:
1864: ospf->t_abr_task = 0;
1865:
1866: if (IS_DEBUG_OSPF_EVENT)
1867: zlog_debug ("Running ABR task on timer");
1868:
1869: ospf_check_abr_status (ospf);
1870: ospf_abr_nssa_check_status (ospf);
1871:
1872: ospf_abr_task (ospf);
1873: ospf_abr_nssa_task (ospf); /* if nssa-abr, then scan Type-7 LSDB */
1874:
1875: return 0;
1876: }
1877:
1878: void
1879: ospf_schedule_abr_task (struct ospf *ospf)
1880: {
1881: if (IS_DEBUG_OSPF_EVENT)
1882: zlog_debug ("Scheduling ABR task");
1883:
1884: if (ospf->t_abr_task == NULL)
1885: ospf->t_abr_task = thread_add_timer (master, ospf_abr_task_timer,
1886: ospf, OSPF_ABR_TASK_DELAY);
1887: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_abr.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