ospfd/ospf_interface.c

   1 /*
   2  * OSPF Interface functions.
   3  * Copyright (C) 1999, 2000 Toshiaki Takada
   4  *
   5  * This file is part of GNU Zebra.
   6  *
   7  * GNU Zebra is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation; either version 2, or (at your
  10  * option) any later version.
  11  *
  12  * GNU Zebra is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with GNU Zebra; see the file COPYING.  If not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <zebra.h>
  24
  25 #include "thread.h"
  26 #include "linklist.h"
  27 #include "prefix.h"
  28 #include "if.h"
  29 #include "table.h"
  30 #include "memory.h"
  31 #include "command.h"
  32 #include "stream.h"
  33 #include "log.h"
  34
  35 #include "ospfd/ospfd.h"
  36 #include "ospfd/ospf_spf.h"
  37 #include "ospfd/ospf_interface.h"
  38 #include "ospfd/ospf_ism.h"
  39 #include "ospfd/ospf_asbr.h"
  40 #include "ospfd/ospf_lsa.h"
  41 #include "ospfd/ospf_lsdb.h"
  42 #include "ospfd/ospf_neighbor.h"
  43 #include "ospfd/ospf_nsm.h"
  44 #include "ospfd/ospf_packet.h"
  45 #include "ospfd/ospf_abr.h"
  46 #include "ospfd/ospf_network.h"
  47 #include "ospfd/ospf_dump.h"
  48 #ifdef HAVE_SNMP
  49 #include "ospfd/ospf_snmp.h"
  50 #endif /* HAVE_SNMP */
  51
  52 \f
  53 int
  54 ospf_if_get_output_cost (struct ospf_interface *oi)
  55 {
  56   /* If all else fails, use default OSPF cost */
  57   u_int32_t cost;
  58   u_int32_t bw, refbw;
  59
  60   bw = oi->ifp->bandwidth ? oi->ifp->bandwidth : OSPF_DEFAULT_BANDWIDTH;
  61   refbw = oi->ospf->ref_bandwidth;
  62
  63   /* A specifed ip ospf cost overrides a calculated one. */
  64   if (OSPF_IF_PARAM_CONFIGURED (IF_DEF_PARAMS (oi->ifp), output_cost_cmd) ||
  65       OSPF_IF_PARAM_CONFIGURED (oi->params, output_cost_cmd))
  66     cost = OSPF_IF_PARAM (oi, output_cost_cmd);
  67   /* See if a cost can be calculated from the zebra processes
  68      interface bandwidth field. */
  69   else
  70     {
  71       cost = (u_int32_t) ((double)refbw / (double)bw + (double)0.5);
  72       if (cost < 1)
  73         cost = 1;
  74       else if (cost > 65535)
  75         cost = 65535;
  76     }
  77
  78   return cost;
  79 }
  80
  81 void
  82 ospf_if_recalculate_output_cost (struct interface *ifp)
  83 {
  84   u_int32_t newcost;
  85   struct route_node *rn;
  86
  87   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
  88     {
  89       struct ospf_interface *oi;
  90
  91       if ( (oi = rn->info) == NULL)
  92         continue;
  93
  94       newcost = ospf_if_get_output_cost (oi);
  95
  96       /* Is actual output cost changed? */
  97       if (oi->output_cost != newcost)
  98         {
  99           oi->output_cost = newcost;
 100           ospf_router_lsa_timer_add (oi->area);
 101         }
 102     }
 103 }
 104
 105 /* Simulate down/up on the interface.  This is needed, for example, when
 106    the MTU changes. */
 107 void
 108 ospf_if_reset(struct interface *ifp)
 109 {
 110   struct route_node *rn;
 111
 112   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 113     {
 114       struct ospf_interface *oi;
 115
 116       if ( (oi = rn->info) == NULL)
 117         continue;
 118
 119       ospf_if_down(oi);
 120       ospf_if_up(oi);
 121     }
 122 }
 123
 124 void
 125 ospf_if_reset_variables (struct ospf_interface *oi)
 126 {
 127   /* Set default values. */
 128   /* don't clear this flag.  oi->flag = OSPF_IF_DISABLE; */
 129
 130   if (oi->vl_data)
 131     oi->type = OSPF_IFTYPE_VIRTUALLINK;
 132   else
 133   /* preserve network-type */
 134   if (oi->type != OSPF_IFTYPE_NBMA)
 135     oi->type = OSPF_IFTYPE_BROADCAST;
 136
 137   oi->state = ISM_Down;
 138
 139   oi->crypt_seqnum = 0;
 140
 141   /* This must be short, (less than RxmtInterval)
 142      - RFC 2328 Section 13.5 para 3.  Set to 1 second to avoid Acks being
 143        held back for too long - MAG */
 144   oi->v_ls_ack = 1;
 145 }
 146
 147 /* lookup oi for specified prefix/ifp */
 148 struct ospf_interface *
 149 ospf_if_table_lookup (struct interface *ifp, struct prefix *prefix)
 150 {
 151   struct prefix p;
 152   struct route_node *rn;
 153   struct ospf_interface *rninfo = NULL;
 154
 155   p = *prefix;
 156   p.prefixlen = IPV4_MAX_PREFIXLEN;
 157
 158   /* route_node_get implicitely locks */
 159   if ((rn = route_node_lookup (IF_OIFS (ifp), &p)))
 160     {
 161       rninfo = (struct ospf_interface *) rn->info;
 162       route_unlock_node (rn);
 163     }
 164
 165   return rninfo;
 166 }
 167
 168 static void
 169 ospf_add_to_if (struct interface *ifp, struct ospf_interface *oi)
 170 {
 171   struct route_node *rn;
 172   struct prefix p;
 173
 174   p = *oi->address;
 175   p.prefixlen = IPV4_MAX_PREFIXLEN;
 176
 177   rn = route_node_get (IF_OIFS (ifp), &p);
 178   /* rn->info should either be NULL or equal to this oi
 179    * as route_node_get may return an existing node
 180    */
 181   assert (!rn->info || rn->info == oi);
 182   rn->info = oi;
 183 }
 184
 185 static void
 186 ospf_delete_from_if (struct interface *ifp, struct ospf_interface *oi)
 187 {
 188   struct route_node *rn;
 189   struct prefix p;
 190
 191   p = *oi->address;
 192   p.prefixlen = IPV4_MAX_PREFIXLEN;
 193
 194   rn = route_node_lookup (IF_OIFS (oi->ifp), &p);
 195   assert (rn);
 196   assert (rn->info);
 197   rn->info = NULL;
 198   route_unlock_node (rn);
 199   route_unlock_node (rn);
 200 }
 201
 202 struct ospf_interface *
 203 ospf_if_new (struct ospf *ospf, struct interface *ifp, struct prefix *p)
 204 {
 205   struct ospf_interface *oi;
 206
 207   if ((oi = ospf_if_table_lookup (ifp, p)) == NULL)
 208     {
 209       oi = XCALLOC (MTYPE_OSPF_IF, sizeof (struct ospf_interface));
 210       memset (oi, 0, sizeof (struct ospf_interface));
 211     }
 212   else
 213     return oi;
 214
 215   /* Set zebra interface pointer. */
 216   oi->ifp = ifp;
 217   oi->address = p;
 218
 219   ospf_add_to_if (ifp, oi);
 220   listnode_add (ospf->oiflist, oi);
 221
 222   /* Clear self-originated network-LSA. */
 223   oi->network_lsa_self = NULL;
 224
 225   /* Initialize neighbor list. */
 226   oi->nbrs = route_table_init ();
 227
 228   /* Initialize static neighbor list. */
 229   oi->nbr_nbma = list_new ();
 230
 231   /* Initialize Link State Acknowledgment list. */
 232   oi->ls_ack = list_new ();
 233   oi->ls_ack_direct.ls_ack = list_new ();
 234
 235   /* Set default values. */
 236   ospf_if_reset_variables (oi);
 237
 238   /* Add pseudo neighbor. */
 239   oi->nbr_self = ospf_nbr_new (oi);
 240
 241   oi->ls_upd_queue = route_table_init ();
 242   oi->t_ls_upd_event = NULL;
 243   oi->t_ls_ack_direct = NULL;
 244
 245   oi->crypt_seqnum = time (NULL);
 246
 247 #ifdef HAVE_OPAQUE_LSA
 248   ospf_opaque_type9_lsa_init (oi);
 249 #endif /* HAVE_OPAQUE_LSA */
 250
 251   oi->ospf = ospf;
 252
 253   return oi;
 254 }
 255
 256 /* Restore an interface to its pre UP state
 257    Used from ism_interface_down only */
 258 void
 259 ospf_if_cleanup (struct ospf_interface *oi)
 260 {
 261   struct route_node *rn;
 262   struct listnode *node, *nnode;
 263   struct ospf_neighbor *nbr;
 264   struct ospf_nbr_nbma *nbr_nbma;
 265   struct ospf_lsa *lsa;
 266
 267   /* oi->nbrs and oi->nbr_nbma should be deleted on InterfaceDown event */
 268   /* delete all static neighbors attached to this interface */
 269   for (ALL_LIST_ELEMENTS (oi->nbr_nbma, node, nnode, nbr_nbma))
 270     {
 271       OSPF_POLL_TIMER_OFF (nbr_nbma->t_poll);
 272
 273       if (nbr_nbma->nbr)
 274         {
 275           nbr_nbma->nbr->nbr_nbma = NULL;
 276           nbr_nbma->nbr = NULL;
 277         }
 278
 279       nbr_nbma->oi = NULL;
 280
 281       listnode_delete (oi->nbr_nbma, nbr_nbma);
 282     }
 283
 284   /* send Neighbor event KillNbr to all associated neighbors. */
 285   for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
 286     if ((nbr = rn->info) != NULL)
 287       if (nbr != oi->nbr_self)
 288         OSPF_NSM_EVENT_EXECUTE (nbr, NSM_KillNbr);
 289
 290   /* Cleanup Link State Acknowlegdment list. */
 291   for (ALL_LIST_ELEMENTS (oi->ls_ack, node, nnode, lsa))
 292     ospf_lsa_unlock (&lsa); /* oi->ls_ack */
 293   list_delete_all_node (oi->ls_ack);
 294
 295   oi->crypt_seqnum = 0;
 296
 297   /* Empty link state update queue */
 298   ospf_ls_upd_queue_empty (oi);
 299
 300   /* Reset pseudo neighbor. */
 301   ospf_nbr_delete (oi->nbr_self);
 302   oi->nbr_self = ospf_nbr_new (oi);
 303   ospf_nbr_add_self (oi);
 304
 305   ospf_lsa_unlock (&oi->network_lsa_self);
 306   oi->network_lsa_self = NULL;
 307   OSPF_TIMER_OFF (oi->t_network_lsa_self);
 308 }
 309
 310 void
 311 ospf_if_free (struct ospf_interface *oi)
 312 {
 313   ospf_if_down (oi);
 314
 315   assert (oi->state == ISM_Down);
 316
 317 #ifdef HAVE_OPAQUE_LSA
 318   ospf_opaque_type9_lsa_term (oi);
 319 #endif /* HAVE_OPAQUE_LSA */
 320
 321   /* Free Pseudo Neighbour */
 322   ospf_nbr_delete (oi->nbr_self);
 323
 324   route_table_finish (oi->nbrs);
 325   route_table_finish (oi->ls_upd_queue);
 326
 327   /* Free any lists that should be freed */
 328   list_free (oi->nbr_nbma);
 329
 330   list_free (oi->ls_ack);
 331   list_free (oi->ls_ack_direct.ls_ack);
 332
 333   ospf_delete_from_if (oi->ifp, oi);
 334
 335   listnode_delete (oi->ospf->oiflist, oi);
 336   listnode_delete (oi->area->oiflist, oi);
 337
 338   memset (oi, 0, sizeof (*oi));
 339   XFREE (MTYPE_OSPF_IF, oi);
 340 }
 341
 342 \f
 343 /*
 344 *  check if interface with given address is configured and
 345 *  return it if yes.  special treatment for PtP networks.
 346 */
 347 struct ospf_interface *
 348 ospf_if_is_configured (struct ospf *ospf, struct in_addr *address)
 349 {
 350   struct listnode *node, *nnode;
 351   struct ospf_interface *oi;
 352   struct prefix_ipv4 addr;
 353
 354   addr.family = AF_INET;
 355   addr.prefix = *address;
 356   addr.prefixlen = IPV4_MAX_PREFIXLEN;
 357
 358   for (ALL_LIST_ELEMENTS (ospf->oiflist, node, nnode, oi))
 359     if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
 360       {
 361         if (oi->type == OSPF_IFTYPE_POINTOPOINT)
 362           {
 363             /* special leniency: match if addr is anywhere on peer subnet */
 364             if (prefix_match(CONNECTED_PREFIX(oi->connected),
 365                              (struct prefix *)&addr))
 366               return oi;
 367           }
 368         else
 369           {
 370             if (IPV4_ADDR_SAME (address, &oi->address->u.prefix4))
 371               return oi;
 372           }
 373       }
 374   return NULL;
 375 }
 376
 377 int
 378 ospf_if_is_up (struct ospf_interface *oi)
 379 {
 380   return if_is_up (oi->ifp);
 381 }
 382
 383 struct ospf_interface *
 384 ospf_if_exists (struct ospf_interface *oic)
 385 {
 386   struct listnode *node;
 387   struct ospf *ospf;
 388   struct ospf_interface *oi;
 389
 390   if ((ospf = ospf_lookup ()) == NULL)
 391     return NULL;
 392
 393   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 394     if (oi == oic)
 395       return oi;
 396
 397   return NULL;
 398 }
 399
 400 struct ospf_interface *
 401 ospf_if_lookup_by_local_addr (struct ospf *ospf,
 402                               struct interface *ifp, struct in_addr address)
 403 {
 404   struct listnode *node;
 405   struct ospf_interface *oi;
 406
 407   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 408     if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
 409       {
 410         if (ifp && oi->ifp != ifp)
 411           continue;
 412
 413         if (IPV4_ADDR_SAME (&address, &oi->address->u.prefix4))
 414           return oi;
 415       }
 416
 417   return NULL;
 418 }
 419
 420 struct ospf_interface *
 421 ospf_if_lookup_by_prefix (struct ospf *ospf, struct prefix_ipv4 *p)
 422 {
 423   struct listnode *node;
 424   struct ospf_interface *oi;
 425
 426   /* Check each Interface. */
 427   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 428     {
 429       if (oi->type != OSPF_IFTYPE_VIRTUALLINK)
 430         {
 431           struct prefix ptmp;
 432
 433           prefix_copy (&ptmp, CONNECTED_PREFIX(oi->connected));
 434           apply_mask (&ptmp);
 435           if (prefix_same (&ptmp, (struct prefix *) p))
 436             return oi;
 437         }
 438     }
 439   return NULL;
 440 }
 441
 442 /* determine receiving interface by ifp and source address */
 443 struct ospf_interface *
 444 ospf_if_lookup_recv_if (struct ospf *ospf, struct in_addr src,
 445                         struct interface *ifp)
 446 {
 447   struct route_node *rn;
 448   struct prefix_ipv4 addr;
 449   struct ospf_interface *oi, *match;
 450
 451   addr.family = AF_INET;
 452   addr.prefix = src;
 453   addr.prefixlen = IPV4_MAX_BITLEN;
 454
 455   match = NULL;
 456
 457   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 458     {
 459       oi = rn->info;
 460
 461       if (!oi) /* oi can be NULL for PtP aliases */
 462         continue;
 463
 464       if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
 465         continue;
 466
 467       if (if_is_loopback (oi->ifp))
 468         continue;
 469
 470       if (prefix_match (CONNECTED_PREFIX(oi->connected),
 471                         (struct prefix *) &addr))
 472         {
 473           if ( (match == NULL) ||
 474                (match->address->prefixlen < oi->address->prefixlen)
 475              )
 476             match = oi;
 477         }
 478     }
 479
 480   return match;
 481 }
 482 \f
 483 void
 484 ospf_if_stream_set (struct ospf_interface *oi)
 485 {
 486   /* set output fifo queue. */
 487   if (oi->obuf == NULL)
 488     oi->obuf = ospf_fifo_new ();
 489 }
 490
 491 void
 492 ospf_if_stream_unset (struct ospf_interface *oi)
 493 {
 494   struct ospf *ospf = oi->ospf;
 495
 496   if (oi->obuf)
 497     {
 498      ospf_fifo_free (oi->obuf);
 499      oi->obuf = NULL;
 500
 501      if (oi->on_write_q)
 502        {
 503          listnode_delete (ospf->oi_write_q, oi);
 504          if (list_isempty(ospf->oi_write_q))
 505            OSPF_TIMER_OFF (ospf->t_write);
 506          oi->on_write_q = 0;
 507        }
 508     }
 509 }
 510
 511 \f
 512 static struct ospf_if_params *
 513 ospf_new_if_params (void)
 514 {
 515   struct ospf_if_params *oip;
 516
 517   oip = XCALLOC (MTYPE_OSPF_IF_PARAMS, sizeof (struct ospf_if_params));
 518
 519   if (!oip)
 520     return NULL;
 521
 522   UNSET_IF_PARAM (oip, output_cost_cmd);
 523   UNSET_IF_PARAM (oip, transmit_delay);
 524   UNSET_IF_PARAM (oip, retransmit_interval);
 525   UNSET_IF_PARAM (oip, passive_interface);
 526   UNSET_IF_PARAM (oip, v_hello);
 527   UNSET_IF_PARAM (oip, fast_hello);
 528   UNSET_IF_PARAM (oip, v_wait);
 529   UNSET_IF_PARAM (oip, priority);
 530   UNSET_IF_PARAM (oip, type);
 531   UNSET_IF_PARAM (oip, auth_simple);
 532   UNSET_IF_PARAM (oip, auth_crypt);
 533   UNSET_IF_PARAM (oip, auth_type);
 534
 535   oip->auth_crypt = list_new ();
 536
 537   return oip;
 538 }
 539
 540 void
 541 ospf_del_if_params (struct ospf_if_params *oip)
 542 {
 543   list_delete (oip->auth_crypt);
 544   XFREE (MTYPE_OSPF_IF_PARAMS, oip);
 545 }
 546
 547 void
 548 ospf_free_if_params (struct interface *ifp, struct in_addr addr)
 549 {
 550   struct ospf_if_params *oip;
 551   struct prefix_ipv4 p;
 552   struct route_node *rn;
 553
 554   p.family = AF_INET;
 555   p.prefixlen = IPV4_MAX_PREFIXLEN;
 556   p.prefix = addr;
 557   rn = route_node_lookup (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 558   if (!rn || !rn->info)
 559     return;
 560
 561   oip = rn->info;
 562   route_unlock_node (rn);
 563
 564   if (!OSPF_IF_PARAM_CONFIGURED (oip, output_cost_cmd) &&
 565       !OSPF_IF_PARAM_CONFIGURED (oip, transmit_delay) &&
 566       !OSPF_IF_PARAM_CONFIGURED (oip, retransmit_interval) &&
 567       !OSPF_IF_PARAM_CONFIGURED (oip, passive_interface) &&
 568       !OSPF_IF_PARAM_CONFIGURED (oip, v_hello) &&
 569       !OSPF_IF_PARAM_CONFIGURED (oip, fast_hello) &&
 570       !OSPF_IF_PARAM_CONFIGURED (oip, v_wait) &&
 571       !OSPF_IF_PARAM_CONFIGURED (oip, priority) &&
 572       !OSPF_IF_PARAM_CONFIGURED (oip, type) &&
 573       !OSPF_IF_PARAM_CONFIGURED (oip, auth_simple) &&
 574       !OSPF_IF_PARAM_CONFIGURED (oip, auth_type) &&
 575       listcount (oip->auth_crypt) == 0)
 576     {
 577       ospf_del_if_params (oip);
 578       rn->info = NULL;
 579       route_unlock_node (rn);
 580     }
 581 }
 582
 583 struct ospf_if_params *
 584 ospf_lookup_if_params (struct interface *ifp, struct in_addr addr)
 585 {
 586   struct prefix_ipv4 p;
 587   struct route_node *rn;
 588
 589   p.family = AF_INET;
 590   p.prefixlen = IPV4_MAX_PREFIXLEN;
 591   p.prefix = addr;
 592
 593   rn = route_node_lookup (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 594
 595   if (rn)
 596     {
 597       route_unlock_node (rn);
 598       return rn->info;
 599     }
 600
 601   return NULL;
 602 }
 603
 604 struct ospf_if_params *
 605 ospf_get_if_params (struct interface *ifp, struct in_addr addr)
 606 {
 607   struct prefix_ipv4 p;
 608   struct route_node *rn;
 609
 610   p.family = AF_INET;
 611   p.prefixlen = IPV4_MAX_PREFIXLEN;
 612   p.prefix = addr;
 613
 614   rn = route_node_get (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 615
 616   if (rn->info == NULL)
 617     rn->info = ospf_new_if_params ();
 618   else
 619     route_unlock_node (rn);
 620
 621   return rn->info;
 622 }
 623
 624 void
 625 ospf_if_update_params (struct interface *ifp, struct in_addr addr)
 626 {
 627   struct route_node *rn;
 628   struct ospf_interface *oi;
 629
 630   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 631     {
 632       if ((oi = rn->info) == NULL)
 633         continue;
 634
 635       if (IPV4_ADDR_SAME (&oi->address->u.prefix4, &addr))
 636         oi->params = ospf_lookup_if_params (ifp, oi->address->u.prefix4);
 637     }
 638 }
 639
 640 int
 641 ospf_if_new_hook (struct interface *ifp)
 642 {
 643   int rc = 0;
 644
 645   ifp->info = XCALLOC (MTYPE_OSPF_IF_INFO, sizeof (struct ospf_if_info));
 646
 647   IF_OIFS (ifp) = route_table_init ();
 648   IF_OIFS_PARAMS (ifp) = route_table_init ();
 649
 650   IF_DEF_PARAMS (ifp) = ospf_new_if_params ();
 651
 652   SET_IF_PARAM (IF_DEF_PARAMS (ifp), transmit_delay);
 653   IF_DEF_PARAMS (ifp)->transmit_delay = OSPF_TRANSMIT_DELAY_DEFAULT;
 654
 655   SET_IF_PARAM (IF_DEF_PARAMS (ifp), retransmit_interval);
 656   IF_DEF_PARAMS (ifp)->retransmit_interval = OSPF_RETRANSMIT_INTERVAL_DEFAULT;
 657
 658   SET_IF_PARAM (IF_DEF_PARAMS (ifp), priority);
 659   IF_DEF_PARAMS (ifp)->priority = OSPF_ROUTER_PRIORITY_DEFAULT;
 660
 661   IF_DEF_PARAMS (ifp)->mtu_ignore = OSPF_MTU_IGNORE_DEFAULT;
 662
 663   SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_hello);
 664   IF_DEF_PARAMS (ifp)->v_hello = OSPF_HELLO_INTERVAL_DEFAULT;
 665
 666   SET_IF_PARAM (IF_DEF_PARAMS (ifp), fast_hello);
 667   IF_DEF_PARAMS (ifp)->fast_hello = OSPF_FAST_HELLO_DEFAULT;
 668
 669   SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_wait);
 670   IF_DEF_PARAMS (ifp)->v_wait = OSPF_ROUTER_DEAD_INTERVAL_DEFAULT;
 671
 672   SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_simple);
 673   memset (IF_DEF_PARAMS (ifp)->auth_simple, 0, OSPF_AUTH_SIMPLE_SIZE);
 674
 675   SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_type);
 676   IF_DEF_PARAMS (ifp)->auth_type = OSPF_AUTH_NOTSET;
 677
 678 #ifdef HAVE_OPAQUE_LSA
 679   rc = ospf_opaque_new_if (ifp);
 680 #endif /* HAVE_OPAQUE_LSA */
 681   return rc;
 682 }
 683
 684 static int
 685 ospf_if_delete_hook (struct interface *ifp)
 686 {
 687   int rc = 0;
 688   struct route_node *rn;
 689 #ifdef HAVE_OPAQUE_LSA
 690   rc = ospf_opaque_del_if (ifp);
 691 #endif /* HAVE_OPAQUE_LSA */
 692
 693   route_table_finish (IF_OIFS (ifp));
 694
 695   for (rn = route_top (IF_OIFS_PARAMS (ifp)); rn; rn = route_next (rn))
 696     if (rn->info)
 697       ospf_del_if_params (rn->info);
 698   route_table_finish (IF_OIFS_PARAMS (ifp));
 699
 700   ospf_del_if_params ((struct ospf_if_params *) IF_DEF_PARAMS (ifp));
 701   XFREE (MTYPE_OSPF_IF_INFO, ifp->info);
 702   ifp->info = NULL;
 703
 704   return rc;
 705 }
 706
 707 int
 708 ospf_if_is_enable (struct ospf_interface *oi)
 709 {
 710   if (!if_is_loopback (oi->ifp))
 711     if (if_is_up (oi->ifp))
 712         return 1;
 713
 714   return 0;
 715 }
 716
 717 void
 718 ospf_if_set_multicast(struct ospf_interface *oi)
 719 {
 720   if ((oi->state > ISM_Loopback) &&
 721       (oi->type != OSPF_IFTYPE_LOOPBACK) &&
 722       (oi->type != OSPF_IFTYPE_VIRTUALLINK) &&
 723       (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_ACTIVE))
 724     {
 725       /* The interface should belong to the OSPF-all-routers group. */
 726       if (!OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS) &&
 727           (ospf_if_add_allspfrouters(oi->ospf, oi->address,
 728                                      oi->ifp->ifindex) >= 0))
 729           /* Set the flag only if the system call to join succeeded. */
 730           OI_MEMBER_JOINED(oi, MEMBER_ALLROUTERS);
 731     }
 732   else
 733     {
 734       /* The interface should NOT belong to the OSPF-all-routers group. */
 735       if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS))
 736         {
 737           /* Only actually drop if this is the last reference */
 738           if (OI_MEMBER_COUNT(oi, MEMBER_ALLROUTERS) == 1)
 739             ospf_if_drop_allspfrouters (oi->ospf, oi->address,
 740                                         oi->ifp->ifindex);
 741           /* Unset the flag regardless of whether the system call to leave
 742              the group succeeded, since it's much safer to assume that
 743              we are not a member. */
 744           OI_MEMBER_LEFT(oi,MEMBER_ALLROUTERS);
 745         }
 746     }
 747
 748   if (((oi->type == OSPF_IFTYPE_BROADCAST) ||
 749        (oi->type == OSPF_IFTYPE_POINTOPOINT)) &&
 750       ((oi->state == ISM_DR) || (oi->state == ISM_Backup)) &&
 751       (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_ACTIVE))
 752     {
 753       /* The interface should belong to the OSPF-designated-routers group. */
 754       if (!OI_MEMBER_CHECK(oi, MEMBER_DROUTERS) &&
 755           (ospf_if_add_alldrouters(oi->ospf, oi->address,
 756                                    oi->ifp->ifindex) >= 0))
 757         /* Set the flag only if the system call to join succeeded. */
 758         OI_MEMBER_JOINED(oi, MEMBER_DROUTERS);
 759     }
 760   else
 761     {
 762       /* The interface should NOT belong to the OSPF-designated-routers group */
 763       if (OI_MEMBER_CHECK(oi, MEMBER_DROUTERS))
 764         {
 765           /* drop only if last reference */
 766           if (OI_MEMBER_COUNT(oi, MEMBER_DROUTERS) == 1)
 767             ospf_if_drop_alldrouters(oi->ospf, oi->address, oi->ifp->ifindex);
 768
 769           /* Unset the flag regardless of whether the system call to leave
 770              the group succeeded, since it's much safer to assume that
 771              we are not a member. */
 772           OI_MEMBER_LEFT(oi, MEMBER_DROUTERS);
 773         }
 774     }
 775 }
 776
 777 int
 778 ospf_if_up (struct ospf_interface *oi)
 779 {
 780   if (oi == NULL)
 781     return 0;
 782
 783   if (oi->type == OSPF_IFTYPE_LOOPBACK)
 784     OSPF_ISM_EVENT_SCHEDULE (oi, ISM_LoopInd);
 785   else
 786     {
 787       struct ospf *ospf = ospf_lookup ();
 788       if (ospf != NULL)
 789         ospf_adjust_sndbuflen (ospf, oi->ifp->mtu);
 790       else
 791         zlog_warn ("%s: ospf_lookup() returned NULL", __func__);
 792       ospf_if_stream_set (oi);
 793       OSPF_ISM_EVENT_SCHEDULE (oi, ISM_InterfaceUp);
 794     }
 795
 796   return 1;
 797 }
 798
 799 int
 800 ospf_if_down (struct ospf_interface *oi)
 801 {
 802   if (oi == NULL)
 803     return 0;
 804
 805   OSPF_ISM_EVENT_EXECUTE (oi, ISM_InterfaceDown);
 806   /* Shutdown packet reception and sending */
 807   ospf_if_stream_unset (oi);
 808
 809   return 1;
 810 }
 811
 812 \f
 813 /* Virtual Link related functions. */
 814
 815 struct ospf_vl_data *
 816 ospf_vl_data_new (struct ospf_area *area, struct in_addr vl_peer)
 817 {
 818   struct ospf_vl_data *vl_data;
 819
 820   vl_data = XCALLOC (MTYPE_OSPF_VL_DATA, sizeof (struct ospf_vl_data));
 821
 822   vl_data->vl_peer.s_addr = vl_peer.s_addr;
 823   vl_data->vl_area_id = area->area_id;
 824   vl_data->format = area->format;
 825
 826   return vl_data;
 827 }
 828
 829 void
 830 ospf_vl_data_free (struct ospf_vl_data *vl_data)
 831 {
 832   XFREE (MTYPE_OSPF_VL_DATA, vl_data);
 833 }
 834
 835 u_int vlink_count = 0;
 836
 837 struct ospf_interface *
 838 ospf_vl_new (struct ospf *ospf, struct ospf_vl_data *vl_data)
 839 {
 840   struct ospf_interface * voi;
 841   struct interface * vi;
 842   char   ifname[INTERFACE_NAMSIZ + 1];
 843   struct ospf_area *area;
 844   struct in_addr area_id;
 845   struct connected *co;
 846   struct prefix_ipv4 *p;
 847
 848   if (IS_DEBUG_OSPF_EVENT)
 849     zlog_debug ("ospf_vl_new(): Start");
 850   if (vlink_count == OSPF_VL_MAX_COUNT)
 851     {
 852       if (IS_DEBUG_OSPF_EVENT)
 853         zlog_debug ("ospf_vl_new(): Alarm: "
 854                    "cannot create more than OSPF_MAX_VL_COUNT virtual links");
 855       return NULL;
 856     }
 857
 858   if (IS_DEBUG_OSPF_EVENT)
 859     zlog_debug ("ospf_vl_new(): creating pseudo zebra interface");
 860
 861   snprintf (ifname, sizeof(ifname), "VLINK%d", vlink_count);
 862   vi = if_create (ifname, strnlen(ifname, sizeof(ifname)));
 863   co = connected_new ();
 864   co->ifp = vi;
 865   listnode_add (vi->connected, co);
 866
 867   p = prefix_ipv4_new ();
 868   p->family = AF_INET;
 869   p->prefix.s_addr = 0;
 870   p->prefixlen = 0;
 871
 872   co->address = (struct prefix *)p;
 873
 874   voi = ospf_if_new (ospf, vi, co->address);
 875   if (voi == NULL)
 876     {
 877       if (IS_DEBUG_OSPF_EVENT)
 878         zlog_debug ("ospf_vl_new(): Alarm: OSPF int structure is not created");
 879       return NULL;
 880     }
 881   voi->connected = co;
 882   voi->vl_data = vl_data;
 883   voi->ifp->mtu = OSPF_VL_MTU;
 884   voi->type = OSPF_IFTYPE_VIRTUALLINK;
 885
 886   vlink_count++;
 887   if (IS_DEBUG_OSPF_EVENT)
 888     zlog_debug ("ospf_vl_new(): Created name: %s", ifname);
 889   if (IS_DEBUG_OSPF_EVENT)
 890     zlog_debug ("ospf_vl_new(): set if->name to %s", vi->name);
 891
 892   area_id.s_addr = 0;
 893   area = ospf_area_get (ospf, area_id, OSPF_AREA_ID_FORMAT_ADDRESS);
 894   voi->area = area;
 895
 896   if (IS_DEBUG_OSPF_EVENT)
 897     zlog_debug ("ospf_vl_new(): set associated area to the backbone");
 898
 899   ospf_nbr_add_self (voi);
 900   ospf_area_add_if (voi->area, voi);
 901
 902   ospf_if_stream_set (voi);
 903
 904   if (IS_DEBUG_OSPF_EVENT)
 905     zlog_debug ("ospf_vl_new(): Stop");
 906   return voi;
 907 }
 908
 909 static void
 910 ospf_vl_if_delete (struct ospf_vl_data *vl_data)
 911 {
 912   struct interface *ifp = vl_data->vl_oi->ifp;
 913   vl_data->vl_oi->address->u.prefix4.s_addr = 0;
 914   vl_data->vl_oi->address->prefixlen = 0;
 915   ospf_if_free (vl_data->vl_oi);
 916   if_delete (ifp);
 917   vlink_count--;
 918 }
 919
 920 /* Look up vl_data for given peer, optionally qualified to be in the
 921  * specified area. NULL area returns first found..
 922  */
 923 struct ospf_vl_data *
 924 ospf_vl_lookup (struct ospf *ospf, struct ospf_area *area,
 925                 struct in_addr vl_peer)
 926 {
 927   struct ospf_vl_data *vl_data;
 928   struct listnode *node;
 929
 930   if (IS_DEBUG_OSPF_EVENT)
 931     {
 932       zlog_debug ("%s: Looking for %s", __func__, inet_ntoa (vl_peer));
 933       if (area)
 934         zlog_debug ("%s: in area %s", __func__, inet_ntoa (area->area_id));
 935     }
 936
 937   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
 938     {
 939       if (IS_DEBUG_OSPF_EVENT)
 940         zlog_debug ("%s: VL %s, peer %s", __func__,
 941                     vl_data->vl_oi->ifp->name,
 942                     inet_ntoa (vl_data->vl_peer));
 943
 944       if (area && !IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
 945         continue;
 946
 947       if (IPV4_ADDR_SAME (&vl_data->vl_peer, &vl_peer))
 948         return vl_data;
 949     }
 950
 951   return NULL;
 952 }
 953
 954 static void
 955 ospf_vl_shutdown (struct ospf_vl_data *vl_data)
 956 {
 957   struct ospf_interface *oi;
 958
 959   if ((oi = vl_data->vl_oi) == NULL)
 960     return;
 961
 962   oi->address->u.prefix4.s_addr = 0;
 963   oi->address->prefixlen = 0;
 964
 965   UNSET_FLAG (oi->ifp->flags, IFF_UP);
 966   /* OSPF_ISM_EVENT_SCHEDULE (oi, ISM_InterfaceDown); */
 967   OSPF_ISM_EVENT_EXECUTE (oi, ISM_InterfaceDown);
 968 }
 969
 970 void
 971 ospf_vl_add (struct ospf *ospf, struct ospf_vl_data *vl_data)
 972 {
 973   listnode_add (ospf->vlinks, vl_data);
 974 #ifdef HAVE_SNMP
 975   ospf_snmp_vl_add (vl_data);
 976 #endif /* HAVE_SNMP */
 977 }
 978
 979 void
 980 ospf_vl_delete (struct ospf *ospf, struct ospf_vl_data *vl_data)
 981 {
 982   ospf_vl_shutdown (vl_data);
 983   ospf_vl_if_delete (vl_data);
 984
 985 #ifdef HAVE_SNMP
 986   ospf_snmp_vl_delete (vl_data);
 987 #endif /* HAVE_SNMP */
 988   listnode_delete (ospf->vlinks, vl_data);
 989
 990   ospf_vl_data_free (vl_data);
 991 }
 992
 993 static int
 994 ospf_vl_set_params (struct ospf_vl_data *vl_data, struct vertex *v)
 995 {
 996   int changed = 0;
 997   struct ospf_interface *voi;
 998   struct listnode *node;
 999   struct vertex_parent *vp = NULL;
1000   int i;
1001   struct router_lsa *rl;
1002
1003   voi = vl_data->vl_oi;
1004
1005   if (voi->output_cost != v->distance)
1006     {
1007
1008       voi->output_cost = v->distance;
1009       changed = 1;
1010     }
1011
1012   for (ALL_LIST_ELEMENTS_RO (v->parents, node, vp))
1013     {
1014       vl_data->nexthop.oi = vp->nexthop->oi;
1015       vl_data->nexthop.router = vp->nexthop->router;
1016
1017       if (!IPV4_ADDR_SAME(&voi->address->u.prefix4,
1018                           &vl_data->nexthop.oi->address->u.prefix4))
1019         changed = 1;
1020
1021       voi->address->u.prefix4 = vl_data->nexthop.oi->address->u.prefix4;
1022       voi->address->prefixlen = vl_data->nexthop.oi->address->prefixlen;
1023
1024       break; /* We take the first interface. */
1025     }
1026
1027   rl = (struct router_lsa *)v->lsa;
1028
1029   /* use SPF determined backlink index in struct vertex
1030    * for virtual link destination address
1031    */
1032   if (vp && vp->backlink >= 0)
1033     {
1034       if (!IPV4_ADDR_SAME (&vl_data->peer_addr,
1035                            &rl->link[vp->backlink].link_data))
1036         changed = 1;
1037       vl_data->peer_addr = rl->link[vp->backlink].link_data;
1038     }
1039   else
1040     {
1041       /* This is highly odd, there is no backlink index
1042        * there should be due to the ospf_spf_has_link() check
1043        * in SPF. Lets warn and try pick a link anyway.
1044        */
1045       zlog_warn ("ospf_vl_set_params: No backlink for %s!",
1046                  vl_data->vl_oi->ifp->name);
1047       for (i = 0; i < ntohs (rl->links); i++)
1048         {
1049           switch (rl->link[i].type)
1050             {
1051               case LSA_LINK_TYPE_VIRTUALLINK:
1052                 if (IS_DEBUG_OSPF_EVENT)
1053                   zlog_debug ("found back link through VL");
1054               case LSA_LINK_TYPE_TRANSIT:
1055               case LSA_LINK_TYPE_POINTOPOINT:
1056                 if (!IPV4_ADDR_SAME (&vl_data->peer_addr,
1057                                      &rl->link[i].link_data))
1058                   changed = 1;
1059                 vl_data->peer_addr = rl->link[i].link_data;
1060             }
1061         }
1062     }
1063
1064   if (IS_DEBUG_OSPF_EVENT)
1065     zlog_debug ("%s: %s peer address: %s, cost: %d,%schanged", __func__,
1066                vl_data->vl_oi->ifp->name,
1067                inet_ntoa(vl_data->peer_addr),
1068                voi->output_cost,
1069                (changed ? " " : " un"));
1070
1071   return changed;
1072 }
1073
1074
1075 void
1076 ospf_vl_up_check (struct ospf_area *area, struct in_addr rid,
1077                   struct vertex *v)
1078 {
1079   struct ospf *ospf = area->ospf;
1080   struct listnode *node;
1081   struct ospf_vl_data *vl_data;
1082   struct ospf_interface *oi;
1083
1084   if (IS_DEBUG_OSPF_EVENT)
1085     {
1086       zlog_debug ("ospf_vl_up_check(): Start");
1087       zlog_debug ("ospf_vl_up_check(): Router ID is %s", inet_ntoa (rid));
1088       zlog_debug ("ospf_vl_up_check(): Area is %s", inet_ntoa (area->area_id));
1089     }
1090
1091   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
1092     {
1093       if (IS_DEBUG_OSPF_EVENT)
1094         {
1095           zlog_debug ("%s: considering VL, %s in area %s", __func__,
1096                      vl_data->vl_oi->ifp->name,
1097                      inet_ntoa (vl_data->vl_area_id));
1098           zlog_debug ("%s: peer ID: %s", __func__,
1099                      inet_ntoa (vl_data->vl_peer));
1100         }
1101
1102       if (IPV4_ADDR_SAME (&vl_data->vl_peer, &rid) &&
1103           IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
1104         {
1105           oi = vl_data->vl_oi;
1106           SET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
1107
1108           if (IS_DEBUG_OSPF_EVENT)
1109             zlog_debug ("ospf_vl_up_check(): this VL matched");
1110
1111           if (oi->state == ISM_Down)
1112             {
1113               if (IS_DEBUG_OSPF_EVENT)
1114                 zlog_debug ("ospf_vl_up_check(): VL is down, waking it up");
1115               SET_FLAG (oi->ifp->flags, IFF_UP);
1116               OSPF_ISM_EVENT_EXECUTE(oi,ISM_InterfaceUp);
1117             }
1118
1119          if (ospf_vl_set_params (vl_data, v))
1120            {
1121              if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
1122                zlog_debug ("ospf_vl_up_check: VL cost change,"
1123                           " scheduling router lsa refresh");
1124              if(ospf->backbone)
1125                ospf_router_lsa_timer_add (ospf->backbone);
1126              else if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
1127                zlog_debug ("ospf_vl_up_check: VL cost change, no backbone!");
1128            }
1129         }
1130     }
1131 }
1132
1133 void
1134 ospf_vl_unapprove (struct ospf *ospf)
1135 {
1136   struct listnode *node;
1137   struct ospf_vl_data *vl_data;
1138
1139   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
1140     UNSET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
1141 }
1142
1143 void
1144 ospf_vl_shut_unapproved (struct ospf *ospf)
1145 {
1146   struct listnode *node, *nnode;
1147   struct ospf_vl_data *vl_data;
1148
1149   for (ALL_LIST_ELEMENTS (ospf->vlinks, node, nnode, vl_data))
1150     if (!CHECK_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED))
1151       ospf_vl_shutdown (vl_data);
1152 }
1153
1154 int
1155 ospf_full_virtual_nbrs (struct ospf_area *area)
1156 {
1157   if (IS_DEBUG_OSPF_EVENT)
1158     {
1159       zlog_debug ("counting fully adjacent virtual neighbors in area %s",
1160                  inet_ntoa (area->area_id));
1161       zlog_debug ("there are %d of them", area->full_vls);
1162     }
1163
1164   return area->full_vls;
1165 }
1166
1167 int
1168 ospf_vls_in_area (struct ospf_area *area)
1169 {
1170   struct listnode *node;
1171   struct ospf_vl_data *vl_data;
1172   int c = 0;
1173
1174   for (ALL_LIST_ELEMENTS_RO (area->ospf->vlinks, node, vl_data))
1175     if (IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
1176       c++;
1177
1178   return c;
1179 }
1180
1181 \f
1182 struct crypt_key *
1183 ospf_crypt_key_new ()
1184 {
1185   return XCALLOC (MTYPE_OSPF_CRYPT_KEY, sizeof (struct crypt_key));
1186 }
1187
1188 void
1189 ospf_crypt_key_add (struct list *crypt, struct crypt_key *ck)
1190 {
1191   listnode_add (crypt, ck);
1192 }
1193
1194 struct crypt_key *
1195 ospf_crypt_key_lookup (struct list *auth_crypt, u_char key_id)
1196 {
1197   struct listnode *node;
1198   struct crypt_key *ck;
1199
1200   for (ALL_LIST_ELEMENTS_RO (auth_crypt, node, ck))
1201     if (ck->key_id == key_id)
1202       return ck;
1203
1204   return NULL;
1205 }
1206
1207 int
1208 ospf_crypt_key_delete (struct list *auth_crypt, u_char key_id)
1209 {
1210   struct listnode *node, *nnode;
1211   struct crypt_key *ck;
1212
1213   for (ALL_LIST_ELEMENTS (auth_crypt, node, nnode, ck))
1214     {
1215       if (ck->key_id == key_id)
1216         {
1217           listnode_delete (auth_crypt, ck);
1218           XFREE (MTYPE_OSPF_CRYPT_KEY, ck);
1219           return 1;
1220         }
1221     }
1222
1223   return 0;
1224 }
1225
1226 u_char
1227 ospf_default_iftype(struct interface *ifp)
1228 {
1229   if (if_is_pointopoint (ifp))
1230     return OSPF_IFTYPE_POINTOPOINT;
1231   else if (if_is_loopback (ifp))
1232     return OSPF_IFTYPE_LOOPBACK;
1233   else
1234     return OSPF_IFTYPE_BROADCAST;
1235 }
1236
1237 void
1238 ospf_if_init ()
1239 {
1240   /* Initialize Zebra interface data structure. */
1241   if_init ();
1242   om->iflist = iflist;
1243   if_add_hook (IF_NEW_HOOK, ospf_if_new_hook);
1244   if_add_hook (IF_DELETE_HOOK, ospf_if_delete_hook);
1245 }