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