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: extern struct isis *isis;
51: extern struct thread_master *master;
52:
53: const char *
54: isis_disflag2string (int disflag)
55: {
56:
57: switch (disflag)
58: {
59: case ISIS_IS_NOT_DIS:
60: return "is not DIS";
61: case ISIS_IS_DIS:
62: return "is DIS";
63: case ISIS_WAS_DIS:
64: return "was DIS";
65: default:
66: return "unknown DIS state";
67: }
68: return NULL; /* not reached */
69: }
70:
71: int
72: isis_run_dr_l1 (struct thread *thread)
73: {
74: struct isis_circuit *circuit;
75:
76: circuit = THREAD_ARG (thread);
77: assert (circuit);
78:
79: if (circuit->u.bc.run_dr_elect[0])
80: zlog_warn ("isis_run_dr(): run_dr_elect already set for l1");
81:
82: circuit->u.bc.t_run_dr[0] = NULL;
83: circuit->u.bc.run_dr_elect[0] = 1;
84:
85: return ISIS_OK;
86: }
87:
88: int
89: isis_run_dr_l2 (struct thread *thread)
90: {
91: struct isis_circuit *circuit;
92:
93: circuit = THREAD_ARG (thread);
94: assert (circuit);
95:
96: if (circuit->u.bc.run_dr_elect[1])
97: zlog_warn ("isis_run_dr(): run_dr_elect already set for l2");
98:
99:
100: circuit->u.bc.t_run_dr[1] = NULL;
101: circuit->u.bc.run_dr_elect[1] = 1;
102:
103: return ISIS_OK;
104: }
105:
106: static int
107: isis_check_dr_change (struct isis_adjacency *adj, int level)
108: {
109: int i;
110:
111: if (adj->dis_record[level - 1].dis !=
112: adj->dis_record[(1 * ISIS_LEVELS) + level - 1].dis)
113: /* was there a DIS state transition ? */
114: {
115: adj->dischanges[level - 1]++;
116: /* ok rotate the history list through */
117: for (i = DIS_RECORDS - 1; i > 0; i--)
118: {
119: adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis =
120: adj->dis_record[((i - 1) * ISIS_LEVELS) + level - 1].dis;
121: adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change =
122: adj->dis_record[((i - 1) * ISIS_LEVELS) + level -
123: 1].last_dis_change;
124: }
125: }
126: return ISIS_OK;
127: }
128:
129: int
130: isis_dr_elect (struct isis_circuit *circuit, int level)
131: {
132: struct list *adjdb;
133: struct listnode *node;
134: struct isis_adjacency *adj, *adj_dr = NULL;
135: struct list *list = list_new ();
136: u_char own_prio;
137: int biggest_prio = -1;
138: int cmp_res, retval = ISIS_OK;
139:
140: own_prio = circuit->u.bc.priority[level - 1];
141: adjdb = circuit->u.bc.adjdb[level - 1];
142:
143: if (!adjdb)
144: {
145: zlog_warn ("isis_dr_elect() adjdb == NULL");
146: retval = ISIS_WARNING;
147: list_delete (list);
148: goto out;
149: }
150: isis_adj_build_up_list (adjdb, list);
151:
152: /*
153: * Loop the adjacencies and find the one with the biggest priority
154: */
155: for (ALL_LIST_ELEMENTS_RO (list, node, adj))
156: {
157: /* clear flag for show output */
158: adj->dis_record[level - 1].dis = ISIS_IS_NOT_DIS;
159: adj->dis_record[level - 1].last_dis_change = time (NULL);
160:
161: if (adj->prio[level - 1] > biggest_prio)
162: {
163: biggest_prio = adj->prio[level - 1];
164: adj_dr = adj;
165: }
166: else if (adj->prio[level - 1] == biggest_prio)
167: {
168: /*
169: * Comparison of MACs breaks a tie
170: */
171: if (adj_dr)
172: {
173: cmp_res = memcmp (adj_dr->snpa, adj->snpa, ETH_ALEN);
174: if (cmp_res < 0)
175: {
176: adj_dr = adj;
177: }
178: if (cmp_res == 0)
179: zlog_warn
180: ("isis_dr_elect(): multiple adjacencies with same SNPA");
181: }
182: else
183: {
184: adj_dr = adj;
185: }
186: }
187: }
188:
189: if (!adj_dr)
190: {
191: /*
192: * Could not find the DR - means we are alone and thus the DR
193: */
194: if (!circuit->u.bc.is_dr[level - 1])
195: {
196: list_delete (list);
197: list = NULL;
198: return isis_dr_commence (circuit, level);
199: }
200: goto out;
201: }
202:
203: /*
204: * Now we have the DR adjacency, compare it to self
205: */
206: if (adj_dr->prio[level - 1] < own_prio
207: || (adj_dr->prio[level - 1] == own_prio
208: && memcmp (adj_dr->snpa, circuit->u.bc.snpa, ETH_ALEN) < 0))
209: {
210: if (!circuit->u.bc.is_dr[level - 1])
211: {
212: /*
213: * We are the DR
214: */
215:
216: /* rotate the history log */
217: for (ALL_LIST_ELEMENTS_RO (list, node, adj))
218: isis_check_dr_change (adj, level);
219:
220: /* commence */
221: list_delete (list);
222: return isis_dr_commence (circuit, level);
223: }
224: }
225: else
226: {
227:
228: /* ok we have found the DIS - lets mark the adjacency */
229: /* set flag for show output */
230: adj_dr->dis_record[level - 1].dis = ISIS_IS_DIS;
231: adj_dr->dis_record[level - 1].last_dis_change = time (NULL);
232:
233: /* now loop through a second time to check if there has been a DIS change
234: * if yes rotate the history log
235: */
236:
237: for (ALL_LIST_ELEMENTS_RO (list, node, adj))
238: isis_check_dr_change (adj, level);
239:
240: /*
241: * We are not DR - if we were -> resign
242: */
243:
244: if (circuit->u.bc.is_dr[level - 1])
245: {
246: list_delete (list);
247: return isis_dr_resign (circuit, level);
248: }
249: }
250: out:
251: if (list)
252: list_delete (list);
253: return retval;
254: }
255:
256: int
257: isis_dr_resign (struct isis_circuit *circuit, int level)
258: {
259: u_char id[ISIS_SYS_ID_LEN + 2];
260:
261: zlog_debug ("isis_dr_resign l%d", level);
262:
263: circuit->u.bc.is_dr[level - 1] = 0;
264: circuit->u.bc.run_dr_elect[level - 1] = 0;
265: THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[level - 1]);
266: THREAD_TIMER_OFF (circuit->u.bc.t_refresh_pseudo_lsp[level - 1]);
267:
268: memcpy (id, isis->sysid, ISIS_SYS_ID_LEN);
269: LSP_PSEUDO_ID (id) = circuit->circuit_id;
270: LSP_FRAGMENT (id) = 0;
271: lsp_purge_dr (id, circuit, level);
272:
273: if (level == 1)
274: {
275: memset (circuit->u.bc.l1_desig_is, 0, ISIS_SYS_ID_LEN + 1);
276:
277: THREAD_TIMER_OFF (circuit->t_send_csnp[0]);
278:
279: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
280: circuit, 2 * circuit->hello_interval[0]);
281:
282: THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
283: isis_jitter (circuit->psnp_interval[level - 1],
284: PSNP_JITTER));
285: }
286: else
287: {
288: memset (circuit->u.bc.l2_desig_is, 0, ISIS_SYS_ID_LEN + 1);
289:
290: THREAD_TIMER_OFF (circuit->t_send_csnp[1]);
291:
292: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
293: circuit, 2 * circuit->hello_interval[1]);
294:
295: THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
296: isis_jitter (circuit->psnp_interval[level - 1],
297: PSNP_JITTER));
298: }
299:
300: thread_add_event (master, isis_event_dis_status_change, circuit, 0);
301:
302: return ISIS_OK;
303: }
304:
305: int
306: isis_dr_commence (struct isis_circuit *circuit, int level)
307: {
308: u_char old_dr[ISIS_SYS_ID_LEN + 2];
309:
310: if (isis->debugs & DEBUG_EVENTS)
311: zlog_debug ("isis_dr_commence l%d", level);
312:
313: /* Lets keep a pause in DR election */
314: circuit->u.bc.run_dr_elect[level - 1] = 0;
315: if (level == 1)
316: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
317: circuit, 2 * circuit->hello_interval[0]);
318: else
319: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
320: circuit, 2 * circuit->hello_interval[1]);
321: circuit->u.bc.is_dr[level - 1] = 1;
322:
323: if (level == 1)
324: {
325: memcpy (old_dr, circuit->u.bc.l1_desig_is, ISIS_SYS_ID_LEN + 1);
326: LSP_FRAGMENT (old_dr) = 0;
327: if (LSP_PSEUDO_ID (old_dr))
328: {
329: /* there was a dr elected, purge its LSPs from the db */
330: lsp_purge_dr (old_dr, circuit, level);
331: }
332: memcpy (circuit->u.bc.l1_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
333: *(circuit->u.bc.l1_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
334:
335: assert (circuit->circuit_id); /* must be non-zero */
336: /* if (circuit->t_send_l1_psnp)
337: thread_cancel (circuit->t_send_l1_psnp); */
338: lsp_l1_pseudo_generate (circuit);
339:
340: THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
341: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[0], isis_run_dr_l1,
342: circuit, 2 * circuit->hello_interval[0]);
343:
344: THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
345: isis_jitter (circuit->csnp_interval[level - 1],
346: CSNP_JITTER));
347:
348: }
349: else
350: {
351: memcpy (old_dr, circuit->u.bc.l2_desig_is, ISIS_SYS_ID_LEN + 1);
352: LSP_FRAGMENT (old_dr) = 0;
353: if (LSP_PSEUDO_ID (old_dr))
354: {
355: /* there was a dr elected, purge its LSPs from the db */
356: lsp_purge_dr (old_dr, circuit, level);
357: }
358: memcpy (circuit->u.bc.l2_desig_is, isis->sysid, ISIS_SYS_ID_LEN);
359: *(circuit->u.bc.l2_desig_is + ISIS_SYS_ID_LEN) = circuit->circuit_id;
360:
361: assert (circuit->circuit_id); /* must be non-zero */
362: /* if (circuit->t_send_l1_psnp)
363: thread_cancel (circuit->t_send_l1_psnp); */
364: lsp_l2_pseudo_generate (circuit);
365:
366: THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
367: THREAD_TIMER_ON (master, circuit->u.bc.t_run_dr[1], isis_run_dr_l2,
368: circuit, 2 * circuit->hello_interval[1]);
369:
370: THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
371: isis_jitter (circuit->csnp_interval[level - 1],
372: CSNP_JITTER));
373: }
374:
375: thread_add_event (master, isis_event_dis_status_change, circuit, 0);
376:
377: return ISIS_OK;
378: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_dr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd