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