[mirror_frr.git] / isisd / isis_events.c

/*
 * IS-IS Rout(e)ing protocol - isis_events.h
 *
 * 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; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <zebra.h>

#include "log.h"
#include "memory.h"
#include "if.h"
#include "linklist.h"
#include "command.h"
#include "thread.h"
#include "hash.h"
#include "prefix.h"
#include "stream.h"
#include "table.h"

#include "isisd/isis_constants.h"
#include "isisd/isis_common.h"
#include "isisd/isis_flags.h"
#include "isisd/isis_circuit.h"
#include "isisd/isis_lsp.h"
#include "isisd/isis_pdu.h"
#include "isisd/isis_network.h"
#include "isisd/isis_misc.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_adjacency.h"
#include "isisd/isis_dr.h"
#include "isisd/isisd.h"
#include "isisd/isis_csm.h"
#include "isisd/isis_events.h"
#include "isisd/isis_spf.h"
#include "isisd/isis_errors.h"

/* debug isis-spf spf-events
 4w4d: ISIS-Spf (tlt): L2 SPF needed, new adjacency, from 0x609229F4
 4w4d: ISIS-Spf (tlt): L2, 0000.0000.0042.01-00 TLV contents changed, code 0x2
 4w4d: ISIS-Spf (tlt): L2, new LSP 0 DEAD.BEEF.0043.00-00
 4w5d: ISIS-Spf (tlt): L1 SPF needed, periodic SPF, from 0x6091C844
 4w5d: ISIS-Spf (tlt): L2 SPF needed, periodic SPF, from 0x6091C844
*/

void isis_event_circuit_state_change(struct isis_circuit *circuit,
				     struct isis_area *area, int up)
{
	area->circuit_state_changes++;

	if (isis->debugs & DEBUG_EVENTS)
		zlog_debug("ISIS-Evt (%s) circuit %s", area->area_tag,
			   up ? "up" : "down");

	/*
	 * Regenerate LSPs this affects
	 */
	lsp_regenerate_schedule(area, IS_LEVEL_1 | IS_LEVEL_2, 0);

	return;
}

static void circuit_commence_level(struct isis_circuit *circuit, int level)
{
	if (!circuit->is_passive) {
		if (level == 1) {
			thread_add_timer(master, send_l1_psnp, circuit,
					 isis_jitter(circuit->psnp_interval[0],
						     PSNP_JITTER),
					 &circuit->t_send_psnp[0]);
		} else {
			thread_add_timer(master, send_l2_psnp, circuit,
					 isis_jitter(circuit->psnp_interval[1],
						     PSNP_JITTER),
					 &circuit->t_send_psnp[1]);
		}
	}

	if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
		thread_add_timer(master, isis_run_dr,
				 &circuit->level_arg[level - 1],
				 2 * circuit->hello_interval[level - 1],
				 &circuit->u.bc.t_run_dr[level - 1]);

		send_hello_sched(circuit, level, TRIGGERED_IIH_DELAY);
		circuit->u.bc.lan_neighs[level - 1] = list_new();
	}
}

static void circuit_resign_level(struct isis_circuit *circuit, int level)
{
	int idx = level - 1;

	THREAD_TIMER_OFF(circuit->t_send_csnp[idx]);
	THREAD_TIMER_OFF(circuit->t_send_psnp[idx]);

	if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
		THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[idx]);
		THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[idx]);
		THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
		circuit->lsp_regenerate_pending[idx] = 0;
		circuit->u.bc.run_dr_elect[idx] = 0;
		if (circuit->u.bc.lan_neighs[idx] != NULL)
			list_delete(&circuit->u.bc.lan_neighs[idx]);
	}

	return;
}

void isis_circuit_is_type_set(struct isis_circuit *circuit, int newtype)
{
	if (circuit->state != C_STATE_UP) {
		circuit->is_type = newtype;
		return;
	}

	if (isis->debugs & DEBUG_EVENTS)
		zlog_debug("ISIS-Evt (%s) circuit type change %s -> %s",
			   circuit->area->area_tag,
			   circuit_t2string(circuit->is_type),
			   circuit_t2string(newtype));

	if (circuit->is_type == newtype)
		return; /* No change */

	if (!(newtype & circuit->area->is_type)) {
		flog_err(
			EC_ISIS_CONFIG,
			"ISIS-Evt (%s) circuit type change - invalid level %s because area is %s",
			circuit->area->area_tag, circuit_t2string(newtype),
			circuit_t2string(circuit->area->is_type));
		return;
	}

	if (!circuit->is_passive) {
		switch (circuit->is_type) {
		case IS_LEVEL_1:
			if (newtype == IS_LEVEL_2)
				circuit_resign_level(circuit, 1);
			circuit_commence_level(circuit, 2);
			break;
		case IS_LEVEL_1_AND_2:
			if (newtype == IS_LEVEL_1)
				circuit_resign_level(circuit, 2);
			else
				circuit_resign_level(circuit, 1);
			break;
		case IS_LEVEL_2:
			if (newtype == IS_LEVEL_1)
				circuit_resign_level(circuit, 2);
			circuit_commence_level(circuit, 1);
			break;
		default:
			break;
		}
	}

	circuit->is_type = newtype;
	lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 | IS_LEVEL_2, 0);

	return;
}

/* 04/18/2002 by Gwak. */
/**************************************************************************
 *
 * EVENTS for LSP generation
 *
 * 1) an Adajacency or Circuit Up/Down event
 * 2) a chnage in Circuit metric
 * 3) a change in Reachable Address metric
 * 4) a change in manualAreaAddresses
 * 5) a change in systemID
 * 6) a change in DIS status
 * 7) a chnage in the waiting status
 *
 * ***********************************************************************
 *
 * current support event
 *
 * 1) Adjacency Up/Down event
 * 6) a change in DIS status
 *
 * ***********************************************************************/

/* events supporting code */

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

	circuit = THREAD_ARG(thread);

	/* invalid arguments */
	if (!circuit || !circuit->area)
		return 0;
	if (isis->debugs & DEBUG_EVENTS)
		zlog_debug("ISIS-Evt (%s) DIS status change",
			   circuit->area->area_tag);

	/* LSP generation again */
	lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 | IS_LEVEL_2, 0);

	return 0;
}

void isis_event_auth_failure(char *area_tag, const char *error_string,
			     uint8_t *sysid)
{
	if (isis->debugs & DEBUG_EVENTS)
		zlog_debug("ISIS-Evt (%s) Authentication failure %s from %s",
			   area_tag, error_string, sysid_print(sysid));

	return;
}
Commit	Line	Data
eb5d44eb	1	/*
d62a17ae	2	* IS-IS Rout(e)ing protocol - isis_events.h
eb5d44eb	3	*
eb5d44eb	4	* Copyright (C) 2001,2002 Sampo Saaristo
d62a17ae	5	* Tampere University of Technology
eb5d44eb	6	* Institute of Communications Engineering
eb5d44eb	7	*
d62a17ae	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public Licenseas published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
eb5d44eb	11	* any later version.
eb5d44eb	12	*
d62a17ae	13	* This program is distributed in the hope that it will be useful,but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
eb5d44eb	16	* more details.
896014f4 DL	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
eb5d44eb	21	*/
eb5d44eb	22	#include <zebra.h>
eb5d44eb	23
	24	#include "log.h"
	25	#include "memory.h"
	26	#include "if.h"
	27	#include "linklist.h"
	28	#include "command.h"
	29	#include "thread.h"
	30	#include "hash.h"
	31	#include "prefix.h"
	32	#include "stream.h"
3f045a08	33	#include "table.h"
eb5d44eb	34
eb5d44eb	35	#include "isisd/isis_constants.h"
eb5d44eb	36	#include "isisd/isis_common.h"
3f045a08	37	#include "isisd/isis_flags.h"
eb5d44eb	38	#include "isisd/isis_circuit.h"
eb5d44eb	39	#include "isisd/isis_lsp.h"
	40	#include "isisd/isis_pdu.h"
	41	#include "isisd/isis_network.h"
	42	#include "isisd/isis_misc.h"
	43	#include "isisd/isis_constants.h"
	44	#include "isisd/isis_adjacency.h"
	45	#include "isisd/isis_dr.h"
eb5d44eb	46	#include "isisd/isisd.h"
	47	#include "isisd/isis_csm.h"
	48	#include "isisd/isis_events.h"
	49	#include "isisd/isis_spf.h"
54ece698	50	#include "isisd/isis_errors.h"
eb5d44eb	51
d62a17ae	52	/* debug isis-spf spf-events
eb5d44eb	53	4w4d: ISIS-Spf (tlt): L2 SPF needed, new adjacency, from 0x609229F4
	54	4w4d: ISIS-Spf (tlt): L2, 0000.0000.0042.01-00 TLV contents changed, code 0x2
	55	4w4d: ISIS-Spf (tlt): L2, new LSP 0 DEAD.BEEF.0043.00-00
	56	4w5d: ISIS-Spf (tlt): L1 SPF needed, periodic SPF, from 0x6091C844
	57	4w5d: ISIS-Spf (tlt): L2 SPF needed, periodic SPF, from 0x6091C844
	58	*/
	59
d62a17ae	60	void isis_event_circuit_state_change(struct isis_circuit *circuit,
d62a17ae	61	struct isis_area *area, int up)
eb5d44eb	62	{
d62a17ae	63	area->circuit_state_changes++;
f390d2c7	64
d62a17ae	65	if (isis->debugs & DEBUG_EVENTS)
	66	zlog_debug("ISIS-Evt (%s) circuit %s", area->area_tag,
	67	up ? "up" : "down");
f390d2c7	68
d62a17ae	69	/*
	70	* Regenerate LSPs this affects
	71	*/
	72	lsp_regenerate_schedule(area, IS_LEVEL_1 \| IS_LEVEL_2, 0);
eb5d44eb	73
d62a17ae	74	return;
eb5d44eb	75	}
eb5d44eb	76
d62a17ae	77	static void circuit_commence_level(struct isis_circuit *circuit, int level)
eb5d44eb	78	{
7c4f7aab CF	79	if (!circuit->is_passive) {
7c4f7aab CF	80	if (level == 1) {
d62a17ae	81	thread_add_timer(master, send_l1_psnp, circuit,
	82	isis_jitter(circuit->psnp_interval[0],
	83	PSNP_JITTER),
	84	&circuit->t_send_psnp[0]);
7c4f7aab	85	} else {
d62a17ae	86	thread_add_timer(master, send_l2_psnp, circuit,
	87	isis_jitter(circuit->psnp_interval[1],
	88	PSNP_JITTER),
	89	&circuit->t_send_psnp[1]);
7c4f7aab CF	90	}
7c4f7aab CF	91	}
d62a17ae	92
7c4f7aab CF	93	if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
	94	thread_add_timer(master, isis_run_dr,
	95	&circuit->level_arg[level - 1],
	96	2 * circuit->hello_interval[level - 1],
	97	&circuit->u.bc.t_run_dr[level - 1]);
d62a17ae	98
a0a707ee	99	send_hello_sched(circuit, level, TRIGGERED_IIH_DELAY);
7c4f7aab	100	circuit->u.bc.lan_neighs[level - 1] = list_new();
f390d2c7	101	}
eb5d44eb	102	}
eb5d44eb	103
d62a17ae	104	static void circuit_resign_level(struct isis_circuit *circuit, int level)
eb5d44eb	105	{
d62a17ae	106	int idx = level - 1;
	107
	108	THREAD_TIMER_OFF(circuit->t_send_csnp[idx]);
	109	THREAD_TIMER_OFF(circuit->t_send_psnp[idx]);
	110
	111	if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
	112	THREAD_TIMER_OFF(circuit->u.bc.t_send_lan_hello[idx]);
	113	THREAD_TIMER_OFF(circuit->u.bc.t_run_dr[idx]);
	114	THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
	115	circuit->lsp_regenerate_pending[idx] = 0;
	116	circuit->u.bc.run_dr_elect[idx] = 0;
affe9e99	117	if (circuit->u.bc.lan_neighs[idx] != NULL)
6a154c88	118	list_delete(&circuit->u.bc.lan_neighs[idx]);
d62a17ae	119	}
	120
	121	return;
eb5d44eb	122	}
eb5d44eb	123
d62a17ae	124	void isis_circuit_is_type_set(struct isis_circuit *circuit, int newtype)
eb5d44eb	125	{
d62a17ae	126	if (circuit->state != C_STATE_UP) {
	127	circuit->is_type = newtype;
	128	return;
	129	}
	130
	131	if (isis->debugs & DEBUG_EVENTS)
	132	zlog_debug("ISIS-Evt (%s) circuit type change %s -> %s",
	133	circuit->area->area_tag,
	134	circuit_t2string(circuit->is_type),
	135	circuit_t2string(newtype));
	136
	137	if (circuit->is_type == newtype)
	138	return; /* No change */
	139
	140	if (!(newtype & circuit->area->is_type)) {
af4c2728	141	flog_err(
1a7ecb96	142	EC_ISIS_CONFIG,
54ece698	143	"ISIS-Evt (%s) circuit type change - invalid level %s because area is %s",
d62a17ae	144	circuit->area->area_tag, circuit_t2string(newtype),
	145	circuit_t2string(circuit->area->is_type));
	146	return;
	147	}
	148
	149	if (!circuit->is_passive) {
	150	switch (circuit->is_type) {
	151	case IS_LEVEL_1:
	152	if (newtype == IS_LEVEL_2)
	153	circuit_resign_level(circuit, 1);
	154	circuit_commence_level(circuit, 2);
	155	break;
	156	case IS_LEVEL_1_AND_2:
	157	if (newtype == IS_LEVEL_1)
	158	circuit_resign_level(circuit, 2);
	159	else
	160	circuit_resign_level(circuit, 1);
	161	break;
	162	case IS_LEVEL_2:
	163	if (newtype == IS_LEVEL_1)
	164	circuit_resign_level(circuit, 2);
	165	circuit_commence_level(circuit, 1);
	166	break;
	167	default:
	168	break;
	169	}
	170	}
	171
	172	circuit->is_type = newtype;
	173	lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 \| IS_LEVEL_2, 0);
	174
	175	return;
eb5d44eb	176	}
eb5d44eb	177
d62a17ae	178	/* 04/18/2002 by Gwak. */
	179	/**************************************************************************
	180	*
	181	* EVENTS for LSP generation
	182	*
	183	* 1) an Adajacency or Circuit Up/Down event
	184	* 2) a chnage in Circuit metric
	185	* 3) a change in Reachable Address metric
	186	* 4) a change in manualAreaAddresses
	187	* 5) a change in systemID
	188	* 6) a change in DIS status
	189	* 7) a chnage in the waiting status
	190	*
	191	* ***********************************************************************
	192	*
	193	* current support event
	194	*
	195	* 1) Adjacency Up/Down event
	196	* 6) a change in DIS status
	197	*
	198	* ***********************************************************************/
	199
eb5d44eb	200	/* events supporting code */
eb5d44eb	201
d62a17ae	202	int isis_event_dis_status_change(struct thread *thread)
eb5d44eb	203	{
d62a17ae	204	struct isis_circuit *circuit;
f390d2c7	205
d62a17ae	206	circuit = THREAD_ARG(thread);
f390d2c7	207
d62a17ae	208	/* invalid arguments */
	209	if (!circuit \|\| !circuit->area)
	210	return 0;
	211	if (isis->debugs & DEBUG_EVENTS)
	212	zlog_debug("ISIS-Evt (%s) DIS status change",
	213	circuit->area->area_tag);
eb5d44eb	214
d62a17ae	215	/* LSP generation again */
d62a17ae	216	lsp_regenerate_schedule(circuit->area, IS_LEVEL_1 \| IS_LEVEL_2, 0);
f390d2c7	217
d62a17ae	218	return 0;
eb5d44eb	219	}
eb5d44eb	220
d62a17ae	221	void isis_event_auth_failure(char area_tag, const char error_string,
d7c0a89a	222	uint8_t *sysid)
eb5d44eb	223	{
d62a17ae	224	if (isis->debugs & DEBUG_EVENTS)
	225	zlog_debug("ISIS-Evt (%s) Authentication failure %s from %s",
	226	area_tag, error_string, sysid_print(sysid));
f390d2c7	227
d62a17ae	228	return;
eb5d44eb	229	}