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