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