isisd/isis_dr.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_dr.c
   3  *                             IS-IS designated router related routines
   4  *
   5  * Copyright (C) 2001,2002   Sampo Saaristo
   6  *                           Tampere University of Technology
   7  *                           Institute of Communications Engineering
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public Licenseas published by the Free
  11  * Software Foundation; either version 2 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17  * more details.
  18
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc.,
  21  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22  */
  23
  24
  25 #include <zebra.h>
  26
  27 #include "log.h"
  28 #include "hash.h"
  29 #include "thread.h"
  30 #include "linklist.h"
  31 #include "vty.h"
  32 #include "stream.h"
  33 #include "if.h"
  34
  35 #include "isisd/dict.h"
  36 #include "isisd/isis_constants.h"
  37 #include "isisd/isis_common.h"
  38 #include "isisd/isis_misc.h"
  39 #include "isisd/isis_flags.h"
  40 #include "isisd/isis_circuit.h"
  41 #include "isisd/isisd.h"
  42 #include "isisd/isis_adjacency.h"
  43 #include "isisd/isis_constants.h"
  44 #include "isisd/isis_pdu.h"
  45 #include "isisd/isis_tlv.h"
  46 #include "isisd/isis_lsp.h"
  47 #include "isisd/isis_dr.h"
  48 #include "isisd/isis_events.h"
  49
  50 const char *
  51 isis_disflag2string (int disflag)
  52 {
  53
  54   switch (disflag)
  55     {
  56     case ISIS_IS_NOT_DIS:
  57       return "is not DIS";
  58     case ISIS_IS_DIS:
  59       return "is DIS";
  60     case ISIS_WAS_DIS:
  61       return "was DIS";
  62     default:
  63       return "unknown DIS state";
  64     }
  65   return NULL;                  /* not reached */
  66 }
  67
  68 int
  69 isis_run_dr_l1 (struct thread *thread)
  70 {
  71   struct isis_circuit *circuit;
  72
  73   circuit = THREAD_ARG (thread);
  74   assert (circuit);
  75
  76   if (circuit->u.bc.run_dr_elect[0])
  77     zlog_warn ("isis_run_dr(): run_dr_elect already set for l1");
  78
  79   circuit->u.bc.t_run_dr[0] = NULL;
  80   circuit->u.bc.run_dr_elect[0] = 1;
  81
  82   return ISIS_OK;
  83 }
  84
  85 int
  86 isis_run_dr_l2 (struct thread *thread)
  87 {
  88   struct isis_circuit *circuit;
  89
  90   circuit = THREAD_ARG (thread);
  91   assert (circuit);
  92
  93   if (circuit->u.bc.run_dr_elect[1])
  94     zlog_warn ("isis_run_dr(): run_dr_elect already set for l2");
  95
  96
  97   circuit->u.bc.t_run_dr[1] = NULL;
  98   circuit->u.bc.run_dr_elect[1] = 1;
  99
 100   return ISIS_OK;
 101 }
 102
 103 static int
 104 isis_check_dr_change (struct isis_adjacency *adj, int level)
 105 {
 106   int i;
 107
 108   if (adj->dis_record[level - 1].dis !=
 109       adj->dis_record[(1 * ISIS_LEVELS) + level - 1].dis)
 110     /* was there a DIS state transition ? */
 111     {
 112       adj->dischanges[level - 1]++;
 113       /* ok rotate the history list through */
 114       for (i = DIS_RECORDS - 1; i > 0; i--)
 115         {
 116           adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
 117             adj->dis_record[((i - 1) * ISIS_LEVELS) + level - 1].dis;
 118           adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change =
 119             adj->dis_record[((i - 1) * ISIS_LEVELS) + level -
 120                             1].last_dis_change;
 121         }
 122     }
 123   return ISIS_OK;
 124 }
 125
 126 int
 127 isis_dr_elect (struct isis_circuit *circuit, int level)
 128 {
 129   struct list *adjdb;
 130   struct listnode *node;
 131   struct isis_adjacency *adj, *adj_dr = NULL;
 132   struct list *list = list_new ();
 133   u_char own_prio;
 134   int biggest_prio = -1;
 135   int cmp_res, retval = ISIS_OK;
 136
 137   own_prio = circuit->priority[level - 1];
 138   adjdb = circuit->u.bc.adjdb[level - 1];
 139
 140   if (!adjdb)
 141     {
 142       zlog_warn ("isis_dr_elect() adjdb == NULL");
 143       list_delete (list);
 144       return ISIS_WARNING;
 145     }
 146   isis_adj_build_up_list (adjdb, list);
 147
 148   /*
 149    * Loop the adjacencies and find the one with the biggest priority
 150    */
 151   for (ALL_LIST_ELEMENTS_RO (list, node, adj))
 152     {
 153       /* clear flag for show output */
 154       adj->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
 155       adj->dis_record[level - 1].last_dis_change = time (NULL);
 156
 157       if (adj->prio[level - 1] > biggest_prio)
 158         {
 159           biggest_prio = adj->prio[level - 1];
 160           adj_dr = adj;
 161         }
 162       else if (adj->prio[level - 1] == biggest_prio)
 163         {
 164           /*
 165            * Comparison of MACs breaks a tie
 166            */
 167           if (adj_dr)
 168             {
 169               cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN);
 170               if (cmp_res < 0)
 171                 {
 172                   adj_dr = adj;
 173                 }
 174               if (cmp_res == 0)
 175                 zlog_warn
 176                   ("isis_dr_elect(): multiple adjacencies with same SNPA");
 177             }
 178           else
 179             {
 180               adj_dr = adj;
 181             }
 182         }
 183     }
 184
 185   if (!adj_dr)
 186     {
 187       /*
 188        * Could not find the DR - means we are alone. Resign if we were DR.
 189        */
 190       if (circuit->u.bc.is_dr[level - 1])
 191         retval = isis_dr_resign (circuit, level);
 192       list_delete (list);
 193       return retval;
 194     }
 195
 196   /*
 197    * Now we have the DR adjacency, compare it to self
 198    */
 199   if (adj_dr->prio[level - 1] < own_prio ||
 200       (adj_dr->prio[level - 1] == own_prio &&
 201        memcmp (adj_dr->snpa, circuit->u.bc.snpa, ETH_ALEN) < 0))
 202     {
 203       adj_dr->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
 204       adj_dr->dis_record[level - 1].last_dis_change = time (NULL);
 205
 206       /* rotate the history log */
 207       for (ALL_LIST_ELEMENTS_RO (list, node, adj))
 208         isis_check_dr_change (adj, level);
 209
 210       /* We are the DR, commence DR */
 211       if (circuit->u.bc.is_dr[level - 1] == 0 && listcount (list) > 0)
 212         retval = isis_dr_commence (circuit, level);
 213     }
 214   else
 215     {
 216       /* ok we have found the DIS - lets mark the adjacency */
 217       /* set flag for show output */
 218       adj_dr->dis_record[level - 1].dis = ISIS_IS_DIS;
 219       adj_dr->dis_record[level - 1].last_dis_change = time (NULL);
 220
 221       /* now loop through a second time to check if there has been a DIS change
 222        * if yes rotate the history log
 223        */
 224
 225       for (ALL_LIST_ELEMENTS_RO (list, node, adj))
 226         isis_check_dr_change (adj, level);
 227
 228       /*
 229        * We are not DR - if we were -> resign
 230        */
 231       if (circuit->u.bc.is_dr[level - 1])
 232         retval = isis_dr_resign (circuit, level);
 233     }
 234   list_delete (list);
 235   return retval;
 236 }
 237
 238 int
 239 isis_dr_resign (struct isis_circuit *circuit, int level)
 240 {
 241   u_char id[ISIS_SYS_ID_LEN + 2];
 242
 243   zlog_debug ("isis_dr_resign l%d", level);
 244
 245   circuit->u.bc.is_dr[level - 1] = 0;
 246   circuit->u.bc.run_dr_elect[level - 1] = 0;
 247   THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[level - 1]);
 248   THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
 249   circuit->lsp_regenerate_pending[level - 1] = 0;
 250
 251   memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
 252   LSP_PSEUDO_ID (id) = circuit->circuit_id;
 253   LSP_FRAGMENT (id) = 0;
 254   lsp_purge_pseudo (id, circuit, level);
 255
 256   if (level == 1)
 257     {
 258       memset (circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);
 259
 260       THREAD_TIMER_OFF (circuit->t_send_csnp[0]);
 261
 262       thread_add_timer(master, isis_run_dr_l1, circuit,
 263                        2 * circuit->hello_interval[0],
 264                        &circuit->u.bc.t_run_dr[0]);
 265
 266       thread_add_timer(master, send_l1_psnp, circuit,
 267                        isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
 268                        &circuit->t_send_psnp[0]);
 269     }
 270   else
 271     {
 272       memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
 273
 274       THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
 275
 276       thread_add_timer(master, isis_run_dr_l2, circuit,
 277                        2 * circuit->hello_interval[1],
 278                        &circuit->u.bc.t_run_dr[1]);
 279
 280       thread_add_timer(master, send_l2_psnp, circuit,
 281                        isis_jitter(circuit->psnp_interval[level - 1], PSNP_JITTER),
 282                        &circuit->t_send_psnp[1]);
 283     }
 284
 285   thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
 286
 287   return ISIS_OK;
 288 }
 289
 290 int
 291 isis_dr_commence (struct isis_circuit *circuit, int level)
 292 {
 293   u_char old_dr[ISIS_SYS_ID_LEN + 2];
 294
 295   if (isis->debugs & DEBUG_EVENTS)
 296     zlog_debug ("isis_dr_commence l%d", level);
 297
 298   /* Lets keep a pause in DR election */
 299   circuit->u.bc.run_dr_elect[level - 1] = 0;
 300   if (level == 1)
 301     thread_add_timer(master, isis_run_dr_l1, circuit,
 302                      2 * circuit->hello_interval[0],
 303                      &circuit->u.bc.t_run_dr[0]);
 304   else
 305     thread_add_timer(master, isis_run_dr_l2, circuit,
 306                      2 * circuit->hello_interval[1],
 307                      &circuit->u.bc.t_run_dr[1]);
 308   circuit->u.bc.is_dr[level - 1] = 1;
 309
 310   if (level == 1)
 311     {
 312       memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
 313       LSP_FRAGMENT (old_dr) = 0;
 314       if (LSP_PSEUDO_ID (old_dr))
 315         {
 316           /* there was a dr elected, purge its LSPs from the db */
 317           lsp_purge_pseudo (old_dr, circuit, level);
 318         }
 319       memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
 320       *(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
 321
 322       assert (circuit->circuit_id);     /* must be non-zero */
 323       /*    if (circuit->t_send_l1_psnp)
 324          thread_cancel (circuit->t_send_l1_psnp); */
 325       lsp_generate_pseudo (circuit, 1);
 326
 327       THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
 328       thread_add_timer(master, isis_run_dr_l1, circuit,
 329                        2 * circuit->hello_interval[0],
 330                        &circuit->u.bc.t_run_dr[0]);
 331
 332       thread_add_timer(master, send_l1_csnp, circuit,
 333                        isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
 334                        &circuit->t_send_csnp[0]);
 335
 336     }
 337   else
 338     {
 339       memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
 340       LSP_FRAGMENT (old_dr) = 0;
 341       if (LSP_PSEUDO_ID (old_dr))
 342         {
 343           /* there was a dr elected, purge its LSPs from the db */
 344           lsp_purge_pseudo (old_dr, circuit, level);
 345         }
 346       memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
 347       *(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
 348
 349       assert (circuit->circuit_id);     /* must be non-zero */
 350       /*    if (circuit->t_send_l1_psnp)
 351          thread_cancel (circuit->t_send_l1_psnp); */
 352       lsp_generate_pseudo (circuit, 2);
 353
 354       THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
 355       thread_add_timer(master, isis_run_dr_l2, circuit,
 356                        2 * circuit->hello_interval[1],
 357                        &circuit->u.bc.t_run_dr[1]);
 358
 359       thread_add_timer(master, send_l2_csnp, circuit,
 360                        isis_jitter(circuit->csnp_interval[level - 1], CSNP_JITTER),
 361                        &circuit->t_send_csnp[1]);
 362     }
 363
 364   thread_add_event(master, isis_event_dis_status_change, circuit, 0, NULL);
 365
 366   return ISIS_OK;
 367 }