]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - ospfd/ospf_flood.c
New upstream version 1.2.4
[quagga-debian.git] / ospfd / ospf_flood.c
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 }