[mirror_frr.git] / isisd / isis_dr.c

/*
 * IS-IS Rout(e)ing protocol - isis_dr.c
 *                             IS-IS designated router related routines   
 *
 * Copyright (C) 2001,2002   Sampo Saaristo
 *                           Tampere University of Technology      
 *                           Institute of Communications Engineering
 *
 * This program is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU General Public Licenseas published by the Free 
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,but WITHOUT 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
 * more details.

 * You should have received a copy of the GNU General Public License along 
 * with this program; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


#include <zebra.h>

#include "log.h"
#include "hash.h"
#include "thread.h"
#include "linklist.h"
#include "vty.h"
#include "stream.h"
#include "if.h"

#include "isisd/dict.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_common.h"
#include "isisd/isis_misc.h"
#include "isisd/isis_flags.h"
#include "isisd/isis_circuit.h"
#include "isisd/isisd.h"
#include "isisd/isis_adjacency.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_pdu.h"
#include "isisd/isis_tlv.h"
#include "isisd/isis_lsp.h"
#include "isisd/isis_dr.h"
#include "isisd/isis_events.h"

const char *
isis_disflag2string (int disflag)
{

  switch (disflag)
    {
    case ISIS_IS_NOT_DIS:
      return "is not DIS";
    case ISIS_IS_DIS:
      return "is DIS";
    case ISIS_WAS_DIS:
      return "was DIS";
    default:
      return "unknown DIS state";
    }
  return NULL;			/* not reached */
}

int
isis_run_dr_l1 (struct thread *thread)
{
  struct isis_circuit *circuit;

  circuit = THREAD_ARG (thread);
  assert (circuit);

  if (circuit->u.bc.run_dr_elect[0])
    zlog_warn ("isis_run_dr(): run_dr_elect already set for l1");

  circuit->u.bc.t_run_dr[0] = NULL;
  circuit->u.bc.run_dr_elect[0] = 1;

  return ISIS_OK;
}

int
isis_run_dr_l2 (struct thread *thread)
{
  struct isis_circuit *circuit;

  circuit = THREAD_ARG (thread);
  assert (circuit);

  if (circuit->u.bc.run_dr_elect[1])
    zlog_warn ("isis_run_dr(): run_dr_elect already set for l2");


  circuit->u.bc.t_run_dr[1] = NULL;
  circuit->u.bc.run_dr_elect[1] = 1;

  return ISIS_OK;
}

static int
isis_check_dr_change (struct isis_adjacency *adj, int level)
{
  int i;

  if (adj->dis_record[level - 1].dis !=
      adj->dis_record[(1 * ISIS_LEVELS) + level - 1].dis)
    /* was there a DIS state transition ? */
    {
      adj->dischanges[level - 1]++;
      /* ok rotate the history list through */
      for (i = DIS_RECORDS - 1; i > 0; i--)
	{
	  adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
	    adj->dis_record[((i - 1) * ISIS_LEVELS) + level - 1].dis;
	  adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change =
	    adj->dis_record[((i - 1) * ISIS_LEVELS) + level -
			    1].last_dis_change;
	}
    }
  return ISIS_OK;
}

int
isis_dr_elect (struct isis_circuit *circuit, int level)
{
  struct list *adjdb;
  struct listnode *node;
  struct isis_adjacency *adj, *adj_dr = NULL;
  struct list *list = list_new ();
  u_char own_prio;
  int biggest_prio = -1;
  int cmp_res, retval = ISIS_OK;

  own_prio = circuit->priority[level - 1];
  adjdb = circuit->u.bc.adjdb[level - 1];

  if (!adjdb)
    {
      zlog_warn ("isis_dr_elect() adjdb == NULL");
      list_delete (list);
      return ISIS_WARNING;
    }
  isis_adj_build_up_list (adjdb, list);

  /*
   * Loop the adjacencies and find the one with the biggest priority
   */
  for (ALL_LIST_ELEMENTS_RO (list, node, adj))
    {
      /* clear flag for show output */
      adj->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
      adj->dis_record[level - 1].last_dis_change = time (NULL);

      if (adj->prio[level - 1] > biggest_prio)
	{
	  biggest_prio = adj->prio[level - 1];
	  adj_dr = adj;
	}
      else if (adj->prio[level - 1] == biggest_prio)
	{
	  /*
	   * Comparison of MACs breaks a tie
	   */
	  if (adj_dr)
	    {
	      cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN);
	      if (cmp_res < 0)
		{
		  adj_dr = adj;
		}
	      if (cmp_res == 0)
		zlog_warn
		  ("isis_dr_elect(): multiple adjacencies with same SNPA");
	    }
	  else
	    {
	      adj_dr = adj;
	    }
	}
    }

  if (!adj_dr)
    {
      /*
       * Could not find the DR - means we are alone. Resign if we were DR.
       */
      if (circuit->u.bc.is_dr[level - 1])
        retval = isis_dr_resign (circuit, level);
      list_delete (list);
      return retval;
    }

  /*
   * Now we have the DR adjacency, compare it to self
   */
  if (adj_dr->prio[level - 1] < own_prio ||
      (adj_dr->prio[level - 1] == own_prio &&
       memcmp (adj_dr->snpa, circuit->u.bc.snpa, ETH_ALEN) < 0))
    {
      adj_dr->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
      adj_dr->dis_record[level - 1].last_dis_change = time (NULL);

      /* rotate the history log */
      for (ALL_LIST_ELEMENTS_RO (list, node, adj))
        isis_check_dr_change (adj, level);

      /* We are the DR, commence DR */
      if (circuit->u.bc.is_dr[level - 1] == 0 && listcount (list) > 0)
        retval = isis_dr_commence (circuit, level);
    }
  else
    {
      /* ok we have found the DIS - lets mark the adjacency */
      /* set flag for show output */
      adj_dr->dis_record[level - 1].dis = ISIS_IS_DIS;
      adj_dr->dis_record[level - 1].last_dis_change = time (NULL);

      /* now loop through a second time to check if there has been a DIS change
       * if yes rotate the history log
       */

      for (ALL_LIST_ELEMENTS_RO (list, node, adj))
        isis_check_dr_change (adj, level);

      /*
       * We are not DR - if we were -> resign
       */
      if (circuit->u.bc.is_dr[level - 1])
        retval = isis_dr_resign (circuit, level);
    }
  list_delete (list);
  return retval;
}

int
isis_dr_resign (struct isis_circuit *circuit, int level)
{
  u_char id[ISIS_SYS_ID_LEN + 2];

  zlog_debug ("isis_dr_resign l%d", level);

  circuit->u.bc.is_dr[level - 1] = 0;
  circuit->u.bc.run_dr_elect[level - 1] = 0;
  THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[level - 1]);
  THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
  circuit->lsp_regenerate_pending[level - 1] = 0;

  memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
  LSP_PSEUDO_ID (id) = circuit->circuit_id;
  LSP_FRAGMENT (id) = 0;
  lsp_purge_pseudo (id, circuit, level);

  if (level == 1)
    {
      memset (circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);

      THREAD_TIMER_OFF (circuit->t_send_csnp[0]);

      THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
		       circuit, 2 * circuit->hello_interval[0]);

      THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
		       isis_jitter (circuit->psnp_interval[level - 1],
				    PSNP_JITTER));
    }
  else
    {
      memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);

      THREAD_TIMER_OFF (circuit->t_send_csnp[1]);

      THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
		       circuit, 2 * circuit->hello_interval[1]);

      THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
		       isis_jitter (circuit->psnp_interval[level - 1],
				    PSNP_JITTER));
    }

  thread_add_event (master, isis_event_dis_status_change, circuit, 0);

  return ISIS_OK;
}

int
isis_dr_commence (struct isis_circuit *circuit, int level)
{
  u_char old_dr[ISIS_SYS_ID_LEN + 2];

  if (isis->debugs & DEBUG_EVENTS)
    zlog_debug ("isis_dr_commence l%d", level);

  /* Lets keep a pause in DR election */
  circuit->u.bc.run_dr_elect[level - 1] = 0;
  if (level == 1)
    THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
		     circuit, 2 * circuit->hello_interval[0]);
  else
    THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
		     circuit, 2 * circuit->hello_interval[1]);
  circuit->u.bc.is_dr[level - 1] = 1;

  if (level == 1)
    {
      memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
      LSP_FRAGMENT (old_dr) = 0;
      if (LSP_PSEUDO_ID (old_dr))
	{
	  /* there was a dr elected, purge its LSPs from the db */
	  lsp_purge_pseudo (old_dr, circuit, level);
	}
      memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
      *(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;

      assert (circuit->circuit_id);	/* must be non-zero */
      /*    if (circuit->t_send_l1_psnp)
         thread_cancel (circuit->t_send_l1_psnp); */
      lsp_generate_pseudo (circuit, 1);

      THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
      THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
		       circuit, 2 * circuit->hello_interval[0]);

      THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
		       isis_jitter (circuit->csnp_interval[level - 1],
				    CSNP_JITTER));

    }
  else
    {
      memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
      LSP_FRAGMENT (old_dr) = 0;
      if (LSP_PSEUDO_ID (old_dr))
	{
	  /* there was a dr elected, purge its LSPs from the db */
	  lsp_purge_pseudo (old_dr, circuit, level);
	}
      memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
      *(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;

      assert (circuit->circuit_id);	/* must be non-zero */
      /*    if (circuit->t_send_l1_psnp)
         thread_cancel (circuit->t_send_l1_psnp); */
      lsp_generate_pseudo (circuit, 2);

      THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
      THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
		       circuit, 2 * circuit->hello_interval[1]);

      THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
		       isis_jitter (circuit->csnp_interval[level - 1],
				    CSNP_JITTER));
    }

  thread_add_event (master, isis_event_dis_status_change, circuit, 0);

  return ISIS_OK;
}
Commit	Line	Data
eb5d44eb	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>
eb5d44eb	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
1cd80845	50	const char *
f390d2c7	51	isis_disflag2string (int disflag)
f390d2c7	52	{
eb5d44eb	53
f390d2c7	54	switch (disflag)
f390d2c7	55	{
eb5d44eb	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";
f390d2c7	62	default:
	63	return "unknown DIS state";
	64	}
	65	return NULL; /* not reached */
eb5d44eb	66	}
eb5d44eb	67
eb5d44eb	68	int
	69	isis_run_dr_l1 (struct thread *thread)
	70	{
	71	struct isis_circuit *circuit;
f390d2c7	72
eb5d44eb	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");
f390d2c7	78
efc1e725	79	circuit->u.bc.t_run_dr[0] = NULL;
eb5d44eb	80	circuit->u.bc.run_dr_elect[0] = 1;
f390d2c7	81
eb5d44eb	82	return ISIS_OK;
	83	}
	84
	85	int
	86	isis_run_dr_l2 (struct thread *thread)
	87	{
	88	struct isis_circuit *circuit;
f390d2c7	89
eb5d44eb	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");
f390d2c7	95
	96
	97	circuit->u.bc.t_run_dr[1] = NULL;
eb5d44eb	98	circuit->u.bc.run_dr_elect[1] = 1;
f390d2c7	99
eb5d44eb	100	return ISIS_OK;
	101	}
	102
92365889	103	static int
eb5d44eb	104	isis_check_dr_change (struct isis_adjacency *adj, int level)
	105	{
	106	int i;
	107
f390d2c7	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 ? */
eb5d44eb	111	{
f390d2c7	112	adj->dischanges[level - 1]++;
eb5d44eb	113	/* ok rotate the history list through */
f390d2c7	114	for (i = DIS_RECORDS - 1; i > 0; i--)
eb5d44eb	115	{
f390d2c7	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;
eb5d44eb	121	}
	122	}
	123	return ISIS_OK;
	124	}
	125
f390d2c7	126	int
eb5d44eb	127	isis_dr_elect (struct isis_circuit *circuit, int level)
	128	{
	129	struct list *adjdb;
3fdb2dd9	130	struct listnode *node;
eb5d44eb	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;
f390d2c7	136
3f045a08	137	own_prio = circuit->priority[level - 1];
eb5d44eb	138	adjdb = circuit->u.bc.adjdb[level - 1];
eb5d44eb	139
f390d2c7	140	if (!adjdb)
	141	{
	142	zlog_warn ("isis_dr_elect() adjdb == NULL");
f390d2c7	143	list_delete (list);
3f045a08	144	return ISIS_WARNING;
f390d2c7	145	}
eb5d44eb	146	isis_adj_build_up_list (adjdb, list);
	147
	148	/*
	149	* Loop the adjacencies and find the one with the biggest priority
	150	*/
3fdb2dd9	151	for (ALL_LIST_ELEMENTS_RO (list, node, adj))
f390d2c7	152	{
f390d2c7	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	{
eb5d44eb	187	/*
3f045a08	188	* Could not find the DR - means we are alone. Resign if we were DR.
eb5d44eb	189	*/
3f045a08 JB	190	if (circuit->u.bc.is_dr[level - 1])
	191	retval = isis_dr_resign (circuit, level);
	192	list_delete (list);
	193	return retval;
eb5d44eb	194	}
eb5d44eb	195
	196	/*
	197	* Now we have the DR adjacency, compare it to self
	198	*/
3f045a08 JB	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))
f390d2c7	202	{
3f045a08 JB	203	adj_dr->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
3f045a08 JB	204	adj_dr->dis_record[level - 1].last_dis_change = time (NULL);
d9c427b2	205
3f045a08 JB	206	/* rotate the history log */
	207	for (ALL_LIST_ELEMENTS_RO (list, node, adj))
	208	isis_check_dr_change (adj, level);
d9c427b2	209
3f045a08 JB	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);
eb5d44eb	213	}
f390d2c7	214	else
f390d2c7	215	{
f390d2c7	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);
eb5d44eb	220
f390d2c7	221	/* now loop through a second time to check if there has been a DIS change
	222	* if yes rotate the history log
	223	*/
eb5d44eb	224
3fdb2dd9	225	for (ALL_LIST_ELEMENTS_RO (list, node, adj))
1eb8ef25	226	isis_check_dr_change (adj, level);
eb5d44eb	227
f390d2c7	228	/*
	229	* We are not DR - if we were -> resign
	230	*/
f390d2c7	231	if (circuit->u.bc.is_dr[level - 1])
3f045a08	232	retval = isis_dr_resign (circuit, level);
eb5d44eb	233	}
3f045a08	234	list_delete (list);
eb5d44eb	235	return retval;
	236	}
	237
f390d2c7	238	int
eb5d44eb	239	isis_dr_resign (struct isis_circuit *circuit, int level)
	240	{
	241	u_char id[ISIS_SYS_ID_LEN + 2];
f390d2c7	242
529d65b3	243	zlog_debug ("isis_dr_resign l%d", level);
eb5d44eb	244
eb5d44eb	245	circuit->u.bc.is_dr[level - 1] = 0;
f390d2c7	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]);
3f045a08	249	circuit->lsp_regenerate_pending[level - 1] = 0;
f390d2c7	250
eb5d44eb	251	memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
f390d2c7	252	LSP_PSEUDO_ID (id) = circuit->circuit_id;
f390d2c7	253	LSP_FRAGMENT (id) = 0;
3f045a08	254	lsp_purge_pseudo (id, circuit, level);
eb5d44eb	255
f390d2c7	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_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
e7fe02fd	263	circuit, 2 * circuit->hello_interval[0]);
f390d2c7	264
	265	THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
	266	isis_jitter (circuit->psnp_interval[level - 1],
	267	PSNP_JITTER));
	268	}
	269	else
	270	{
	271	memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
	272
	273	THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
	274
	275	THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
	276	circuit, 2 * circuit->hello_interval[1]);
	277
	278	THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
	279	isis_jitter (circuit->psnp_interval[level - 1],
	280	PSNP_JITTER));
	281	}
	282
eb5d44eb	283	thread_add_event (master, isis_event_dis_status_change, circuit, 0);
	284
	285	return ISIS_OK;
	286	}
	287
f390d2c7	288	int
eb5d44eb	289	isis_dr_commence (struct isis_circuit *circuit, int level)
	290	{
	291	u_char old_dr[ISIS_SYS_ID_LEN + 2];
f390d2c7	292
c89c05dd	293	if (isis->debugs & DEBUG_EVENTS)
c89c05dd	294	zlog_debug ("isis_dr_commence l%d", level);
eb5d44eb	295
	296	/* Lets keep a pause in DR election */
	297	circuit->u.bc.run_dr_elect[level - 1] = 0;
f390d2c7	298	if (level == 1)
f390d2c7	299	THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
a211d65d	300	circuit, 2 * circuit->hello_interval[0]);
f390d2c7	301	else
f390d2c7	302	THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
a211d65d	303	circuit, 2 * circuit->hello_interval[1]);
eb5d44eb	304	circuit->u.bc.is_dr[level - 1] = 1;
eb5d44eb	305
f390d2c7	306	if (level == 1)
	307	{
	308	memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
	309	LSP_FRAGMENT (old_dr) = 0;
	310	if (LSP_PSEUDO_ID (old_dr))
	311	{
	312	/* there was a dr elected, purge its LSPs from the db */
3f045a08	313	lsp_purge_pseudo (old_dr, circuit, level);
f390d2c7	314	}
	315	memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
	316	*(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
	317
	318	assert (circuit->circuit_id); /* must be non-zero */
	319	/* if (circuit->t_send_l1_psnp)
	320	thread_cancel (circuit->t_send_l1_psnp); */
3f045a08	321	lsp_generate_pseudo (circuit, 1);
f390d2c7	322
	323	THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
	324	THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
	325	circuit, 2 * circuit->hello_interval[0]);
	326
	327	THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
	328	isis_jitter (circuit->csnp_interval[level - 1],
	329	CSNP_JITTER));
	330
eb5d44eb	331	}
f390d2c7	332	else
	333	{
	334	memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
	335	LSP_FRAGMENT (old_dr) = 0;
	336	if (LSP_PSEUDO_ID (old_dr))
	337	{
	338	/* there was a dr elected, purge its LSPs from the db */
3f045a08	339	lsp_purge_pseudo (old_dr, circuit, level);
f390d2c7	340	}
	341	memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
	342	*(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
	343
	344	assert (circuit->circuit_id); /* must be non-zero */
	345	/* if (circuit->t_send_l1_psnp)
	346	thread_cancel (circuit->t_send_l1_psnp); */
3f045a08	347	lsp_generate_pseudo (circuit, 2);
f390d2c7	348
	349	THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
	350	THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
	351	circuit, 2 * circuit->hello_interval[1]);
	352
	353	THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
	354	isis_jitter (circuit->csnp_interval[level - 1],
	355	CSNP_JITTER));
eb5d44eb	356	}
eb5d44eb	357
eb5d44eb	358	thread_add_event (master, isis_event_dis_status_change, circuit, 0);
f390d2c7	359
eb5d44eb	360	return ISIS_OK;
eb5d44eb	361	}