1: /*
2: * OSPF Flooding -- RFC2328 Section 13.
3: * Copyright (C) 1999, 2000 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
8: * it under the terms of the GNU General Public License as published
9: * by the Free Software Foundation; either version 2, or (at your
10: * option) any 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 "linklist.h"
26: #include "prefix.h"
27: #include "if.h"
28: #include "command.h"
29: #include "table.h"
30: #include "thread.h"
31: #include "memory.h"
32: #include "log.h"
33: #include "zclient.h"
34:
35: #include "ospfd/ospfd.h"
36: #include "ospfd/ospf_interface.h"
37: #include "ospfd/ospf_ism.h"
38: #include "ospfd/ospf_asbr.h"
39: #include "ospfd/ospf_lsa.h"
40: #include "ospfd/ospf_lsdb.h"
41: #include "ospfd/ospf_neighbor.h"
42: #include "ospfd/ospf_nsm.h"
43: #include "ospfd/ospf_spf.h"
44: #include "ospfd/ospf_flood.h"
45: #include "ospfd/ospf_packet.h"
46: #include "ospfd/ospf_abr.h"
47: #include "ospfd/ospf_route.h"
48: #include "ospfd/ospf_zebra.h"
49: #include "ospfd/ospf_dump.h"
50:
51: extern struct zclient *zclient;
52:
53: /* Do the LSA acking specified in table 19, Section 13.5, row 2
54: * This get called from ospf_flood_out_interface. Declared inline
55: * for speed. */
56: static void
57: ospf_flood_delayed_lsa_ack (struct ospf_neighbor *inbr, struct ospf_lsa *lsa)
58: {
59: /* LSA is more recent than database copy, but was not
60: flooded back out receiving interface. Delayed
61: acknowledgment sent. If interface is in Backup state
62: delayed acknowledgment sent only if advertisement
63: received from Designated Router, otherwise do nothing See
64: RFC 2328 Section 13.5 */
65:
66: /* Whether LSA is more recent or not, and whether this is in
67: response to the LSA being sent out recieving interface has been
68: worked out previously */
69:
70: /* Deal with router as BDR */
71: if (inbr->oi->state == ISM_Backup && ! NBR_IS_DR (inbr))
72: return;
73:
74: /* Schedule a delayed LSA Ack to be sent */
75: listnode_add (inbr->oi->ls_ack, ospf_lsa_lock (lsa)); /* delayed LSA Ack */
76: }
77:
78: /* Check LSA is related to external info. */
79: struct external_info *
80: ospf_external_info_check (struct ospf_lsa *lsa)
81: {
82: struct as_external_lsa *al;
83: struct prefix_ipv4 p;
84: struct route_node *rn;
85: int type;
86:
87: al = (struct as_external_lsa *) lsa->data;
88:
89: p.family = AF_INET;
90: p.prefix = lsa->data->id;
91: p.prefixlen = ip_masklen (al->mask);
92:
93: for (type = 0; type <= ZEBRA_ROUTE_MAX; type++)
94: {
95: int redist_type = is_prefix_default (&p) ? DEFAULT_ROUTE : type;
96: if (ospf_is_type_redistributed (redist_type))
97: if (EXTERNAL_INFO (type))
98: {
99: rn = route_node_lookup (EXTERNAL_INFO (type),
100: (struct prefix *) &p);
101: if (rn)
102: {
103: route_unlock_node (rn);
104: if (rn->info != NULL)
105: return (struct external_info *) rn->info;
106: }
107: }
108: }
109:
110: return NULL;
111: }
112:
113: static void
114: ospf_process_self_originated_lsa (struct ospf *ospf,
115: struct ospf_lsa *new, struct ospf_area *area)
116: {
117: struct ospf_interface *oi;
118: struct external_info *ei;
119: struct listnode *node;
120:
121: if (IS_DEBUG_OSPF_EVENT)
122: zlog_debug ("LSA[Type%d:%s]: Process self-originated LSA seq 0x%x",
123: new->data->type, inet_ntoa (new->data->id),
124: ntohl(new->data->ls_seqnum));
125:
126: /* If we're here, we installed a self-originated LSA that we received
127: from a neighbor, i.e. it's more recent. We must see whether we want
128: to originate it.
129: If yes, we should use this LSA's sequence number and reoriginate
130: a new instance.
131: if not --- we must flush this LSA from the domain. */
132: switch (new->data->type)
133: {
134: case OSPF_ROUTER_LSA:
135: /* Originate a new instance and schedule flooding */
136: if (area->router_lsa_self)
137: area->router_lsa_self->data->ls_seqnum = new->data->ls_seqnum;
138: ospf_router_lsa_update_area (area);
139: return;
140: case OSPF_NETWORK_LSA:
141: #ifdef HAVE_OPAQUE_LSA
142: case OSPF_OPAQUE_LINK_LSA:
143: #endif /* HAVE_OPAQUE_LSA */
144: /* We must find the interface the LSA could belong to.
145: If the interface is no more a broadcast type or we are no more
146: the DR, we flush the LSA otherwise -- create the new instance and
147: schedule flooding. */
148:
149: /* Look through all interfaces, not just area, since interface
150: could be moved from one area to another. */
151: for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
152: /* These are sanity check. */
153: if (IPV4_ADDR_SAME (&oi->address->u.prefix4, &new->data->id))
154: {
155: if (oi->area != area ||
156: oi->type != OSPF_IFTYPE_BROADCAST ||
157: !IPV4_ADDR_SAME (&oi->address->u.prefix4, &DR (oi)))
158: {
159: ospf_schedule_lsa_flush_area (area, new);
160: return;
161: }
162:
163: #ifdef HAVE_OPAQUE_LSA
164: if (new->data->type == OSPF_OPAQUE_LINK_LSA)
165: {
166: ospf_opaque_lsa_refresh (new);
167: return;
168: }
169: #endif /* HAVE_OPAQUE_LSA */
170:
171: if (oi->network_lsa_self)
172: oi->network_lsa_self->data->ls_seqnum = new->data->ls_seqnum;
173: /* Schedule network-LSA origination. */
174: ospf_network_lsa_update (oi);
175: return;
176: }
177: break;
178: case OSPF_SUMMARY_LSA:
179: case OSPF_ASBR_SUMMARY_LSA:
180: ospf_schedule_abr_task (ospf);
181: break;
182: case OSPF_AS_EXTERNAL_LSA :
183: case OSPF_AS_NSSA_LSA:
184: if ( (new->data->type == OSPF_AS_EXTERNAL_LSA)
185: && CHECK_FLAG (new->flags, OSPF_LSA_LOCAL_XLT))
186: {
187: ospf_translated_nssa_refresh (ospf, NULL, new);
188: return;
189: }
190: ei = ospf_external_info_check (new);
191: if (ei)
192: ospf_external_lsa_refresh (ospf, new, ei, LSA_REFRESH_FORCE);
193: else
194: ospf_lsa_flush_as (ospf, new);
195: break;
196: #ifdef HAVE_OPAQUE_LSA
197: case OSPF_OPAQUE_AREA_LSA:
198: ospf_opaque_lsa_refresh (new);
199: break;
200: case OSPF_OPAQUE_AS_LSA:
201: ospf_opaque_lsa_refresh (new); /* Reconsideration may needed. *//* XXX */
202: break;
203: #endif /* HAVE_OPAQUE_LSA */
204: default:
205: break;
206: }
207: }
208:
209: /* OSPF LSA flooding -- RFC2328 Section 13.(5). */
210:
211: /* Now Updated for NSSA operation, as follows:
212:
213:
214: Type-5's have no change. Blocked to STUB or NSSA.
215:
216: Type-7's can be received, and if a DR
217: they will also flood the local NSSA Area as Type-7's
218:
219: If a Self-Originated LSA (now an ASBR),
220: The LSDB will be updated as Type-5's, (for continual re-fresh)
221:
222: If an NSSA-IR it is installed/flooded as Type-7, P-bit on.
223: if an NSSA-ABR it is installed/flooded as Type-7, P-bit off.
224:
225: Later, during the ABR TASK, if the ABR is the Elected NSSA
226: translator, then All Type-7s (with P-bit ON) are Translated to
227: Type-5's and flooded to all non-NSSA/STUB areas.
228:
229: During ASE Calculations,
230: non-ABRs calculate external routes from Type-7's
231: ABRs calculate external routes from Type-5's and non-self Type-7s
232: */
233: int
234: ospf_flood (struct ospf *ospf, struct ospf_neighbor *nbr,
235: struct ospf_lsa *current, struct ospf_lsa *new)
236: {
237: struct ospf_interface *oi;
238: int lsa_ack_flag;
239:
240: /* Type-7 LSA's will be flooded throughout their native NSSA area,
241: but will also be flooded as Type-5's into ABR capable links. */
242:
243: if (IS_DEBUG_OSPF_EVENT)
244: zlog_debug ("LSA[Flooding]: start, NBR %s (%s), cur(%p), New-LSA[%s]",
245: inet_ntoa (nbr->router_id),
246: LOOKUP (ospf_nsm_state_msg, nbr->state),
247: current,
248: dump_lsa_key (new));
249:
250: lsa_ack_flag = 0;
251: oi = nbr->oi;
252:
253: /* If there is already a database copy, and if the
254: database copy was received via flooding and installed less
255: than MinLSArrival seconds ago, discard the new LSA
256: (without acknowledging it). */
257: if (current != NULL) /* -- endo. */
258: {
259: if (IS_LSA_SELF (current)
260: && (ntohs (current->data->ls_age) == 0
261: && ntohl (current->data->ls_seqnum) == OSPF_INITIAL_SEQUENCE_NUMBER))
262: {
263: if (IS_DEBUG_OSPF_EVENT)
264: zlog_debug ("LSA[Flooding]: Got a self-originated LSA, "
265: "while local one is initial instance.");
266: ; /* Accept this LSA for quick LSDB resynchronization. */
267: }
268: else if (tv_cmp (tv_sub (recent_relative_time (), current->tv_recv),
269: int2tv (OSPF_MIN_LS_ARRIVAL)) < 0)
270: {
271: if (IS_DEBUG_OSPF_EVENT)
272: zlog_debug ("LSA[Flooding]: LSA is received recently.");
273: return -1;
274: }
275: }
276:
277: /* Flood the new LSA out some subset of the router's interfaces.
278: In some cases (e.g., the state of the receiving interface is
279: DR and the LSA was received from a router other than the
280: Backup DR) the LSA will be flooded back out the receiving
281: interface. */
282: lsa_ack_flag = ospf_flood_through (ospf, nbr, new);
283:
284: #ifdef HAVE_OPAQUE_LSA
285: /* Remove the current database copy from all neighbors' Link state
286: retransmission lists. AS_EXTERNAL and AS_EXTERNAL_OPAQUE does
287: ^^^^^^^^^^^^^^^^^^^^^^^
288: not have area ID.
289: All other (even NSSA's) do have area ID. */
290: #else /* HAVE_OPAQUE_LSA */
291: /* Remove the current database copy from all neighbors' Link state
292: retransmission lists. Only AS_EXTERNAL does not have area ID.
293: All other (even NSSA's) do have area ID. */
294: #endif /* HAVE_OPAQUE_LSA */
295: if (current)
296: {
297: switch (current->data->type)
298: {
299: case OSPF_AS_EXTERNAL_LSA:
300: #ifdef HAVE_OPAQUE_LSA
301: case OSPF_OPAQUE_AS_LSA:
302: #endif /* HAVE_OPAQUE_LSA */
303: ospf_ls_retransmit_delete_nbr_as (ospf, current);
304: break;
305: default:
306: ospf_ls_retransmit_delete_nbr_area (nbr->oi->area, current);
307: break;
308: }
309: }
310:
311: /* Do some internal house keeping that is needed here */
312: SET_FLAG (new->flags, OSPF_LSA_RECEIVED);
313: ospf_lsa_is_self_originated (ospf, new); /* Let it set the flag */
314:
315: /* Install the new LSA in the link state database
316: (replacing the current database copy). This may cause the
317: routing table calculation to be scheduled. In addition,
318: timestamp the new LSA with the current time. The flooding
319: procedure cannot overwrite the newly installed LSA until
320: MinLSArrival seconds have elapsed. */
321:
322: if (! (new = ospf_lsa_install (ospf, nbr->oi, new)))
323: return -1; /* unknown LSA type or any other error condition */
324:
325: /* Acknowledge the receipt of the LSA by sending a Link State
326: Acknowledgment packet back out the receiving interface. */
327: if (lsa_ack_flag)
328: ospf_flood_delayed_lsa_ack (nbr, new);
329:
330: /* If this new LSA indicates that it was originated by the
331: receiving router itself, the router must take special action,
332: either updating the LSA or in some cases flushing it from
333: the routing domain. */
334: if (ospf_lsa_is_self_originated (ospf, new))
335: ospf_process_self_originated_lsa (ospf, new, oi->area);
336: else
337: /* Update statistics value for OSPF-MIB. */
338: ospf->rx_lsa_count++;
339:
340: return 0;
341: }
342:
343: /* OSPF LSA flooding -- RFC2328 Section 13.3. */
344: static int
345: ospf_flood_through_interface (struct ospf_interface *oi,
346: struct ospf_neighbor *inbr,
347: struct ospf_lsa *lsa)
348: {
349: struct ospf_neighbor *onbr;
350: struct route_node *rn;
351: int retx_flag;
352:
353: if (IS_DEBUG_OSPF_EVENT)
354: zlog_debug ("ospf_flood_through_interface(): "
355: "considering int %s, INBR(%s), LSA[%s]",
356: IF_NAME (oi), inbr ? inet_ntoa (inbr->router_id) : "NULL",
357: dump_lsa_key (lsa));
358:
359: if (!ospf_if_is_enable (oi))
360: return 0;
361:
362: /* Remember if new LSA is aded to a retransmit list. */
363: retx_flag = 0;
364:
365: /* Each of the neighbors attached to this interface are examined,
366: to determine whether they must receive the new LSA. The following
367: steps are executed for each neighbor: */
368: for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
369: {
370: struct ospf_lsa *ls_req;
371:
372: if (rn->info == NULL)
373: continue;
374:
375: onbr = rn->info;
376: if (IS_DEBUG_OSPF_EVENT)
377: zlog_debug ("ospf_flood_through_interface(): considering nbr %s (%s)",
378: inet_ntoa (onbr->router_id),
379: LOOKUP (ospf_nsm_state_msg, onbr->state));
380:
381: /* If the neighbor is in a lesser state than Exchange, it
382: does not participate in flooding, and the next neighbor
383: should be examined. */
384: if (onbr->state < NSM_Exchange)
385: continue;
386:
387: /* If the adjacency is not yet full (neighbor state is
388: Exchange or Loading), examine the Link state request
389: list associated with this adjacency. If there is an
390: instance of the new LSA on the list, it indicates that
391: the neighboring router has an instance of the LSA
392: already. Compare the new LSA to the neighbor's copy: */
393: if (onbr->state < NSM_Full)
394: {
395: if (IS_DEBUG_OSPF_EVENT)
396: zlog_debug ("ospf_flood_through_interface(): nbr adj is not Full");
397: ls_req = ospf_ls_request_lookup (onbr, lsa);
398: if (ls_req != NULL)
399: {
400: int ret;
401:
402: ret = ospf_lsa_more_recent (ls_req, lsa);
403: /* The new LSA is less recent. */
404: if (ret > 0)
405: continue;
406: /* The two copies are the same instance, then delete
407: the LSA from the Link state request list. */
408: else if (ret == 0)
409: {
410: ospf_ls_request_delete (onbr, ls_req);
411: ospf_check_nbr_loading (onbr);
412: continue;
413: }
414: /* The new LSA is more recent. Delete the LSA
415: from the Link state request list. */
416: else
417: {
418: ospf_ls_request_delete (onbr, ls_req);
419: ospf_check_nbr_loading (onbr);
420: }
421: }
422: }
423:
424: #ifdef HAVE_OPAQUE_LSA
425: if (IS_OPAQUE_LSA (lsa->data->type))
426: {
427: if (! CHECK_FLAG (onbr->options, OSPF_OPTION_O))
428: {
429: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
430: zlog_debug ("Skip this neighbor: Not Opaque-capable.");
431: continue;
432: }
433:
434: if (IS_OPAQUE_LSA_ORIGINATION_BLOCKED (oi->ospf->opaque)
435: && IS_LSA_SELF (lsa)
436: && onbr->state == NSM_Full)
437: {
438: /* Small attempt to reduce unnecessary retransmission. */
439: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
440: zlog_debug ("Skip this neighbor: Initial flushing done.");
441: continue;
442: }
443: }
444: #endif /* HAVE_OPAQUE_LSA */
445:
446: /* If the new LSA was received from this neighbor,
447: examine the next neighbor. */
448: #ifdef ORIGINAL_CODING
449: if (inbr)
450: if (IPV4_ADDR_SAME (&inbr->router_id, &onbr->router_id))
451: continue;
452: #else /* ORIGINAL_CODING */
453: if (inbr)
454: {
455: /*
456: * Triggered by LSUpd message parser "ospf_ls_upd ()".
457: * E.g., all LSAs handling here is received via network.
458: */
459: if (IPV4_ADDR_SAME (&inbr->router_id, &onbr->router_id))
460: {
461: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
462: zlog_debug ("Skip this neighbor: inbr == onbr");
463: continue;
464: }
465: }
466: else
467: {
468: /*
469: * Triggered by MaxAge remover, so far.
470: * NULL "inbr" means flooding starts from this node.
471: */
472: if (IPV4_ADDR_SAME (&lsa->data->adv_router, &onbr->router_id))
473: {
474: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
475: zlog_debug ("Skip this neighbor: lsah->adv_router == onbr");
476: continue;
477: }
478: }
479: #endif /* ORIGINAL_CODING */
480:
481: /* Add the new LSA to the Link state retransmission list
482: for the adjacency. The LSA will be retransmitted
483: at intervals until an acknowledgment is seen from
484: the neighbor. */
485: ospf_ls_retransmit_add (onbr, lsa);
486: retx_flag = 1;
487: }
488:
489: /* If in the previous step, the LSA was NOT added to any of
490: the Link state retransmission lists, there is no need to
491: flood the LSA out the interface. */
492: if (retx_flag == 0)
493: {
494: return (inbr && inbr->oi == oi);
495: }
496:
497: /* if we've received the lsa on this interface we need to perform
498: additional checking */
499: if (inbr && (inbr->oi == oi))
500: {
501: /* If the new LSA was received on this interface, and it was
502: received from either the Designated Router or the Backup
503: Designated Router, chances are that all the neighbors have
504: received the LSA already. */
505: if (NBR_IS_DR (inbr) || NBR_IS_BDR (inbr))
506: {
507: if (IS_DEBUG_OSPF_NSSA)
508: zlog_debug ("ospf_flood_through_interface(): "
509: "DR/BDR NOT SEND to int %s", IF_NAME (oi));
510: return 1;
511: }
512:
513: /* If the new LSA was received on this interface, and the
514: interface state is Backup, examine the next interface. The
515: Designated Router will do the flooding on this interface.
516: However, if the Designated Router fails the router will
517: end up retransmitting the updates. */
518:
519: if (oi->state == ISM_Backup)
520: {
521: if (IS_DEBUG_OSPF_NSSA)
522: zlog_debug ("ospf_flood_through_interface(): "
523: "ISM_Backup NOT SEND to int %s", IF_NAME (oi));
524: return 1;
525: }
526: }
527:
528: /* The LSA must be flooded out the interface. Send a Link State
529: Update packet (including the new LSA as contents) out the
530: interface. The LSA's LS age must be incremented by InfTransDelay
531: (which must be > 0) when it is copied into the outgoing Link
532: State Update packet (until the LS age field reaches the maximum
533: value of MaxAge). */
534: /* XXX HASSO: Is this IS_DEBUG_OSPF_NSSA really correct? */
535: if (IS_DEBUG_OSPF_NSSA)
536: zlog_debug ("ospf_flood_through_interface(): "
537: "DR/BDR sending upd to int %s", IF_NAME (oi));
538:
539: /* RFC2328 Section 13.3
540: On non-broadcast networks, separate Link State Update
541: packets must be sent, as unicasts, to each adjacent neighbor
542: (i.e., those in state Exchange or greater). The destination
543: IP addresses for these packets are the neighbors' IP
544: addresses. */
545: if (oi->type == OSPF_IFTYPE_NBMA)
546: {
547: struct route_node *rn;
548: struct ospf_neighbor *nbr;
549:
550: for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
551: if ((nbr = rn->info) != NULL)
552: if (nbr != oi->nbr_self && nbr->state >= NSM_Exchange)
553: ospf_ls_upd_send_lsa (nbr, lsa, OSPF_SEND_PACKET_DIRECT);
554: }
555: else
556: ospf_ls_upd_send_lsa (oi->nbr_self, lsa, OSPF_SEND_PACKET_INDIRECT);
557:
558: return 0;
559: }
560:
561: int
562: ospf_flood_through_area (struct ospf_area *area,
563: struct ospf_neighbor *inbr, struct ospf_lsa *lsa)
564: {
565: struct listnode *node, *nnode;
566: struct ospf_interface *oi;
567: int lsa_ack_flag = 0;
568:
569: /* All other types are specific to a single area (Area A). The
570: eligible interfaces are all those interfaces attaching to the
571: Area A. If Area A is the backbone, this includes all the virtual
572: links. */
573: for (ALL_LIST_ELEMENTS (area->oiflist, node, nnode, oi))
574: {
575: if (area->area_id.s_addr != OSPF_AREA_BACKBONE &&
576: oi->type == OSPF_IFTYPE_VIRTUALLINK)
577: continue;
578:
579: #ifdef HAVE_OPAQUE_LSA
580: if ((lsa->data->type == OSPF_OPAQUE_LINK_LSA) && (lsa->oi != oi))
581: {
582: /*
583: * Link local scoped Opaque-LSA should only be flooded
584: * for the link on which the LSA has received.
585: */
586: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
587: zlog_debug ("Type-9 Opaque-LSA: lsa->oi(%p) != oi(%p)", lsa->oi, oi);
588: continue;
589: }
590: #endif /* HAVE_OPAQUE_LSA */
591:
592: if (ospf_flood_through_interface (oi, inbr, lsa))
593: lsa_ack_flag = 1;
594: }
595:
596: return (lsa_ack_flag);
597: }
598:
599: int
600: ospf_flood_through_as (struct ospf *ospf, struct ospf_neighbor *inbr,
601: struct ospf_lsa *lsa)
602: {
603: struct listnode *node;
604: struct ospf_area *area;
605: int lsa_ack_flag;
606:
607: lsa_ack_flag = 0;
608:
609: /* The incoming LSA is type 5 or type 7 (AS-EXTERNAL or AS-NSSA )
610:
611: Divert the Type-5 LSA's to all non-NSSA/STUB areas
612:
613: Divert the Type-7 LSA's to all NSSA areas
614:
615: AS-external-LSAs are flooded throughout the entire AS, with the
616: exception of stub areas (see Section 3.6). The eligible
617: interfaces are all the router's interfaces, excluding virtual
618: links and those interfaces attaching to stub areas. */
619:
620: if (CHECK_FLAG (lsa->flags, OSPF_LSA_LOCAL_XLT)) /* Translated from 7 */
621: if (IS_DEBUG_OSPF_NSSA)
622: zlog_debug ("Flood/AS: NSSA TRANSLATED LSA");
623:
624: for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
625: {
626: int continue_flag = 0;
627: struct listnode *if_node;
628: struct ospf_interface *oi;
629:
630: switch (area->external_routing)
631: {
632: /* Don't send AS externals into stub areas. Various types
633: of support for partial stub areas can be implemented
634: here. NSSA's will receive Type-7's that have areas
635: matching the originl LSA. */
636: case OSPF_AREA_NSSA: /* Sending Type 5 or 7 into NSSA area */
637: /* Type-7, flood NSSA area */
638: if (lsa->data->type == OSPF_AS_NSSA_LSA
639: && area == lsa->area)
640: /* We will send it. */
641: continue_flag = 0;
642: else
643: continue_flag = 1; /* Skip this NSSA area for Type-5's et al */
644: break;
645:
646: case OSPF_AREA_TYPE_MAX:
647: case OSPF_AREA_STUB:
648: continue_flag = 1; /* Skip this area. */
649: break;
650:
651: case OSPF_AREA_DEFAULT:
652: default:
653: /* No Type-7 into normal area */
654: if (lsa->data->type == OSPF_AS_NSSA_LSA)
655: continue_flag = 1; /* skip Type-7 */
656: else
657: continue_flag = 0; /* Do this area. */
658: break;
659: }
660:
661: /* Do continue for above switch. Saves a big if then mess */
662: if (continue_flag)
663: continue; /* main for-loop */
664:
665: /* send to every interface in this area */
666:
667: for (ALL_LIST_ELEMENTS_RO (area->oiflist, if_node, oi))
668: {
669: /* Skip virtual links */
670: if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
671: if (ospf_flood_through_interface (oi, inbr, lsa)) /* lsa */
672: lsa_ack_flag = 1;
673: }
674: } /* main area for-loop */
675:
676: return (lsa_ack_flag);
677: }
678:
679: int
680: ospf_flood_through (struct ospf *ospf,
681: struct ospf_neighbor *inbr, struct ospf_lsa *lsa)
682: {
683: int lsa_ack_flag = 0;
684:
685: /* Type-7 LSA's for NSSA are flooded throughout the AS here, and
686: upon return are updated in the LSDB for Type-7's. Later,
687: re-fresh will re-send them (and also, if ABR, packet code will
688: translate to Type-5's)
689:
690: As usual, Type-5 LSA's (if not DISCARDED because we are STUB or
691: NSSA) are flooded throughout the AS, and are updated in the
692: global table. */
693: #ifdef ORIGINAL_CODING
694: switch (lsa->data->type)
695: {
696: case OSPF_ROUTER_LSA:
697: case OSPF_NETWORK_LSA:
698: case OSPF_SUMMARY_LSA:
699: case OSPF_ASBR_SUMMARY_LSA:
700: #ifdef HAVE_OPAQUE_LSA
701: case OSPF_OPAQUE_LINK_LSA: /* ospf_flood_through_interface ? */
702: case OSPF_OPAQUE_AREA_LSA:
703: #endif /* HAVE_OPAQUE_LSA */
704: lsa_ack_flag = ospf_flood_through_area (inbr->oi->area, inbr, lsa);
705: break;
706: case OSPF_AS_EXTERNAL_LSA: /* Type-5 */
707: #ifdef HAVE_OPAQUE_LSA
708: case OSPF_OPAQUE_AS_LSA:
709: #endif /* HAVE_OPAQUE_LSA */
710: lsa_ack_flag = ospf_flood_through_as (ospf, inbr, lsa);
711: break;
712: /* Type-7 Only received within NSSA, then flooded */
713: case OSPF_AS_NSSA_LSA:
714: /* Any P-bit was installed with the Type-7. */
715: lsa_ack_flag = ospf_flood_through_area (inbr->oi->area, inbr, lsa);
716:
717: if (IS_DEBUG_OSPF_NSSA)
718: zlog_debug ("ospf_flood_through: LOCAL NSSA FLOOD of Type-7.");
719: break;
720: default:
721: break;
722: }
723: #else /* ORIGINAL_CODING */
724: /*
725: * At the common sub-sub-function "ospf_flood_through_interface()",
726: * a parameter "inbr" will be used to distinguish the called context
727: * whether the given LSA was received from the neighbor, or the
728: * flooding for the LSA starts from this node (e.g. the LSA was self-
729: * originated, or the LSA is going to be flushed from routing domain).
730: *
731: * So, for consistency reasons, this function "ospf_flood_through()"
732: * should also allow the usage that the given "inbr" parameter to be
733: * NULL. If we do so, corresponding AREA parameter should be referred
734: * by "lsa->area", instead of "inbr->oi->area".
735: */
736: switch (lsa->data->type)
737: {
738: case OSPF_AS_EXTERNAL_LSA: /* Type-5 */
739: #ifdef HAVE_OPAQUE_LSA
740: case OSPF_OPAQUE_AS_LSA:
741: #endif /* HAVE_OPAQUE_LSA */
742: lsa_ack_flag = ospf_flood_through_as (ospf, inbr, lsa);
743: break;
744: /* Type-7 Only received within NSSA, then flooded */
745: case OSPF_AS_NSSA_LSA:
746: /* Any P-bit was installed with the Type-7. */
747:
748: if (IS_DEBUG_OSPF_NSSA)
749: zlog_debug ("ospf_flood_through: LOCAL NSSA FLOOD of Type-7.");
750: /* Fallthrough */
751: default:
752: lsa_ack_flag = ospf_flood_through_area (lsa->area, inbr, lsa);
753: break;
754: }
755: #endif /* ORIGINAL_CODING */
756:
757: return (lsa_ack_flag);
758: }
759:
760:
761:
762: /* Management functions for neighbor's Link State Request list. */
763: void
764: ospf_ls_request_add (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
765: {
766: /*
767: * We cannot make use of the newly introduced callback function
768: * "lsdb->new_lsa_hook" to replace debug output below, just because
769: * it seems no simple and smart way to pass neighbor information to
770: * the common function "ospf_lsdb_add()" -- endo.
771: */
772: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
773: zlog_debug ("RqstL(%lu)++, NBR(%s), LSA[%s]",
774: ospf_ls_request_count (nbr),
775: inet_ntoa (nbr->router_id), dump_lsa_key (lsa));
776:
777: ospf_lsdb_add (&nbr->ls_req, lsa);
778: }
779:
780: unsigned long
781: ospf_ls_request_count (struct ospf_neighbor *nbr)
782: {
783: return ospf_lsdb_count_all (&nbr->ls_req);
784: }
785:
786: int
787: ospf_ls_request_isempty (struct ospf_neighbor *nbr)
788: {
789: return ospf_lsdb_isempty (&nbr->ls_req);
790: }
791:
792: /* Remove LSA from neighbor's ls-request list. */
793: void
794: ospf_ls_request_delete (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
795: {
796: if (nbr->ls_req_last == lsa)
797: {
798: ospf_lsa_unlock (&nbr->ls_req_last);
799: nbr->ls_req_last = NULL;
800: }
801:
802: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING)) /* -- endo. */
803: zlog_debug ("RqstL(%lu)--, NBR(%s), LSA[%s]",
804: ospf_ls_request_count (nbr),
805: inet_ntoa (nbr->router_id), dump_lsa_key (lsa));
806:
807: ospf_lsdb_delete (&nbr->ls_req, lsa);
808: }
809:
810: /* Remove all LSA from neighbor's ls-requenst list. */
811: void
812: ospf_ls_request_delete_all (struct ospf_neighbor *nbr)
813: {
814: ospf_lsa_unlock (&nbr->ls_req_last);
815: nbr->ls_req_last = NULL;
816: ospf_lsdb_delete_all (&nbr->ls_req);
817: }
818:
819: /* Lookup LSA from neighbor's ls-request list. */
820: struct ospf_lsa *
821: ospf_ls_request_lookup (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
822: {
823: return ospf_lsdb_lookup (&nbr->ls_req, lsa);
824: }
825:
826: struct ospf_lsa *
827: ospf_ls_request_new (struct lsa_header *lsah)
828: {
829: struct ospf_lsa *new;
830:
831: new = ospf_lsa_new ();
832: new->data = ospf_lsa_data_new (OSPF_LSA_HEADER_SIZE);
833: memcpy (new->data, lsah, OSPF_LSA_HEADER_SIZE);
834:
835: return new;
836: }
837:
838:
839: /* Management functions for neighbor's ls-retransmit list. */
840: unsigned long
841: ospf_ls_retransmit_count (struct ospf_neighbor *nbr)
842: {
843: return ospf_lsdb_count_all (&nbr->ls_rxmt);
844: }
845:
846: unsigned long
847: ospf_ls_retransmit_count_self (struct ospf_neighbor *nbr, int lsa_type)
848: {
849: return ospf_lsdb_count_self (&nbr->ls_rxmt, lsa_type);
850: }
851:
852: int
853: ospf_ls_retransmit_isempty (struct ospf_neighbor *nbr)
854: {
855: return ospf_lsdb_isempty (&nbr->ls_rxmt);
856: }
857:
858: /* Add LSA to be retransmitted to neighbor's ls-retransmit list. */
859: void
860: ospf_ls_retransmit_add (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
861: {
862: struct ospf_lsa *old;
863:
864: old = ospf_ls_retransmit_lookup (nbr, lsa);
865:
866: if (ospf_lsa_more_recent (old, lsa) < 0)
867: {
868: if (old)
869: {
870: old->retransmit_counter--;
871: ospf_lsdb_delete (&nbr->ls_rxmt, old);
872: }
873: lsa->retransmit_counter++;
874: /*
875: * We cannot make use of the newly introduced callback function
876: * "lsdb->new_lsa_hook" to replace debug output below, just because
877: * it seems no simple and smart way to pass neighbor information to
878: * the common function "ospf_lsdb_add()" -- endo.
879: */
880: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING))
881: zlog_debug ("RXmtL(%lu)++, NBR(%s), LSA[%s]",
882: ospf_ls_retransmit_count (nbr),
883: inet_ntoa (nbr->router_id), dump_lsa_key (lsa));
884: ospf_lsdb_add (&nbr->ls_rxmt, lsa);
885: }
886: }
887:
888: /* Remove LSA from neibghbor's ls-retransmit list. */
889: void
890: ospf_ls_retransmit_delete (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
891: {
892: if (ospf_ls_retransmit_lookup (nbr, lsa))
893: {
894: lsa->retransmit_counter--;
895: if (IS_DEBUG_OSPF (lsa, LSA_FLOODING)) /* -- endo. */
896: zlog_debug ("RXmtL(%lu)--, NBR(%s), LSA[%s]",
897: ospf_ls_retransmit_count (nbr),
898: inet_ntoa (nbr->router_id), dump_lsa_key (lsa));
899: ospf_lsdb_delete (&nbr->ls_rxmt, lsa);
900: }
901: }
902:
903: /* Clear neighbor's ls-retransmit list. */
904: void
905: ospf_ls_retransmit_clear (struct ospf_neighbor *nbr)
906: {
907: struct ospf_lsdb *lsdb;
908: int i;
909:
910: lsdb = &nbr->ls_rxmt;
911:
912: for (i = OSPF_MIN_LSA; i < OSPF_MAX_LSA; i++)
913: {
914: struct route_table *table = lsdb->type[i].db;
915: struct route_node *rn;
916: struct ospf_lsa *lsa;
917:
918: for (rn = route_top (table); rn; rn = route_next (rn))
919: if ((lsa = rn->info) != NULL)
920: ospf_ls_retransmit_delete (nbr, lsa);
921: }
922:
923: ospf_lsa_unlock (&nbr->ls_req_last);
924: nbr->ls_req_last = NULL;
925: }
926:
927: /* Lookup LSA from neighbor's ls-retransmit list. */
928: struct ospf_lsa *
929: ospf_ls_retransmit_lookup (struct ospf_neighbor *nbr, struct ospf_lsa *lsa)
930: {
931: return ospf_lsdb_lookup (&nbr->ls_rxmt, lsa);
932: }
933:
934: static void
935: ospf_ls_retransmit_delete_nbr_if (struct ospf_interface *oi,
936: struct ospf_lsa *lsa)
937: {
938: struct route_node *rn;
939: struct ospf_neighbor *nbr;
940: struct ospf_lsa *lsr;
941:
942: if (ospf_if_is_enable (oi))
943: for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
944: /* If LSA find in LS-retransmit list, then remove it. */
945: if ((nbr = rn->info) != NULL)
946: {
947: lsr = ospf_ls_retransmit_lookup (nbr, lsa);
948:
949: /* If LSA find in ls-retransmit list, remove it. */
950: if (lsr != NULL && lsr->data->ls_seqnum == lsa->data->ls_seqnum)
951: ospf_ls_retransmit_delete (nbr, lsr);
952: }
953: }
954:
955: void
956: ospf_ls_retransmit_delete_nbr_area (struct ospf_area *area,
957: struct ospf_lsa *lsa)
958: {
959: struct listnode *node, *nnode;
960: struct ospf_interface *oi;
961:
962: for (ALL_LIST_ELEMENTS (area->oiflist, node, nnode, oi))
963: ospf_ls_retransmit_delete_nbr_if (oi, lsa);
964: }
965:
966: void
967: ospf_ls_retransmit_delete_nbr_as (struct ospf *ospf, struct ospf_lsa *lsa)
968: {
969: struct listnode *node, *nnode;
970: struct ospf_interface *oi;
971:
972: for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
973: ospf_ls_retransmit_delete_nbr_if (oi, lsa);
974: }
975:
976:
977: /* Sets ls_age to MaxAge and floods throu the area.
978: When we implement ASE routing, there will be anothe function
979: flushing an LSA from the whole domain. */
980: void
981: ospf_lsa_flush_area (struct ospf_lsa *lsa, struct ospf_area *area)
982: {
983: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE);
984: ospf_flood_through_area (area, NULL, lsa);
985: ospf_lsa_maxage (area->ospf, lsa);
986: }
987:
988: void
989: ospf_lsa_flush_as (struct ospf *ospf, struct ospf_lsa *lsa)
990: {
991: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE);
992: ospf_flood_through_as (ospf, NULL, lsa);
993: ospf_lsa_maxage (ospf, lsa);
994: }
995:
996: void
997: ospf_lsa_flush (struct ospf *ospf, struct ospf_lsa *lsa)
998: {
999: lsa->data->ls_age = htons (OSPF_LSA_MAXAGE);
1000:
1001: switch (lsa->data->type)
1002: {
1003: case OSPF_ROUTER_LSA:
1004: case OSPF_NETWORK_LSA:
1005: case OSPF_SUMMARY_LSA:
1006: case OSPF_ASBR_SUMMARY_LSA:
1007: case OSPF_AS_NSSA_LSA:
1008: #ifdef HAVE_OPAQUE_LSA
1009: case OSPF_OPAQUE_LINK_LSA:
1010: case OSPF_OPAQUE_AREA_LSA:
1011: #endif /* HAVE_OPAQUE_LSA */
1012: ospf_lsa_flush_area (lsa, lsa->area);
1013: break;
1014: case OSPF_AS_EXTERNAL_LSA:
1015: #ifdef HAVE_OPAQUE_LSA
1016: case OSPF_OPAQUE_AS_LSA:
1017: #endif /* HAVE_OPAQUE_LSA */
1018: ospf_lsa_flush_as (ospf, lsa);
1019: break;
1020: default:
1021: zlog_info ("%s: Unknown LSA type %u", __func__, lsa->data->type);
1022: break;
1023: }
1024: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ospf_flood.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