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 along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  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 "routemap.h"
  36 #include "plist.h"
  37 #include "sockopt.h"
  38 #include "bfd.h"
  39 #include "libfrr.h"
  40 #include "defaults.h"
  41 #include "lib_errors.h"
  42
  43 #include "ospfd/ospfd.h"
  44 #include "ospfd/ospf_network.h"
  45 #include "ospfd/ospf_interface.h"
  46 #include "ospfd/ospf_ism.h"
  47 #include "ospfd/ospf_asbr.h"
  48 #include "ospfd/ospf_lsa.h"
  49 #include "ospfd/ospf_lsdb.h"
  50 #include "ospfd/ospf_neighbor.h"
  51 #include "ospfd/ospf_nsm.h"
  52 #include "ospfd/ospf_spf.h"
  53 #include "ospfd/ospf_packet.h"
  54 #include "ospfd/ospf_dump.h"
  55 #include "ospfd/ospf_route.h"
  56 #include "ospfd/ospf_zebra.h"
  57 #include "ospfd/ospf_abr.h"
  58 #include "ospfd/ospf_flood.h"
  59 #include "ospfd/ospf_ase.h"
  60
  61
  62 DEFINE_QOBJ_TYPE(ospf)
  63
  64 /* OSPF process wide configuration. */
  65 static struct ospf_master ospf_master;
  66
  67 /* OSPF process wide configuration pointer to export. */
  68 struct ospf_master *om;
  69
  70 extern struct zclient *zclient;
  71
  72
  73 static void ospf_remove_vls_through_area(struct ospf *, struct ospf_area *);
  74 static void ospf_network_free(struct ospf *, struct ospf_network *);
  75 static void ospf_area_free(struct ospf_area *);
  76 static void ospf_network_run(struct prefix *, struct ospf_area *);
  77 static void ospf_network_run_interface(struct ospf *, struct interface *,
  78                                        struct prefix *, struct ospf_area *);
  79 static void ospf_network_run_subnet(struct ospf *, struct connected *,
  80                                     struct prefix *, struct ospf_area *);
  81 static int ospf_network_match_iface(const struct connected *,
  82                                     const struct prefix *);
  83 static void ospf_finish_final(struct ospf *);
  84
  85 #define OSPF_EXTERNAL_LSA_ORIGINATE_DELAY 1
  86
  87 void ospf_router_id_update(struct ospf *ospf)
  88 {
  89         struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
  90         struct in_addr router_id, router_id_old;
  91         struct ospf_interface *oi;
  92         struct interface *ifp;
  93         struct listnode *node;
  94         int type;
  95
  96         if (!ospf->oi_running) {
  97                 if (IS_DEBUG_OSPF_EVENT)
  98                         zlog_debug(
  99                                 "Router ospf not configured -- Router-ID update postponed");
 100                 return;
 101         }
 102
 103         if (IS_DEBUG_OSPF_EVENT)
 104                 zlog_debug("Router-ID[OLD:%s]: Update",
 105                            inet_ntoa(ospf->router_id));
 106
 107         router_id_old = ospf->router_id;
 108
 109         /* Select the router ID based on these priorities:
 110              1. Statically assigned router ID is always the first choice.
 111              2. If there is no statically assigned router ID, then try to stick
 112                 with the most recent value, since changing router ID's is very
 113                 disruptive.
 114              3. Last choice: just go with whatever the zebra daemon recommends.
 115         */
 116         if (ospf->router_id_static.s_addr != 0)
 117                 router_id = ospf->router_id_static;
 118         else if (ospf->router_id.s_addr != 0)
 119                 router_id = ospf->router_id;
 120         else
 121                 router_id = ospf->router_id_zebra;
 122
 123         if (IS_DEBUG_OSPF_EVENT)
 124                 zlog_debug("Router-ID[OLD:%s]: Update to %s",
 125                            inet_ntoa(ospf->router_id), inet_ntoa(router_id));
 126
 127         if (!IPV4_ADDR_SAME(&router_id_old, &router_id)) {
 128
 129                 for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
 130                         /* Some nbrs are identified by router_id, these needs
 131                          * to be rebuilt. Possible optimization would be to do
 132                          * oi->nbr_self->router_id = router_id for
 133                          * !(virtual | ptop) links
 134                          */
 135                         ospf_nbr_self_reset(oi, router_id);
 136                 }
 137
 138                 /* If AS-external-LSA is queued, then flush those LSAs. */
 139                 if (router_id_old.s_addr == 0 && ospf->external_origin) {
 140                         /* Originate each redistributed external route. */
 141                         for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
 142                                 if (ospf->external_origin & (1 << type))
 143                                         thread_add_event(
 144                                                 master,
 145                                                 ospf_external_lsa_originate_timer,
 146                                                 ospf, type, NULL);
 147                         /* Originate Deafult. */
 148                         if (ospf->external_origin & (1 << ZEBRA_ROUTE_MAX))
 149                                 thread_add_event(master,
 150                                                  ospf_default_originate_timer,
 151                                                  ospf, 0, NULL);
 152
 153                         ospf->external_origin = 0;
 154                 }
 155
 156                 /* Flush (inline) all external LSAs based on the OSPF_LSA_SELF
 157                  * flag */
 158                 if (ospf->lsdb) {
 159                         struct route_node *rn;
 160                         struct ospf_lsa *lsa;
 161
 162                         LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
 163                                 if (IS_LSA_SELF(lsa))
 164                                         ospf_lsa_flush_schedule(ospf, lsa);
 165                 }
 166
 167                 ospf->router_id = router_id;
 168                 if (IS_DEBUG_OSPF_EVENT)
 169                         zlog_debug("Router-ID[NEW:%s]: Update",
 170                                    inet_ntoa(ospf->router_id));
 171
 172                 /* Flush (inline) all external LSAs which now match the new
 173                    router-id,
 174                    need to adjust the OSPF_LSA_SELF flag, so the flush doesnt
 175                    hit
 176                    asserts in ospf_refresher_unregister_lsa(). This step is
 177                    needed
 178                    because the current quagga code does look-up for
 179                    self-originated LSAs
 180                    based on the self router-id alone but expects OSPF_LSA_SELF
 181                    to be
 182                    properly set */
 183                 if (ospf->lsdb) {
 184                         struct route_node *rn;
 185                         struct ospf_lsa *lsa;
 186
 187                         LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa) {
 188                                 /* AdvRouter and Router ID is the same. */
 189                                 if (IPV4_ADDR_SAME(&lsa->data->adv_router,
 190                                                    &ospf->router_id)) {
 191                                         SET_FLAG(lsa->flags,
 192                                                  OSPF_LSA_SELF_CHECKED);
 193                                         SET_FLAG(lsa->flags, OSPF_LSA_SELF);
 194                                         ospf_lsa_flush_schedule(ospf, lsa);
 195                                 }
 196                         }
 197                 }
 198
 199                 /* Originate each redistributed external route. */
 200                 for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
 201                         thread_add_event(master,
 202                                          ospf_external_lsa_originate_timer,
 203                                          ospf, type, NULL);
 204                 thread_add_event(master, ospf_default_originate_timer, ospf, 0,
 205                                  NULL);
 206
 207                 /* update router-lsa's for each area */
 208                 ospf_router_lsa_update(ospf);
 209
 210                 /* update ospf_interface's */
 211                 FOR_ALL_INTERFACES (vrf, ifp)
 212                         ospf_if_update(ospf, ifp);
 213         }
 214 }
 215
 216 /* For OSPF area sort by area id. */
 217 static int ospf_area_id_cmp(struct ospf_area *a1, struct ospf_area *a2)
 218 {
 219         if (ntohl(a1->area_id.s_addr) > ntohl(a2->area_id.s_addr))
 220                 return 1;
 221         if (ntohl(a1->area_id.s_addr) < ntohl(a2->area_id.s_addr))
 222                 return -1;
 223         return 0;
 224 }
 225
 226 /* Allocate new ospf structure. */
 227 static struct ospf *ospf_new(unsigned short instance, const char *name)
 228 {
 229         int i;
 230         struct vrf *vrf = NULL;
 231
 232         struct ospf *new = XCALLOC(MTYPE_OSPF_TOP, sizeof(struct ospf));
 233
 234         new->instance = instance;
 235         new->router_id.s_addr = htonl(0);
 236         new->router_id_static.s_addr = htonl(0);
 237         if (name && !strmatch(name, VRF_DEFAULT_NAME)) {
 238                 new->vrf_id = VRF_UNKNOWN;
 239                 /* Freed in ospf_finish_final */
 240                 new->name = XSTRDUP(MTYPE_OSPF_TOP, name);
 241                 if (IS_DEBUG_OSPF_EVENT)
 242                         zlog_debug(
 243                                 "%s: Create new ospf instance with vrf_name %s vrf_id %u",
 244                                 __PRETTY_FUNCTION__, name, new->vrf_id);
 245         } else {
 246                 new->vrf_id = VRF_DEFAULT;
 247                 vrf = vrf_lookup_by_id(VRF_DEFAULT);
 248         }
 249
 250         if (vrf)
 251                 ospf_vrf_link(new, vrf);
 252
 253         ospf_zebra_vrf_register(new);
 254
 255         new->abr_type = OSPF_ABR_DEFAULT;
 256         new->oiflist = list_new();
 257         new->vlinks = list_new();
 258         new->areas = list_new();
 259         new->areas->cmp = (int (*)(void *, void *))ospf_area_id_cmp;
 260         new->networks = route_table_init();
 261         new->nbr_nbma = route_table_init();
 262
 263         new->lsdb = ospf_lsdb_new();
 264
 265         new->default_originate = DEFAULT_ORIGINATE_NONE;
 266
 267         new->passive_interface_default = OSPF_IF_ACTIVE;
 268
 269         new->new_external_route = route_table_init();
 270         new->old_external_route = route_table_init();
 271         new->external_lsas = route_table_init();
 272
 273         new->stub_router_startup_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 274         new->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 275         new->stub_router_admin_set = OSPF_STUB_ROUTER_ADMINISTRATIVE_UNSET;
 276
 277         /* Distribute parameter init. */
 278         for (i = 0; i <= ZEBRA_ROUTE_MAX; i++) {
 279                 new->dtag[i] = 0;
 280         }
 281         new->default_metric = -1;
 282         new->ref_bandwidth = OSPF_DEFAULT_REF_BANDWIDTH;
 283
 284         /* LSA timers */
 285         new->min_ls_interval = OSPF_MIN_LS_INTERVAL;
 286         new->min_ls_arrival = OSPF_MIN_LS_ARRIVAL;
 287
 288         /* SPF timer value init. */
 289         new->spf_delay = OSPF_SPF_DELAY_DEFAULT;
 290         new->spf_holdtime = OSPF_SPF_HOLDTIME_DEFAULT;
 291         new->spf_max_holdtime = OSPF_SPF_MAX_HOLDTIME_DEFAULT;
 292         new->spf_hold_multiplier = 1;
 293
 294         /* MaxAge init. */
 295         new->maxage_delay = OSPF_LSA_MAXAGE_REMOVE_DELAY_DEFAULT;
 296         new->maxage_lsa = route_table_init();
 297         new->t_maxage_walker = NULL;
 298         thread_add_timer(master, ospf_lsa_maxage_walker, new,
 299                          OSPF_LSA_MAXAGE_CHECK_INTERVAL, &new->t_maxage_walker);
 300
 301         /* Distance table init. */
 302         new->distance_table = route_table_init();
 303
 304         new->lsa_refresh_queue.index = 0;
 305         new->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
 306         new->t_lsa_refresher = NULL;
 307         thread_add_timer(master, ospf_lsa_refresh_walker, new,
 308                          new->lsa_refresh_interval, &new->t_lsa_refresher);
 309         new->lsa_refresher_started = monotime(NULL);
 310
 311         if ((new->ibuf = stream_new(OSPF_MAX_PACKET_SIZE + 1)) == NULL) {
 312                 zlog_err(
 313                         "ospf_new: fatal error: stream_new(%u) failed allocating ibuf",
 314                         OSPF_MAX_PACKET_SIZE + 1);
 315                 exit(1);
 316         }
 317         new->t_read = NULL;
 318         new->oi_write_q = list_new();
 319         new->write_oi_count = OSPF_WRITE_INTERFACE_COUNT_DEFAULT;
 320
 321 /* Enable "log-adjacency-changes" */
 322 #if DFLT_OSPF_LOG_ADJACENCY_CHANGES
 323         SET_FLAG(new->config, OSPF_LOG_ADJACENCY_CHANGES);
 324 #endif
 325
 326         QOBJ_REG(new, ospf);
 327
 328         new->fd = -1;
 329         if ((ospf_sock_init(new)) < 0) {
 330                 if (new->vrf_id != VRF_UNKNOWN)
 331                         zlog_warn(
 332                                 "%s: ospf_sock_init is unable to open a socket",
 333                                 __func__);
 334                 return new;
 335         }
 336         thread_add_read(master, ospf_read, new, new->fd, &new->t_read);
 337
 338         return new;
 339 }
 340
 341 struct ospf *ospf_lookup_instance(unsigned short instance)
 342 {
 343         struct ospf *ospf;
 344         struct listnode *node, *nnode;
 345
 346         if (listcount(om->ospf) == 0)
 347                 return NULL;
 348
 349         for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
 350                 if ((ospf->instance == 0 && instance == 0)
 351                     || (ospf->instance && instance
 352                         && ospf->instance == instance))
 353                         return ospf;
 354
 355         return NULL;
 356 }
 357
 358 static int ospf_is_ready(struct ospf *ospf)
 359 {
 360         /* OSPF must be on and Router-ID must be configured. */
 361         if (!ospf || ospf->router_id.s_addr == 0)
 362                 return 0;
 363
 364         return 1;
 365 }
 366
 367 static void ospf_add(struct ospf *ospf)
 368 {
 369         listnode_add(om->ospf, ospf);
 370 }
 371
 372 static void ospf_delete(struct ospf *ospf)
 373 {
 374         listnode_delete(om->ospf, ospf);
 375 }
 376
 377 struct ospf *ospf_lookup_by_inst_name(unsigned short instance, const char *name)
 378 {
 379         struct ospf *ospf = NULL;
 380         struct listnode *node, *nnode;
 381
 382         if (name == NULL || strmatch(name, VRF_DEFAULT_NAME))
 383                 return ospf_lookup_by_vrf_id(VRF_DEFAULT);
 384
 385         for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf)) {
 386                 if ((ospf->instance == instance)
 387                     && ((ospf->name == NULL && name == NULL)
 388                         || (ospf->name && name
 389                             && strcmp(ospf->name, name) == 0)))
 390                         return ospf;
 391         }
 392         return NULL;
 393 }
 394
 395 struct ospf *ospf_get(unsigned short instance, const char *name)
 396 {
 397         struct ospf *ospf;
 398
 399         /* vrf name provided call inst and name based api
 400          * in case of no name pass default ospf instance */
 401         if (name)
 402                 ospf = ospf_lookup_by_inst_name(instance, name);
 403         else
 404                 ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
 405
 406         if (ospf == NULL) {
 407                 ospf = ospf_new(instance, name);
 408                 ospf_add(ospf);
 409
 410                 if (ospf->router_id_static.s_addr == 0)
 411                         ospf_router_id_update(ospf);
 412
 413                 ospf_opaque_type11_lsa_init(ospf);
 414         }
 415
 416         return ospf;
 417 }
 418
 419 struct ospf *ospf_get_instance(unsigned short instance)
 420 {
 421         struct ospf *ospf;
 422
 423         ospf = ospf_lookup_instance(instance);
 424         if (ospf == NULL) {
 425                 ospf = ospf_new(instance, NULL /* VRF_DEFAULT*/);
 426                 ospf_add(ospf);
 427
 428                 if (ospf->router_id_static.s_addr == 0) {
 429                         if (vrf_lookup_by_id(ospf->vrf_id))
 430                                 ospf_router_id_update(ospf);
 431                         else {
 432                                 if (IS_DEBUG_OSPF_EVENT)
 433                                         zlog_debug(
 434                                                 "%s: ospf VRF (id %d) is not active yet, skip router id update",
 435                                                 __PRETTY_FUNCTION__,
 436                                                 ospf->vrf_id);
 437                         }
 438                         ospf_router_id_update(ospf);
 439                 }
 440
 441                 ospf_opaque_type11_lsa_init(ospf);
 442         }
 443
 444         return ospf;
 445 }
 446
 447 struct ospf *ospf_lookup_by_vrf_id(vrf_id_t vrf_id)
 448 {
 449         struct vrf *vrf = NULL;
 450
 451         vrf = vrf_lookup_by_id(vrf_id);
 452         if (!vrf)
 453                 return NULL;
 454         return (vrf->info) ? (struct ospf *)vrf->info : NULL;
 455 }
 456
 457 /* It should only be used when processing incoming info update from zebra.
 458  * Other situations, it is not sufficient to lookup the ospf instance by
 459  * vrf_name only without using the instance number.
 460  */
 461 static struct ospf *ospf_lookup_by_name(const char *vrf_name)
 462 {
 463         struct ospf *ospf = NULL;
 464         struct listnode *node, *nnode;
 465
 466         for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
 467                 if ((ospf->name == NULL && vrf_name == NULL)
 468                     || (ospf->name && vrf_name
 469                         && strcmp(ospf->name, vrf_name) == 0))
 470                         return ospf;
 471         return NULL;
 472 }
 473
 474 /* Handle the second half of deferred shutdown. This is called either
 475  * from the deferred-shutdown timer thread, or directly through
 476  * ospf_deferred_shutdown_check.
 477  *
 478  * Function is to cleanup G-R state, if required then call ospf_finish_final
 479  * to complete shutdown of this ospf instance. Possibly exit if the
 480  * whole process is being shutdown and this was the last OSPF instance.
 481  */
 482 static void ospf_deferred_shutdown_finish(struct ospf *ospf)
 483 {
 484         ospf->stub_router_shutdown_time = OSPF_STUB_ROUTER_UNCONFIGURED;
 485         OSPF_TIMER_OFF(ospf->t_deferred_shutdown);
 486
 487         ospf_finish_final(ospf);
 488
 489         /* *ospf is now invalid */
 490
 491         /* ospfd being shut-down? If so, was this the last ospf instance? */
 492         if (CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN)
 493             && (listcount(om->ospf) == 0)) {
 494                 exit(0);
 495         }
 496
 497         return;
 498 }
 499
 500 /* Timer thread for G-R */
 501 static int ospf_deferred_shutdown_timer(struct thread *t)
 502 {
 503         struct ospf *ospf = THREAD_ARG(t);
 504
 505         ospf_deferred_shutdown_finish(ospf);
 506
 507         return 0;
 508 }
 509
 510 /* Check whether deferred-shutdown must be scheduled, otherwise call
 511  * down directly into second-half of instance shutdown.
 512  */
 513 static void ospf_deferred_shutdown_check(struct ospf *ospf)
 514 {
 515         unsigned long timeout;
 516         struct listnode *ln;
 517         struct ospf_area *area;
 518
 519         /* deferred shutdown already running? */
 520         if (ospf->t_deferred_shutdown)
 521                 return;
 522
 523         /* Should we try push out max-metric LSAs? */
 524         if (ospf->stub_router_shutdown_time != OSPF_STUB_ROUTER_UNCONFIGURED) {
 525                 for (ALL_LIST_ELEMENTS_RO(ospf->areas, ln, area)) {
 526                         SET_FLAG(area->stub_router_state,
 527                                  OSPF_AREA_ADMIN_STUB_ROUTED);
 528
 529                         if (!CHECK_FLAG(area->stub_router_state,
 530                                         OSPF_AREA_IS_STUB_ROUTED))
 531                                 ospf_router_lsa_update_area(area);
 532                 }
 533                 timeout = ospf->stub_router_shutdown_time;
 534         } else {
 535                 /* No timer needed */
 536                 ospf_deferred_shutdown_finish(ospf);
 537                 return;
 538         }
 539
 540         OSPF_TIMER_ON(ospf->t_deferred_shutdown, ospf_deferred_shutdown_timer,
 541                       timeout);
 542         return;
 543 }
 544
 545 /* Shut down the entire process */
 546 void ospf_terminate(void)
 547 {
 548         struct ospf *ospf;
 549         struct listnode *node, *nnode;
 550
 551         /* shutdown already in progress */
 552         if (CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
 553                 return;
 554
 555         SET_FLAG(om->options, OSPF_MASTER_SHUTDOWN);
 556
 557         /* exit immediately if OSPF not actually running */
 558         if (listcount(om->ospf) == 0)
 559                 exit(0);
 560
 561         bfd_gbl_exit();
 562         for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
 563                 ospf_finish(ospf);
 564
 565         /* Cleanup route maps */
 566         route_map_finish();
 567
 568         /* reverse prefix_list_init */
 569         prefix_list_add_hook(NULL);
 570         prefix_list_delete_hook(NULL);
 571         prefix_list_reset();
 572
 573         /* Cleanup vrf info */
 574         ospf_vrf_terminate();
 575
 576         /* Deliberately go back up, hopefully to thread scheduler, as
 577          * One or more ospf_finish()'s may have deferred shutdown to a timer
 578          * thread
 579          */
 580         zclient_stop(zclient);
 581         zclient_free(zclient);
 582
 583         frr_fini();
 584 }
 585
 586 void ospf_finish(struct ospf *ospf)
 587 {
 588         /* let deferred shutdown decide */
 589         ospf_deferred_shutdown_check(ospf);
 590
 591         /* if ospf_deferred_shutdown returns, then ospf_finish_final is
 592          * deferred to expiry of G-S timer thread. Return back up, hopefully
 593          * to thread scheduler.
 594          */
 595         return;
 596 }
 597
 598 /* Final cleanup of ospf instance */
 599 static void ospf_finish_final(struct ospf *ospf)
 600 {
 601         struct vrf *vrf = vrf_lookup_by_id(ospf->vrf_id);
 602         struct route_node *rn;
 603         struct ospf_nbr_nbma *nbr_nbma;
 604         struct ospf_lsa *lsa;
 605         struct interface *ifp;
 606         struct ospf_interface *oi;
 607         struct ospf_area *area;
 608         struct ospf_vl_data *vl_data;
 609         struct listnode *node, *nnode;
 610         int i;
 611         unsigned short instance = 0;
 612
 613         QOBJ_UNREG(ospf);
 614
 615         ospf_opaque_type11_lsa_term(ospf);
 616
 617         ospf_opaque_finish();
 618
 619         ospf_flush_self_originated_lsas_now(ospf);
 620
 621         /* Unregister redistribution */
 622         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
 623                 struct list *red_list;
 624                 struct ospf_redist *red;
 625
 626                 red_list = ospf->redist[i];
 627                 if (!red_list)
 628                         continue;
 629
 630                 for (ALL_LIST_ELEMENTS(red_list, node, nnode, red))
 631                         ospf_redistribute_unset(ospf, i, red->instance);
 632         }
 633         ospf_redistribute_default_unset(ospf);
 634
 635         for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area))
 636                 ospf_remove_vls_through_area(ospf, area);
 637
 638         for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
 639                 ospf_vl_delete(ospf, vl_data);
 640
 641         list_delete_and_null(&ospf->vlinks);
 642
 643         /* Remove any ospf interface config params */
 644         FOR_ALL_INTERFACES (vrf, ifp) {
 645                 struct ospf_if_params *params;
 646
 647                 params = IF_DEF_PARAMS(ifp);
 648                 if (OSPF_IF_PARAM_CONFIGURED(params, if_area))
 649                         UNSET_IF_PARAM(params, if_area);
 650         }
 651
 652         /* Reset interface. */
 653         for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi))
 654                 ospf_if_free(oi);
 655         list_delete_and_null(&ospf->oiflist);
 656
 657         /* De-Register VRF */
 658         ospf_zebra_vrf_deregister(ospf);
 659
 660         /* Clear static neighbors */
 661         for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
 662                 if ((nbr_nbma = rn->info)) {
 663                         OSPF_POLL_TIMER_OFF(nbr_nbma->t_poll);
 664
 665                         if (nbr_nbma->nbr) {
 666                                 nbr_nbma->nbr->nbr_nbma = NULL;
 667                                 nbr_nbma->nbr = NULL;
 668                         }
 669
 670                         if (nbr_nbma->oi) {
 671                                 listnode_delete(nbr_nbma->oi->nbr_nbma,
 672                                                 nbr_nbma);
 673                                 nbr_nbma->oi = NULL;
 674                         }
 675
 676                         XFREE(MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
 677                 }
 678
 679         route_table_finish(ospf->nbr_nbma);
 680
 681         /* Clear networks and Areas. */
 682         for (rn = route_top(ospf->networks); rn; rn = route_next(rn)) {
 683                 struct ospf_network *network;
 684
 685                 if ((network = rn->info) != NULL) {
 686                         ospf_network_free(ospf, network);
 687                         rn->info = NULL;
 688                         route_unlock_node(rn);
 689                 }
 690         }
 691         route_table_finish(ospf->networks);
 692
 693         for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
 694                 listnode_delete(ospf->areas, area);
 695                 ospf_area_free(area);
 696         }
 697
 698         /* Cancel all timers. */
 699         OSPF_TIMER_OFF(ospf->t_external_lsa);
 700         OSPF_TIMER_OFF(ospf->t_spf_calc);
 701         OSPF_TIMER_OFF(ospf->t_ase_calc);
 702         OSPF_TIMER_OFF(ospf->t_maxage);
 703         OSPF_TIMER_OFF(ospf->t_maxage_walker);
 704         OSPF_TIMER_OFF(ospf->t_abr_task);
 705         OSPF_TIMER_OFF(ospf->t_asbr_check);
 706         OSPF_TIMER_OFF(ospf->t_distribute_update);
 707         OSPF_TIMER_OFF(ospf->t_lsa_refresher);
 708         OSPF_TIMER_OFF(ospf->t_read);
 709         OSPF_TIMER_OFF(ospf->t_write);
 710         OSPF_TIMER_OFF(ospf->t_opaque_lsa_self);
 711         OSPF_TIMER_OFF(ospf->t_sr_update);
 712
 713         close(ospf->fd);
 714         stream_free(ospf->ibuf);
 715
 716         LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
 717                 ospf_discard_from_db(ospf, ospf->lsdb, lsa);
 718         LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
 719                 ospf_discard_from_db(ospf, ospf->lsdb, lsa);
 720
 721         ospf_lsdb_delete_all(ospf->lsdb);
 722         ospf_lsdb_free(ospf->lsdb);
 723
 724         for (rn = route_top(ospf->maxage_lsa); rn; rn = route_next(rn)) {
 725                 struct ospf_lsa *lsa;
 726
 727                 if ((lsa = rn->info) != NULL) {
 728                         ospf_lsa_unlock(&lsa);
 729                         rn->info = NULL;
 730                 }
 731                 route_unlock_node(rn);
 732         }
 733         route_table_finish(ospf->maxage_lsa);
 734
 735         if (ospf->old_table)
 736                 ospf_route_table_free(ospf->old_table);
 737         if (ospf->new_table) {
 738                 ospf_route_delete(ospf, ospf->new_table);
 739                 ospf_route_table_free(ospf->new_table);
 740         }
 741         if (ospf->old_rtrs)
 742                 ospf_rtrs_free(ospf->old_rtrs);
 743         if (ospf->new_rtrs)
 744                 ospf_rtrs_free(ospf->new_rtrs);
 745         if (ospf->new_external_route) {
 746                 ospf_route_delete(ospf, ospf->new_external_route);
 747                 ospf_route_table_free(ospf->new_external_route);
 748         }
 749         if (ospf->old_external_route) {
 750                 ospf_route_delete(ospf, ospf->old_external_route);
 751                 ospf_route_table_free(ospf->old_external_route);
 752         }
 753         if (ospf->external_lsas) {
 754                 ospf_ase_external_lsas_finish(ospf->external_lsas);
 755         }
 756
 757         list_delete_and_null(&ospf->areas);
 758         list_delete_and_null(&ospf->oi_write_q);
 759
 760         for (i = ZEBRA_ROUTE_SYSTEM; i <= ZEBRA_ROUTE_MAX; i++) {
 761                 struct list *ext_list;
 762                 struct listnode *node;
 763                 struct ospf_external *ext;
 764
 765                 ext_list = ospf->external[i];
 766                 if (!ext_list)
 767                         continue;
 768
 769                 for (ALL_LIST_ELEMENTS_RO(ext_list, node, ext)) {
 770                         if (ext->external_info)
 771                                 for (rn = route_top(ext->external_info); rn;
 772                                      rn = route_next(rn)) {
 773                                         if (rn->info == NULL)
 774                                                 continue;
 775
 776                                         XFREE(MTYPE_OSPF_EXTERNAL_INFO,
 777                                               rn->info);
 778                                         rn->info = NULL;
 779                                         route_unlock_node(rn);
 780                                 }
 781                 }
 782         }
 783
 784         ospf_distance_reset(ospf);
 785         route_table_finish(ospf->distance_table);
 786
 787         if (!CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
 788                 instance = ospf->instance;
 789
 790         ospf_delete(ospf);
 791
 792         if (ospf->name) {
 793                 vrf = vrf_lookup_by_name(ospf->name);
 794                 if (vrf)
 795                         ospf_vrf_unlink(ospf, vrf);
 796                 XFREE(MTYPE_OSPF_TOP, ospf->name);
 797         } else {
 798                 vrf = vrf_lookup_by_id(VRF_DEFAULT);
 799                 if (vrf)
 800                         ospf_vrf_unlink(ospf, vrf);
 801         }
 802
 803         XFREE(MTYPE_OSPF_TOP, ospf);
 804
 805         if (!CHECK_FLAG(om->options, OSPF_MASTER_SHUTDOWN))
 806                 ospf_get_instance(instance);
 807 }
 808
 809
 810 /* allocate new OSPF Area object */
 811 static struct ospf_area *ospf_area_new(struct ospf *ospf,
 812                                        struct in_addr area_id)
 813 {
 814         struct ospf_area *new;
 815
 816         /* Allocate new config_network. */
 817         new = XCALLOC(MTYPE_OSPF_AREA, sizeof(struct ospf_area));
 818
 819         new->ospf = ospf;
 820
 821         new->area_id = area_id;
 822         new->area_id_fmt = OSPF_AREA_ID_FMT_DOTTEDQUAD;
 823
 824         new->external_routing = OSPF_AREA_DEFAULT;
 825         new->default_cost = 1;
 826         new->auth_type = OSPF_AUTH_NULL;
 827
 828         /* New LSDB init. */
 829         new->lsdb = ospf_lsdb_new();
 830
 831         /* Self-originated LSAs initialize. */
 832         new->router_lsa_self = NULL;
 833
 834         ospf_opaque_type10_lsa_init(new);
 835
 836         new->oiflist = list_new();
 837         new->ranges = route_table_init();
 838
 839         if (area_id.s_addr == OSPF_AREA_BACKBONE)
 840                 ospf->backbone = new;
 841
 842         return new;
 843 }
 844
 845 static void ospf_area_free(struct ospf_area *area)
 846 {
 847         struct route_node *rn;
 848         struct ospf_lsa *lsa;
 849
 850         ospf_opaque_type10_lsa_term(area);
 851
 852         /* Free LSDBs. */
 853         LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
 854                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 855         LSDB_LOOP (NETWORK_LSDB(area), rn, lsa)
 856                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 857         LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
 858                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 859         LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
 860                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 861
 862         LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
 863                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 864         LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
 865                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 866         LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
 867                 ospf_discard_from_db(area->ospf, area->lsdb, lsa);
 868
 869         ospf_lsdb_delete_all(area->lsdb);
 870         ospf_lsdb_free(area->lsdb);
 871
 872         ospf_lsa_unlock(&area->router_lsa_self);
 873
 874         route_table_finish(area->ranges);
 875         list_delete_and_null(&area->oiflist);
 876
 877         if (EXPORT_NAME(area))
 878                 free(EXPORT_NAME(area));
 879
 880         if (IMPORT_NAME(area))
 881                 free(IMPORT_NAME(area));
 882
 883         /* Cancel timer. */
 884         OSPF_TIMER_OFF(area->t_stub_router);
 885         OSPF_TIMER_OFF(area->t_opaque_lsa_self);
 886
 887         if (OSPF_IS_AREA_BACKBONE(area))
 888                 area->ospf->backbone = NULL;
 889
 890         XFREE(MTYPE_OSPF_AREA, area);
 891 }
 892
 893 void ospf_area_check_free(struct ospf *ospf, struct in_addr area_id)
 894 {
 895         struct ospf_area *area;
 896
 897         area = ospf_area_lookup_by_area_id(ospf, area_id);
 898         if (area && listcount(area->oiflist) == 0 && area->ranges->top == NULL
 899             && area->shortcut_configured == OSPF_SHORTCUT_DEFAULT
 900             && area->external_routing == OSPF_AREA_DEFAULT
 901             && area->no_summary == 0 && area->default_cost == 1
 902             && EXPORT_NAME(area) == NULL && IMPORT_NAME(area) == NULL
 903             && area->auth_type == OSPF_AUTH_NULL) {
 904                 listnode_delete(ospf->areas, area);
 905                 ospf_area_free(area);
 906         }
 907 }
 908
 909 struct ospf_area *ospf_area_get(struct ospf *ospf, struct in_addr area_id)
 910 {
 911         struct ospf_area *area;
 912
 913         area = ospf_area_lookup_by_area_id(ospf, area_id);
 914         if (!area) {
 915                 area = ospf_area_new(ospf, area_id);
 916                 listnode_add_sort(ospf->areas, area);
 917                 ospf_check_abr_status(ospf);
 918                 if (ospf->stub_router_admin_set
 919                     == OSPF_STUB_ROUTER_ADMINISTRATIVE_SET) {
 920                         SET_FLAG(area->stub_router_state,
 921                                  OSPF_AREA_ADMIN_STUB_ROUTED);
 922                 }
 923         }
 924
 925         return area;
 926 }
 927
 928 struct ospf_area *ospf_area_lookup_by_area_id(struct ospf *ospf,
 929                                               struct in_addr area_id)
 930 {
 931         struct ospf_area *area;
 932         struct listnode *node;
 933
 934         for (ALL_LIST_ELEMENTS_RO(ospf->areas, node, area))
 935                 if (IPV4_ADDR_SAME(&area->area_id, &area_id))
 936                         return area;
 937
 938         return NULL;
 939 }
 940
 941 void ospf_area_add_if(struct ospf_area *area, struct ospf_interface *oi)
 942 {
 943         listnode_add(area->oiflist, oi);
 944 }
 945
 946 void ospf_area_del_if(struct ospf_area *area, struct ospf_interface *oi)
 947 {
 948         listnode_delete(area->oiflist, oi);
 949 }
 950
 951
 952 static void add_ospf_interface(struct connected *co, struct ospf_area *area)
 953 {
 954         struct ospf_interface *oi;
 955
 956         oi = ospf_if_new(area->ospf, co->ifp, co->address);
 957         oi->connected = co;
 958
 959         oi->area = area;
 960
 961         oi->params = ospf_lookup_if_params(co->ifp, oi->address->u.prefix4);
 962         oi->output_cost = ospf_if_get_output_cost(oi);
 963
 964         /* Relate ospf interface to ospf instance. */
 965         oi->ospf = area->ospf;
 966
 967         /* update network type as interface flag */
 968         /* If network type is specified previously,
 969            skip network type setting. */
 970         oi->type = IF_DEF_PARAMS(co->ifp)->type;
 971
 972         /* Add pseudo neighbor. */
 973         ospf_nbr_self_reset(oi, oi->ospf->router_id);
 974
 975         ospf_area_add_if(oi->area, oi);
 976
 977         /*
 978          * if router_id is not configured, dont bring up
 979          * interfaces.
 980          * ospf_router_id_update() will call ospf_if_update
 981          * whenever r-id is configured instead.
 982          */
 983         if ((area->ospf->router_id.s_addr != 0) && if_is_operative(co->ifp))
 984                 ospf_if_up(oi);
 985 }
 986
 987 static void update_redistributed(struct ospf *ospf, int add_to_ospf)
 988 {
 989         struct route_node *rn;
 990         struct external_info *ei;
 991         struct ospf_external *ext;
 992
 993         if (ospf_is_type_redistributed(ospf, ZEBRA_ROUTE_CONNECT, 0)) {
 994                 ext = ospf_external_lookup(ospf, ZEBRA_ROUTE_CONNECT, 0);
 995                 if ((ext) && EXTERNAL_INFO(ext)) {
 996                         for (rn = route_top(EXTERNAL_INFO(ext)); rn;
 997                              rn = route_next(rn)) {
 998                                 ei = rn->info;
 999                                 if (ei == NULL)
1000                                         continue;
1001
1002                                 if (add_to_ospf) {
1003                                         if (ospf_external_info_find_lsa(ospf,
1004                                                                         &ei->p))
1005                                                 if (!ospf_distribute_check_connected(
1006                                                             ospf, ei))
1007                                                         ospf_external_lsa_flush(
1008                                                                 ospf, ei->type,
1009                                                                 &ei->p,
1010                                                                 ei->ifindex /*, ei->nexthop */);
1011                                 } else {
1012                                         if (!ospf_external_info_find_lsa(
1013                                                     ospf, &ei->p))
1014                                                 if (ospf_distribute_check_connected(
1015                                                             ospf, ei))
1016                                                         ospf_external_lsa_originate(
1017                                                                 ospf, ei);
1018                                 }
1019                         }
1020                 }
1021         }
1022 }
1023
1024 /* Config network statement related functions. */
1025 static struct ospf_network *ospf_network_new(struct in_addr area_id)
1026 {
1027         struct ospf_network *new;
1028         new = XCALLOC(MTYPE_OSPF_NETWORK, sizeof(struct ospf_network));
1029
1030         new->area_id = area_id;
1031         new->area_id_fmt = OSPF_AREA_ID_FMT_DOTTEDQUAD;
1032
1033         return new;
1034 }
1035
1036 static void ospf_network_free(struct ospf *ospf, struct ospf_network *network)
1037 {
1038         ospf_area_check_free(ospf, network->area_id);
1039         ospf_schedule_abr_task(ospf);
1040         XFREE(MTYPE_OSPF_NETWORK, network);
1041 }
1042
1043 int ospf_network_set(struct ospf *ospf, struct prefix_ipv4 *p,
1044                      struct in_addr area_id, int df)
1045 {
1046         struct ospf_network *network;
1047         struct ospf_area *area;
1048         struct route_node *rn;
1049
1050         rn = route_node_get(ospf->networks, (struct prefix *)p);
1051         if (rn->info) {
1052                 network = rn->info;
1053                 route_unlock_node(rn);
1054
1055                 if (IPV4_ADDR_SAME(&area_id, &network->area_id)) {
1056                         return 1;
1057                 } else {
1058                         /* There is already same network statement. */
1059                         return 0;
1060                 }
1061         }
1062
1063         rn->info = network = ospf_network_new(area_id);
1064         network->area_id_fmt = df;
1065         area = ospf_area_get(ospf, area_id);
1066         ospf_area_display_format_set(ospf, area, df);
1067
1068         /* Run network config now. */
1069         ospf_network_run((struct prefix *)p, area);
1070
1071         /* Update connected redistribute. */
1072         update_redistributed(ospf, 1); /* interfaces possibly added */
1073
1074         ospf_area_check_free(ospf, area_id);
1075
1076         return 1;
1077 }
1078
1079 int ospf_network_unset(struct ospf *ospf, struct prefix_ipv4 *p,
1080                        struct in_addr area_id)
1081 {
1082         struct route_node *rn;
1083         struct ospf_network *network;
1084         struct listnode *node, *nnode;
1085         struct ospf_interface *oi;
1086
1087         rn = route_node_lookup(ospf->networks, (struct prefix *)p);
1088         if (rn == NULL)
1089                 return 0;
1090
1091         network = rn->info;
1092         route_unlock_node(rn);
1093         if (!IPV4_ADDR_SAME(&area_id, &network->area_id))
1094                 return 0;
1095
1096         ospf_network_free(ospf, rn->info);
1097         rn->info = NULL;
1098         route_unlock_node(rn); /* initial reference */
1099
1100         /* Find interfaces that are not configured already.  */
1101         for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi)) {
1102
1103                 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
1104                         continue;
1105
1106                 ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
1107         }
1108
1109         /* Update connected redistribute. */
1110         update_redistributed(ospf, 0); /* interfaces possibly removed */
1111         ospf_area_check_free(ospf, area_id);
1112
1113         return 1;
1114 }
1115
1116 /* Ensure there's an OSPF instance, as "ip ospf area" enabled OSPF means
1117  * there might not be any 'router ospf' config.
1118  *
1119  * Otherwise, doesn't do anything different to ospf_if_update for now
1120  */
1121 void ospf_interface_area_set(struct ospf *ospf, struct interface *ifp)
1122 {
1123         if (!ospf)
1124                 return;
1125
1126         ospf_if_update(ospf, ifp);
1127         /* if_update does a update_redistributed */
1128
1129         return;
1130 }
1131
1132 void ospf_interface_area_unset(struct ospf *ospf, struct interface *ifp)
1133 {
1134         struct route_node *rn_oi;
1135
1136         if (!ospf)
1137                 return; /* Ospf not ready yet */
1138
1139         /* Find interfaces that may need to be removed. */
1140         for (rn_oi = route_top(IF_OIFS(ifp)); rn_oi;
1141              rn_oi = route_next(rn_oi)) {
1142                 struct ospf_interface *oi = NULL;
1143
1144                 if ((oi = rn_oi->info) == NULL)
1145                         continue;
1146
1147                 if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
1148                         continue;
1149
1150                 ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
1151         }
1152
1153         /* Update connected redistribute. */
1154         update_redistributed(ospf, 0); /* interfaces possibly removed */
1155 }
1156
1157 /* Check whether interface matches given network
1158  * returns: 1, true. 0, false
1159  */
1160 static int ospf_network_match_iface(const struct connected *co,
1161                                     const struct prefix *net)
1162 {
1163         /* new approach: more elegant and conceptually clean */
1164         return prefix_match_network_statement(net, CONNECTED_PREFIX(co));
1165 }
1166
1167 static void ospf_update_interface_area(struct connected *co,
1168                                        struct ospf_area *area)
1169 {
1170         struct ospf_interface *oi = ospf_if_table_lookup(co->ifp, co->address);
1171
1172         /* nothing to be done case */
1173         if (oi && oi->area == area) {
1174                 return;
1175         }
1176
1177         if (oi)
1178                 ospf_if_free(oi);
1179
1180         add_ospf_interface(co, area);
1181 }
1182
1183 /* Run OSPF for the given subnet, taking into account the following
1184  * possible sources of area configuration, in the given order of preference:
1185  *
1186  * - Whether there is interface+address specific area configuration
1187  * - Whether there is a default area for the interface
1188  * - Whether there is an area given as a parameter.
1189  * - If no specific network prefix/area is supplied, whether there's
1190  *   a matching network configured.
1191  */
1192 static void ospf_network_run_subnet(struct ospf *ospf, struct connected *co,
1193                                     struct prefix *p,
1194                                     struct ospf_area *given_area)
1195 {
1196         struct ospf_interface *oi;
1197         struct ospf_if_params *params;
1198         struct ospf_area *area = NULL;
1199         struct route_node *rn;
1200         int configed = 0;
1201
1202         if (CHECK_FLAG(co->flags, ZEBRA_IFA_SECONDARY))
1203                 return;
1204
1205         if (co->address->family != AF_INET)
1206                 return;
1207
1208         /* Try determine the appropriate area for this interface + address
1209          * Start by checking interface config
1210          */
1211         params = ospf_lookup_if_params(co->ifp, co->address->u.prefix4);
1212         if (params && OSPF_IF_PARAM_CONFIGURED(params, if_area))
1213                 area = ospf_area_get(ospf, params->if_area);
1214         else {
1215                 params = IF_DEF_PARAMS(co->ifp);
1216                 if (OSPF_IF_PARAM_CONFIGURED(params, if_area))
1217                         area = ospf_area_get(ospf, params->if_area);
1218         }
1219
1220         /* If we've found an interface and/or addr specific area, then we're
1221          * done
1222          */
1223         if (area) {
1224                 ospf_update_interface_area(co, area);
1225                 return;
1226         }
1227
1228         /* Otherwise, only remaining possibility is a matching network statement
1229          */
1230         if (p) {
1231                 assert(given_area != NULL);
1232
1233                 /* Which either was supplied as a parameter.. (e.g. cause a new
1234                  * network/area was just added)..
1235                  */
1236                 if (p->family == co->address->family
1237                     && ospf_network_match_iface(co, p))
1238                         ospf_update_interface_area(co, given_area);
1239
1240                 return;
1241         }
1242
1243         /* Else we have to search the existing network/area config to see
1244          * if any match..
1245          */
1246         for (rn = route_top(ospf->networks); rn; rn = route_next(rn))
1247                 if (rn->info != NULL && ospf_network_match_iface(co, &rn->p)) {
1248                         struct ospf_network *network =
1249                                 (struct ospf_network *)rn->info;
1250                         area = ospf_area_get(ospf, network->area_id);
1251                         ospf_update_interface_area(co, area);
1252                         configed = 1;
1253                 }
1254
1255         /* If the subnet isn't in any area, deconfigure */
1256         if (!configed && (oi = ospf_if_table_lookup(co->ifp, co->address)))
1257                 ospf_if_free(oi);
1258 }
1259
1260 static void ospf_network_run_interface(struct ospf *ospf, struct interface *ifp,
1261                                        struct prefix *p,
1262                                        struct ospf_area *given_area)
1263 {
1264         struct listnode *cnode;
1265         struct connected *co;
1266
1267         if (memcmp(ifp->name, "VLINK", 5) == 0)
1268                 return;
1269
1270         /* Network prefix without area is nonsensical */
1271         if (p)
1272                 assert(given_area != NULL);
1273
1274         /* if interface prefix is match specified prefix,
1275            then create socket and join multicast group. */
1276         for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, co))
1277                 ospf_network_run_subnet(ospf, co, p, given_area);
1278 }
1279
1280 static void ospf_network_run(struct prefix *p, struct ospf_area *area)
1281 {
1282         struct vrf *vrf = vrf_lookup_by_id(area->ospf->vrf_id);
1283         struct interface *ifp;
1284
1285         /* Schedule Router ID Update. */
1286         if (area->ospf->router_id.s_addr == 0)
1287                 ospf_router_id_update(area->ospf);
1288
1289         /* Get target interface. */
1290         FOR_ALL_INTERFACES (vrf, ifp)
1291                 ospf_network_run_interface(area->ospf, ifp, p, area);
1292 }
1293
1294 void ospf_ls_upd_queue_empty(struct ospf_interface *oi)
1295 {
1296         struct route_node *rn;
1297         struct listnode *node, *nnode;
1298         struct list *lst;
1299         struct ospf_lsa *lsa;
1300
1301         /* empty ls update queue */
1302         for (rn = route_top(oi->ls_upd_queue); rn; rn = route_next(rn))
1303                 if ((lst = (struct list *)rn->info)) {
1304                         for (ALL_LIST_ELEMENTS(lst, node, nnode, lsa))
1305                                 ospf_lsa_unlock(&lsa); /* oi->ls_upd_queue */
1306                         list_delete_and_null(&lst);
1307                         rn->info = NULL;
1308                 }
1309
1310         /* remove update event */
1311         if (oi->t_ls_upd_event) {
1312                 thread_cancel(oi->t_ls_upd_event);
1313                 oi->t_ls_upd_event = NULL;
1314         }
1315 }
1316
1317 void ospf_if_update(struct ospf *ospf, struct interface *ifp)
1318 {
1319
1320         if (!ospf)
1321                 return;
1322
1323         if (IS_DEBUG_OSPF_EVENT)
1324                 zlog_debug(
1325                         "%s: interface %s ifp->vrf_id %u ospf vrf %s vrf_id %u router_id %s",
1326                         __PRETTY_FUNCTION__, ifp->name, ifp->vrf_id,
1327                         ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id,
1328                         inet_ntoa(ospf->router_id));
1329
1330         /* OSPF must be ready. */
1331         if (!ospf_is_ready(ospf))
1332                 return;
1333
1334         ospf_network_run_interface(ospf, ifp, NULL, NULL);
1335
1336         /* Update connected redistribute. */
1337         update_redistributed(ospf, 1);
1338 }
1339
1340 void ospf_remove_vls_through_area(struct ospf *ospf, struct ospf_area *area)
1341 {
1342         struct listnode *node, *nnode;
1343         struct ospf_vl_data *vl_data;
1344
1345         for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
1346                 if (IPV4_ADDR_SAME(&vl_data->vl_area_id, &area->area_id))
1347                         ospf_vl_delete(ospf, vl_data);
1348 }
1349
1350
1351 static const struct message ospf_area_type_msg[] = {
1352         {OSPF_AREA_DEFAULT, "Default"},
1353         {OSPF_AREA_STUB, "Stub"},
1354         {OSPF_AREA_NSSA, "NSSA"},
1355         {0}};
1356
1357 static void ospf_area_type_set(struct ospf_area *area, int type)
1358 {
1359         struct listnode *node;
1360         struct ospf_interface *oi;
1361
1362         if (area->external_routing == type) {
1363                 if (IS_DEBUG_OSPF_EVENT)
1364                         zlog_debug("Area[%s]: Types are the same, ignored.",
1365                                    inet_ntoa(area->area_id));
1366                 return;
1367         }
1368
1369         area->external_routing = type;
1370
1371         if (IS_DEBUG_OSPF_EVENT)
1372                 zlog_debug("Area[%s]: Configured as %s",
1373                            inet_ntoa(area->area_id),
1374                            lookup_msg(ospf_area_type_msg, type, NULL));
1375
1376         switch (area->external_routing) {
1377         case OSPF_AREA_DEFAULT:
1378                 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1379                         if (oi->nbr_self != NULL) {
1380                                 UNSET_FLAG(oi->nbr_self->options,
1381                                            OSPF_OPTION_NP);
1382                                 SET_FLAG(oi->nbr_self->options, OSPF_OPTION_E);
1383                         }
1384                 break;
1385         case OSPF_AREA_STUB:
1386                 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1387                         if (oi->nbr_self != NULL) {
1388                                 if (IS_DEBUG_OSPF_EVENT)
1389                                         zlog_debug(
1390                                                 "setting options on %s accordingly",
1391                                                 IF_NAME(oi));
1392                                 UNSET_FLAG(oi->nbr_self->options,
1393                                            OSPF_OPTION_NP);
1394                                 UNSET_FLAG(oi->nbr_self->options,
1395                                            OSPF_OPTION_E);
1396                                 if (IS_DEBUG_OSPF_EVENT)
1397                                         zlog_debug("options set on %s: %x",
1398                                                    IF_NAME(oi), OPTIONS(oi));
1399                         }
1400                 break;
1401         case OSPF_AREA_NSSA:
1402                 for (ALL_LIST_ELEMENTS_RO(area->oiflist, node, oi))
1403                         if (oi->nbr_self != NULL) {
1404                                 zlog_debug(
1405                                         "setting nssa options on %s accordingly",
1406                                         IF_NAME(oi));
1407                                 UNSET_FLAG(oi->nbr_self->options,
1408                                            OSPF_OPTION_E);
1409                                 SET_FLAG(oi->nbr_self->options, OSPF_OPTION_NP);
1410                                 zlog_debug("options set on %s: %x", IF_NAME(oi),
1411                                            OPTIONS(oi));
1412                         }
1413                 break;
1414         default:
1415                 break;
1416         }
1417
1418         ospf_router_lsa_update_area(area);
1419         ospf_schedule_abr_task(area->ospf);
1420 }
1421
1422 int ospf_area_shortcut_set(struct ospf *ospf, struct ospf_area *area, int mode)
1423 {
1424         if (area->shortcut_configured == mode)
1425                 return 0;
1426
1427         area->shortcut_configured = mode;
1428         ospf_router_lsa_update_area(area);
1429         ospf_schedule_abr_task(ospf);
1430
1431         ospf_area_check_free(ospf, area->area_id);
1432
1433         return 1;
1434 }
1435
1436 int ospf_area_shortcut_unset(struct ospf *ospf, struct ospf_area *area)
1437 {
1438         area->shortcut_configured = OSPF_SHORTCUT_DEFAULT;
1439         ospf_router_lsa_update_area(area);
1440         ospf_area_check_free(ospf, area->area_id);
1441         ospf_schedule_abr_task(ospf);
1442
1443         return 1;
1444 }
1445
1446 static int ospf_area_vlink_count(struct ospf *ospf, struct ospf_area *area)
1447 {
1448         struct ospf_vl_data *vl;
1449         struct listnode *node;
1450         int count = 0;
1451
1452         for (ALL_LIST_ELEMENTS_RO(ospf->vlinks, node, vl))
1453                 if (IPV4_ADDR_SAME(&vl->vl_area_id, &area->area_id))
1454                         count++;
1455
1456         return count;
1457 }
1458
1459 int ospf_area_display_format_set(struct ospf *ospf, struct ospf_area *area,
1460                                  int df)
1461 {
1462         area->area_id_fmt = df;
1463
1464         return 1;
1465 }
1466
1467 int ospf_area_stub_set(struct ospf *ospf, struct in_addr area_id)
1468 {
1469         struct ospf_area *area;
1470
1471         area = ospf_area_get(ospf, area_id);
1472         if (ospf_area_vlink_count(ospf, area))
1473                 return 0;
1474
1475         if (area->external_routing != OSPF_AREA_STUB)
1476                 ospf_area_type_set(area, OSPF_AREA_STUB);
1477
1478         return 1;
1479 }
1480
1481 int ospf_area_stub_unset(struct ospf *ospf, struct in_addr area_id)
1482 {
1483         struct ospf_area *area;
1484
1485         area = ospf_area_lookup_by_area_id(ospf, area_id);
1486         if (area == NULL)
1487                 return 1;
1488
1489         if (area->external_routing == OSPF_AREA_STUB)
1490                 ospf_area_type_set(area, OSPF_AREA_DEFAULT);
1491
1492         ospf_area_check_free(ospf, area_id);
1493
1494         return 1;
1495 }
1496
1497 int ospf_area_no_summary_set(struct ospf *ospf, struct in_addr area_id)
1498 {
1499         struct ospf_area *area;
1500
1501         area = ospf_area_get(ospf, area_id);
1502         area->no_summary = 1;
1503
1504         return 1;
1505 }
1506
1507 int ospf_area_no_summary_unset(struct ospf *ospf, struct in_addr area_id)
1508 {
1509         struct ospf_area *area;
1510
1511         area = ospf_area_lookup_by_area_id(ospf, area_id);
1512         if (area == NULL)
1513                 return 0;
1514
1515         area->no_summary = 0;
1516         ospf_area_check_free(ospf, area_id);
1517
1518         return 1;
1519 }
1520
1521 int ospf_area_nssa_no_summary_set(struct ospf *ospf, struct in_addr area_id)
1522 {
1523         struct ospf_area *area;
1524
1525         area = ospf_area_get(ospf, area_id);
1526         if (ospf_area_vlink_count(ospf, area))
1527                 return 0;
1528
1529         if (area->external_routing != OSPF_AREA_NSSA) {
1530                 ospf_area_type_set(area, OSPF_AREA_NSSA);
1531                 ospf->anyNSSA++;
1532                 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1533         }
1534
1535         ospf_area_no_summary_set(ospf, area_id);
1536
1537         return 1;
1538 }
1539
1540 int ospf_area_nssa_set(struct ospf *ospf, struct in_addr area_id)
1541 {
1542         struct ospf_area *area;
1543
1544         area = ospf_area_get(ospf, area_id);
1545         if (ospf_area_vlink_count(ospf, area))
1546                 return 0;
1547
1548         if (area->external_routing != OSPF_AREA_NSSA) {
1549                 ospf_area_type_set(area, OSPF_AREA_NSSA);
1550                 ospf->anyNSSA++;
1551
1552                 /* set NSSA area defaults */
1553                 area->no_summary = 0;
1554                 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1555                 area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
1556                 area->NSSATranslatorStabilityInterval =
1557                         OSPF_NSSA_TRANS_STABLE_DEFAULT;
1558         }
1559         return 1;
1560 }
1561
1562 int ospf_area_nssa_unset(struct ospf *ospf, struct in_addr area_id, int argc)
1563 {
1564         struct ospf_area *area;
1565
1566         area = ospf_area_lookup_by_area_id(ospf, area_id);
1567         if (area == NULL)
1568                 return 0;
1569
1570         /* argc < 5 -> 'no area x nssa' */
1571         if (argc < 5 && area->external_routing == OSPF_AREA_NSSA) {
1572                 ospf->anyNSSA--;
1573                 /* set NSSA area defaults */
1574                 area->no_summary = 0;
1575                 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1576                 area->NSSATranslatorState = OSPF_NSSA_TRANSLATE_DISABLED;
1577                 area->NSSATranslatorStabilityInterval =
1578                         OSPF_NSSA_TRANS_STABLE_DEFAULT;
1579                 ospf_area_type_set(area, OSPF_AREA_DEFAULT);
1580         } else {
1581                 area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1582         }
1583
1584         ospf_area_check_free(ospf, area_id);
1585
1586         return 1;
1587 }
1588
1589 int ospf_area_nssa_translator_role_set(struct ospf *ospf,
1590                                        struct in_addr area_id, int role)
1591 {
1592         struct ospf_area *area;
1593
1594         area = ospf_area_lookup_by_area_id(ospf, area_id);
1595         if (area == NULL)
1596                 return 0;
1597
1598         area->NSSATranslatorRole = role;
1599
1600         return 1;
1601 }
1602
1603 #if 0
1604 /* XXX: unused? Leave for symmetry? */
1605 static int
1606 ospf_area_nssa_translator_role_unset (struct ospf *ospf,
1607                                       struct in_addr area_id)
1608 {
1609   struct ospf_area *area;
1610
1611   area = ospf_area_lookup_by_area_id (ospf, area_id);
1612   if (area == NULL)
1613     return 0;
1614
1615   area->NSSATranslatorRole = OSPF_NSSA_ROLE_CANDIDATE;
1616
1617   ospf_area_check_free (ospf, area_id);
1618
1619   return 1;
1620 }
1621 #endif
1622
1623 int ospf_area_export_list_set(struct ospf *ospf, struct ospf_area *area,
1624                               const char *list_name)
1625 {
1626         struct access_list *list;
1627         list = access_list_lookup(AFI_IP, list_name);
1628
1629         EXPORT_LIST(area) = list;
1630
1631         if (EXPORT_NAME(area))
1632                 free(EXPORT_NAME(area));
1633
1634         EXPORT_NAME(area) = strdup(list_name);
1635         ospf_schedule_abr_task(ospf);
1636
1637         return 1;
1638 }
1639
1640 int ospf_area_export_list_unset(struct ospf *ospf, struct ospf_area *area)
1641 {
1642
1643         EXPORT_LIST(area) = 0;
1644
1645         if (EXPORT_NAME(area))
1646                 free(EXPORT_NAME(area));
1647
1648         EXPORT_NAME(area) = NULL;
1649
1650         ospf_area_check_free(ospf, area->area_id);
1651
1652         ospf_schedule_abr_task(ospf);
1653
1654         return 1;
1655 }
1656
1657 int ospf_area_import_list_set(struct ospf *ospf, struct ospf_area *area,
1658                               const char *name)
1659 {
1660         struct access_list *list;
1661         list = access_list_lookup(AFI_IP, name);
1662
1663         IMPORT_LIST(area) = list;
1664
1665         if (IMPORT_NAME(area))
1666                 free(IMPORT_NAME(area));
1667
1668         IMPORT_NAME(area) = strdup(name);
1669         ospf_schedule_abr_task(ospf);
1670
1671         return 1;
1672 }
1673
1674 int ospf_area_import_list_unset(struct ospf *ospf, struct ospf_area *area)
1675 {
1676         IMPORT_LIST(area) = 0;
1677
1678         if (IMPORT_NAME(area))
1679                 free(IMPORT_NAME(area));
1680
1681         IMPORT_NAME(area) = NULL;
1682         ospf_area_check_free(ospf, area->area_id);
1683
1684         ospf_schedule_abr_task(ospf);
1685
1686         return 1;
1687 }
1688
1689 int ospf_timers_refresh_set(struct ospf *ospf, int interval)
1690 {
1691         int time_left;
1692
1693         if (ospf->lsa_refresh_interval == interval)
1694                 return 1;
1695
1696         time_left = ospf->lsa_refresh_interval
1697                     - (monotime(NULL) - ospf->lsa_refresher_started);
1698
1699         if (time_left > interval) {
1700                 OSPF_TIMER_OFF(ospf->t_lsa_refresher);
1701                 thread_add_timer(master, ospf_lsa_refresh_walker, ospf,
1702                                  interval, &ospf->t_lsa_refresher);
1703         }
1704         ospf->lsa_refresh_interval = interval;
1705
1706         return 1;
1707 }
1708
1709 int ospf_timers_refresh_unset(struct ospf *ospf)
1710 {
1711         int time_left;
1712
1713         time_left = ospf->lsa_refresh_interval
1714                     - (monotime(NULL) - ospf->lsa_refresher_started);
1715
1716         if (time_left > OSPF_LSA_REFRESH_INTERVAL_DEFAULT) {
1717                 OSPF_TIMER_OFF(ospf->t_lsa_refresher);
1718                 ospf->t_lsa_refresher = NULL;
1719                 thread_add_timer(master, ospf_lsa_refresh_walker, ospf,
1720                                  OSPF_LSA_REFRESH_INTERVAL_DEFAULT,
1721                                  &ospf->t_lsa_refresher);
1722         }
1723
1724         ospf->lsa_refresh_interval = OSPF_LSA_REFRESH_INTERVAL_DEFAULT;
1725
1726         return 1;
1727 }
1728
1729
1730 static struct ospf_nbr_nbma *ospf_nbr_nbma_new(void)
1731 {
1732         struct ospf_nbr_nbma *nbr_nbma;
1733
1734         nbr_nbma = XCALLOC(MTYPE_OSPF_NEIGHBOR_STATIC,
1735                            sizeof(struct ospf_nbr_nbma));
1736
1737         nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1738         nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
1739
1740         return nbr_nbma;
1741 }
1742
1743 static void ospf_nbr_nbma_free(struct ospf_nbr_nbma *nbr_nbma)
1744 {
1745         XFREE(MTYPE_OSPF_NEIGHBOR_STATIC, nbr_nbma);
1746 }
1747
1748 static void ospf_nbr_nbma_delete(struct ospf *ospf,
1749                                  struct ospf_nbr_nbma *nbr_nbma)
1750 {
1751         struct route_node *rn;
1752         struct prefix_ipv4 p;
1753
1754         p.family = AF_INET;
1755         p.prefix = nbr_nbma->addr;
1756         p.prefixlen = IPV4_MAX_BITLEN;
1757
1758         rn = route_node_lookup(ospf->nbr_nbma, (struct prefix *)&p);
1759         if (rn) {
1760                 ospf_nbr_nbma_free(rn->info);
1761                 rn->info = NULL;
1762                 route_unlock_node(rn);
1763                 route_unlock_node(rn);
1764         }
1765 }
1766
1767 static void ospf_nbr_nbma_down(struct ospf_nbr_nbma *nbr_nbma)
1768 {
1769         OSPF_TIMER_OFF(nbr_nbma->t_poll);
1770
1771         if (nbr_nbma->nbr) {
1772                 nbr_nbma->nbr->nbr_nbma = NULL;
1773                 OSPF_NSM_EVENT_EXECUTE(nbr_nbma->nbr, NSM_KillNbr);
1774         }
1775
1776         if (nbr_nbma->oi)
1777                 listnode_delete(nbr_nbma->oi->nbr_nbma, nbr_nbma);
1778 }
1779
1780 static void ospf_nbr_nbma_add(struct ospf_nbr_nbma *nbr_nbma,
1781                               struct ospf_interface *oi)
1782 {
1783         struct ospf_neighbor *nbr;
1784         struct route_node *rn;
1785         struct prefix p;
1786
1787         if (oi->type != OSPF_IFTYPE_NBMA)
1788                 return;
1789
1790         if (nbr_nbma->nbr != NULL)
1791                 return;
1792
1793         if (IPV4_ADDR_SAME(&oi->nbr_self->address.u.prefix4, &nbr_nbma->addr))
1794                 return;
1795
1796         nbr_nbma->oi = oi;
1797         listnode_add(oi->nbr_nbma, nbr_nbma);
1798
1799         /* Get neighbor information from table. */
1800         p.family = AF_INET;
1801         p.prefixlen = IPV4_MAX_BITLEN;
1802         p.u.prefix4 = nbr_nbma->addr;
1803
1804         rn = route_node_get(oi->nbrs, (struct prefix *)&p);
1805         if (rn->info) {
1806                 nbr = rn->info;
1807                 nbr->nbr_nbma = nbr_nbma;
1808                 nbr_nbma->nbr = nbr;
1809
1810                 route_unlock_node(rn);
1811         } else {
1812                 nbr = rn->info = ospf_nbr_new(oi);
1813                 nbr->state = NSM_Down;
1814                 nbr->src = nbr_nbma->addr;
1815                 nbr->nbr_nbma = nbr_nbma;
1816                 nbr->priority = nbr_nbma->priority;
1817                 nbr->address = p;
1818
1819                 nbr_nbma->nbr = nbr;
1820
1821                 OSPF_NSM_EVENT_EXECUTE(nbr, NSM_Start);
1822         }
1823 }
1824
1825 void ospf_nbr_nbma_if_update(struct ospf *ospf, struct ospf_interface *oi)
1826 {
1827         struct ospf_nbr_nbma *nbr_nbma;
1828         struct route_node *rn;
1829         struct prefix_ipv4 p;
1830
1831         if (oi->type != OSPF_IFTYPE_NBMA)
1832                 return;
1833
1834         for (rn = route_top(ospf->nbr_nbma); rn; rn = route_next(rn))
1835                 if ((nbr_nbma = rn->info))
1836                         if (nbr_nbma->oi == NULL && nbr_nbma->nbr == NULL) {
1837                                 p.family = AF_INET;
1838                                 p.prefix = nbr_nbma->addr;
1839                                 p.prefixlen = IPV4_MAX_BITLEN;
1840
1841                                 if (prefix_match(oi->address,
1842                                                  (struct prefix *)&p))
1843                                         ospf_nbr_nbma_add(nbr_nbma, oi);
1844                         }
1845 }
1846
1847 struct ospf_nbr_nbma *ospf_nbr_nbma_lookup(struct ospf *ospf,
1848                                            struct in_addr nbr_addr)
1849 {
1850         struct route_node *rn;
1851         struct prefix_ipv4 p;
1852
1853         p.family = AF_INET;
1854         p.prefix = nbr_addr;
1855         p.prefixlen = IPV4_MAX_BITLEN;
1856
1857         rn = route_node_lookup(ospf->nbr_nbma, (struct prefix *)&p);
1858         if (rn) {
1859                 route_unlock_node(rn);
1860                 return rn->info;
1861         }
1862         return NULL;
1863 }
1864
1865 struct ospf_nbr_nbma *ospf_nbr_nbma_lookup_next(struct ospf *ospf,
1866                                                 struct in_addr *addr, int first)
1867 {
1868 #if 0
1869   struct ospf_nbr_nbma *nbr_nbma;
1870   struct listnode *node;
1871 #endif
1872
1873         if (ospf == NULL)
1874                 return NULL;
1875
1876 #if 0
1877   for (ALL_LIST_ELEMENTS_RO (ospf->nbr_nbma, node, nbr_nbma))
1878     {
1879       if (first)
1880         {
1881           *addr = nbr_nbma->addr;
1882           return nbr_nbma;
1883         }
1884       else if (ntohl (nbr_nbma->addr.s_addr) > ntohl (addr->s_addr))
1885         {
1886           *addr = nbr_nbma->addr;
1887           return nbr_nbma;
1888         }
1889     }
1890 #endif
1891         return NULL;
1892 }
1893
1894 int ospf_nbr_nbma_set(struct ospf *ospf, struct in_addr nbr_addr)
1895 {
1896         struct ospf_nbr_nbma *nbr_nbma;
1897         struct ospf_interface *oi;
1898         struct prefix_ipv4 p;
1899         struct route_node *rn;
1900         struct listnode *node;
1901
1902         nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1903         if (nbr_nbma)
1904                 return 0;
1905
1906         nbr_nbma = ospf_nbr_nbma_new();
1907         nbr_nbma->addr = nbr_addr;
1908
1909         p.family = AF_INET;
1910         p.prefix = nbr_addr;
1911         p.prefixlen = IPV4_MAX_BITLEN;
1912
1913         rn = route_node_get(ospf->nbr_nbma, (struct prefix *)&p);
1914         if (rn->info)
1915                 route_unlock_node(rn);
1916         rn->info = nbr_nbma;
1917
1918         for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
1919                 if (oi->type == OSPF_IFTYPE_NBMA)
1920                         if (prefix_match(oi->address, (struct prefix *)&p)) {
1921                                 ospf_nbr_nbma_add(nbr_nbma, oi);
1922                                 break;
1923                         }
1924         }
1925
1926         return 1;
1927 }
1928
1929 int ospf_nbr_nbma_unset(struct ospf *ospf, struct in_addr nbr_addr)
1930 {
1931         struct ospf_nbr_nbma *nbr_nbma;
1932
1933         nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1934         if (nbr_nbma == NULL)
1935                 return 0;
1936
1937         ospf_nbr_nbma_down(nbr_nbma);
1938         ospf_nbr_nbma_delete(ospf, nbr_nbma);
1939
1940         return 1;
1941 }
1942
1943 int ospf_nbr_nbma_priority_set(struct ospf *ospf, struct in_addr nbr_addr,
1944                                uint8_t priority)
1945 {
1946         struct ospf_nbr_nbma *nbr_nbma;
1947
1948         nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1949         if (nbr_nbma == NULL)
1950                 return 0;
1951
1952         if (nbr_nbma->priority != priority)
1953                 nbr_nbma->priority = priority;
1954
1955         return 1;
1956 }
1957
1958 int ospf_nbr_nbma_priority_unset(struct ospf *ospf, struct in_addr nbr_addr)
1959 {
1960         struct ospf_nbr_nbma *nbr_nbma;
1961
1962         nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1963         if (nbr_nbma == NULL)
1964                 return 0;
1965
1966         if (nbr_nbma != OSPF_NEIGHBOR_PRIORITY_DEFAULT)
1967                 nbr_nbma->priority = OSPF_NEIGHBOR_PRIORITY_DEFAULT;
1968
1969         return 1;
1970 }
1971
1972 int ospf_nbr_nbma_poll_interval_set(struct ospf *ospf, struct in_addr nbr_addr,
1973                                     unsigned int interval)
1974 {
1975         struct ospf_nbr_nbma *nbr_nbma;
1976
1977         nbr_nbma = ospf_nbr_nbma_lookup(ospf, nbr_addr);
1978         if (nbr_nbma == NULL)
1979                 return 0;
1980
1981         if (nbr_nbma->v_poll != interval) {
1982                 nbr_nbma->v_poll = interval;
1983                 if (nbr_nbma->oi && ospf_if_is_up(nbr_nbma->oi)) {
1984                         OSPF_TIMER_OFF(nbr_nbma->t_poll);
1985                         OSPF_POLL_TIMER_ON(nbr_nbma->t_poll, ospf_poll_timer,
1986                                            nbr_nbma->v_poll);
1987                 }
1988         }
1989
1990         return 1;
1991 }
1992
1993 int ospf_nbr_nbma_poll_interval_unset(struct ospf *ospf, struct in_addr addr)
1994 {
1995         struct ospf_nbr_nbma *nbr_nbma;
1996
1997         nbr_nbma = ospf_nbr_nbma_lookup(ospf, addr);
1998         if (nbr_nbma == NULL)
1999                 return 0;
2000
2001         if (nbr_nbma->v_poll != OSPF_POLL_INTERVAL_DEFAULT)
2002                 nbr_nbma->v_poll = OSPF_POLL_INTERVAL_DEFAULT;
2003
2004         return 1;
2005 }
2006
2007 void ospf_master_init(struct thread_master *master)
2008 {
2009         memset(&ospf_master, 0, sizeof(struct ospf_master));
2010
2011         om = &ospf_master;
2012         om->ospf = list_new();
2013         om->master = master;
2014 }
2015
2016 /* Link OSPF instance to VRF. */
2017 void ospf_vrf_link(struct ospf *ospf, struct vrf *vrf)
2018 {
2019         ospf->vrf_id = vrf->vrf_id;
2020         if (vrf->info != (void *)ospf)
2021                 vrf->info = (void *)ospf;
2022 }
2023
2024 /* Unlink OSPF instance from VRF. */
2025 void ospf_vrf_unlink(struct ospf *ospf, struct vrf *vrf)
2026 {
2027         if (vrf->info == (void *)ospf)
2028                 vrf->info = NULL;
2029         ospf->vrf_id = VRF_UNKNOWN;
2030 }
2031
2032 /* This is hook function for vrf create called as part of vrf_init */
2033 static int ospf_vrf_new(struct vrf *vrf)
2034 {
2035         if (IS_DEBUG_OSPF_EVENT)
2036                 zlog_debug("%s: VRF Created: %s(%u)", __PRETTY_FUNCTION__,
2037                            vrf->name, vrf->vrf_id);
2038
2039         return 0;
2040 }
2041
2042 /* This is hook function for vrf delete call as part of vrf_init */
2043 static int ospf_vrf_delete(struct vrf *vrf)
2044 {
2045         if (IS_DEBUG_OSPF_EVENT)
2046                 zlog_debug("%s: VRF Deletion: %s(%u)", __PRETTY_FUNCTION__,
2047                            vrf->name, vrf->vrf_id);
2048
2049         return 0;
2050 }
2051
2052 static void ospf_set_redist_vrf_bitmaps(struct ospf *ospf)
2053 {
2054         int type;
2055         struct list *red_list;
2056
2057         for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
2058                 red_list = ospf->redist[type];
2059                 if (!red_list)
2060                         continue;
2061                 if (IS_DEBUG_OSPF_EVENT)
2062                         zlog_debug(
2063                                 "%s: setting redist vrf %d bitmap for type %d",
2064                                 __func__, ospf->vrf_id, type);
2065                 vrf_bitmap_set(zclient->redist[AFI_IP][type], ospf->vrf_id);
2066         }
2067 }
2068
2069 /* Enable OSPF VRF instance */
2070 static int ospf_vrf_enable(struct vrf *vrf)
2071 {
2072         struct ospf *ospf = NULL;
2073         vrf_id_t old_vrf_id;
2074         int ret = 0;
2075
2076         if (IS_DEBUG_OSPF_EVENT)
2077                 zlog_debug("%s: VRF %s id %u enabled", __PRETTY_FUNCTION__,
2078                            vrf->name, vrf->vrf_id);
2079
2080         ospf = ospf_lookup_by_name(vrf->name);
2081         if (ospf) {
2082                 if (ospf->name && strmatch(vrf->name, VRF_DEFAULT_NAME)) {
2083                         XFREE(MTYPE_OSPF_TOP, ospf->name);
2084                         ospf->name = NULL;
2085                 }
2086                 old_vrf_id = ospf->vrf_id;
2087                 /* We have instance configured, link to VRF and make it "up". */
2088                 ospf_vrf_link(ospf, vrf);
2089                 if (IS_DEBUG_OSPF_EVENT)
2090                         zlog_debug(
2091                                 "%s: ospf linked to vrf %s vrf_id %u (old id %u)",
2092                                 __PRETTY_FUNCTION__, vrf->name, ospf->vrf_id,
2093                                 old_vrf_id);
2094
2095                 if (old_vrf_id != ospf->vrf_id) {
2096                         frr_elevate_privs(&ospfd_privs) {
2097                                 /* stop zebra redist to us for old vrf */
2098                                 zclient_send_dereg_requests(zclient,
2099                                                             old_vrf_id);
2100
2101                                 ospf_set_redist_vrf_bitmaps(ospf);
2102
2103                                 /* start zebra redist to us for new vrf */
2104                                 ospf_zebra_vrf_register(ospf);
2105
2106                                 ret = ospf_sock_init(ospf);
2107                         }
2108                         if (ret < 0 || ospf->fd <= 0)
2109                                 return 0;
2110                         thread_add_read(master, ospf_read, ospf, ospf->fd,
2111                                         &ospf->t_read);
2112                         ospf->oi_running = 1;
2113                         ospf_router_id_update(ospf);
2114                 }
2115         }
2116
2117         return 0;
2118 }
2119
2120 /* Disable OSPF VRF instance */
2121 static int ospf_vrf_disable(struct vrf *vrf)
2122 {
2123         struct ospf *ospf = NULL;
2124         vrf_id_t old_vrf_id = VRF_UNKNOWN;
2125
2126         if (vrf->vrf_id == VRF_DEFAULT)
2127                 return 0;
2128
2129         if (IS_DEBUG_OSPF_EVENT)
2130                 zlog_debug("%s: VRF %s id %d disabled.", __PRETTY_FUNCTION__,
2131                            vrf->name, vrf->vrf_id);
2132
2133         ospf = ospf_lookup_by_name(vrf->name);
2134         if (ospf) {
2135                 old_vrf_id = ospf->vrf_id;
2136
2137                 /* We have instance configured, unlink
2138                  * from VRF and make it "down".
2139                  */
2140                 ospf_vrf_unlink(ospf, vrf);
2141                 ospf->oi_running = 0;
2142                 if (IS_DEBUG_OSPF_EVENT)
2143                         zlog_debug("%s: ospf old_vrf_id %d unlinked",
2144                                    __PRETTY_FUNCTION__, old_vrf_id);
2145                 thread_cancel(ospf->t_read);
2146                 close(ospf->fd);
2147                 ospf->fd = -1;
2148         }
2149
2150         /* Note: This is a callback, the VRF will be deleted by the caller. */
2151         return 0;
2152 }
2153
2154 void ospf_vrf_init(void)
2155 {
2156         vrf_init(ospf_vrf_new, ospf_vrf_enable, ospf_vrf_disable,
2157                  ospf_vrf_delete, NULL);
2158 }
2159
2160 void ospf_vrf_terminate(void)
2161 {
2162         vrf_terminate();
2163 }
2164
2165 const char *ospf_vrf_id_to_name(vrf_id_t vrf_id)
2166 {
2167         struct vrf *vrf = vrf_lookup_by_id(vrf_id);
2168
2169         return vrf ? vrf->name : "NIL";
2170 }