Annotation of embedaddon/quagga/isisd/isis_adjacency.c, revision 1.1.1.3
1.1 misho 1: /*
2: * IS-IS Rout(e)ing protocol - isis_adjacency.c
3: * handling of IS-IS adjacencies
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: #include <zebra.h>
25:
26: #include "log.h"
27: #include "memory.h"
28: #include "hash.h"
29: #include "vty.h"
30: #include "linklist.h"
31: #include "thread.h"
32: #include "if.h"
33: #include "stream.h"
34:
35: #include "isisd/dict.h"
36: #include "isisd/include-netbsd/iso.h"
37: #include "isisd/isis_constants.h"
38: #include "isisd/isis_common.h"
1.1.1.2 misho 39: #include "isisd/isis_flags.h"
1.1 misho 40: #include "isisd/isisd.h"
41: #include "isisd/isis_circuit.h"
42: #include "isisd/isis_adjacency.h"
43: #include "isisd/isis_misc.h"
44: #include "isisd/isis_dr.h"
45: #include "isisd/isis_dynhn.h"
46: #include "isisd/isis_pdu.h"
1.1.1.2 misho 47: #include "isisd/isis_tlv.h"
48: #include "isisd/isis_lsp.h"
49: #include "isisd/isis_spf.h"
50: #include "isisd/isis_events.h"
1.1 misho 51:
52: extern struct isis *isis;
53:
54: static struct isis_adjacency *
55: adj_alloc (u_char * id)
56: {
57: struct isis_adjacency *adj;
58:
59: adj = XCALLOC (MTYPE_ISIS_ADJACENCY, sizeof (struct isis_adjacency));
60: memcpy (adj->sysid, id, ISIS_SYS_ID_LEN);
61:
62: return adj;
63: }
64:
65: struct isis_adjacency *
66: isis_new_adj (u_char * id, u_char * snpa, int level,
67: struct isis_circuit *circuit)
68: {
69: struct isis_adjacency *adj;
70: int i;
71:
72: adj = adj_alloc (id); /* P2P kludge */
73:
74: if (adj == NULL)
75: {
76: zlog_err ("Out of memory!");
77: return NULL;
78: }
79:
80: if (snpa) {
1.1.1.2 misho 81: memcpy (adj->snpa, snpa, ETH_ALEN);
1.1 misho 82: } else {
1.1.1.2 misho 83: memset (adj->snpa, ' ', ETH_ALEN);
1.1 misho 84: }
85:
86: adj->circuit = circuit;
87: adj->level = level;
88: adj->flaps = 0;
89: adj->last_flap = time (NULL);
90: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
91: {
92: listnode_add (circuit->u.bc.adjdb[level - 1], adj);
93: adj->dischanges[level - 1] = 0;
94: for (i = 0; i < DIS_RECORDS; i++) /* clear N DIS state change records */
95: {
96: adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis
97: = ISIS_UNKNOWN_DIS;
98: adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change
99: = time (NULL);
100: }
101: }
102:
103: return adj;
104: }
105:
106: struct isis_adjacency *
107: isis_adj_lookup (u_char * sysid, struct list *adjdb)
108: {
109: struct isis_adjacency *adj;
110: struct listnode *node;
111:
112: for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
113: if (memcmp (adj->sysid, sysid, ISIS_SYS_ID_LEN) == 0)
114: return adj;
115:
116: return NULL;
117: }
118:
119: struct isis_adjacency *
120: isis_adj_lookup_snpa (u_char * ssnpa, struct list *adjdb)
121: {
122: struct listnode *node;
123: struct isis_adjacency *adj;
124:
125: for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
126: if (memcmp (adj->snpa, ssnpa, ETH_ALEN) == 0)
127: return adj;
128:
129: return NULL;
130: }
131:
132: void
1.1.1.2 misho 133: isis_delete_adj (void *arg)
1.1 misho 134: {
1.1.1.2 misho 135: struct isis_adjacency *adj = arg;
136:
1.1 misho 137: if (!adj)
138: return;
139:
1.1.1.2 misho 140: THREAD_TIMER_OFF (adj->t_expire);
141:
142: /* remove from SPF trees */
143: spftree_area_adj_del (adj->circuit->area, adj);
1.1 misho 144:
1.1.1.2 misho 145: if (adj->area_addrs)
146: list_delete (adj->area_addrs);
1.1 misho 147: if (adj->ipv4_addrs)
148: list_delete (adj->ipv4_addrs);
149: #ifdef HAVE_IPV6
150: if (adj->ipv6_addrs)
151: list_delete (adj->ipv6_addrs);
152: #endif
1.1.1.2 misho 153:
1.1 misho 154: XFREE (MTYPE_ISIS_ADJACENCY, adj);
155: return;
156: }
157:
1.1.1.2 misho 158: static const char *
159: adj_state2string (int state)
160: {
161:
162: switch (state)
163: {
164: case ISIS_ADJ_INITIALIZING:
165: return "Initializing";
166: case ISIS_ADJ_UP:
167: return "Up";
168: case ISIS_ADJ_DOWN:
169: return "Down";
170: default:
171: return "Unknown";
172: }
173:
174: return NULL; /* not reached */
175: }
176:
1.1 misho 177: void
1.1.1.2 misho 178: isis_adj_state_change (struct isis_adjacency *adj, enum isis_adj_state new_state,
1.1 misho 179: const char *reason)
180: {
181: int old_state;
1.1.1.2 misho 182: int level;
1.1 misho 183: struct isis_circuit *circuit;
184:
185: old_state = adj->adj_state;
1.1.1.2 misho 186: adj->adj_state = new_state;
1.1 misho 187:
188: circuit = adj->circuit;
189:
190: if (isis->debugs & DEBUG_ADJ_PACKETS)
191: {
192: zlog_debug ("ISIS-Adj (%s): Adjacency state change %d->%d: %s",
193: circuit->area->area_tag,
1.1.1.2 misho 194: old_state, new_state, reason ? reason : "unspecified");
1.1 misho 195: }
196:
1.1.1.2 misho 197: if (circuit->area->log_adj_changes)
1.1 misho 198: {
1.1.1.2 misho 199: const char *adj_name;
200: struct isis_dynhn *dyn;
201:
202: dyn = dynhn_find_by_id (adj->sysid);
203: if (dyn)
204: adj_name = (const char *)dyn->name.name;
205: else
206: adj_name = adj->sysid ? sysid_print (adj->sysid) : "unknown";
207:
208: zlog_info ("%%ADJCHANGE: Adjacency to %s (%s) changed from %s to %s, %s",
209: adj_name,
1.1.1.3 ! misho 210: adj->circuit->interface->name,
1.1.1.2 misho 211: adj_state2string (old_state),
212: adj_state2string (new_state),
213: reason ? reason : "unspecified");
214: }
1.1 misho 215:
1.1.1.2 misho 216: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
217: {
218: for (level = IS_LEVEL_1; level <= IS_LEVEL_2; level++)
219: {
220: if ((adj->level & level) == 0)
221: continue;
222: if (new_state == ISIS_ADJ_UP)
223: {
224: circuit->upadjcount[level - 1]++;
225: isis_event_adjacency_state_change (adj, new_state);
226: /* update counter & timers for debugging purposes */
227: adj->last_flap = time (NULL);
228: adj->flaps++;
229: }
230: else if (new_state == ISIS_ADJ_DOWN)
231: {
232: listnode_delete (circuit->u.bc.adjdb[level - 1], adj);
233: circuit->upadjcount[level - 1]--;
234: if (circuit->upadjcount[level - 1] == 0)
235: {
236: /* Clean lsp_queue when no adj is up. */
237: if (circuit->lsp_queue)
238: list_delete_all_node (circuit->lsp_queue);
239: }
240: isis_event_adjacency_state_change (adj, new_state);
241: isis_delete_adj (adj);
242: }
243:
244: if (circuit->u.bc.lan_neighs[level - 1])
245: {
246: list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
247: isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
248: circuit->u.bc.lan_neighs[level - 1]);
249: }
250:
251: /* On adjacency state change send new pseudo LSP if we are the DR */
252: if (circuit->u.bc.is_dr[level - 1])
253: lsp_regenerate_schedule_pseudo (circuit, level);
254: }
255: }
256: else if (circuit->circ_type == CIRCUIT_T_P2P)
257: {
258: for (level = IS_LEVEL_1; level <= IS_LEVEL_2; level++)
259: {
260: if ((adj->level & level) == 0)
261: continue;
262: if (new_state == ISIS_ADJ_UP)
263: {
264: circuit->upadjcount[level - 1]++;
265: isis_event_adjacency_state_change (adj, new_state);
266:
267: if (adj->sys_type == ISIS_SYSTYPE_UNKNOWN)
268: send_hello (circuit, level);
269:
270: /* update counter & timers for debugging purposes */
271: adj->last_flap = time (NULL);
272: adj->flaps++;
273:
274: /* 7.3.17 - going up on P2P -> send CSNP */
275: /* FIXME: yup, I know its wrong... but i will do it! (for now) */
276: send_csnp (circuit, level);
277: }
278: else if (new_state == ISIS_ADJ_DOWN)
279: {
280: if (adj->circuit->u.p2p.neighbor == adj)
281: adj->circuit->u.p2p.neighbor = NULL;
282: circuit->upadjcount[level - 1]--;
283: if (circuit->upadjcount[level - 1] == 0)
284: {
285: /* Clean lsp_queue when no adj is up. */
286: if (circuit->lsp_queue)
287: list_delete_all_node (circuit->lsp_queue);
288: }
289: isis_event_adjacency_state_change (adj, new_state);
290: isis_delete_adj (adj);
291: }
292: }
1.1 misho 293: }
1.1.1.2 misho 294:
1.1 misho 295: return;
296: }
297:
298:
299: void
300: isis_adj_print (struct isis_adjacency *adj)
301: {
302: struct isis_dynhn *dyn;
303: struct listnode *node;
304: struct in_addr *ipv4_addr;
305: #ifdef HAVE_IPV6
306: struct in6_addr *ipv6_addr;
307: u_char ip6[INET6_ADDRSTRLEN];
308: #endif /* HAVE_IPV6 */
309:
310: if (!adj)
311: return;
312: dyn = dynhn_find_by_id (adj->sysid);
313: if (dyn)
314: zlog_debug ("%s", dyn->name.name);
315:
316: zlog_debug ("SystemId %20s SNPA %s, level %d\nHolding Time %d",
317: adj->sysid ? sysid_print (adj->sysid) : "unknown",
318: snpa_print (adj->snpa), adj->level, adj->hold_time);
319: if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0)
320: {
1.1.1.2 misho 321: zlog_debug ("IPv4 Address(es):");
1.1 misho 322:
323: for (ALL_LIST_ELEMENTS_RO (adj->ipv4_addrs, node, ipv4_addr))
324: zlog_debug ("%s", inet_ntoa (*ipv4_addr));
325: }
326:
327: #ifdef HAVE_IPV6
328: if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0)
329: {
1.1.1.2 misho 330: zlog_debug ("IPv6 Address(es):");
1.1 misho 331: for (ALL_LIST_ELEMENTS_RO (adj->ipv6_addrs, node, ipv6_addr))
332: {
333: inet_ntop (AF_INET6, ipv6_addr, (char *)ip6, INET6_ADDRSTRLEN);
334: zlog_debug ("%s", ip6);
335: }
336: }
337: #endif /* HAVE_IPV6 */
338: zlog_debug ("Speaks: %s", nlpid2string (&adj->nlpids));
339:
340: return;
341: }
342:
343: int
344: isis_adj_expire (struct thread *thread)
345: {
346: struct isis_adjacency *adj;
347:
348: /*
349: * Get the adjacency
350: */
351: adj = THREAD_ARG (thread);
352: assert (adj);
353: adj->t_expire = NULL;
354:
355: /* trigger the adj expire event */
356: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "holding time expired");
357:
358: return 0;
359: }
360:
361: /*
1.1.1.2 misho 362: * show isis neighbor [detail]
1.1 misho 363: */
1.1.1.2 misho 364: void
365: isis_adj_print_vty (struct isis_adjacency *adj, struct vty *vty, char detail)
1.1 misho 366: {
367: #ifdef HAVE_IPV6
368: struct in6_addr *ipv6_addr;
369: u_char ip6[INET6_ADDRSTRLEN];
370: #endif /* HAVE_IPV6 */
371: struct in_addr *ip_addr;
372: time_t now;
373: struct isis_dynhn *dyn;
374: int level;
375: struct listnode *node;
376:
377: dyn = dynhn_find_by_id (adj->sysid);
378: if (dyn)
379: vty_out (vty, " %-20s", dyn->name.name);
380: else if (adj->sysid)
381: {
382: vty_out (vty, " %-20s", sysid_print (adj->sysid));
383: }
384: else
385: {
386: vty_out (vty, " unknown ");
387: }
388:
389: if (detail == ISIS_UI_LEVEL_BRIEF)
390: {
391: if (adj->circuit)
392: vty_out (vty, "%-12s", adj->circuit->interface->name);
393: else
394: vty_out (vty, "NULL circuit!");
395: vty_out (vty, "%-3u", adj->level); /* level */
396: vty_out (vty, "%-13s", adj_state2string (adj->adj_state));
397: now = time (NULL);
398: if (adj->last_upd)
399: vty_out (vty, "%-9lu", adj->last_upd + adj->hold_time - now);
400: else
401: vty_out (vty, "- ");
402: vty_out (vty, "%-10s", snpa_print (adj->snpa));
403: vty_out (vty, "%s", VTY_NEWLINE);
404: }
405:
406: if (detail == ISIS_UI_LEVEL_DETAIL)
407: {
408: level = adj->level;
1.1.1.2 misho 409: vty_out (vty, "%s", VTY_NEWLINE);
1.1 misho 410: if (adj->circuit)
1.1.1.2 misho 411: vty_out (vty, " Interface: %s", adj->circuit->interface->name);
1.1 misho 412: else
1.1.1.2 misho 413: vty_out (vty, " Interface: NULL circuit");
1.1 misho 414: vty_out (vty, ", Level: %u", adj->level); /* level */
415: vty_out (vty, ", State: %s", adj_state2string (adj->adj_state));
416: now = time (NULL);
417: if (adj->last_upd)
418: vty_out (vty, ", Expires in %s",
419: time2string (adj->last_upd + adj->hold_time - now));
420: else
421: vty_out (vty, ", Expires in %s", time2string (adj->hold_time));
1.1.1.2 misho 422: vty_out (vty, "%s", VTY_NEWLINE);
423: vty_out (vty, " Adjacency flaps: %u", adj->flaps);
1.1 misho 424: vty_out (vty, ", Last: %s ago", time2string (now - adj->last_flap));
1.1.1.2 misho 425: vty_out (vty, "%s", VTY_NEWLINE);
426: vty_out (vty, " Circuit type: %s", circuit_t2string (adj->circuit_t));
1.1 misho 427: vty_out (vty, ", Speaks: %s", nlpid2string (&adj->nlpids));
1.1.1.2 misho 428: vty_out (vty, "%s", VTY_NEWLINE);
429: vty_out (vty, " SNPA: %s", snpa_print (adj->snpa));
1.1.1.3 ! misho 430: if (adj->circuit && (adj->circuit->circ_type == CIRCUIT_T_BROADCAST))
1.1.1.2 misho 431: {
432: dyn = dynhn_find_by_id (adj->lanid);
433: if (dyn)
434: vty_out (vty, ", LAN id: %s.%02x",
435: dyn->name.name, adj->lanid[ISIS_SYS_ID_LEN]);
436: else
437: vty_out (vty, ", LAN id: %s.%02x",
438: sysid_print (adj->lanid), adj->lanid[ISIS_SYS_ID_LEN]);
439:
440: vty_out (vty, "%s", VTY_NEWLINE);
441: vty_out (vty, " LAN Priority: %u", adj->prio[adj->level - 1]);
442:
443: vty_out (vty, ", %s, DIS flaps: %u, Last: %s ago",
444: isis_disflag2string (adj->dis_record[ISIS_LEVELS + level - 1].
445: dis), adj->dischanges[level - 1],
446: time2string (now -
447: (adj->dis_record[ISIS_LEVELS + level - 1].
448: last_dis_change)));
449: }
450: vty_out (vty, "%s", VTY_NEWLINE);
1.1 misho 451:
1.1.1.2 misho 452: if (adj->area_addrs && listcount (adj->area_addrs) > 0)
453: {
454: struct area_addr *area_addr;
455: vty_out (vty, " Area Address(es):%s", VTY_NEWLINE);
456: for (ALL_LIST_ELEMENTS_RO (adj->area_addrs, node, area_addr))
457: vty_out (vty, " %s%s", isonet_print (area_addr->area_addr,
458: area_addr->addr_len), VTY_NEWLINE);
459: }
1.1 misho 460: if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0)
461: {
1.1.1.2 misho 462: vty_out (vty, " IPv4 Address(es):%s", VTY_NEWLINE);
1.1 misho 463: for (ALL_LIST_ELEMENTS_RO (adj->ipv4_addrs, node, ip_addr))
464: vty_out (vty, " %s%s", inet_ntoa (*ip_addr), VTY_NEWLINE);
465: }
466: #ifdef HAVE_IPV6
467: if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0)
468: {
1.1.1.2 misho 469: vty_out (vty, " IPv6 Address(es):%s", VTY_NEWLINE);
1.1 misho 470: for (ALL_LIST_ELEMENTS_RO (adj->ipv6_addrs, node, ipv6_addr))
471: {
472: inet_ntop (AF_INET6, ipv6_addr, (char *)ip6, INET6_ADDRSTRLEN);
473: vty_out (vty, " %s%s", ip6, VTY_NEWLINE);
474: }
475: }
476: #endif /* HAVE_IPV6 */
477: vty_out (vty, "%s", VTY_NEWLINE);
478: }
479: return;
480: }
481:
482: void
483: isis_adj_build_neigh_list (struct list *adjdb, struct list *list)
484: {
485: struct isis_adjacency *adj;
486: struct listnode *node;
487:
488: if (!list)
489: {
490: zlog_warn ("isis_adj_build_neigh_list(): NULL list");
491: return;
492: }
493:
494: for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
495: {
496: if (!adj)
497: {
498: zlog_warn ("isis_adj_build_neigh_list(): NULL adj");
499: return;
500: }
501:
502: if ((adj->adj_state == ISIS_ADJ_UP ||
503: adj->adj_state == ISIS_ADJ_INITIALIZING))
504: listnode_add (list, adj->snpa);
505: }
506: return;
507: }
508:
509: void
510: isis_adj_build_up_list (struct list *adjdb, struct list *list)
511: {
512: struct isis_adjacency *adj;
513: struct listnode *node;
514:
515: if (!list)
516: {
517: zlog_warn ("isis_adj_build_up_list(): NULL list");
518: return;
519: }
520:
521: for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
522: {
523: if (!adj)
524: {
525: zlog_warn ("isis_adj_build_up_list(): NULL adj");
526: return;
527: }
528:
529: if (adj->adj_state == ISIS_ADJ_UP)
530: listnode_add (list, adj);
531: }
532:
533: return;
534: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_adjacency.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