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