ospfd/ospfd.c

   1 /* OSPF version 2 daemon program.
   2    Copyright (C) 1999, 2000 Toshiaki Takada
   3
   4 This file is part of GNU Zebra.
   5
   6 GNU Zebra is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 GNU Zebra is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #include <zebra.h>
  22
  23 #include "thread.h"
  24 #include "vty.h"
  25 #include "command.h"
  26 #include "linklist.h"
  27 #include "prefix.h"
  28 #include "table.h"
  29 #include "if.h"
  30 #include "memory.h"
  31 #include "stream.h"
  32 #include "log.h"
  33 #include "sockunion.h"          /* for inet_aton () */
  34 #include "zclient.h"
  35 #include "plist.h"
  36 #include "sockopt.h"
  37
  38 #include "ospfd/ospfd.h"
  39 #include "ospfd/ospf_network.h"
  40 #include "ospfd/ospf_interface.h"
  41 #include "ospfd/ospf_ism.h"
  42 #include "ospfd/ospf_asbr.h"
  43 #include "ospfd/ospf_lsa.h"
  44 #include "ospfd/ospf_lsdb.h"
  45 #include "ospfd/ospf_neighbor.h"
  46 #include "ospfd/ospf_nsm.h"
  47 #include "ospfd/ospf_spf.h"
  48 #include "ospfd/ospf_packet.h"
  49 #include "ospfd/ospf_dump.h"
  50 #include "ospfd/ospf_zebra.h"
  51 #include "ospfd/ospf_abr.h"
  52 #include "ospfd/ospf_flood.h"
  53 #include "ospfd/ospf_route.h"
  54 #include "ospfd/ospf_ase.h"
  55
  56 \f
  57
  58 /* OSPF process wide configuration. */
  59 static struct ospf_master ospf_master;
  60
  61 /* OSPF process wide configuration pointer to export. */
  62 struct ospf_master *om;
  63
  64 extern struct zclient *zclient;
  65 extern struct in_addr router_id_zebra;
  66
  67 \f
  68 static void ospf_remove_vls_through_area (struct ospf *, struct ospf_area *);
  69 static void ospf_network_free (struct ospf *, struct ospf_network *);
  70 static void ospf_area_free (struct ospf_area *);
  71 static void ospf_network_run (struct prefix *, struct ospf_area *);
  72 static void ospf_network_run_interface (struct prefix *, struct ospf_area *,
  73                                         struct interface *);
  74 static void ospf_finish_final (struct ospf *);
  75
  76 #define OSPF_EXTERNAL_LSA_ORIGINATE_DELAY 1
  77 \f
  78 void
  79 ospf_router_id_update (struct ospf *ospf)
  80 {
  81   struct in_addr router_id, router_id_old;
  82   struct ospf_interface *oi;
  83   struct interface *ifp;
  84   struct listnode *node;
  85
  86   if (IS_DEBUG_OSPF_EVENT)
  87     zlog_debug ("Router-ID[OLD:%s]: Update", inet_ntoa (ospf->router_id));
  88
  89   router_id_old = ospf->router_id;
  90
  91   /* Select the router ID based on these priorities:
  92        1. Statically assigned router ID is always the first choice.
  93        2. If there is no statically assigned router ID, then try to stick
  94           with the most recent value, since changing router ID's is very
  95           disruptive.
  96        3. Last choice: just go with whatever the zebra daemon recommends.
  97   */
  98   if (ospf->router_id_static.s_addr != 0)
  99     router_id = ospf->router_id_static;
 100   else if (ospf->router_id.s_addr != 0)
 101     router_id = ospf->router_id;
 102   else
 103     router_id = router_id_zebra;
 104
 105   ospf->router_id = router_id;
 106
 107   if (IS_DEBUG_OSPF_EVENT)
 108     zlog_debug ("Router-ID[NEW:%s]: Update", inet_ntoa (ospf->router_id));
 109
 110   if (!IPV4_ADDR_SAME (&router_id_old, &router_id))
 111     {
 112       for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 113         /* Update self-neighbor's router_id. */
 114         oi->nbr_self->router_id = router_id;
 115
 116       /* If AS-external-LSA is queued, then flush those LSAs. */
 117       if (router_id_old.s_addr == 0 && ospf->external_origin)
 118         {
 119           int type;
 120           /* Originate each redistributed external route. */
 121           for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
 122             if (ospf->external_origin & (1 << type))
 123               thread_add_event (master, ospf_external_lsa_originate_timer,
 124                                 ospf, type);
 125           /* Originate Deafult. */
 126           if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
 127             thread_add_event (master, ospf_default_originate_timer, ospf, 0);
 128
 129           ospf->external_origin = 0;
 130         }
 131
 132       OSPF_TIMER_ON (ospf->t_router_lsa_update,
 133                      ospf_router_lsa_update_timer, OSPF_LSA_UPDATE_DELAY);
 134
 135       /* update ospf_interface's */
 136       for (ALL_LIST_ELEMENTS_RO (om->iflist, node, ifp))
 137         ospf_if_update (ospf, ifp);
 138     }
 139 }
 140 \f
 141 /* For OSPF area sort by area id. */
 142 static int
 143 ospf_area_id_cmp (struct ospf_area *a1, struct ospf_area *a2)
 144 {
 145   if (ntohl (a1->area_id.s_addr) > ntohl (a2->area_id.s_addr))
 146     return 1;
 147   if (ntohl (a1->area_id.s_addr) < ntohl (a2->area_id.s_addr))
 148     return -1;
 149   return 0;
 150 }
 151
 152 /* Allocate new ospf structure. */
 153 static struct ospf *
 154 ospf_new (void)
 155 {
 156   int i;
 157
 158   struct ospf *new = XCALLOC (MTYPE_OSPF_TOP, sizeof (struct ospf));
 159
 160   new->router_id.s_addr = htonl (0);
 161   new->router_id_static.s_addr = htonl (0);
 162
 163   new->abr_type = OSPF_ABR_DEFAULT;
 164   new->oiflist = list_new ();
 165   new->vlinks = list_new ();
 166   new->areas = list_new ();
 167   new->areas->cmp = (int (*)(void *, void *)) ospf_area_id_cmp;
 168   new->networks = route_table_init ();
 169   new->nbr_nbma = route_table_init ();
 170
 171   new->lsdb = ospf_lsdb_new ();
 172
 173   new->default_originate = DEFAULT_ORIGINATE_NONE;
 174
 175   new->passive_interface_default = OSPF_IF_ACTIVE;
 176
 177   new->new_external_route = route_table_init ();
 178   new->old_external_route = route_table_init ();
 179   new->external_lsas = route_table_init ();
 180
 181   new->stub_router_startup_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 182   new->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 183
 184   /* Distribute parameter init. */
 185   for (i = 0; i <= ZEBRA_ROUTE_MAX; i++)
 186     {
 187       new->dmetric[i].type = -1;
 188       new->dmetric[i].value = -1;
 189     }
 190   new->default_metric = -1;
 191   new->ref_bandwidth = OSPF_DEFAULT_REF_BANDWIDTH;
 192
 193   /* SPF timer value init. */
 194   new->spf_delay = OSPF_SPF_DELAY_DEFAULT;
 195   new->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
 196   new->spf_max_holdtime = OSPF_SPF_MAX_HOLDTIME_DEFAULT;
 197   new->spf_hold_multiplier = 1;
 198
 199   /* MaxAge init. */
 200   new->maxage_lsa = list_new ();
 201   new->t_maxage_walker =
 202     thread_add_timer (master, ospf_lsa_maxage_walker,
 203                       new, OSPF_LSA_MAXAGE_CHECK_INTERVAL);
 204
 205   /* Distance table init. */
 206   new->distance_table = route_table_init ();
 207
 208   new->lsa_refresh_queue.index = 0;
 209   new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
 210   new->t_lsa_refresher = thread_add_timer (master, ospf_lsa_refresh_walker,
 211                                            new, new->lsa_refresh_interval);
 212   new->lsa_refresher_started = quagga_time (NULL);
 213
 214   if ((new->fd = ospf_sock_init()) < 0)
 215     {
 216       zlog_err("ospf_new: fatal error: ospf_sock_init was unable to open "
 217                "a socket");
 218       exit(1);
 219     }
 220   new->maxsndbuflen = getsockopt_so_sendbuf (new->fd);
 221   if (IS_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
 222     zlog_debug ("%s: starting with OSPF send buffer size %d",
 223       __func__, new->maxsndbuflen);
 224   if ((new->ibuf = stream_new(OSPF_MAX_PACKET_SIZE+1)) == NULL)
 225     {
 226       zlog_err("ospf_new: fatal error: stream_new(%u) failed allocating ibuf",
 227                OSPF_MAX_PACKET_SIZE+1);
 228       exit(1);
 229     }
 230   new->t_read = thread_add_read (master, ospf_read, new, new->fd);
 231   new->oi_write_q = list_new ();
 232
 233   return new;
 234 }
 235
 236 struct ospf *
 237 ospf_lookup ()
 238 {
 239   if (listcount (om->ospf) == 0)
 240     return NULL;
 241
 242   return listgetdata (listhead (om->ospf));
 243 }
 244
 245 static void
 246 ospf_add (struct ospf *ospf)
 247 {
 248   listnode_add (om->ospf, ospf);
 249 }
 250
 251 static void
 252 ospf_delete (struct ospf *ospf)
 253 {
 254   listnode_delete (om->ospf, ospf);
 255 }
 256
 257 struct ospf *
 258 ospf_get ()
 259 {
 260   struct ospf *ospf;
 261
 262   ospf = ospf_lookup ();
 263   if (ospf == NULL)
 264     {
 265       ospf = ospf_new ();
 266       ospf_add (ospf);
 267
 268       if (ospf->router_id_static.s_addr == 0)
 269         ospf_router_id_update (ospf);
 270
 271 #ifdef HAVE_OPAQUE_LSA
 272       ospf_opaque_type11_lsa_init (ospf);
 273 #endif /* HAVE_OPAQUE_LSA */
 274     }
 275
 276   return ospf;
 277 }
 278 \f
 279 /* Handle the second half of deferred shutdown. This is called either
 280  * from the deferred-shutdown timer thread, or directly through
 281  * ospf_deferred_shutdown_check.
 282  *
 283  * Function is to cleanup G-R state, if required then call ospf_finish_final
 284  * to complete shutdown of this ospf instance. Possibly exit if the
 285  * whole process is being shutdown and this was the last OSPF instance.
 286  */
 287 static void
 288 ospf_deferred_shutdown_finish (struct ospf *ospf)
 289 {
 290   ospf->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 291   OSPF_TIMER_OFF (ospf->t_deferred_shutdown);
 292
 293   ospf_finish_final (ospf);
 294
 295   /* *ospf is now invalid */
 296
 297   /* ospfd being shut-down? If so, was this the last ospf instance? */
 298   if (CHECK_FLAG (om->options, OSPF_MASTER_SHUTDOWN)
 299       && (listcount (om->ospf) == 0))
 300     exit (0);
 301
 302   return;
 303 }
 304
 305 /* Timer thread for G-R */
 306 static int
 307 ospf_deferred_shutdown_timer (struct thread *t)
 308 {
 309   struct ospf *ospf = THREAD_ARG(t);
 310
 311   ospf_deferred_shutdown_finish (ospf);
 312
 313   return 0;
 314 }
 315
 316 /* Check whether deferred-shutdown must be scheduled, otherwise call
 317  * down directly into second-half of instance shutdown.
 318  */
 319 static void
 320 ospf_deferred_shutdown_check (struct ospf *ospf)
 321 {
 322   unsigned long timeout;
 323   struct listnode *ln;
 324   struct ospf_area *area;
 325
 326   /* deferred shutdown already running? */
 327   if (ospf->t_deferred_shutdown)
 328     return;
 329
 330   /* Should we try push out max-metric LSAs? */
 331   if (ospf->stub_router_shutdown_time != OSPF_STUB_ROUTER_UNCONFIGURED)
 332     {
 333       for (ALL_LIST_ELEMENTS_RO (ospf->areas, ln, area))
 334         {
 335           SET_FLAG (area->stub_router_state, OSPF_AREA_ADMIN_STUB_ROUTED);
 336
 337           if (!CHECK_FLAG (area->stub_router_state, OSPF_AREA_IS_STUB_ROUTED))
 338               ospf_router_lsa_timer_add (area);
 339         }
 340       timeout = ospf->stub_router_shutdown_time;
 341     }
 342   else
 343     {
 344       /* No timer needed */
 345       ospf_deferred_shutdown_finish (ospf);
 346       return;
 347     }
 348
 349   OSPF_TIMER_ON (ospf->t_deferred_shutdown, ospf_deferred_shutdown_timer,
 350                  timeout);
 351   return;
 352 }
 353 \f
 354 /* Shut down the entire process */
 355 void
 356 ospf_terminate (void)
 357 {
 358   struct ospf *ospf;
 359   struct listnode *node, *nnode;
 360
 361   /* shutdown already in progress */
 362   if (CHECK_FLAG (om->options, OSPF_MASTER_SHUTDOWN))
 363     return;
 364
 365   SET_FLAG (om->options, OSPF_MASTER_SHUTDOWN);
 366
 367   /* exit immediately if OSPF not actually running */
 368   if (listcount(om->ospf) == 0)
 369     exit(0);
 370
 371   for (ALL_LIST_ELEMENTS (om->ospf, node, nnode, ospf))
 372     ospf_finish (ospf);
 373
 374   /* Deliberately go back up, hopefully to thread scheduler, as
 375    * One or more ospf_finish()'s may have deferred shutdown to a timer
 376    * thread
 377    */
 378 }
 379
 380 void
 381 ospf_finish (struct ospf *ospf)
 382 {
 383   /* let deferred shutdown decide */
 384   ospf_deferred_shutdown_check (ospf);
 385
 386   /* if ospf_deferred_shutdown returns, then ospf_finish_final is
 387    * deferred to expiry of G-S timer thread. Return back up, hopefully
 388    * to thread scheduler.
 389    */
 390   return;
 391 }
 392
 393 /* Final cleanup of ospf instance */
 394 static void
 395 ospf_finish_final (struct ospf *ospf)
 396 {
 397   struct route_node *rn;
 398   struct ospf_nbr_nbma *nbr_nbma;
 399   struct ospf_lsa *lsa;
 400   struct ospf_interface *oi;
 401   struct ospf_area *area;
 402   struct ospf_vl_data *vl_data;
 403   struct listnode *node, *nnode;
 404   int i;
 405
 406 #ifdef HAVE_OPAQUE_LSA
 407   ospf_opaque_type11_lsa_term (ospf);
 408 #endif /* HAVE_OPAQUE_LSA */
 409
 410   /* be nice if this worked, but it doesn't */
 411   /*ospf_flush_self_originated_lsas_now (ospf);*/
 412
 413   /* Unregister redistribution */
 414   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
 415     ospf_redistribute_unset (ospf, i);
 416   ospf_redistribute_default_unset (ospf);
 417
 418   for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
 419     ospf_remove_vls_through_area (ospf, area);
 420
 421   for (ALL_LIST_ELEMENTS (ospf->vlinks, node, nnode, vl_data))
 422     ospf_vl_delete (ospf, vl_data);
 423
 424   list_delete (ospf->vlinks);
 425
 426   /* Reset interface. */
 427   for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
 428     ospf_if_free (oi);
 429
 430   /* Clear static neighbors */
 431   for (rn = route_top (ospf->nbr_nbma); rn; rn = route_next (rn))
 432     if ((nbr_nbma = rn->info))
 433       {
 434         OSPF_POLL_TIMER_OFF (nbr_nbma->t_poll);
 435
 436         if (nbr_nbma->nbr)
 437           {
 438             nbr_nbma->nbr->nbr_nbma = NULL;
 439             nbr_nbma->nbr = NULL;
 440           }
 441
 442         if (nbr_nbma->oi)
 443           {
 444             listnode_delete (nbr_nbma->oi->nbr_nbma, nbr_nbma);
 445             nbr_nbma->oi = NULL;
 446           }
 447
 448         XFREE (MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
 449       }
 450
 451   route_table_finish (ospf->nbr_nbma);
 452
 453   /* Clear networks and Areas. */
 454   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
 455     {
 456       struct ospf_network *network;
 457
 458       if ((network = rn->info) != NULL)
 459         {
 460           ospf_network_free (ospf, network);
 461           rn->info = NULL;
 462           route_unlock_node (rn);
 463         }
 464     }
 465
 466   for (ALL_LIST_ELEMENTS (ospf->areas, node, nnode, area))
 467     {
 468       listnode_delete (ospf->areas, area);
 469       ospf_area_free (area);
 470     }
 471
 472   /* Cancel all timers. */
 473   OSPF_TIMER_OFF (ospf->t_external_lsa);
 474   OSPF_TIMER_OFF (ospf->t_router_lsa_update);
 475   OSPF_TIMER_OFF (ospf->t_spf_calc);
 476   OSPF_TIMER_OFF (ospf->t_ase_calc);
 477   OSPF_TIMER_OFF (ospf->t_maxage);
 478   OSPF_TIMER_OFF (ospf->t_maxage_walker);
 479   OSPF_TIMER_OFF (ospf->t_abr_task);
 480   OSPF_TIMER_OFF (ospf->t_asbr_check);
 481   OSPF_TIMER_OFF (ospf->t_distribute_update);
 482   OSPF_TIMER_OFF (ospf->t_lsa_refresher);
 483   OSPF_TIMER_OFF (ospf->t_read);
 484   OSPF_TIMER_OFF (ospf->t_write);
 485 #ifdef HAVE_OPAQUE_LSA
 486   OSPF_TIMER_OFF (ospf->t_opaque_lsa_self);
 487 #endif
 488
 489   close (ospf->fd);
 490   stream_free(ospf->ibuf);
 491
 492 #ifdef HAVE_OPAQUE_LSA
 493   LSDB_LOOP (OPAQUE_AS_LSDB (ospf), rn, lsa)
 494     ospf_discard_from_db (ospf, ospf->lsdb, lsa);
 495 #endif /* HAVE_OPAQUE_LSA */
 496   LSDB_LOOP (EXTERNAL_LSDB (ospf), rn, lsa)
 497     ospf_discard_from_db (ospf, ospf->lsdb, lsa);
 498
 499   ospf_lsdb_delete_all (ospf->lsdb);
 500   ospf_lsdb_free (ospf->lsdb);
 501
 502   for (ALL_LIST_ELEMENTS (ospf->maxage_lsa, node, nnode, lsa))
 503     ospf_lsa_unlock (&lsa); /* maxage_lsa */
 504
 505   list_delete (ospf->maxage_lsa);
 506
 507   if (ospf->old_table)
 508     ospf_route_table_free (ospf->old_table);
 509   if (ospf->new_table)
 510     {
 511       ospf_route_delete (ospf->new_table);
 512       ospf_route_table_free (ospf->new_table);
 513     }
 514   if (ospf->old_rtrs)
 515     ospf_rtrs_free (ospf->old_rtrs);
 516   if (ospf->new_rtrs)
 517     ospf_rtrs_free (ospf->new_rtrs);
 518   if (ospf->new_external_route)
 519     {
 520       ospf_route_delete (ospf->new_external_route);
 521       ospf_route_table_free (ospf->new_external_route);
 522     }
 523   if (ospf->old_external_route)
 524     {
 525       ospf_route_delete (ospf->old_external_route);
 526       ospf_route_table_free (ospf->old_external_route);
 527     }
 528   if (ospf->external_lsas)
 529     {
 530       ospf_ase_external_lsas_finish (ospf->external_lsas);
 531     }
 532
 533   list_delete (ospf->areas);
 534
 535   for (i = ZEBRA_ROUTE_SYSTEM; i <= ZEBRA_ROUTE_MAX; i++)
 536     if (EXTERNAL_INFO (i) != NULL)
 537       for (rn = route_top (EXTERNAL_INFO (i)); rn; rn = route_next (rn))
 538         {
 539           if (rn->info == NULL)
 540             continue;
 541
 542           XFREE (MTYPE_OSPF_EXTERNAL_INFO, rn->info);
 543           rn->info = NULL;
 544           route_unlock_node (rn);
 545         }
 546
 547   ospf_distance_reset (ospf);
 548   route_table_finish (ospf->distance_table);
 549
 550   ospf_delete (ospf);
 551
 552   XFREE (MTYPE_OSPF_TOP, ospf);
 553 }
 554
 555 \f
 556 /* allocate new OSPF Area object */
 557 static struct ospf_area *
 558 ospf_area_new (struct ospf *ospf, struct in_addr area_id)
 559 {
 560   struct ospf_area *new;
 561
 562   /* Allocate new config_network. */
 563   new = XCALLOC (MTYPE_OSPF_AREA, sizeof (struct ospf_area));
 564
 565   new->ospf = ospf;
 566
 567   new->area_id = area_id;
 568
 569   new->external_routing = OSPF_AREA_DEFAULT;
 570   new->default_cost = 1;
 571   new->auth_type = OSPF_AUTH_NULL;
 572
 573   /* New LSDB init. */
 574   new->lsdb = ospf_lsdb_new ();
 575
 576   /* Self-originated LSAs initialize. */
 577   new->router_lsa_self = NULL;
 578
 579 #ifdef HAVE_OPAQUE_LSA
 580   ospf_opaque_type10_lsa_init (new);
 581 #endif /* HAVE_OPAQUE_LSA */
 582
 583   new->oiflist = list_new ();
 584   new->ranges = route_table_init ();
 585
 586   if (area_id.s_addr == OSPF_AREA_BACKBONE)
 587     ospf->backbone = new;
 588
 589   return new;
 590 }
 591
 592 void
 593 ospf_area_free (struct ospf_area *area)
 594 {
 595   struct route_node *rn;
 596   struct ospf_lsa *lsa;
 597
 598   /* Free LSDBs. */
 599   LSDB_LOOP (ROUTER_LSDB (area), rn, lsa)
 600     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 601   LSDB_LOOP (NETWORK_LSDB (area), rn, lsa)
 602     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 603   LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
 604     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 605   LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
 606     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 607
 608   LSDB_LOOP (NSSA_LSDB (area), rn, lsa)
 609     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 610 #ifdef HAVE_OPAQUE_LSA
 611   LSDB_LOOP (OPAQUE_AREA_LSDB (area), rn, lsa)
 612     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 613   LSDB_LOOP (OPAQUE_LINK_LSDB (area), rn, lsa)
 614     ospf_discard_from_db (area->ospf, area->lsdb, lsa);
 615 #endif /* HAVE_OPAQUE_LSA */
 616
 617   ospf_lsdb_delete_all (area->lsdb);
 618   ospf_lsdb_free (area->lsdb);
 619
 620   ospf_lsa_unlock (&area->router_lsa_self);
 621
 622   route_table_finish (area->ranges);
 623   list_delete (area->oiflist);
 624
 625   if (EXPORT_NAME (area))
 626     free (EXPORT_NAME (area));
 627
 628   if (IMPORT_NAME (area))
 629     free (IMPORT_NAME (area));
 630
 631   /* Cancel timer. */
 632   OSPF_TIMER_OFF (area->t_router_lsa_self);
 633   OSPF_TIMER_OFF (area->t_stub_router);
 634 #ifdef HAVE_OPAQUE_LSA
 635   OSPF_TIMER_OFF (area->t_opaque_lsa_self);
 636 #endif /* HAVE_OPAQUE_LSA */
 637
 638   if (OSPF_IS_AREA_BACKBONE (area))
 639     area->ospf->backbone = NULL;
 640
 641   XFREE (MTYPE_OSPF_AREA, area);
 642 }
 643
 644 void
 645 ospf_area_check_free (struct ospf *ospf, struct in_addr area_id)
 646 {
 647   struct ospf_area *area;
 648
 649   area = ospf_area_lookup_by_area_id (ospf, area_id);
 650   if (area &&
 651       listcount (area->oiflist) == 0 &&
 652       area->ranges->top == NULL &&
 653       area->shortcut_configured == OSPF_SHORTCUT_DEFAULT &&
 654       area->external_routing == OSPF_AREA_DEFAULT &&
 655       area->no_summary == 0 &&
 656       area->default_cost == 1 &&
 657       EXPORT_NAME (area) == NULL &&
 658       IMPORT_NAME (area) == NULL &&
 659       area->auth_type == OSPF_AUTH_NULL)
 660     {
 661       listnode_delete (ospf->areas, area);
 662       ospf_area_free (area);
 663     }
 664 }
 665
 666 struct ospf_area *
 667 ospf_area_get (struct ospf *ospf, struct in_addr area_id, int format)
 668 {
 669   struct ospf_area *area;
 670
 671   area = ospf_area_lookup_by_area_id (ospf, area_id);
 672   if (!area)
 673     {
 674       area = ospf_area_new (ospf, area_id);
 675       area->format = format;
 676       listnode_add_sort (ospf->areas, area);
 677       ospf_check_abr_status (ospf);
 678     }
 679
 680   return area;
 681 }
 682
 683 struct ospf_area *
 684 ospf_area_lookup_by_area_id (struct ospf *ospf, struct in_addr area_id)
 685 {
 686   struct ospf_area *area;
 687   struct listnode *node;
 688
 689   for (ALL_LIST_ELEMENTS_RO (ospf->areas, node, area))
 690     if (IPV4_ADDR_SAME (&area->area_id, &area_id))
 691       return area;
 692
 693   return NULL;
 694 }
 695
 696 void
 697 ospf_area_add_if (struct ospf_area *area, struct ospf_interface *oi)
 698 {
 699   listnode_add (area->oiflist, oi);
 700 }
 701
 702 void
 703 ospf_area_del_if (struct ospf_area *area, struct ospf_interface *oi)
 704 {
 705   listnode_delete (area->oiflist, oi);
 706 }
 707
 708 \f
 709 /* Config network statement related functions. */
 710 static struct ospf_network *
 711 ospf_network_new (struct in_addr area_id, int format)
 712 {
 713   struct ospf_network *new;
 714   new = XCALLOC (MTYPE_OSPF_NETWORK, sizeof (struct ospf_network));
 715
 716   new->area_id = area_id;
 717   new->format = format;
 718
 719   return new;
 720 }
 721
 722 void
 723 ospf_network_free (struct ospf *ospf, struct ospf_network *network)
 724 {
 725   ospf_area_check_free (ospf, network->area_id);
 726   ospf_schedule_abr_task (ospf);
 727   XFREE (MTYPE_OSPF_NETWORK, network);
 728 }
 729
 730 int
 731 ospf_network_set (struct ospf *ospf, struct prefix_ipv4 *p,
 732                   struct in_addr area_id)
 733 {
 734   struct ospf_network *network;
 735   struct ospf_area *area;
 736   struct route_node *rn;
 737   struct external_info *ei;
 738   int ret = OSPF_AREA_ID_FORMAT_ADDRESS;
 739
 740   rn = route_node_get (ospf->networks, (struct prefix *)p);
 741   if (rn->info)
 742     {
 743       /* There is already same network statement. */
 744       route_unlock_node (rn);
 745       return 0;
 746     }
 747
 748   rn->info = network = ospf_network_new (area_id, ret);
 749   area = ospf_area_get (ospf, area_id, ret);
 750
 751   /* Run network config now. */
 752   ospf_network_run ((struct prefix *)p, area);
 753
 754   /* Update connected redistribute. */
 755   if (ospf_is_type_redistributed (ZEBRA_ROUTE_CONNECT))
 756     if (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT))
 757       for (rn = route_top (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT));
 758            rn; rn = route_next (rn))
 759         if ((ei = rn->info) != NULL)
 760           if (ospf_external_info_find_lsa (ospf, &ei->p))
 761             if (!ospf_distribute_check_connected (ospf, ei))
 762               ospf_external_lsa_flush (ospf, ei->type, &ei->p,
 763                                        ei->ifindex /*, ei->nexthop */);
 764
 765   ospf_area_check_free (ospf, area_id);
 766
 767   return 1;
 768 }
 769
 770 int
 771 ospf_network_unset (struct ospf *ospf, struct prefix_ipv4 *p,
 772                     struct in_addr area_id)
 773 {
 774   struct route_node *rn;
 775   struct ospf_network *network;
 776   struct external_info *ei;
 777   struct listnode *node, *nnode;
 778   struct ospf_interface *oi;
 779
 780   rn = route_node_lookup (ospf->networks, (struct prefix *)p);
 781   if (rn == NULL)
 782     return 0;
 783
 784   network = rn->info;
 785   route_unlock_node (rn);
 786   if (!IPV4_ADDR_SAME (&area_id, &network->area_id))
 787     return 0;
 788
 789   ospf_network_free (ospf, rn->info);
 790   rn->info = NULL;
 791   route_unlock_node (rn);       /* initial reference */
 792
 793   /* Find interfaces that not configured already.  */
 794   for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
 795     {
 796       int found = 0;
 797       struct connected *co = oi->connected;
 798
 799       if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
 800         continue;
 801
 802       for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
 803         {
 804           if (rn->info == NULL)
 805             continue;
 806
 807           if (ospf_network_match_iface(co,&rn->p))
 808             {
 809               found = 1;
 810               route_unlock_node (rn);
 811               break;
 812             }
 813         }
 814
 815       if (found == 0)
 816         ospf_if_free (oi);
 817     }
 818
 819   /* Update connected redistribute. */
 820   if (ospf_is_type_redistributed (ZEBRA_ROUTE_CONNECT))
 821     if (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT))
 822       for (rn = route_top (EXTERNAL_INFO (ZEBRA_ROUTE_CONNECT));
 823            rn; rn = route_next (rn))
 824         if ((ei = rn->info) != NULL)
 825           if (!ospf_external_info_find_lsa (ospf, &ei->p))
 826             if (ospf_distribute_check_connected (ospf, ei))
 827               ospf_external_lsa_originate (ospf, ei);
 828
 829   return 1;
 830 }
 831
 832 /* Check whether interface matches given network
 833  * returns: 1, true. 0, false
 834  */
 835 int
 836 ospf_network_match_iface(struct connected *co, struct prefix *net)
 837 {
 838 /* #define COMPATIBILITY_MODE */
 839   /* The old code used to have a special case for PtP interfaces:
 840
 841      if (if_is_pointopoint (co->ifp) && co->destination &&
 842          IPV4_ADDR_SAME ( &(co->destination->u.prefix4), &(net->u.prefix4)))
 843        return 1;
 844
 845      The new approach is much more general.  If a peer address is supplied,
 846      then we are routing to that prefix, so that's the address to compare
 847      against (not the local address, which may not be unique).
 848   */
 849 #ifndef COMPATIBILITY_MODE
 850   /* new approach: more elegant and conceptually clean */
 851   return prefix_match(net, CONNECTED_PREFIX(co));
 852 #else /* COMPATIBILITY_MODE */
 853   /* match old (strange?) behavior */
 854
 855   /* Behaviour to match both Cisco where:
 856    *   iface address lies within network specified -> ospf
 857    * and zebra 0.9[2ish-3]:
 858    *   PtP special case: network specified == iface peer addr -> ospf
 859    */
 860
 861   /* For PtP, match if peer address matches network address exactly.
 862    * This can be addr/32 or addr/p for p < 32, but the addr must match
 863    * exactly; this is not a test for falling within the prefix.  This
 864    * test is solely for compatibility with zebra.
 865    */
 866   if (CONNECTED_PEER(co) &&
 867       IPV4_ADDR_SAME ( &(co->destination->u.prefix4), &(net->u.prefix4)))
 868     return 1;
 869
 870 #if 0
 871   /* Decline to accept PtP if dst address does not match the
 872    * prefix. (ifdefed out because this is a workaround, not the
 873    * desired behavior.) */
 874   if (if_is_pointopoint (co->ifp) &&
 875       ! prefix_match (net, co->destination))
 876     return 0;
 877 #endif
 878
 879   /* If the address is within the prefix, accept.  Note that this
 880    * applies to PtP as well as other types.
 881    */
 882   if (prefix_match (net, co->address))
 883     return 1;
 884
 885   return 0;                     /* no match */
 886
 887 #endif /* COMPATIBILITY_MODE */
 888 }
 889
 890 void
 891 ospf_network_run_interface (struct prefix *p, struct ospf_area *area,
 892                             struct interface *ifp)
 893 {
 894   struct listnode *cnode;
 895   struct connected *co;
 896
 897   if (memcmp (ifp->name, "VLINK", 5) == 0)
 898     return;
 899
 900   /* if interface prefix is match specified prefix,
 901      then create socket and join multicast group. */
 902   for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, co))
 903     {
 904
 905       if (CHECK_FLAG(co->flags,ZEBRA_IFA_SECONDARY))
 906         continue;
 907
 908       if (p->family == co->address->family
 909           && ! ospf_if_table_lookup(ifp, co->address)
 910           && ospf_network_match_iface(co,p))
 911         {
 912            struct ospf_interface *oi;
 913
 914             oi = ospf_if_new (area->ospf, ifp, co->address);
 915             oi->connected = co;
 916
 917             oi->area = area;
 918
 919             oi->params = ospf_lookup_if_params (ifp, oi->address->u.prefix4);
 920             oi->output_cost = ospf_if_get_output_cost (oi);
 921
 922             /* Add pseudo neighbor. */
 923             ospf_nbr_add_self (oi);
 924
 925             /* Relate ospf interface to ospf instance. */
 926             oi->ospf = area->ospf;
 927
 928             /* update network type as interface flag */
 929             /* If network type is specified previously,
 930                skip network type setting. */
 931             oi->type = IF_DEF_PARAMS (ifp)->type;
 932
 933             ospf_area_add_if (oi->area, oi);
 934
 935             /* if router_id is not configured, dont bring up
 936              * interfaces.
 937              * ospf_router_id_update() will call ospf_if_update
 938              * whenever r-id is configured instead.
 939              */
 940             if ((area->ospf->router_id.s_addr != 0)
 941                 && if_is_operative (ifp))
 942               ospf_if_up (oi);
 943           }
 944     }
 945 }
 946
 947 void
 948 ospf_network_run (struct prefix *p, struct ospf_area *area)
 949 {
 950   struct interface *ifp;
 951   struct listnode *node;
 952
 953   /* Schedule Router ID Update. */
 954   if (area->ospf->router_id.s_addr == 0)
 955     ospf_router_id_update (area->ospf);
 956
 957   /* Get target interface. */
 958   for (ALL_LIST_ELEMENTS_RO (om->iflist, node, ifp))
 959     ospf_network_run_interface (p, area, ifp);
 960 }
 961
 962 void
 963 ospf_ls_upd_queue_empty (struct ospf_interface *oi)
 964 {
 965   struct route_node *rn;
 966   struct listnode *node, *nnode;
 967   struct list *lst;
 968   struct ospf_lsa *lsa;
 969
 970   /* empty ls update queue */
 971   for (rn = route_top (oi->ls_upd_queue); rn;
 972        rn = route_next (rn))
 973     if ((lst = (struct list *) rn->info))
 974       {
 975         for (ALL_LIST_ELEMENTS (lst, node, nnode, lsa))
 976           ospf_lsa_unlock (&lsa); /* oi->ls_upd_queue */
 977         list_free (lst);
 978         rn->info = NULL;
 979       }
 980
 981   /* remove update event */
 982   if (oi->t_ls_upd_event)
 983     {
 984       thread_cancel (oi->t_ls_upd_event);
 985       oi->t_ls_upd_event = NULL;
 986     }
 987 }
 988
 989 void
 990 ospf_if_update (struct ospf *ospf, struct interface *ifp)
 991 {
 992   struct route_node *rn;
 993   struct ospf_network *network;
 994   struct ospf_area *area;
 995
 996   if (!ospf)
 997     ospf = ospf_lookup ();
 998
 999   /* OSPF must be on and Router-ID must be configured. */
1000   if (!ospf || ospf->router_id.s_addr == 0)
1001     return;
1002
1003   /* Run each netowrk for this interface. */
1004   for (rn = route_top (ospf->networks); rn; rn = route_next (rn))
1005     if (rn->info != NULL)
1006       {
1007         network = (struct ospf_network *) rn->info;
1008         area = ospf_area_get (ospf, network->area_id, network->format);
1009         ospf_network_run_interface (&rn->p, area, ifp);
1010       }
1011 }
1012
1013 void
1014 ospf_remove_vls_through_area (struct ospf *ospf, struct ospf_area *area)
1015 {
1016   struct listnode *node, *nnode;
1017   struct ospf_vl_data *vl_data;
1018
1019   for (ALL_LIST_ELEMENTS (ospf->vlinks, node, nnode, vl_data))
1020     if (IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
1021       ospf_vl_delete (ospf, vl_data);
1022 }
1023
1024 \f
1025 static const struct message ospf_area_type_msg[] =
1026 {
1027   { OSPF_AREA_DEFAULT,  "Default" },
1028   { OSPF_AREA_STUB,     "Stub" },
1029   { OSPF_AREA_NSSA,     "NSSA" },
1030 };
1031 static const int ospf_area_type_msg_max = OSPF_AREA_TYPE_MAX;
1032
1033 static void
1034 ospf_area_type_set (struct ospf_area *area, int type)
1035 {
1036   struct listnode *node;
1037   struct ospf_interface *oi;
1038
1039   if (area->external_routing == type)
1040     {
1041       if (IS_DEBUG_OSPF_EVENT)
1042         zlog_debug ("Area[%s]: Types are the same, ignored.",
1043                    inet_ntoa (area->area_id));
1044       return;
1045     }
1046
1047   area->external_routing = type;
1048
1049   if (IS_DEBUG_OSPF_EVENT)
1050     zlog_debug ("Area[%s]: Configured as %s", inet_ntoa (area->area_id),
1051                LOOKUP (ospf_area_type_msg, type));
1052
1053   switch (area->external_routing)
1054     {
1055     case OSPF_AREA_DEFAULT:
1056       for (ALL_LIST_ELEMENTS_RO (area->oiflist, node, oi))
1057         if (oi->nbr_self != NULL)
1058           {
1059             UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_NP);
1060             SET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
1061           }
1062       break;
1063     case OSPF_AREA_STUB:
1064       for (ALL_LIST_ELEMENTS_RO (area->oiflist, node, oi))
1065         if (oi->nbr_self != NULL)
1066           {
1067             if (IS_DEBUG_OSPF_EVENT)
1068               zlog_debug ("setting options on %s accordingly", IF_NAME (oi));
1069             UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_NP);
1070             UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
1071             if (IS_DEBUG_OSPF_EVENT)
1072               zlog_debug ("options set on %s: %x",
1073                          IF_NAME (oi), OPTIONS (oi));
1074           }
1075       break;
1076     case OSPF_AREA_NSSA:
1077       for (ALL_LIST_ELEMENTS_RO (area->oiflist, node, oi))
1078         if (oi->nbr_self != NULL)
1079           {
1080             zlog_debug ("setting nssa options on %s accordingly", IF_NAME (oi));
1081             UNSET_FLAG (oi->nbr_self->options, OSPF_OPTION_E);
1082             SET_FLAG (oi->nbr_self->options, OSPF_OPTION_NP);
1083             zlog_debug ("options set on %s: %x", IF_NAME (oi), OPTIONS (oi));
1084           }
1085       break;
1086     default:
1087       break;
1088     }
1089
1090   ospf_router_lsa_timer_add (area);
1091   ospf_schedule_abr_task (area->ospf);
1092 }
1093
1094 int
1095 ospf_area_shortcut_set (struct ospf *ospf, struct ospf_area *area, int mode)
1096 {
1097   if (area->shortcut_configured == mode)
1098     return 0;
1099
1100   area->shortcut_configured = mode;
1101   ospf_router_lsa_timer_add (area);
1102   ospf_schedule_abr_task (ospf);
1103
1104   ospf_area_check_free (ospf, area->area_id);
1105
1106   return 1;
1107 }
1108
1109 int
1110 ospf_area_shortcut_unset (struct ospf *ospf, struct ospf_area *area)
1111 {
1112   area->shortcut_configured = OSPF_SHORTCUT_DEFAULT;
1113   ospf_router_lsa_timer_add (area);
1114   ospf_area_check_free (ospf, area->area_id);
1115   ospf_schedule_abr_task (ospf);
1116
1117   return 1;
1118 }
1119
1120 static int
1121 ospf_area_vlink_count (struct ospf *ospf, struct ospf_area *area)
1122 {
1123   struct ospf_vl_data *vl;
1124   struct listnode *node;
1125   int count = 0;
1126
1127   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl))
1128     if (IPV4_ADDR_SAME (&vl->vl_area_id, &area->area_id))
1129       count++;
1130
1131   return count;
1132 }
1133
1134 int
1135 ospf_area_stub_set (struct ospf *ospf, struct in_addr area_id)
1136 {
1137   struct ospf_area *area;
1138   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
1139
1140   area = ospf_area_get (ospf, area_id, format);
1141   if (ospf_area_vlink_count (ospf, area))
1142     return 0;
1143
1144   if (area->external_routing != OSPF_AREA_STUB)
1145     ospf_area_type_set (area, OSPF_AREA_STUB);
1146
1147   return 1;
1148 }
1149
1150 int
1151 ospf_area_stub_unset (struct ospf *ospf, struct in_addr area_id)
1152 {
1153   struct ospf_area *area;
1154
1155   area = ospf_area_lookup_by_area_id (ospf, area_id);
1156   if (area == NULL)
1157     return 1;
1158
1159   if (area->external_routing == OSPF_AREA_STUB)
1160     ospf_area_type_set (area, OSPF_AREA_DEFAULT);
1161
1162   ospf_area_check_free (ospf, area_id);
1163
1164   return 1;
1165 }
1166
1167 int
1168 ospf_area_no_summary_set (struct ospf *ospf, struct in_addr area_id)
1169 {
1170   struct ospf_area *area;
1171   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
1172
1173   area = ospf_area_get (ospf, area_id, format);
1174   area->no_summary = 1;
1175
1176   return 1;
1177 }
1178
1179 int
1180 ospf_area_no_summary_unset (struct ospf *ospf, struct in_addr area_id)
1181 {
1182   struct ospf_area *area;
1183
1184   area = ospf_area_lookup_by_area_id (ospf, area_id);
1185   if (area == NULL)
1186     return 0;
1187
1188   area->no_summary = 0;
1189   ospf_area_check_free (ospf, area_id);
1190
1191   return 1;
1192 }
1193
1194 int
1195 ospf_area_nssa_set (struct ospf *ospf, struct in_addr area_id)
1196 {
1197   struct ospf_area *area;
1198   int format = OSPF_AREA_ID_FORMAT_ADDRESS;
1199
1200   area = ospf_area_get (ospf, area_id, format);
1201   if (ospf_area_vlink_count (ospf, area))
1202     return 0;
1203
1204   if (area->external_routing != OSPF_AREA_NSSA)
1205     {
1206       ospf_area_type_set (area, OSPF_AREA_NSSA);
1207       ospf->anyNSSA++;
1208     }
1209
1210   /* set NSSA area defaults */
1211   area->no_summary = 0;
1212   area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1213   area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
1214   area->NSSATranslatorStabilityInterval = OSPF_NSSA_TRANS_STABLE_DEFAULT;
1215
1216   return 1;
1217 }
1218
1219 int
1220 ospf_area_nssa_unset (struct ospf *ospf, struct in_addr area_id)
1221 {
1222   struct ospf_area *area;
1223
1224   area = ospf_area_lookup_by_area_id (ospf, area_id);
1225   if (area == NULL)
1226     return 0;
1227
1228   if (area->external_routing == OSPF_AREA_NSSA)
1229     {
1230       ospf->anyNSSA--;
1231       ospf_area_type_set (area, OSPF_AREA_DEFAULT);
1232     }
1233
1234   ospf_area_check_free (ospf, area_id);
1235
1236   return 1;
1237 }
1238
1239 int
1240 ospf_area_nssa_translator_role_set (struct ospf *ospf, struct in_addr area_id,
1241                                     int role)
1242 {
1243   struct ospf_area *area;
1244
1245   area = ospf_area_lookup_by_area_id (ospf, area_id);
1246   if (area == NULL)
1247     return 0;
1248
1249   area->NSSATranslatorRole = role;
1250
1251   return 1;
1252 }
1253
1254 /* XXX: unused? Leave for symmetry? */
1255 static int
1256 ospf_area_nssa_translator_role_unset (struct ospf *ospf,
1257                                       struct in_addr area_id)
1258 {
1259   struct ospf_area *area;
1260
1261   area = ospf_area_lookup_by_area_id (ospf, area_id);
1262   if (area == NULL)
1263     return 0;
1264
1265   area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1266
1267   ospf_area_check_free (ospf, area_id);
1268
1269   return 1;
1270 }
1271
1272 int
1273 ospf_area_export_list_set (struct ospf *ospf,
1274                            struct ospf_area *area, const char *list_name)
1275 {
1276   struct access_list *list;
1277   list = access_list_lookup (AFI_IP, list_name);
1278
1279   EXPORT_LIST (area) = list;
1280
1281   if (EXPORT_NAME (area))
1282     free (EXPORT_NAME (area));
1283
1284   EXPORT_NAME (area) = strdup (list_name);
1285   ospf_schedule_abr_task (ospf);
1286
1287   return 1;
1288 }
1289
1290 int
1291 ospf_area_export_list_unset (struct ospf *ospf, struct ospf_area * area)
1292 {
1293
1294   EXPORT_LIST (area) = 0;
1295
1296   if (EXPORT_NAME (area))
1297     free (EXPORT_NAME (area));
1298
1299   EXPORT_NAME (area) = NULL;
1300
1301   ospf_area_check_free (ospf, area->area_id);
1302
1303   ospf_schedule_abr_task (ospf);
1304
1305   return 1;
1306 }
1307
1308 int
1309 ospf_area_import_list_set (struct ospf *ospf, struct ospf_area *area,
1310                            const char *name)
1311 {
1312   struct access_list *list;
1313   list = access_list_lookup (AFI_IP, name);
1314
1315   IMPORT_LIST (area) = list;
1316
1317   if (IMPORT_NAME (area))
1318     free (IMPORT_NAME (area));
1319
1320   IMPORT_NAME (area) = strdup (name);
1321   ospf_schedule_abr_task (ospf);
1322
1323   return 1;
1324 }
1325
1326 int
1327 ospf_area_import_list_unset (struct ospf *ospf, struct ospf_area * area)
1328 {
1329   IMPORT_LIST (area) = 0;
1330
1331   if (IMPORT_NAME (area))
1332     free (IMPORT_NAME (area));
1333
1334   IMPORT_NAME (area) = NULL;
1335   ospf_area_check_free (ospf, area->area_id);
1336
1337   ospf_schedule_abr_task (ospf);
1338
1339   return 1;
1340 }
1341
1342 int
1343 ospf_timers_refresh_set (struct ospf *ospf, int interval)
1344 {
1345   int time_left;
1346
1347   if (ospf->lsa_refresh_interval == interval)
1348     return 1;
1349
1350   time_left = ospf->lsa_refresh_interval -
1351     (quagga_time (NULL) - ospf->lsa_refresher_started);
1352
1353   if (time_left > interval)
1354     {
1355       OSPF_TIMER_OFF (ospf->t_lsa_refresher);
1356       ospf->t_lsa_refresher =
1357         thread_add_timer (master, ospf_lsa_refresh_walker, ospf, interval);
1358     }
1359   ospf->lsa_refresh_interval = interval;
1360
1361   return 1;
1362 }
1363
1364 int
1365 ospf_timers_refresh_unset (struct ospf *ospf)
1366 {
1367   int time_left;
1368
1369   time_left = ospf->lsa_refresh_interval -
1370     (quagga_time (NULL) - ospf->lsa_refresher_started);
1371
1372   if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
1373     {
1374       OSPF_TIMER_OFF (ospf->t_lsa_refresher);
1375       ospf->t_lsa_refresher =
1376         thread_add_timer (master, ospf_lsa_refresh_walker, ospf,
1377                           OSPF_LSA_REFRESH_INTERVAL_DEFAULT);
1378     }
1379
1380   ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
1381
1382   return 1;
1383 }
1384
1385 \f
1386 static struct ospf_nbr_nbma *
1387 ospf_nbr_nbma_new (void)
1388 {
1389   struct ospf_nbr_nbma *nbr_nbma;
1390
1391   nbr_nbma = XCALLOC (MTYPE_OSPF_NEIGHBOR_STATIC,
1392                       sizeof (struct ospf_nbr_nbma));
1393
1394   nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1395   nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
1396
1397   return nbr_nbma;
1398 }
1399
1400 static void
1401 ospf_nbr_nbma_free (struct ospf_nbr_nbma *nbr_nbma)
1402 {
1403   XFREE (MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
1404 }
1405
1406 static void
1407 ospf_nbr_nbma_delete (struct ospf *ospf, struct ospf_nbr_nbma *nbr_nbma)
1408 {
1409   struct route_node *rn;
1410   struct prefix_ipv4 p;
1411
1412   p.family = AF_INET;
1413   p.prefix = nbr_nbma->addr;
1414   p.prefixlen = IPV4_MAX_BITLEN;
1415
1416   rn = route_node_lookup (ospf->nbr_nbma, (struct prefix *)&p);
1417   if (rn)
1418     {
1419       ospf_nbr_nbma_free (rn->info);
1420       rn->info = NULL;
1421       route_unlock_node (rn);
1422       route_unlock_node (rn);
1423     }
1424 }
1425
1426 static void
1427 ospf_nbr_nbma_down (struct ospf_nbr_nbma *nbr_nbma)
1428 {
1429   OSPF_TIMER_OFF (nbr_nbma->t_poll);
1430
1431   if (nbr_nbma->nbr)
1432     {
1433       nbr_nbma->nbr->nbr_nbma = NULL;
1434       OSPF_NSM_EVENT_EXECUTE (nbr_nbma->nbr, NSM_KillNbr);
1435     }
1436
1437   if (nbr_nbma->oi)
1438     listnode_delete (nbr_nbma->oi->nbr_nbma, nbr_nbma);
1439 }
1440
1441 static void
1442 ospf_nbr_nbma_add (struct ospf_nbr_nbma *nbr_nbma,
1443                    struct ospf_interface *oi)
1444 {
1445   struct ospf_neighbor *nbr;
1446   struct route_node *rn;
1447   struct prefix p;
1448
1449   if (oi->type != OSPF_IFTYPE_NBMA)
1450     return;
1451
1452   if (nbr_nbma->nbr != NULL)
1453     return;
1454
1455   if (IPV4_ADDR_SAME (&oi->nbr_self->address.u.prefix4, &nbr_nbma->addr))
1456     return;
1457
1458   nbr_nbma->oi = oi;
1459   listnode_add (oi->nbr_nbma, nbr_nbma);
1460
1461   /* Get neighbor information from table. */
1462   p.family = AF_INET;
1463   p.prefixlen = IPV4_MAX_BITLEN;
1464   p.u.prefix4 = nbr_nbma->addr;
1465
1466   rn = route_node_get (oi->nbrs, (struct prefix *)&p);
1467   if (rn->info)
1468     {
1469       nbr = rn->info;
1470       nbr->nbr_nbma = nbr_nbma;
1471       nbr_nbma->nbr = nbr;
1472
1473       route_unlock_node (rn);
1474     }
1475   else
1476     {
1477       nbr = rn->info = ospf_nbr_new (oi);
1478       nbr->state = NSM_Down;
1479       nbr->src = nbr_nbma->addr;
1480       nbr->nbr_nbma = nbr_nbma;
1481       nbr->priority = nbr_nbma->priority;
1482       nbr->address = p;
1483
1484       nbr_nbma->nbr = nbr;
1485
1486       OSPF_NSM_EVENT_EXECUTE (nbr, NSM_Start);
1487     }
1488 }
1489
1490 void
1491 ospf_nbr_nbma_if_update (struct ospf *ospf, struct ospf_interface *oi)
1492 {
1493   struct ospf_nbr_nbma *nbr_nbma;
1494   struct route_node *rn;
1495   struct prefix_ipv4 p;
1496
1497   if (oi->type != OSPF_IFTYPE_NBMA)
1498     return;
1499
1500   for (rn = route_top (ospf->nbr_nbma); rn; rn = route_next (rn))
1501     if ((nbr_nbma = rn->info))
1502       if (nbr_nbma->oi == NULL && nbr_nbma->nbr == NULL)
1503         {
1504           p.family = AF_INET;
1505           p.prefix = nbr_nbma->addr;
1506           p.prefixlen = IPV4_MAX_BITLEN;
1507
1508           if (prefix_match (oi->address, (struct prefix *)&p))
1509             ospf_nbr_nbma_add (nbr_nbma, oi);
1510         }
1511 }
1512
1513 struct ospf_nbr_nbma *
1514 ospf_nbr_nbma_lookup (struct ospf *ospf, struct in_addr nbr_addr)
1515 {
1516   struct route_node *rn;
1517   struct prefix_ipv4 p;
1518
1519   p.family = AF_INET;
1520   p.prefix = nbr_addr;
1521   p.prefixlen = IPV4_MAX_BITLEN;
1522
1523   rn = route_node_lookup (ospf->nbr_nbma, (struct prefix *)&p);
1524   if (rn)
1525     {
1526       route_unlock_node (rn);
1527       return rn->info;
1528     }
1529   return NULL;
1530 }
1531
1532 struct ospf_nbr_nbma *
1533 ospf_nbr_nbma_lookup_next (struct ospf *ospf, struct in_addr *addr, int first)
1534 {
1535 #if 0
1536   struct ospf_nbr_nbma *nbr_nbma;
1537   struct listnode *node;
1538 #endif
1539
1540   if (ospf == NULL)
1541     return NULL;
1542
1543 #if 0
1544   for (ALL_LIST_ELEMENTS_RO (ospf->nbr_nbma, node, nbr_nbma))
1545     {
1546       if (first)
1547         {
1548           *addr = nbr_nbma->addr;
1549           return nbr_nbma;
1550         }
1551       else if (ntohl (nbr_nbma->addr.s_addr) > ntohl (addr->s_addr))
1552         {
1553           *addr = nbr_nbma->addr;
1554           return nbr_nbma;
1555         }
1556     }
1557 #endif
1558   return NULL;
1559 }
1560
1561 int
1562 ospf_nbr_nbma_set (struct ospf *ospf, struct in_addr nbr_addr)
1563 {
1564   struct ospf_nbr_nbma *nbr_nbma;
1565   struct ospf_interface *oi;
1566   struct prefix_ipv4 p;
1567   struct route_node *rn;
1568   struct listnode *node;
1569
1570   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
1571   if (nbr_nbma)
1572     return 0;
1573
1574   nbr_nbma = ospf_nbr_nbma_new ();
1575   nbr_nbma->addr = nbr_addr;
1576
1577   p.family = AF_INET;
1578   p.prefix = nbr_addr;
1579   p.prefixlen = IPV4_MAX_BITLEN;
1580
1581   rn = route_node_get (ospf->nbr_nbma, (struct prefix *)&p);
1582   rn->info = nbr_nbma;
1583
1584   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
1585     {
1586       if (oi->type == OSPF_IFTYPE_NBMA)
1587         if (prefix_match (oi->address, (struct prefix *)&p))
1588           {
1589             ospf_nbr_nbma_add (nbr_nbma, oi);
1590             break;
1591           }
1592     }
1593
1594   return 1;
1595 }
1596
1597 int
1598 ospf_nbr_nbma_unset (struct ospf *ospf, struct in_addr nbr_addr)
1599 {
1600   struct ospf_nbr_nbma *nbr_nbma;
1601
1602   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
1603   if (nbr_nbma == NULL)
1604     return 0;
1605
1606   ospf_nbr_nbma_down (nbr_nbma);
1607   ospf_nbr_nbma_delete (ospf, nbr_nbma);
1608
1609   return 1;
1610 }
1611
1612 int
1613 ospf_nbr_nbma_priority_set (struct ospf *ospf, struct in_addr nbr_addr,
1614                             u_char priority)
1615 {
1616   struct ospf_nbr_nbma *nbr_nbma;
1617
1618   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
1619   if (nbr_nbma == NULL)
1620     return 0;
1621
1622   if (nbr_nbma->priority != priority)
1623     nbr_nbma->priority = priority;
1624
1625   return 1;
1626 }
1627
1628 int
1629 ospf_nbr_nbma_priority_unset (struct ospf *ospf, struct in_addr nbr_addr)
1630 {
1631   struct ospf_nbr_nbma *nbr_nbma;
1632
1633   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
1634   if (nbr_nbma == NULL)
1635     return 0;
1636
1637   if (nbr_nbma != OSPF_NEIGHBOR_PRIORITY_DEFAULT)
1638     nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1639
1640   return 1;
1641 }
1642
1643 int
1644 ospf_nbr_nbma_poll_interval_set (struct ospf *ospf, struct in_addr nbr_addr,
1645                                  unsigned int interval)
1646 {
1647   struct ospf_nbr_nbma *nbr_nbma;
1648
1649   nbr_nbma = ospf_nbr_nbma_lookup (ospf, nbr_addr);
1650   if (nbr_nbma == NULL)
1651     return 0;
1652
1653   if (nbr_nbma->v_poll != interval)
1654     {
1655       nbr_nbma->v_poll = interval;
1656       if (nbr_nbma->oi && ospf_if_is_up (nbr_nbma->oi))
1657         {
1658           OSPF_TIMER_OFF (nbr_nbma->t_poll);
1659           OSPF_POLL_TIMER_ON (nbr_nbma->t_poll, ospf_poll_timer,
1660                               nbr_nbma->v_poll);
1661         }
1662     }
1663
1664   return 1;
1665 }
1666
1667 int
1668 ospf_nbr_nbma_poll_interval_unset (struct ospf *ospf, struct in_addr addr)
1669 {
1670   struct ospf_nbr_nbma *nbr_nbma;
1671
1672   nbr_nbma = ospf_nbr_nbma_lookup (ospf, addr);
1673   if (nbr_nbma == NULL)
1674     return 0;
1675
1676   if (nbr_nbma->v_poll != OSPF_POLL_INTERVAL_DEFAULT)
1677     nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
1678
1679   return 1;
1680 }
1681
1682 void
1683 ospf_master_init ()
1684 {
1685   memset (&ospf_master, 0, sizeof (struct ospf_master));
1686
1687   om = &ospf_master;
1688   om->ospf = list_new ();
1689   om->master = thread_master_create ();
1690   om->start_time = quagga_time (NULL);
1691 }