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 static 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 source of packet */
 443 struct ospf_interface *
 444 ospf_if_lookup_recv_if (struct ospf *ospf, struct in_addr src)
 445 {
 446   struct listnode *node;
 447   struct prefix_ipv4 addr;
 448   struct ospf_interface *oi, *match;
 449
 450   addr.family = AF_INET;
 451   addr.prefix = src;
 452   addr.prefixlen = IPV4_MAX_BITLEN;
 453
 454   match = NULL;
 455
 456   for (ALL_LIST_ELEMENTS_RO (ospf->oiflist, node, oi))
 457     {
 458       if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
 459         continue;
 460
 461       if (if_is_loopback (oi->ifp))
 462         continue;
 463
 464       if (prefix_match (CONNECTED_PREFIX(oi->connected),
 465                         (struct prefix *) &addr))
 466         {
 467           if ( (match == NULL) ||
 468                (match->address->prefixlen < oi->address->prefixlen)
 469              )
 470             match = oi;
 471         }
 472     }
 473
 474   return match;
 475 }
 476 \f
 477 void
 478 ospf_if_stream_set (struct ospf_interface *oi)
 479 {
 480   /* set output fifo queue. */
 481   if (oi->obuf == NULL)
 482     oi->obuf = ospf_fifo_new ();
 483 }
 484
 485 void
 486 ospf_if_stream_unset (struct ospf_interface *oi)
 487 {
 488   struct ospf *ospf = oi->ospf;
 489
 490   if (oi->obuf)
 491     {
 492      ospf_fifo_free (oi->obuf);
 493      oi->obuf = NULL;
 494
 495      if (oi->on_write_q)
 496        {
 497          listnode_delete (ospf->oi_write_q, oi);
 498          if (list_isempty(ospf->oi_write_q))
 499            OSPF_TIMER_OFF (ospf->t_write);
 500          oi->on_write_q = 0;
 501        }
 502     }
 503 }
 504
 505 \f
 506 static struct ospf_if_params *
 507 ospf_new_if_params (void)
 508 {
 509   struct ospf_if_params *oip;
 510
 511   oip = XCALLOC (MTYPE_OSPF_IF_PARAMS, sizeof (struct ospf_if_params));
 512
 513   if (!oip)
 514     return NULL;
 515
 516   UNSET_IF_PARAM (oip, output_cost_cmd);
 517   UNSET_IF_PARAM (oip, transmit_delay);
 518   UNSET_IF_PARAM (oip, retransmit_interval);
 519   UNSET_IF_PARAM (oip, passive_interface);
 520   UNSET_IF_PARAM (oip, v_hello);
 521   UNSET_IF_PARAM (oip, fast_hello);
 522   UNSET_IF_PARAM (oip, v_wait);
 523   UNSET_IF_PARAM (oip, priority);
 524   UNSET_IF_PARAM (oip, type);
 525   UNSET_IF_PARAM (oip, auth_simple);
 526   UNSET_IF_PARAM (oip, auth_crypt);
 527   UNSET_IF_PARAM (oip, auth_type);
 528
 529   oip->auth_crypt = list_new ();
 530
 531   return oip;
 532 }
 533
 534 void
 535 ospf_del_if_params (struct ospf_if_params *oip)
 536 {
 537   list_delete (oip->auth_crypt);
 538   XFREE (MTYPE_OSPF_IF_PARAMS, oip);
 539 }
 540
 541 void
 542 ospf_free_if_params (struct interface *ifp, struct in_addr addr)
 543 {
 544   struct ospf_if_params *oip;
 545   struct prefix_ipv4 p;
 546   struct route_node *rn;
 547
 548   p.family = AF_INET;
 549   p.prefixlen = IPV4_MAX_PREFIXLEN;
 550   p.prefix = addr;
 551   rn = route_node_lookup (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 552   if (!rn || !rn->info)
 553     return;
 554
 555   oip = rn->info;
 556   route_unlock_node (rn);
 557
 558   if (!OSPF_IF_PARAM_CONFIGURED (oip, output_cost_cmd) &&
 559       !OSPF_IF_PARAM_CONFIGURED (oip, transmit_delay) &&
 560       !OSPF_IF_PARAM_CONFIGURED (oip, retransmit_interval) &&
 561       !OSPF_IF_PARAM_CONFIGURED (oip, passive_interface) &&
 562       !OSPF_IF_PARAM_CONFIGURED (oip, v_hello) &&
 563       !OSPF_IF_PARAM_CONFIGURED (oip, fast_hello) &&
 564       !OSPF_IF_PARAM_CONFIGURED (oip, v_wait) &&
 565       !OSPF_IF_PARAM_CONFIGURED (oip, priority) &&
 566       !OSPF_IF_PARAM_CONFIGURED (oip, type) &&
 567       !OSPF_IF_PARAM_CONFIGURED (oip, auth_simple) &&
 568       !OSPF_IF_PARAM_CONFIGURED (oip, auth_type) &&
 569       listcount (oip->auth_crypt) == 0)
 570     {
 571       ospf_del_if_params (oip);
 572       rn->info = NULL;
 573       route_unlock_node (rn);
 574     }
 575 }
 576
 577 struct ospf_if_params *
 578 ospf_lookup_if_params (struct interface *ifp, struct in_addr addr)
 579 {
 580   struct prefix_ipv4 p;
 581   struct route_node *rn;
 582
 583   p.family = AF_INET;
 584   p.prefixlen = IPV4_MAX_PREFIXLEN;
 585   p.prefix = addr;
 586
 587   rn = route_node_lookup (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 588
 589   if (rn)
 590     {
 591       route_unlock_node (rn);
 592       return rn->info;
 593     }
 594
 595   return NULL;
 596 }
 597
 598 struct ospf_if_params *
 599 ospf_get_if_params (struct interface *ifp, struct in_addr addr)
 600 {
 601   struct prefix_ipv4 p;
 602   struct route_node *rn;
 603
 604   p.family = AF_INET;
 605   p.prefixlen = IPV4_MAX_PREFIXLEN;
 606   p.prefix = addr;
 607
 608   rn = route_node_get (IF_OIFS_PARAMS (ifp), (struct prefix*)&p);
 609
 610   if (rn->info == NULL)
 611     rn->info = ospf_new_if_params ();
 612   else
 613     route_unlock_node (rn);
 614
 615   return rn->info;
 616 }
 617
 618 void
 619 ospf_if_update_params (struct interface *ifp, struct in_addr addr)
 620 {
 621   struct route_node *rn;
 622   struct ospf_interface *oi;
 623
 624   for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
 625     {
 626       if ((oi = rn->info) == NULL)
 627         continue;
 628
 629       if (IPV4_ADDR_SAME (&oi->address->u.prefix4, &addr))
 630         oi->params = ospf_lookup_if_params (ifp, oi->address->u.prefix4);
 631     }
 632 }
 633
 634 int
 635 ospf_if_new_hook (struct interface *ifp)
 636 {
 637   int rc = 0;
 638
 639   ifp->info = XCALLOC (MTYPE_OSPF_IF_INFO, sizeof (struct ospf_if_info));
 640
 641   IF_OIFS (ifp) = route_table_init ();
 642   IF_OIFS_PARAMS (ifp) = route_table_init ();
 643
 644   IF_DEF_PARAMS (ifp) = ospf_new_if_params ();
 645
 646   SET_IF_PARAM (IF_DEF_PARAMS (ifp), transmit_delay);
 647   IF_DEF_PARAMS (ifp)->transmit_delay = OSPF_TRANSMIT_DELAY_DEFAULT;
 648
 649   SET_IF_PARAM (IF_DEF_PARAMS (ifp), retransmit_interval);
 650   IF_DEF_PARAMS (ifp)->retransmit_interval = OSPF_RETRANSMIT_INTERVAL_DEFAULT;
 651
 652   SET_IF_PARAM (IF_DEF_PARAMS (ifp), priority);
 653   IF_DEF_PARAMS (ifp)->priority = OSPF_ROUTER_PRIORITY_DEFAULT;
 654
 655   IF_DEF_PARAMS (ifp)->mtu_ignore = OSPF_MTU_IGNORE_DEFAULT;
 656
 657   SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_hello);
 658   IF_DEF_PARAMS (ifp)->v_hello = OSPF_HELLO_INTERVAL_DEFAULT;
 659
 660   SET_IF_PARAM (IF_DEF_PARAMS (ifp), fast_hello);
 661   IF_DEF_PARAMS (ifp)->fast_hello = OSPF_FAST_HELLO_DEFAULT;
 662
 663   SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_wait);
 664   IF_DEF_PARAMS (ifp)->v_wait = OSPF_ROUTER_DEAD_INTERVAL_DEFAULT;
 665
 666   SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_simple);
 667   memset (IF_DEF_PARAMS (ifp)->auth_simple, 0, OSPF_AUTH_SIMPLE_SIZE);
 668
 669   SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_type);
 670   IF_DEF_PARAMS (ifp)->auth_type = OSPF_AUTH_NOTSET;
 671
 672 #ifdef HAVE_OPAQUE_LSA
 673   rc = ospf_opaque_new_if (ifp);
 674 #endif /* HAVE_OPAQUE_LSA */
 675   return rc;
 676 }
 677
 678 static int
 679 ospf_if_delete_hook (struct interface *ifp)
 680 {
 681   int rc = 0;
 682   struct route_node *rn;
 683 #ifdef HAVE_OPAQUE_LSA
 684   rc = ospf_opaque_del_if (ifp);
 685 #endif /* HAVE_OPAQUE_LSA */
 686
 687   route_table_finish (IF_OIFS (ifp));
 688
 689   for (rn = route_top (IF_OIFS_PARAMS (ifp)); rn; rn = route_next (rn))
 690     if (rn->info)
 691       ospf_del_if_params (rn->info);
 692   route_table_finish (IF_OIFS_PARAMS (ifp));
 693
 694   ospf_del_if_params ((struct ospf_if_params *) IF_DEF_PARAMS (ifp));
 695   XFREE (MTYPE_OSPF_IF_INFO, ifp->info);
 696   ifp->info = NULL;
 697
 698   return rc;
 699 }
 700
 701 int
 702 ospf_if_is_enable (struct ospf_interface *oi)
 703 {
 704   if (!if_is_loopback (oi->ifp))
 705     if (if_is_up (oi->ifp))
 706         return 1;
 707
 708   return 0;
 709 }
 710
 711 void
 712 ospf_if_set_multicast(struct ospf_interface *oi)
 713 {
 714   if ((oi->state > ISM_Loopback) &&
 715       (oi->type != OSPF_IFTYPE_LOOPBACK) &&
 716       (oi->type != OSPF_IFTYPE_VIRTUALLINK) &&
 717       (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_ACTIVE))
 718     {
 719       /* The interface should belong to the OSPF-all-routers group. */
 720       if (!OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS) &&
 721           (ospf_if_add_allspfrouters(oi->ospf, oi->address,
 722                                      oi->ifp->ifindex) >= 0))
 723           /* Set the flag only if the system call to join succeeded. */
 724           OI_MEMBER_JOINED(oi, MEMBER_ALLROUTERS);
 725     }
 726   else
 727     {
 728       /* The interface should NOT belong to the OSPF-all-routers group. */
 729       if (OI_MEMBER_CHECK(oi, MEMBER_ALLROUTERS))
 730         {
 731           /* Only actually drop if this is the last reference */
 732           if (OI_MEMBER_COUNT(oi, MEMBER_ALLROUTERS) == 1)
 733             ospf_if_drop_allspfrouters (oi->ospf, oi->address,
 734                                         oi->ifp->ifindex);
 735           /* Unset the flag regardless of whether the system call to leave
 736              the group succeeded, since it's much safer to assume that
 737              we are not a member. */
 738           OI_MEMBER_LEFT(oi,MEMBER_ALLROUTERS);
 739         }
 740     }
 741
 742   if (((oi->type == OSPF_IFTYPE_BROADCAST) ||
 743        (oi->type == OSPF_IFTYPE_POINTOPOINT)) &&
 744       ((oi->state == ISM_DR) || (oi->state == ISM_Backup)) &&
 745       (OSPF_IF_PASSIVE_STATUS(oi) == OSPF_IF_ACTIVE))
 746     {
 747       /* The interface should belong to the OSPF-designated-routers group. */
 748       if (!OI_MEMBER_CHECK(oi, MEMBER_DROUTERS) &&
 749           (ospf_if_add_alldrouters(oi->ospf, oi->address,
 750                                    oi->ifp->ifindex) >= 0))
 751         /* Set the flag only if the system call to join succeeded. */
 752         OI_MEMBER_JOINED(oi, MEMBER_DROUTERS);
 753     }
 754   else
 755     {
 756       /* The interface should NOT belong to the OSPF-designated-routers group */
 757       if (OI_MEMBER_CHECK(oi, MEMBER_DROUTERS))
 758         {
 759           /* drop only if last reference */
 760           if (OI_MEMBER_COUNT(oi, MEMBER_DROUTERS) == 1)
 761             ospf_if_drop_alldrouters(oi->ospf, oi->address, oi->ifp->ifindex);
 762
 763           /* Unset the flag regardless of whether the system call to leave
 764              the group succeeded, since it's much safer to assume that
 765              we are not a member. */
 766           OI_MEMBER_LEFT(oi, MEMBER_DROUTERS);
 767         }
 768     }
 769 }
 770
 771 int
 772 ospf_if_up (struct ospf_interface *oi)
 773 {
 774   if (oi == NULL)
 775     return 0;
 776
 777   if (oi->type == OSPF_IFTYPE_LOOPBACK)
 778     OSPF_ISM_EVENT_SCHEDULE (oi, ISM_LoopInd);
 779   else
 780     {
 781       struct ospf *ospf = ospf_lookup ();
 782       if (ospf != NULL)
 783         ospf_adjust_sndbuflen (ospf, oi->ifp->mtu);
 784       else
 785         zlog_warn ("%s: ospf_lookup() returned NULL", __func__);
 786       ospf_if_stream_set (oi);
 787       OSPF_ISM_EVENT_SCHEDULE (oi, ISM_InterfaceUp);
 788     }
 789
 790   return 1;
 791 }
 792
 793 int
 794 ospf_if_down (struct ospf_interface *oi)
 795 {
 796   if (oi == NULL)
 797     return 0;
 798
 799   OSPF_ISM_EVENT_EXECUTE (oi, ISM_InterfaceDown);
 800   /* Shutdown packet reception and sending */
 801   ospf_if_stream_unset (oi);
 802
 803   return 1;
 804 }
 805
 806 \f
 807 /* Virtual Link related functions. */
 808
 809 struct ospf_vl_data *
 810 ospf_vl_data_new (struct ospf_area *area, struct in_addr vl_peer)
 811 {
 812   struct ospf_vl_data *vl_data;
 813
 814   vl_data = XCALLOC (MTYPE_OSPF_VL_DATA, sizeof (struct ospf_vl_data));
 815
 816   vl_data->vl_peer.s_addr = vl_peer.s_addr;
 817   vl_data->vl_area_id = area->area_id;
 818   vl_data->format = area->format;
 819
 820   return vl_data;
 821 }
 822
 823 void
 824 ospf_vl_data_free (struct ospf_vl_data *vl_data)
 825 {
 826   XFREE (MTYPE_OSPF_VL_DATA, vl_data);
 827 }
 828
 829 u_int vlink_count = 0;
 830
 831 struct ospf_interface *
 832 ospf_vl_new (struct ospf *ospf, struct ospf_vl_data *vl_data)
 833 {
 834   struct ospf_interface * voi;
 835   struct interface * vi;
 836   char   ifname[INTERFACE_NAMSIZ + 1];
 837   struct ospf_area *area;
 838   struct in_addr area_id;
 839   struct connected *co;
 840   struct prefix_ipv4 *p;
 841
 842   if (IS_DEBUG_OSPF_EVENT)
 843     zlog_debug ("ospf_vl_new(): Start");
 844   if (vlink_count == OSPF_VL_MAX_COUNT)
 845     {
 846       if (IS_DEBUG_OSPF_EVENT)
 847         zlog_debug ("ospf_vl_new(): Alarm: "
 848                    "cannot create more than OSPF_MAX_VL_COUNT virtual links");
 849       return NULL;
 850     }
 851
 852   if (IS_DEBUG_OSPF_EVENT)
 853     zlog_debug ("ospf_vl_new(): creating pseudo zebra interface");
 854
 855   snprintf (ifname, sizeof(ifname), "VLINK%d", vlink_count);
 856   vi = if_create (ifname, strnlen(ifname, sizeof(ifname)));
 857   co = connected_new ();
 858   co->ifp = vi;
 859   listnode_add (vi->connected, co);
 860
 861   p = prefix_ipv4_new ();
 862   p->family = AF_INET;
 863   p->prefix.s_addr = 0;
 864   p->prefixlen = 0;
 865
 866   co->address = (struct prefix *)p;
 867
 868   voi = ospf_if_new (ospf, vi, co->address);
 869   if (voi == NULL)
 870     {
 871       if (IS_DEBUG_OSPF_EVENT)
 872         zlog_debug ("ospf_vl_new(): Alarm: OSPF int structure is not created");
 873       return NULL;
 874     }
 875   voi->connected = co;
 876   voi->vl_data = vl_data;
 877   voi->ifp->mtu = OSPF_VL_MTU;
 878   voi->type = OSPF_IFTYPE_VIRTUALLINK;
 879
 880   vlink_count++;
 881   if (IS_DEBUG_OSPF_EVENT)
 882     zlog_debug ("ospf_vl_new(): Created name: %s", ifname);
 883   if (IS_DEBUG_OSPF_EVENT)
 884     zlog_debug ("ospf_vl_new(): set if->name to %s", vi->name);
 885
 886   area_id.s_addr = 0;
 887   area = ospf_area_get (ospf, area_id, OSPF_AREA_ID_FORMAT_ADDRESS);
 888   voi->area = area;
 889
 890   if (IS_DEBUG_OSPF_EVENT)
 891     zlog_debug ("ospf_vl_new(): set associated area to the backbone");
 892
 893   ospf_nbr_add_self (voi);
 894   ospf_area_add_if (voi->area, voi);
 895
 896   ospf_if_stream_set (voi);
 897
 898   if (IS_DEBUG_OSPF_EVENT)
 899     zlog_debug ("ospf_vl_new(): Stop");
 900   return voi;
 901 }
 902
 903 static void
 904 ospf_vl_if_delete (struct ospf_vl_data *vl_data)
 905 {
 906   struct interface *ifp = vl_data->vl_oi->ifp;
 907   vl_data->vl_oi->address->u.prefix4.s_addr = 0;
 908   vl_data->vl_oi->address->prefixlen = 0;
 909   ospf_if_free (vl_data->vl_oi);
 910   if_delete (ifp);
 911   vlink_count--;
 912 }
 913
 914 /* Look up vl_data for given peer, optionally qualified to be in the
 915  * specified area. NULL area returns first found..
 916  */
 917 struct ospf_vl_data *
 918 ospf_vl_lookup (struct ospf *ospf, struct ospf_area *area,
 919                 struct in_addr vl_peer)
 920 {
 921   struct ospf_vl_data *vl_data;
 922   struct listnode *node;
 923
 924   if (IS_DEBUG_OSPF_EVENT)
 925     {
 926       zlog_debug ("%s: Looking for %s", __func__, inet_ntoa (vl_peer));
 927       if (area)
 928         zlog_debug ("%s: in area %s", __func__, inet_ntoa (area->area_id));
 929     }
 930
 931   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
 932     {
 933       if (IS_DEBUG_OSPF_EVENT)
 934         zlog_debug ("%s: VL %s, peer %s", __func__,
 935                     vl_data->vl_oi->ifp->name,
 936                     inet_ntoa (vl_data->vl_peer));
 937
 938       if (area && !IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
 939         continue;
 940
 941       if (IPV4_ADDR_SAME (&vl_data->vl_peer, &vl_peer))
 942         return vl_data;
 943     }
 944
 945   return NULL;
 946 }
 947
 948 static void
 949 ospf_vl_shutdown (struct ospf_vl_data *vl_data)
 950 {
 951   struct ospf_interface *oi;
 952
 953   if ((oi = vl_data->vl_oi) == NULL)
 954     return;
 955
 956   oi->address->u.prefix4.s_addr = 0;
 957   oi->address->prefixlen = 0;
 958
 959   UNSET_FLAG (oi->ifp->flags, IFF_UP);
 960   /* OSPF_ISM_EVENT_SCHEDULE (oi, ISM_InterfaceDown); */
 961   OSPF_ISM_EVENT_EXECUTE (oi, ISM_InterfaceDown);
 962 }
 963
 964 void
 965 ospf_vl_add (struct ospf *ospf, struct ospf_vl_data *vl_data)
 966 {
 967   listnode_add (ospf->vlinks, vl_data);
 968 #ifdef HAVE_SNMP
 969   ospf_snmp_vl_add (vl_data);
 970 #endif /* HAVE_SNMP */
 971 }
 972
 973 void
 974 ospf_vl_delete (struct ospf *ospf, struct ospf_vl_data *vl_data)
 975 {
 976   ospf_vl_shutdown (vl_data);
 977   ospf_vl_if_delete (vl_data);
 978
 979 #ifdef HAVE_SNMP
 980   ospf_snmp_vl_delete (vl_data);
 981 #endif /* HAVE_SNMP */
 982   listnode_delete (ospf->vlinks, vl_data);
 983
 984   ospf_vl_data_free (vl_data);
 985 }
 986
 987 static int
 988 ospf_vl_set_params (struct ospf_vl_data *vl_data, struct vertex *v)
 989 {
 990   int changed = 0;
 991   struct ospf_interface *voi;
 992   struct listnode *node;
 993   struct vertex_parent *vp = NULL;
 994   int i;
 995   struct router_lsa *rl;
 996
 997   voi = vl_data->vl_oi;
 998
 999   if (voi->output_cost != v->distance)
1000     {
1001
1002       voi->output_cost = v->distance;
1003       changed = 1;
1004     }
1005
1006   for (ALL_LIST_ELEMENTS_RO (v->parents, node, vp))
1007     {
1008       vl_data->nexthop.oi = vp->nexthop->oi;
1009       vl_data->nexthop.router = vp->nexthop->router;
1010
1011       if (!IPV4_ADDR_SAME(&voi->address->u.prefix4,
1012                           &vl_data->nexthop.oi->address->u.prefix4))
1013         changed = 1;
1014
1015       voi->address->u.prefix4 = vl_data->nexthop.oi->address->u.prefix4;
1016       voi->address->prefixlen = vl_data->nexthop.oi->address->prefixlen;
1017
1018       break; /* We take the first interface. */
1019     }
1020
1021   rl = (struct router_lsa *)v->lsa;
1022
1023   /* use SPF determined backlink index in struct vertex
1024    * for virtual link destination address
1025    */
1026   if (vp && vp->backlink >= 0)
1027     {
1028       if (!IPV4_ADDR_SAME (&vl_data->peer_addr,
1029                            &rl->link[vp->backlink].link_data))
1030         changed = 1;
1031       vl_data->peer_addr = rl->link[vp->backlink].link_data;
1032     }
1033   else
1034     {
1035       /* This is highly odd, there is no backlink index
1036        * there should be due to the ospf_spf_has_link() check
1037        * in SPF. Lets warn and try pick a link anyway.
1038        */
1039       zlog_warn ("ospf_vl_set_params: No backlink for %s!",
1040                  vl_data->vl_oi->ifp->name);
1041       for (i = 0; i < ntohs (rl->links); i++)
1042         {
1043           switch (rl->link[i].type)
1044             {
1045               case LSA_LINK_TYPE_VIRTUALLINK:
1046                 if (IS_DEBUG_OSPF_EVENT)
1047                   zlog_debug ("found back link through VL");
1048               case LSA_LINK_TYPE_TRANSIT:
1049               case LSA_LINK_TYPE_POINTOPOINT:
1050                 if (!IPV4_ADDR_SAME (&vl_data->peer_addr,
1051                                      &rl->link[i].link_data))
1052                   changed = 1;
1053                 vl_data->peer_addr = rl->link[i].link_data;
1054             }
1055         }
1056     }
1057
1058   if (IS_DEBUG_OSPF_EVENT)
1059     zlog_debug ("%s: %s peer address: %s, cost: %d,%schanged", __func__,
1060                vl_data->vl_oi->ifp->name,
1061                inet_ntoa(vl_data->peer_addr),
1062                voi->output_cost,
1063                (changed ? " " : " un"));
1064
1065   return changed;
1066 }
1067
1068
1069 void
1070 ospf_vl_up_check (struct ospf_area *area, struct in_addr rid,
1071                   struct vertex *v)
1072 {
1073   struct ospf *ospf = area->ospf;
1074   struct listnode *node;
1075   struct ospf_vl_data *vl_data;
1076   struct ospf_interface *oi;
1077
1078   if (IS_DEBUG_OSPF_EVENT)
1079     {
1080       zlog_debug ("ospf_vl_up_check(): Start");
1081       zlog_debug ("ospf_vl_up_check(): Router ID is %s", inet_ntoa (rid));
1082       zlog_debug ("ospf_vl_up_check(): Area is %s", inet_ntoa (area->area_id));
1083     }
1084
1085   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
1086     {
1087       if (IS_DEBUG_OSPF_EVENT)
1088         {
1089           zlog_debug ("%s: considering VL, %s in area %s", __func__,
1090                      vl_data->vl_oi->ifp->name,
1091                      inet_ntoa (vl_data->vl_area_id));
1092           zlog_debug ("%s: peer ID: %s", __func__,
1093                      inet_ntoa (vl_data->vl_peer));
1094         }
1095
1096       if (IPV4_ADDR_SAME (&vl_data->vl_peer, &rid) &&
1097           IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
1098         {
1099           oi = vl_data->vl_oi;
1100           SET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
1101
1102           if (IS_DEBUG_OSPF_EVENT)
1103             zlog_debug ("ospf_vl_up_check(): this VL matched");
1104
1105           if (oi->state == ISM_Down)
1106             {
1107               if (IS_DEBUG_OSPF_EVENT)
1108                 zlog_debug ("ospf_vl_up_check(): VL is down, waking it up");
1109               SET_FLAG (oi->ifp->flags, IFF_UP);
1110               OSPF_ISM_EVENT_EXECUTE(oi,ISM_InterfaceUp);
1111             }
1112
1113          if (ospf_vl_set_params (vl_data, v))
1114            {
1115              if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
1116                zlog_debug ("ospf_vl_up_check: VL cost change,"
1117                           " scheduling router lsa refresh");
1118              if(ospf->backbone)
1119                ospf_router_lsa_timer_add (ospf->backbone);
1120              else if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
1121                zlog_debug ("ospf_vl_up_check: VL cost change, no backbone!");
1122            }
1123         }
1124     }
1125 }
1126
1127 void
1128 ospf_vl_unapprove (struct ospf *ospf)
1129 {
1130   struct listnode *node;
1131   struct ospf_vl_data *vl_data;
1132
1133   for (ALL_LIST_ELEMENTS_RO (ospf->vlinks, node, vl_data))
1134     UNSET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
1135 }
1136
1137 void
1138 ospf_vl_shut_unapproved (struct ospf *ospf)
1139 {
1140   struct listnode *node, *nnode;
1141   struct ospf_vl_data *vl_data;
1142
1143   for (ALL_LIST_ELEMENTS (ospf->vlinks, node, nnode, vl_data))
1144     if (!CHECK_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED))
1145       ospf_vl_shutdown (vl_data);
1146 }
1147
1148 int
1149 ospf_full_virtual_nbrs (struct ospf_area *area)
1150 {
1151   if (IS_DEBUG_OSPF_EVENT)
1152     {
1153       zlog_debug ("counting fully adjacent virtual neighbors in area %s",
1154                  inet_ntoa (area->area_id));
1155       zlog_debug ("there are %d of them", area->full_vls);
1156     }
1157
1158   return area->full_vls;
1159 }
1160
1161 int
1162 ospf_vls_in_area (struct ospf_area *area)
1163 {
1164   struct listnode *node;
1165   struct ospf_vl_data *vl_data;
1166   int c = 0;
1167
1168   for (ALL_LIST_ELEMENTS_RO (area->ospf->vlinks, node, vl_data))
1169     if (IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
1170       c++;
1171
1172   return c;
1173 }
1174
1175 \f
1176 struct crypt_key *
1177 ospf_crypt_key_new ()
1178 {
1179   return XCALLOC (MTYPE_OSPF_CRYPT_KEY, sizeof (struct crypt_key));
1180 }
1181
1182 void
1183 ospf_crypt_key_add (struct list *crypt, struct crypt_key *ck)
1184 {
1185   listnode_add (crypt, ck);
1186 }
1187
1188 struct crypt_key *
1189 ospf_crypt_key_lookup (struct list *auth_crypt, u_char key_id)
1190 {
1191   struct listnode *node;
1192   struct crypt_key *ck;
1193
1194   for (ALL_LIST_ELEMENTS_RO (auth_crypt, node, ck))
1195     if (ck->key_id == key_id)
1196       return ck;
1197
1198   return NULL;
1199 }
1200
1201 int
1202 ospf_crypt_key_delete (struct list *auth_crypt, u_char key_id)
1203 {
1204   struct listnode *node, *nnode;
1205   struct crypt_key *ck;
1206
1207   for (ALL_LIST_ELEMENTS (auth_crypt, node, nnode, ck))
1208     {
1209       if (ck->key_id == key_id)
1210         {
1211           listnode_delete (auth_crypt, ck);
1212           XFREE (MTYPE_OSPF_CRYPT_KEY, ck);
1213           return 1;
1214         }
1215     }
1216
1217   return 0;
1218 }
1219
1220 u_char
1221 ospf_default_iftype(struct interface *ifp)
1222 {
1223   if (if_is_pointopoint (ifp))
1224     return OSPF_IFTYPE_POINTOPOINT;
1225   else if (if_is_loopback (ifp))
1226     return OSPF_IFTYPE_LOOPBACK;
1227   else
1228     return OSPF_IFTYPE_BROADCAST;
1229 }
1230
1231 void
1232 ospf_if_init ()
1233 {
1234   /* Initialize Zebra interface data structure. */
1235   if_init ();
1236   om->iflist = iflist;
1237   if_add_hook (IF_NEW_HOOK, ospf_if_new_hook);
1238   if_add_hook (IF_DELETE_HOOK, ospf_if_delete_hook);
1239 }