Annotation of embedaddon/quagga/isisd/isis_pdu.c, revision 1.1
1.1 ! misho 1: /*
! 2: * IS-IS Rout(e)ing protocol - isis_pdu.c
! 3: * PDU processing
! 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 "memory.h"
! 27: #include "thread.h"
! 28: #include "linklist.h"
! 29: #include "log.h"
! 30: #include "stream.h"
! 31: #include "vty.h"
! 32: #include "hash.h"
! 33: #include "prefix.h"
! 34: #include "if.h"
! 35: #include "checksum.h"
! 36:
! 37: #include "isisd/dict.h"
! 38: #include "isisd/include-netbsd/iso.h"
! 39: #include "isisd/isis_constants.h"
! 40: #include "isisd/isis_common.h"
! 41: #include "isisd/isis_adjacency.h"
! 42: #include "isisd/isis_circuit.h"
! 43: #include "isisd/isis_network.h"
! 44: #include "isisd/isis_misc.h"
! 45: #include "isisd/isis_dr.h"
! 46: #include "isisd/isis_flags.h"
! 47: #include "isisd/isis_tlv.h"
! 48: #include "isisd/isisd.h"
! 49: #include "isisd/isis_dynhn.h"
! 50: #include "isisd/isis_lsp.h"
! 51: #include "isisd/isis_pdu.h"
! 52: #include "isisd/iso_checksum.h"
! 53: #include "isisd/isis_csm.h"
! 54: #include "isisd/isis_events.h"
! 55:
! 56: extern struct thread_master *master;
! 57: extern struct isis *isis;
! 58:
! 59: #define ISIS_MINIMUM_FIXED_HDR_LEN 15
! 60: #define ISIS_MIN_PDU_LEN 13 /* partial seqnum pdu with id_len=2 */
! 61:
! 62: #ifndef PNBBY
! 63: #define PNBBY 8
! 64: #endif /* PNBBY */
! 65:
! 66: /* Utility mask array. */
! 67: static const u_char maskbit[] = {
! 68: 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
! 69: };
! 70:
! 71: /*
! 72: * HELPER FUNCS
! 73: */
! 74:
! 75: /*
! 76: * Compares two sets of area addresses
! 77: */
! 78: static int
! 79: area_match (struct list *left, struct list *right)
! 80: {
! 81: struct area_addr *addr1, *addr2;
! 82: struct listnode *node1, *node2;
! 83:
! 84: for (ALL_LIST_ELEMENTS_RO (left, node1, addr1))
! 85: {
! 86: for (ALL_LIST_ELEMENTS_RO (right, node2, addr2))
! 87: {
! 88: if (addr1->addr_len == addr2->addr_len &&
! 89: !memcmp (addr1->area_addr, addr2->area_addr, (int) addr1->addr_len))
! 90: return 1; /* match */
! 91: }
! 92: }
! 93:
! 94: return 0; /* mismatch */
! 95: }
! 96:
! 97: /*
! 98: * Check if ip2 is in the ip1's network (function like Prefix.h:prefix_match() )
! 99: * param ip1 the IS interface ip address structure
! 100: * param ip2 the IIH's ip address
! 101: * return 0 the IIH's IP is not in the IS's subnetwork
! 102: * 1 the IIH's IP is in the IS's subnetwork
! 103: */
! 104: static int
! 105: ip_same_subnet (struct prefix_ipv4 *ip1, struct in_addr *ip2)
! 106: {
! 107: u_char *addr1, *addr2;
! 108: int shift, offset, offsetloop;
! 109: int len;
! 110:
! 111: addr1 = (u_char *) & ip1->prefix.s_addr;
! 112: addr2 = (u_char *) & ip2->s_addr;
! 113: len = ip1->prefixlen;
! 114:
! 115: shift = len % PNBBY;
! 116: offsetloop = offset = len / PNBBY;
! 117:
! 118: while (offsetloop--)
! 119: if (addr1[offsetloop] != addr2[offsetloop])
! 120: return 0;
! 121:
! 122: if (shift)
! 123: if (maskbit[shift] & (addr1[offset] ^ addr2[offset]))
! 124: return 0;
! 125:
! 126: return 1; /* match */
! 127: }
! 128:
! 129: /*
! 130: * Compares two set of ip addresses
! 131: * param left the local interface's ip addresses
! 132: * param right the iih interface's ip address
! 133: * return 0 no match;
! 134: * 1 match;
! 135: */
! 136: static int
! 137: ip_match (struct list *left, struct list *right)
! 138: {
! 139: struct prefix_ipv4 *ip1;
! 140: struct in_addr *ip2;
! 141: struct listnode *node1, *node2;
! 142:
! 143: if ((left == NULL) || (right == NULL))
! 144: return 0;
! 145:
! 146: for (ALL_LIST_ELEMENTS_RO (left, node1, ip1))
! 147: {
! 148: for (ALL_LIST_ELEMENTS_RO (right, node2, ip2))
! 149: {
! 150: if (ip_same_subnet (ip1, ip2))
! 151: {
! 152: return 1; /* match */
! 153: }
! 154: }
! 155:
! 156: }
! 157: return 0;
! 158: }
! 159:
! 160: /*
! 161: * Checks whether we should accept a PDU of given level
! 162: */
! 163: static int
! 164: accept_level (int level, int circuit_t)
! 165: {
! 166: int retval = ((circuit_t & level) == level); /* simple approach */
! 167:
! 168: return retval;
! 169: }
! 170:
! 171: int
! 172: authentication_check (struct isis_passwd *one, struct isis_passwd *theother)
! 173: {
! 174: if (one->type != theother->type)
! 175: {
! 176: zlog_warn ("Unsupported authentication type %d", theother->type);
! 177: return 1; /* Auth fail (different authentication types) */
! 178: }
! 179: switch (one->type)
! 180: {
! 181: case ISIS_PASSWD_TYPE_CLEARTXT:
! 182: if (one->len != theother->len)
! 183: return 1; /* Auth fail () - passwd len mismatch */
! 184: return memcmp (one->passwd, theother->passwd, one->len);
! 185: break;
! 186: default:
! 187: zlog_warn ("Unsupported authentication type");
! 188: break;
! 189: }
! 190: return 0; /* Auth pass */
! 191: }
! 192:
! 193: /*
! 194: * Processing helper functions
! 195: */
! 196: static void
! 197: tlvs_to_adj_nlpids (struct tlvs *tlvs, struct isis_adjacency *adj)
! 198: {
! 199: int i;
! 200: struct nlpids *tlv_nlpids;
! 201:
! 202: if (tlvs->nlpids)
! 203: {
! 204:
! 205: tlv_nlpids = tlvs->nlpids;
! 206:
! 207: adj->nlpids.count = tlv_nlpids->count;
! 208:
! 209: for (i = 0; i < tlv_nlpids->count; i++)
! 210: {
! 211: adj->nlpids.nlpids[i] = tlv_nlpids->nlpids[i];
! 212: }
! 213: }
! 214: }
! 215:
! 216: static void
! 217: del_ip_addr (void *val)
! 218: {
! 219: XFREE (MTYPE_ISIS_TMP, val);
! 220: }
! 221:
! 222: static void
! 223: tlvs_to_adj_ipv4_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
! 224: {
! 225: struct listnode *node;
! 226: struct in_addr *ipv4_addr, *malloced;
! 227:
! 228: if (adj->ipv4_addrs)
! 229: {
! 230: adj->ipv4_addrs->del = del_ip_addr;
! 231: list_delete (adj->ipv4_addrs);
! 232: }
! 233: adj->ipv4_addrs = list_new ();
! 234: if (tlvs->ipv4_addrs)
! 235: {
! 236: for (ALL_LIST_ELEMENTS_RO (tlvs->ipv4_addrs, node, ipv4_addr))
! 237: {
! 238: malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in_addr));
! 239: memcpy (malloced, ipv4_addr, sizeof (struct in_addr));
! 240: listnode_add (adj->ipv4_addrs, malloced);
! 241: }
! 242: }
! 243: }
! 244:
! 245: #ifdef HAVE_IPV6
! 246: static void
! 247: tlvs_to_adj_ipv6_addrs (struct tlvs *tlvs, struct isis_adjacency *adj)
! 248: {
! 249: struct listnode *node;
! 250: struct in6_addr *ipv6_addr, *malloced;
! 251:
! 252: if (adj->ipv6_addrs)
! 253: {
! 254: adj->ipv6_addrs->del = del_ip_addr;
! 255: list_delete (adj->ipv6_addrs);
! 256: }
! 257: adj->ipv6_addrs = list_new ();
! 258: if (tlvs->ipv6_addrs)
! 259: {
! 260: for (ALL_LIST_ELEMENTS_RO (tlvs->ipv6_addrs, node, ipv6_addr))
! 261: {
! 262: malloced = XMALLOC (MTYPE_ISIS_TMP, sizeof (struct in6_addr));
! 263: memcpy (malloced, ipv6_addr, sizeof (struct in6_addr));
! 264: listnode_add (adj->ipv6_addrs, malloced);
! 265: }
! 266: }
! 267:
! 268: }
! 269: #endif /* HAVE_IPV6 */
! 270:
! 271: /*
! 272: * RECEIVE SIDE
! 273: */
! 274:
! 275: /*
! 276: * Process P2P IIH
! 277: * ISO - 10589
! 278: * Section 8.2.5 - Receiving point-to-point IIH PDUs
! 279: *
! 280: */
! 281: static int
! 282: process_p2p_hello (struct isis_circuit *circuit)
! 283: {
! 284: int retval = ISIS_OK;
! 285: struct isis_p2p_hello_hdr *hdr;
! 286: struct isis_adjacency *adj;
! 287: u_int32_t expected = 0, found;
! 288: struct tlvs tlvs;
! 289:
! 290: if ((stream_get_endp (circuit->rcv_stream) -
! 291: stream_get_getp (circuit->rcv_stream)) < ISIS_P2PHELLO_HDRLEN)
! 292: {
! 293: zlog_warn ("Packet too short");
! 294: return ISIS_WARNING;
! 295: }
! 296:
! 297: /* 8.2.5.1 PDU acceptance tests */
! 298:
! 299: /* 8.2.5.1 a) external domain untrue */
! 300: /* FIXME: not useful at all? */
! 301:
! 302: /* 8.2.5.1 b) ID Length mismatch */
! 303: /* checked at the handle_pdu */
! 304:
! 305: /* 8.2.5.2 IIH PDU Processing */
! 306:
! 307: /* 8.2.5.2 a) 1) Maximum Area Addresses */
! 308: /* Already checked, and can also be ommited */
! 309:
! 310: /*
! 311: * Get the header
! 312: */
! 313: hdr = (struct isis_p2p_hello_hdr *) STREAM_PNT (circuit->rcv_stream);
! 314: circuit->rcv_stream->getp += ISIS_P2PHELLO_HDRLEN;
! 315:
! 316: /* hdr.circuit_t = stream_getc (stream);
! 317: stream_get (hdr.source_id, stream, ISIS_SYS_ID_LEN);
! 318: hdr.hold_time = stream_getw (stream);
! 319: hdr.pdu_len = stream_getw (stream);
! 320: hdr.local_id = stream_getc (stream); */
! 321:
! 322: /*
! 323: * My interpertation of the ISO, if no adj exists we will create one for
! 324: * the circuit
! 325: */
! 326:
! 327: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 328: {
! 329: zlog_debug ("ISIS-Adj (%s): Rcvd P2P IIH from (%s), cir type %s,"
! 330: " cir id %02d, length %d",
! 331: circuit->area->area_tag, circuit->interface->name,
! 332: circuit_t2string (circuit->circuit_is_type),
! 333: circuit->circuit_id, ntohs (hdr->pdu_len));
! 334: }
! 335:
! 336: adj = circuit->u.p2p.neighbor;
! 337: if (!adj)
! 338: {
! 339: adj = isis_new_adj (hdr->source_id, NULL, 0, circuit);
! 340: if (adj == NULL)
! 341: return ISIS_ERROR;
! 342: circuit->u.p2p.neighbor = adj;
! 343: isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
! 344: adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
! 345: }
! 346:
! 347: /* 8.2.6 Monitoring point-to-point adjacencies */
! 348: adj->hold_time = ntohs (hdr->hold_time);
! 349: adj->last_upd = time (NULL);
! 350:
! 351: /*
! 352: * Lets get the TLVS now
! 353: */
! 354: expected |= TLVFLAG_AREA_ADDRS;
! 355: expected |= TLVFLAG_AUTH_INFO;
! 356: expected |= TLVFLAG_NLPID;
! 357: expected |= TLVFLAG_IPV4_ADDR;
! 358: expected |= TLVFLAG_IPV6_ADDR;
! 359:
! 360: retval = parse_tlvs (circuit->area->area_tag,
! 361: STREAM_PNT (circuit->rcv_stream),
! 362: ntohs (hdr->pdu_len) - ISIS_P2PHELLO_HDRLEN
! 363: - ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
! 364:
! 365: if (retval > ISIS_WARNING)
! 366: {
! 367: free_tlvs (&tlvs);
! 368: return retval;
! 369: };
! 370:
! 371: /* 8.2.5.1 c) Authentication */
! 372: if (circuit->passwd.type)
! 373: {
! 374: if (!(found & TLVFLAG_AUTH_INFO) ||
! 375: authentication_check (&circuit->passwd, &tlvs.auth_info))
! 376: {
! 377: isis_event_auth_failure (circuit->area->area_tag,
! 378: "P2P hello authentication failure",
! 379: hdr->source_id);
! 380: return ISIS_OK;
! 381: }
! 382: }
! 383:
! 384: /* we do this now because the adj may not survive till the end... */
! 385:
! 386: /* we need to copy addresses to the adj */
! 387: tlvs_to_adj_ipv4_addrs (&tlvs, adj);
! 388:
! 389: #ifdef HAVE_IPV6
! 390: tlvs_to_adj_ipv6_addrs (&tlvs, adj);
! 391: #endif /* HAVE_IPV6 */
! 392:
! 393: /* lets take care of the expiry */
! 394: THREAD_TIMER_OFF (adj->t_expire);
! 395: THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
! 396: (long) adj->hold_time);
! 397:
! 398: /* 8.2.5.2 a) a match was detected */
! 399: if (area_match (circuit->area->area_addrs, tlvs.area_addrs))
! 400: {
! 401: /* 8.2.5.2 a) 2) If the system is L1 - table 5 */
! 402: if (circuit->area->is_type == IS_LEVEL_1)
! 403: {
! 404: switch (hdr->circuit_t)
! 405: {
! 406: case IS_LEVEL_1:
! 407: case IS_LEVEL_1_AND_2:
! 408: if (adj->adj_state != ISIS_ADJ_UP)
! 409: {
! 410: /* (4) adj state up */
! 411: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 412: /* (5) adj usage level 1 */
! 413: adj->adj_usage = ISIS_ADJ_LEVEL1;
! 414: }
! 415: else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
! 416: {
! 417: ; /* accept */
! 418: }
! 419: break;
! 420: case IS_LEVEL_2:
! 421: if (adj->adj_state != ISIS_ADJ_UP)
! 422: {
! 423: /* (7) reject - wrong system type event */
! 424: zlog_warn ("wrongSystemType");
! 425: return ISIS_WARNING; /* Reject */
! 426: }
! 427: else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
! 428: {
! 429: /* (6) down - wrong system */
! 430: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 431: }
! 432: break;
! 433: }
! 434: }
! 435:
! 436: /* 8.2.5.2 a) 3) If the system is L1L2 - table 6 */
! 437: if (circuit->area->is_type == IS_LEVEL_1_AND_2)
! 438: {
! 439: switch (hdr->circuit_t)
! 440: {
! 441: case IS_LEVEL_1:
! 442: if (adj->adj_state != ISIS_ADJ_UP)
! 443: {
! 444: /* (6) adj state up */
! 445: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 446: /* (7) adj usage level 1 */
! 447: adj->adj_usage = ISIS_ADJ_LEVEL1;
! 448: }
! 449: else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
! 450: {
! 451: ; /* accept */
! 452: }
! 453: else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
! 454: (adj->adj_usage == ISIS_ADJ_LEVEL2))
! 455: {
! 456: /* (8) down - wrong system */
! 457: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 458: }
! 459: break;
! 460: case IS_LEVEL_2:
! 461: if (adj->adj_state != ISIS_ADJ_UP)
! 462: {
! 463: /* (6) adj state up */
! 464: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 465: /* (9) adj usage level 2 */
! 466: adj->adj_usage = ISIS_ADJ_LEVEL2;
! 467: }
! 468: else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
! 469: (adj->adj_usage == ISIS_ADJ_LEVEL1AND2))
! 470: {
! 471: /* (8) down - wrong system */
! 472: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 473: }
! 474: else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
! 475: {
! 476: ; /* Accept */
! 477: }
! 478: break;
! 479: case IS_LEVEL_1_AND_2:
! 480: if (adj->adj_state != ISIS_ADJ_UP)
! 481: {
! 482: /* (6) adj state up */
! 483: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 484: /* (10) adj usage level 1 */
! 485: adj->adj_usage = ISIS_ADJ_LEVEL1AND2;
! 486: }
! 487: else if ((adj->adj_usage == ISIS_ADJ_LEVEL1) ||
! 488: (adj->adj_usage == ISIS_ADJ_LEVEL2))
! 489: {
! 490: /* (8) down - wrong system */
! 491: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 492: }
! 493: else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
! 494: {
! 495: ; /* Accept */
! 496: }
! 497: break;
! 498: }
! 499: }
! 500:
! 501: /* 8.2.5.2 a) 4) If the system is L2 - table 7 */
! 502: if (circuit->area->is_type == IS_LEVEL_2)
! 503: {
! 504: switch (hdr->circuit_t)
! 505: {
! 506: case IS_LEVEL_1:
! 507: if (adj->adj_state != ISIS_ADJ_UP)
! 508: {
! 509: /* (5) reject - wrong system type event */
! 510: zlog_warn ("wrongSystemType");
! 511: return ISIS_WARNING; /* Reject */
! 512: }
! 513: else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
! 514: (adj->adj_usage == ISIS_ADJ_LEVEL2))
! 515: {
! 516: /* (6) down - wrong system */
! 517: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 518: }
! 519: break;
! 520: case IS_LEVEL_1_AND_2:
! 521: case IS_LEVEL_2:
! 522: if (adj->adj_state != ISIS_ADJ_UP)
! 523: {
! 524: /* (7) adj state up */
! 525: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 526: /* (8) adj usage level 2 */
! 527: adj->adj_usage = ISIS_ADJ_LEVEL2;
! 528: }
! 529: else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
! 530: {
! 531: /* (6) down - wrong system */
! 532: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 533: }
! 534: else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
! 535: {
! 536: ; /* Accept */
! 537: }
! 538: break;
! 539: }
! 540: }
! 541: }
! 542: /* 8.2.5.2 b) if no match was detected */
! 543: else
! 544: {
! 545: if (circuit->area->is_type == IS_LEVEL_1)
! 546: {
! 547: /* 8.2.5.2 b) 1) is_type L1 and adj is not up */
! 548: if (adj->adj_state != ISIS_ADJ_UP)
! 549: {
! 550: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
! 551: /* 8.2.5.2 b) 2)is_type L1 and adj is up */
! 552: }
! 553: else
! 554: {
! 555: isis_adj_state_change (adj, ISIS_ADJ_DOWN,
! 556: "Down - Area Mismatch");
! 557: }
! 558: }
! 559: /* 8.2.5.2 b 3 If the system is L2 or L1L2 - table 8 */
! 560: else
! 561: {
! 562: switch (hdr->circuit_t)
! 563: {
! 564: case IS_LEVEL_1:
! 565: if (adj->adj_state != ISIS_ADJ_UP)
! 566: {
! 567: /* (6) reject - Area Mismatch event */
! 568: zlog_warn ("AreaMismatch");
! 569: return ISIS_WARNING; /* Reject */
! 570: }
! 571: else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
! 572: {
! 573: /* (7) down - area mismatch */
! 574: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Area Mismatch");
! 575:
! 576: }
! 577: else if ((adj->adj_usage == ISIS_ADJ_LEVEL1AND2) ||
! 578: (adj->adj_usage == ISIS_ADJ_LEVEL2))
! 579: {
! 580: /* (7) down - wrong system */
! 581: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 582: }
! 583: break;
! 584: case IS_LEVEL_1_AND_2:
! 585: case IS_LEVEL_2:
! 586: if (adj->adj_state != ISIS_ADJ_UP)
! 587: {
! 588: /* (8) adj state up */
! 589: isis_adj_state_change (adj, ISIS_ADJ_UP, NULL);
! 590: /* (9) adj usage level 2 */
! 591: adj->adj_usage = ISIS_ADJ_LEVEL2;
! 592: }
! 593: else if (adj->adj_usage == ISIS_ADJ_LEVEL1)
! 594: {
! 595: /* (7) down - wrong system */
! 596: isis_adj_state_change (adj, ISIS_ADJ_DOWN, "Wrong System");
! 597: }
! 598: else if (adj->adj_usage == ISIS_ADJ_LEVEL1AND2)
! 599: {
! 600: if (hdr->circuit_t == IS_LEVEL_2)
! 601: {
! 602: /* (7) down - wrong system */
! 603: isis_adj_state_change (adj, ISIS_ADJ_DOWN,
! 604: "Wrong System");
! 605: }
! 606: else
! 607: {
! 608: /* (7) down - area mismatch */
! 609: isis_adj_state_change (adj, ISIS_ADJ_DOWN,
! 610: "Area Mismatch");
! 611: }
! 612: }
! 613: else if (adj->adj_usage == ISIS_ADJ_LEVEL2)
! 614: {
! 615: ; /* Accept */
! 616: }
! 617: break;
! 618: }
! 619: }
! 620: }
! 621: /* 8.2.5.2 c) if the action was up - comparing circuit IDs */
! 622: /* FIXME - Missing parts */
! 623:
! 624: /* some of my own understanding of the ISO, why the heck does
! 625: * it not say what should I change the system_type to...
! 626: */
! 627: switch (adj->adj_usage)
! 628: {
! 629: case ISIS_ADJ_LEVEL1:
! 630: adj->sys_type = ISIS_SYSTYPE_L1_IS;
! 631: break;
! 632: case ISIS_ADJ_LEVEL2:
! 633: adj->sys_type = ISIS_SYSTYPE_L2_IS;
! 634: break;
! 635: case ISIS_ADJ_LEVEL1AND2:
! 636: adj->sys_type = ISIS_SYSTYPE_L2_IS;
! 637: break;
! 638: case ISIS_ADJ_NONE:
! 639: adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
! 640: break;
! 641: }
! 642:
! 643: adj->circuit_t = hdr->circuit_t;
! 644: adj->level = hdr->circuit_t;
! 645:
! 646: free_tlvs (&tlvs);
! 647:
! 648: return retval;
! 649: }
! 650:
! 651: /*
! 652: * Process IS-IS LAN Level 1/2 Hello PDU
! 653: */
! 654: static int
! 655: process_lan_hello (int level, struct isis_circuit *circuit, u_char * ssnpa)
! 656: {
! 657: int retval = ISIS_OK;
! 658: struct isis_lan_hello_hdr hdr;
! 659: struct isis_adjacency *adj;
! 660: u_int32_t expected = 0, found;
! 661: struct tlvs tlvs;
! 662: u_char *snpa;
! 663: struct listnode *node;
! 664:
! 665: if ((stream_get_endp (circuit->rcv_stream) -
! 666: stream_get_getp (circuit->rcv_stream)) < ISIS_LANHELLO_HDRLEN)
! 667: {
! 668: zlog_warn ("Packet too short");
! 669: return ISIS_WARNING;
! 670: }
! 671:
! 672: if (circuit->ext_domain)
! 673: {
! 674: zlog_debug ("level %d LAN Hello received over circuit with "
! 675: "externalDomain = true", level);
! 676: return ISIS_WARNING;
! 677: }
! 678:
! 679: if (!accept_level (level, circuit->circuit_is_type))
! 680: {
! 681: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 682: {
! 683: zlog_debug ("ISIS-Adj (%s): Interface level mismatch, %s",
! 684: circuit->area->area_tag, circuit->interface->name);
! 685: }
! 686: return ISIS_WARNING;
! 687: }
! 688:
! 689: #if 0
! 690: /* Cisco's debug message compatability */
! 691: if (!accept_level (level, circuit->area->is_type))
! 692: {
! 693: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 694: {
! 695: zlog_debug ("ISIS-Adj (%s): is type mismatch",
! 696: circuit->area->area_tag);
! 697: }
! 698: return ISIS_WARNING;
! 699: }
! 700: #endif
! 701: /*
! 702: * Fill the header
! 703: */
! 704: hdr.circuit_t = stream_getc (circuit->rcv_stream);
! 705: stream_get (hdr.source_id, circuit->rcv_stream, ISIS_SYS_ID_LEN);
! 706: hdr.hold_time = stream_getw (circuit->rcv_stream);
! 707: hdr.pdu_len = stream_getw (circuit->rcv_stream);
! 708: hdr.prio = stream_getc (circuit->rcv_stream);
! 709: stream_get (hdr.lan_id, circuit->rcv_stream, ISIS_SYS_ID_LEN + 1);
! 710:
! 711: if (hdr.circuit_t != IS_LEVEL_1 && hdr.circuit_t != IS_LEVEL_2 &&
! 712: hdr.circuit_t != IS_LEVEL_1_AND_2)
! 713: {
! 714: zlog_warn ("Level %d LAN Hello with Circuit Type %d", level,
! 715: hdr.circuit_t);
! 716: return ISIS_ERROR;
! 717: }
! 718: /*
! 719: * Then get the tlvs
! 720: */
! 721: expected |= TLVFLAG_AUTH_INFO;
! 722: expected |= TLVFLAG_AREA_ADDRS;
! 723: expected |= TLVFLAG_LAN_NEIGHS;
! 724: expected |= TLVFLAG_NLPID;
! 725: expected |= TLVFLAG_IPV4_ADDR;
! 726: expected |= TLVFLAG_IPV6_ADDR;
! 727:
! 728: retval = parse_tlvs (circuit->area->area_tag,
! 729: STREAM_PNT (circuit->rcv_stream),
! 730: hdr.pdu_len - ISIS_LANHELLO_HDRLEN -
! 731: ISIS_FIXED_HDR_LEN, &expected, &found, &tlvs);
! 732:
! 733: if (retval > ISIS_WARNING)
! 734: {
! 735: zlog_warn ("parse_tlvs() failed");
! 736: goto out;
! 737: }
! 738:
! 739: if (!(found & TLVFLAG_AREA_ADDRS))
! 740: {
! 741: zlog_warn ("No Area addresses TLV in Level %d LAN IS to IS hello",
! 742: level);
! 743: retval = ISIS_WARNING;
! 744: goto out;
! 745: }
! 746:
! 747: if (circuit->passwd.type)
! 748: {
! 749: if (!(found & TLVFLAG_AUTH_INFO) ||
! 750: authentication_check (&circuit->passwd, &tlvs.auth_info))
! 751: {
! 752: isis_event_auth_failure (circuit->area->area_tag,
! 753: "LAN hello authentication failure",
! 754: hdr.source_id);
! 755: retval = ISIS_WARNING;
! 756: goto out;
! 757: }
! 758: }
! 759:
! 760: /*
! 761: * Accept the level 1 adjacency only if a match between local and
! 762: * remote area addresses is found
! 763: */
! 764: if (level == 1 && !area_match (circuit->area->area_addrs, tlvs.area_addrs))
! 765: {
! 766: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 767: {
! 768: zlog_debug ("ISIS-Adj (%s): Area mismatch, level %d IIH on %s",
! 769: circuit->area->area_tag, level,
! 770: circuit->interface->name);
! 771: }
! 772: retval = ISIS_OK;
! 773: goto out;
! 774: }
! 775:
! 776: /*
! 777: * it's own IIH PDU - discard silently
! 778: */
! 779: if (!memcmp (circuit->u.bc.snpa, ssnpa, ETH_ALEN))
! 780: {
! 781: zlog_debug ("ISIS-Adj (%s): it's own IIH PDU - discarded",
! 782: circuit->area->area_tag);
! 783:
! 784: retval = ISIS_OK;
! 785: goto out;
! 786: }
! 787:
! 788: /*
! 789: * check if it's own interface ip match iih ip addrs
! 790: */
! 791: if (!(found & TLVFLAG_IPV4_ADDR)
! 792: || !ip_match (circuit->ip_addrs, tlvs.ipv4_addrs))
! 793: {
! 794: zlog_debug
! 795: ("ISIS-Adj: No usable IP interface addresses in LAN IIH from %s\n",
! 796: circuit->interface->name);
! 797: retval = ISIS_WARNING;
! 798: goto out;
! 799: }
! 800:
! 801: adj = isis_adj_lookup (hdr.source_id, circuit->u.bc.adjdb[level - 1]);
! 802: if (!adj)
! 803: {
! 804: /*
! 805: * Do as in 8.4.2.5
! 806: */
! 807: adj = isis_new_adj (hdr.source_id, ssnpa, level, circuit);
! 808: if (adj == NULL)
! 809: {
! 810: retval = ISIS_ERROR;
! 811: goto out;
! 812: }
! 813:
! 814: adj->level = level;
! 815: isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
! 816:
! 817: if (level == 1)
! 818: {
! 819: adj->sys_type = ISIS_SYSTYPE_L1_IS;
! 820: }
! 821: else
! 822: {
! 823: adj->sys_type = ISIS_SYSTYPE_L2_IS;
! 824: }
! 825: list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
! 826: isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
! 827: circuit->u.bc.lan_neighs[level - 1]);
! 828: }
! 829:
! 830: if(adj->dis_record[level-1].dis==ISIS_IS_DIS)
! 831: switch (level)
! 832: {
! 833: case 1:
! 834: if (memcmp (circuit->u.bc.l1_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
! 835: {
! 836: thread_add_event (master, isis_event_dis_status_change, circuit, 0);
! 837: memcpy (&circuit->u.bc.l1_desig_is, hdr.lan_id,
! 838: ISIS_SYS_ID_LEN + 1);
! 839: }
! 840: break;
! 841: case 2:
! 842: if (memcmp (circuit->u.bc.l2_desig_is, hdr.lan_id, ISIS_SYS_ID_LEN + 1))
! 843: {
! 844: thread_add_event (master, isis_event_dis_status_change, circuit, 0);
! 845: memcpy (&circuit->u.bc.l2_desig_is, hdr.lan_id,
! 846: ISIS_SYS_ID_LEN + 1);
! 847: }
! 848: break;
! 849: }
! 850:
! 851: adj->hold_time = hdr.hold_time;
! 852: adj->last_upd = time (NULL);
! 853: adj->prio[level - 1] = hdr.prio;
! 854:
! 855: memcpy (adj->lanid, hdr.lan_id, ISIS_SYS_ID_LEN + 1);
! 856:
! 857: /* which protocol are spoken ??? */
! 858: if (found & TLVFLAG_NLPID)
! 859: tlvs_to_adj_nlpids (&tlvs, adj);
! 860:
! 861: /* we need to copy addresses to the adj */
! 862: if (found & TLVFLAG_IPV4_ADDR)
! 863: tlvs_to_adj_ipv4_addrs (&tlvs, adj);
! 864:
! 865: #ifdef HAVE_IPV6
! 866: if (found & TLVFLAG_IPV6_ADDR)
! 867: tlvs_to_adj_ipv6_addrs (&tlvs, adj);
! 868: #endif /* HAVE_IPV6 */
! 869:
! 870: adj->circuit_t = hdr.circuit_t;
! 871:
! 872: /* lets take care of the expiry */
! 873: THREAD_TIMER_OFF (adj->t_expire);
! 874: THREAD_TIMER_ON (master, adj->t_expire, isis_adj_expire, adj,
! 875: (long) adj->hold_time);
! 876:
! 877: /*
! 878: * If the snpa for this circuit is found from LAN Neighbours TLV
! 879: * we have two-way communication -> adjacency can be put to state "up"
! 880: */
! 881:
! 882: if (found & TLVFLAG_LAN_NEIGHS)
! 883: {
! 884: if (adj->adj_state != ISIS_ADJ_UP)
! 885: {
! 886: for (ALL_LIST_ELEMENTS_RO (tlvs.lan_neighs, node, snpa))
! 887: if (!memcmp (snpa, circuit->u.bc.snpa, ETH_ALEN))
! 888: {
! 889: isis_adj_state_change (adj, ISIS_ADJ_UP,
! 890: "own SNPA found in LAN Neighbours TLV");
! 891: }
! 892: }
! 893: }
! 894:
! 895: out:
! 896: /* DEBUG_ADJ_PACKETS */
! 897: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 898: {
! 899: /* FIXME: is this place right? fix missing info */
! 900: zlog_debug ("ISIS-Adj (%s): Rcvd L%d LAN IIH from %s on %s, cirType %s, "
! 901: "cirID %u, length %ld",
! 902: circuit->area->area_tag,
! 903: level, snpa_print (ssnpa), circuit->interface->name,
! 904: circuit_t2string (circuit->circuit_is_type),
! 905: circuit->circuit_id,
! 906: /* FIXME: use %z when we stop supporting old compilers. */
! 907: (unsigned long) stream_get_endp (circuit->rcv_stream));
! 908: }
! 909:
! 910: free_tlvs (&tlvs);
! 911:
! 912: return retval;
! 913: }
! 914:
! 915: /*
! 916: * Process Level 1/2 Link State
! 917: * ISO - 10589
! 918: * Section 7.3.15.1 - Action on receipt of a link state PDU
! 919: */
! 920: static int
! 921: process_lsp (int level, struct isis_circuit *circuit, u_char * ssnpa)
! 922: {
! 923: struct isis_link_state_hdr *hdr;
! 924: struct isis_adjacency *adj = NULL;
! 925: struct isis_lsp *lsp, *lsp0 = NULL;
! 926: int retval = ISIS_OK, comp = 0;
! 927: u_char lspid[ISIS_SYS_ID_LEN + 2];
! 928: struct isis_passwd *passwd;
! 929:
! 930: /* Sanity check - FIXME: move to correct place */
! 931: if ((stream_get_endp (circuit->rcv_stream) -
! 932: stream_get_getp (circuit->rcv_stream)) < ISIS_LSP_HDR_LEN)
! 933: {
! 934: zlog_warn ("Packet too short");
! 935: return ISIS_WARNING;
! 936: }
! 937:
! 938: /* Reference the header */
! 939: hdr = (struct isis_link_state_hdr *) STREAM_PNT (circuit->rcv_stream);
! 940:
! 941: if (isis->debugs & DEBUG_UPDATE_PACKETS)
! 942: {
! 943: zlog_debug ("ISIS-Upd (%s): Rcvd L%d LSP %s, seq 0x%08x, cksum 0x%04x, "
! 944: "lifetime %us, len %lu, on %s",
! 945: circuit->area->area_tag,
! 946: level,
! 947: rawlspid_print (hdr->lsp_id),
! 948: ntohl (hdr->seq_num),
! 949: ntohs (hdr->checksum),
! 950: ntohs (hdr->rem_lifetime),
! 951: /* FIXME: use %z when we stop supporting old compilers. */
! 952: (unsigned long) stream_get_endp (circuit->rcv_stream),
! 953: circuit->interface->name);
! 954: }
! 955:
! 956: assert (ntohs (hdr->pdu_len) > ISIS_LSP_HDR_LEN);
! 957:
! 958: /* Checksum sanity check - FIXME: move to correct place */
! 959: /* 12 = sysid+pdu+remtime */
! 960: if (iso_csum_verify (STREAM_PNT (circuit->rcv_stream) + 4,
! 961: ntohs (hdr->pdu_len) - 12, &hdr->checksum))
! 962: {
! 963: zlog_debug ("ISIS-Upd (%s): LSP %s invalid LSP checksum 0x%04x",
! 964: circuit->area->area_tag,
! 965: rawlspid_print (hdr->lsp_id), ntohs (hdr->checksum));
! 966:
! 967: return ISIS_WARNING;
! 968: }
! 969:
! 970: /* 7.3.15.1 a) 1 - external domain circuit will discard lsps */
! 971: if (circuit->ext_domain)
! 972: {
! 973: zlog_debug
! 974: ("ISIS-Upd (%s): LSP %s received at level %d over circuit with "
! 975: "externalDomain = true", circuit->area->area_tag,
! 976: rawlspid_print (hdr->lsp_id), level);
! 977:
! 978: return ISIS_WARNING;
! 979: }
! 980:
! 981: /* 7.3.15.1 a) 2,3 - manualL2OnlyMode not implemented */
! 982: if (!accept_level (level, circuit->circuit_is_type))
! 983: {
! 984: zlog_debug ("ISIS-Upd (%s): LSP %s received at level %d over circuit of"
! 985: " type %s",
! 986: circuit->area->area_tag,
! 987: rawlspid_print (hdr->lsp_id),
! 988: level, circuit_t2string (circuit->circuit_is_type));
! 989:
! 990: return ISIS_WARNING;
! 991: }
! 992:
! 993: /* 7.3.15.1 a) 4 - need to make sure IDLength matches */
! 994:
! 995: /* 7.3.15.1 a) 5 - maximum area match, can be ommited since we only use 3 */
! 996:
! 997: /* 7.3.15.1 a) 7 - password check */
! 998: (level == ISIS_LEVEL1) ? (passwd = &circuit->area->area_passwd) :
! 999: (passwd = &circuit->area->domain_passwd);
! 1000: if (passwd->type)
! 1001: {
! 1002: if (isis_lsp_authinfo_check (circuit->rcv_stream, circuit->area,
! 1003: ntohs (hdr->pdu_len), passwd))
! 1004: {
! 1005: isis_event_auth_failure (circuit->area->area_tag,
! 1006: "LSP authentication failure", hdr->lsp_id);
! 1007: return ISIS_WARNING;
! 1008: }
! 1009: }
! 1010: /* Find the LSP in our database and compare it to this Link State header */
! 1011: lsp = lsp_search (hdr->lsp_id, circuit->area->lspdb[level - 1]);
! 1012: if (lsp)
! 1013: comp = lsp_compare (circuit->area->area_tag, lsp, hdr->seq_num,
! 1014: hdr->checksum, hdr->rem_lifetime);
! 1015: if (lsp && (lsp->own_lsp
! 1016: #ifdef TOPOLOGY_GENERATE
! 1017: || lsp->from_topology
! 1018: #endif /* TOPOLOGY_GENERATE */
! 1019: ))
! 1020: goto dontcheckadj;
! 1021:
! 1022: /* 7.3.15.1 a) 6 - Must check that we have an adjacency of the same level */
! 1023: /* for broadcast circuits, snpa should be compared */
! 1024: /* FIXME : Point To Point */
! 1025:
! 1026: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 1027: {
! 1028: adj = isis_adj_lookup_snpa (ssnpa, circuit->u.bc.adjdb[level - 1]);
! 1029: if (!adj)
! 1030: {
! 1031: zlog_debug ("(%s): DS ======= LSP %s, seq 0x%08x, cksum 0x%04x, "
! 1032: "lifetime %us on %s",
! 1033: circuit->area->area_tag,
! 1034: rawlspid_print (hdr->lsp_id),
! 1035: ntohl (hdr->seq_num),
! 1036: ntohs (hdr->checksum),
! 1037: ntohs (hdr->rem_lifetime), circuit->interface->name);
! 1038: return ISIS_WARNING; /* Silently discard */
! 1039: }
! 1040: }
! 1041:
! 1042: /* for non broadcast, we just need to find same level adj */
! 1043: else
! 1044: {
! 1045: /* If no adj, or no sharing of level */
! 1046: if (!circuit->u.p2p.neighbor)
! 1047: {
! 1048: return ISIS_OK; /* Silently discard */
! 1049: }
! 1050: else
! 1051: {
! 1052: if (((level == 1) &&
! 1053: (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL2)) ||
! 1054: ((level == 2) &&
! 1055: (circuit->u.p2p.neighbor->adj_usage == ISIS_ADJ_LEVEL1)))
! 1056: return ISIS_WARNING; /* Silently discard */
! 1057: }
! 1058: }
! 1059: dontcheckadj:
! 1060: /* 7.3.15.1 a) 7 - Passwords for level 1 - not implemented */
! 1061:
! 1062: /* 7.3.15.1 a) 8 - Passwords for level 2 - not implemented */
! 1063:
! 1064: /* 7.3.15.1 a) 9 - OriginatingLSPBufferSize - not implemented FIXME: do it */
! 1065:
! 1066: /* 7.3.15.1 b) - If the remaining life time is 0, we perform 7.3.16.4 */
! 1067: if (hdr->rem_lifetime == 0)
! 1068: {
! 1069: if (!lsp)
! 1070: {
! 1071: /* 7.3.16.4 a) 1) No LSP in db -> send an ack, but don't save */
! 1072: /* only needed on explicit update, eg - p2p */
! 1073: if (circuit->circ_type == CIRCUIT_T_P2P)
! 1074: ack_lsp (hdr, circuit, level);
! 1075: return retval; /* FIXME: do we need a purge? */
! 1076: }
! 1077: else
! 1078: {
! 1079: if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
! 1080: {
! 1081: /* LSP by some other system -> do 7.3.16.4 b) */
! 1082: /* 7.3.16.4 b) 1) */
! 1083: if (comp == LSP_NEWER)
! 1084: {
! 1085: lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area,
! 1086: level);
! 1087: /* ii */
! 1088: ISIS_FLAGS_SET_ALL (lsp->SRMflags);
! 1089: /* iii */
! 1090: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1091: /* v */
! 1092: ISIS_FLAGS_CLEAR_ALL (lsp->SSNflags); /* FIXME: OTHER than c */
! 1093: /* iv */
! 1094: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1095: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1096:
! 1097: } /* 7.3.16.4 b) 2) */
! 1098: else if (comp == LSP_EQUAL)
! 1099: {
! 1100: /* i */
! 1101: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1102: /* ii */
! 1103: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1104: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1105: } /* 7.3.16.4 b) 3) */
! 1106: else
! 1107: {
! 1108: ISIS_SET_FLAG (lsp->SRMflags, circuit);
! 1109: ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
! 1110: }
! 1111: }
! 1112: else
! 1113: {
! 1114: /* our own LSP -> 7.3.16.4 c) */
! 1115: if (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) !=
! 1116: circuit->circuit_id
! 1117: || (LSP_PSEUDO_ID (lsp->lsp_header->lsp_id) ==
! 1118: circuit->circuit_id
! 1119: && circuit->u.bc.is_dr[level - 1] == 1))
! 1120: {
! 1121: lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
! 1122: if (isis->debugs & DEBUG_UPDATE_PACKETS)
! 1123: zlog_debug ("LSP LEN: %d",
! 1124: ntohs (lsp->lsp_header->pdu_len));
! 1125: fletcher_checksum (STREAM_DATA (lsp->pdu) + 12,
! 1126: ntohs (lsp->lsp_header->pdu_len) - 12, 12);
! 1127: ISIS_FLAGS_SET_ALL (lsp->SRMflags);
! 1128: if (isis->debugs & DEBUG_UPDATE_PACKETS)
! 1129: zlog_debug ("ISIS-Upd (%s): (1) re-originating LSP %s new "
! 1130: "seq 0x%08x", circuit->area->area_tag,
! 1131: rawlspid_print (hdr->lsp_id),
! 1132: ntohl (lsp->lsp_header->seq_num));
! 1133: lsp->lsp_header->rem_lifetime =
! 1134: htons (isis_jitter
! 1135: (circuit->area->max_lsp_lifetime[level - 1],
! 1136: MAX_AGE_JITTER));
! 1137: }
! 1138: else
! 1139: {
! 1140: /* Got purge for own pseudo-lsp, and we are not DR */
! 1141: lsp_purge_dr (lsp->lsp_header->lsp_id, circuit, level);
! 1142: }
! 1143: }
! 1144: }
! 1145: return retval;
! 1146: }
! 1147: /* 7.3.15.1 c) - If this is our own lsp and we don't have it initiate a
! 1148: * purge */
! 1149: if (memcmp (hdr->lsp_id, isis->sysid, ISIS_SYS_ID_LEN) == 0)
! 1150: {
! 1151: if (!lsp)
! 1152: {
! 1153: /* 7.3.16.4: initiate a purge */
! 1154: lsp_purge_non_exist (hdr, circuit->area);
! 1155: return ISIS_OK;
! 1156: }
! 1157: /* 7.3.15.1 d) - If this is our own lsp and we have it */
! 1158:
! 1159: /* In 7.3.16.1, If an Intermediate system R somewhere in the domain
! 1160: * has information that the current sequence number for source S is
! 1161: * "greater" than that held by S, ... */
! 1162:
! 1163: else if (ntohl (hdr->seq_num) > ntohl (lsp->lsp_header->seq_num))
! 1164: {
! 1165: /* 7.3.16.1 */
! 1166: lsp->lsp_header->seq_num = htonl (ntohl (hdr->seq_num) + 1);
! 1167:
! 1168: fletcher_checksum (STREAM_DATA (lsp->pdu) + 12,
! 1169: ntohs (lsp->lsp_header->pdu_len) - 12, 12);
! 1170:
! 1171: ISIS_FLAGS_SET_ALL (lsp->SRMflags);
! 1172: if (isis->debugs & DEBUG_UPDATE_PACKETS)
! 1173: zlog_debug ("ISIS-Upd (%s): (2) re-originating LSP %s new seq "
! 1174: "0x%08x", circuit->area->area_tag,
! 1175: rawlspid_print (hdr->lsp_id),
! 1176: ntohl (lsp->lsp_header->seq_num));
! 1177: lsp->lsp_header->rem_lifetime =
! 1178: htons (isis_jitter
! 1179: (circuit->area->max_lsp_lifetime[level - 1],
! 1180: MAX_AGE_JITTER));
! 1181: }
! 1182: }
! 1183: else
! 1184: {
! 1185: /* 7.3.15.1 e) - This lsp originated on another system */
! 1186:
! 1187: /* 7.3.15.1 e) 1) LSP newer than the one in db or no LSP in db */
! 1188: if ((!lsp || comp == LSP_NEWER))
! 1189: {
! 1190: /* i */
! 1191: if (lsp)
! 1192: {
! 1193: #ifdef EXTREME_DEBUG
! 1194: zlog_debug ("level %d number is - %ld", level,
! 1195: circuit->area->lspdb[level - 1]->dict_nodecount);
! 1196: #endif /* EXTREME DEBUG */
! 1197: lsp_search_and_destroy (hdr->lsp_id,
! 1198: circuit->area->lspdb[level - 1]);
! 1199: /* exists, so we overwrite */
! 1200: #ifdef EXTREME_DEBUG
! 1201: zlog_debug ("level %d number is - %ld", level,
! 1202: circuit->area->lspdb[level - 1]->dict_nodecount);
! 1203: #endif /* EXTREME DEBUG */
! 1204: }
! 1205: /*
! 1206: * If this lsp is a frag, need to see if we have zero lsp present
! 1207: */
! 1208: if (LSP_FRAGMENT (hdr->lsp_id) != 0)
! 1209: {
! 1210: memcpy (lspid, hdr->lsp_id, ISIS_SYS_ID_LEN + 1);
! 1211: LSP_FRAGMENT (lspid) = 0;
! 1212: lsp0 = lsp_search (lspid, circuit->area->lspdb[level - 1]);
! 1213: if (!lsp0)
! 1214: {
! 1215: zlog_debug ("Got lsp frag, while zero lsp not database");
! 1216: return ISIS_OK;
! 1217: }
! 1218: }
! 1219: lsp =
! 1220: lsp_new_from_stream_ptr (circuit->rcv_stream,
! 1221: ntohs (hdr->pdu_len), lsp0,
! 1222: circuit->area);
! 1223: lsp->level = level;
! 1224: lsp->adj = adj;
! 1225: lsp_insert (lsp, circuit->area->lspdb[level - 1]);
! 1226: /* ii */
! 1227: ISIS_FLAGS_SET_ALL (lsp->SRMflags);
! 1228: /* iii */
! 1229: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1230:
! 1231: /* iv */
! 1232: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1233: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1234: /* FIXME: v) */
! 1235: }
! 1236: /* 7.3.15.1 e) 2) LSP equal to the one in db */
! 1237: else if (comp == LSP_EQUAL)
! 1238: {
! 1239: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1240: lsp_update (lsp, hdr, circuit->rcv_stream, circuit->area, level);
! 1241: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1242: {
! 1243: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1244: }
! 1245: }
! 1246: /* 7.3.15.1 e) 3) LSP older than the one in db */
! 1247: else
! 1248: {
! 1249: ISIS_SET_FLAG (lsp->SRMflags, circuit);
! 1250: ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
! 1251: }
! 1252: }
! 1253: if (lsp)
! 1254: lsp->adj = adj;
! 1255: return retval;
! 1256: }
! 1257:
! 1258: /*
! 1259: * Process Sequence Numbers
! 1260: * ISO - 10589
! 1261: * Section 7.3.15.2 - Action on receipt of a sequence numbers PDU
! 1262: */
! 1263:
! 1264: static int
! 1265: process_snp (int snp_type, int level, struct isis_circuit *circuit,
! 1266: u_char * ssnpa)
! 1267: {
! 1268: int retval = ISIS_OK;
! 1269: int cmp, own_lsp;
! 1270: char typechar = ' ';
! 1271: int len;
! 1272: struct isis_adjacency *adj;
! 1273: struct isis_complete_seqnum_hdr *chdr = NULL;
! 1274: struct isis_partial_seqnum_hdr *phdr = NULL;
! 1275: uint32_t found = 0, expected = 0;
! 1276: struct isis_lsp *lsp;
! 1277: struct lsp_entry *entry;
! 1278: struct listnode *node, *nnode;
! 1279: struct listnode *node2, *nnode2;
! 1280: struct tlvs tlvs;
! 1281: struct list *lsp_list = NULL;
! 1282: struct isis_passwd *passwd;
! 1283:
! 1284: if (snp_type == ISIS_SNP_CSNP_FLAG)
! 1285: {
! 1286: /* getting the header info */
! 1287: typechar = 'C';
! 1288: chdr =
! 1289: (struct isis_complete_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
! 1290: circuit->rcv_stream->getp += ISIS_CSNP_HDRLEN;
! 1291: len = ntohs (chdr->pdu_len);
! 1292: if (len < ISIS_CSNP_HDRLEN)
! 1293: {
! 1294: zlog_warn ("Received a CSNP with bogus length!");
! 1295: return ISIS_OK;
! 1296: }
! 1297: }
! 1298: else
! 1299: {
! 1300: typechar = 'P';
! 1301: phdr =
! 1302: (struct isis_partial_seqnum_hdr *) STREAM_PNT (circuit->rcv_stream);
! 1303: circuit->rcv_stream->getp += ISIS_PSNP_HDRLEN;
! 1304: len = ntohs (phdr->pdu_len);
! 1305: if (len < ISIS_PSNP_HDRLEN)
! 1306: {
! 1307: zlog_warn ("Received a CSNP with bogus length!");
! 1308: return ISIS_OK;
! 1309: }
! 1310: }
! 1311:
! 1312: /* 7.3.15.2 a) 1 - external domain circuit will discard snp pdu */
! 1313: if (circuit->ext_domain)
! 1314: {
! 1315:
! 1316: zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
! 1317: "skipping: circuit externalDomain = true",
! 1318: circuit->area->area_tag,
! 1319: level, typechar, circuit->interface->name);
! 1320:
! 1321: return ISIS_OK;
! 1322: }
! 1323:
! 1324: /* 7.3.15.2 a) 2,3 - manualL2OnlyMode not implemented */
! 1325: if (!accept_level (level, circuit->circuit_is_type))
! 1326: {
! 1327:
! 1328: zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP on %s, "
! 1329: "skipping: circuit type %s does not match level %d",
! 1330: circuit->area->area_tag,
! 1331: level,
! 1332: typechar,
! 1333: circuit->interface->name,
! 1334: circuit_t2string (circuit->circuit_is_type), level);
! 1335:
! 1336: return ISIS_OK;
! 1337: }
! 1338:
! 1339: /* 7.3.15.2 a) 4 - not applicable for CSNP only PSNPs on broadcast */
! 1340: if ((snp_type == ISIS_SNP_PSNP_FLAG) &&
! 1341: (circuit->circ_type == CIRCUIT_T_BROADCAST))
! 1342: {
! 1343: if (!circuit->u.bc.is_dr[level - 1])
! 1344: {
! 1345:
! 1346: zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s, "
! 1347: "skipping: we are not the DIS",
! 1348: circuit->area->area_tag,
! 1349: level,
! 1350: typechar, snpa_print (ssnpa), circuit->interface->name);
! 1351:
! 1352: return ISIS_OK;
! 1353: }
! 1354: }
! 1355:
! 1356: /* 7.3.15.2 a) 5 - need to make sure IDLength matches - already checked */
! 1357:
! 1358: /* 7.3.15.2 a) 6 - maximum area match, can be ommited since we only use 3
! 1359: * - already checked */
! 1360:
! 1361: /* 7.3.15.2 a) 7 - Must check that we have an adjacency of the same level */
! 1362: /* for broadcast circuits, snpa should be compared */
! 1363: /* FIXME : Do we need to check SNPA? */
! 1364: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 1365: {
! 1366: if (snp_type == ISIS_SNP_CSNP_FLAG)
! 1367: {
! 1368: adj =
! 1369: isis_adj_lookup (chdr->source_id, circuit->u.bc.adjdb[level - 1]);
! 1370: }
! 1371: else
! 1372: {
! 1373: /* a psnp on a broadcast, how lovely of Juniper :) */
! 1374: adj =
! 1375: isis_adj_lookup (phdr->source_id, circuit->u.bc.adjdb[level - 1]);
! 1376: }
! 1377: if (!adj)
! 1378: return ISIS_OK; /* Silently discard */
! 1379: }
! 1380: else
! 1381: {
! 1382: if (!circuit->u.p2p.neighbor)
! 1383: return ISIS_OK; /* Silently discard */
! 1384: }
! 1385:
! 1386: /* 7.3.15.2 a) 8 - Passwords for level 1 - not implemented */
! 1387:
! 1388: /* 7.3.15.2 a) 9 - Passwords for level 2 - not implemented */
! 1389:
! 1390: memset (&tlvs, 0, sizeof (struct tlvs));
! 1391:
! 1392: /* parse the SNP */
! 1393: expected |= TLVFLAG_LSP_ENTRIES;
! 1394: expected |= TLVFLAG_AUTH_INFO;
! 1395: retval = parse_tlvs (circuit->area->area_tag,
! 1396: STREAM_PNT (circuit->rcv_stream),
! 1397: len - circuit->rcv_stream->getp,
! 1398: &expected, &found, &tlvs);
! 1399:
! 1400: if (retval > ISIS_WARNING)
! 1401: {
! 1402: zlog_warn ("something went very wrong processing SNP");
! 1403: free_tlvs (&tlvs);
! 1404: return retval;
! 1405: }
! 1406:
! 1407: if (level == 1)
! 1408: passwd = &circuit->area->area_passwd;
! 1409: else
! 1410: passwd = &circuit->area->domain_passwd;
! 1411:
! 1412: if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_RECV))
! 1413: {
! 1414: if (passwd->type)
! 1415: {
! 1416: if (!(found & TLVFLAG_AUTH_INFO) ||
! 1417: authentication_check (passwd, &tlvs.auth_info))
! 1418: {
! 1419: isis_event_auth_failure (circuit->area->area_tag,
! 1420: "SNP authentication" " failure",
! 1421: phdr ? phdr->source_id : chdr->source_id);
! 1422: return ISIS_OK;
! 1423: }
! 1424: }
! 1425: }
! 1426:
! 1427: /* debug isis snp-packets */
! 1428: if (isis->debugs & DEBUG_SNP_PACKETS)
! 1429: {
! 1430: zlog_debug ("ISIS-Snp (%s): Rcvd L%d %cSNP from %s on %s",
! 1431: circuit->area->area_tag,
! 1432: level,
! 1433: typechar, snpa_print (ssnpa), circuit->interface->name);
! 1434: if (tlvs.lsp_entries)
! 1435: {
! 1436: for (ALL_LIST_ELEMENTS_RO (tlvs.lsp_entries, node, entry))
! 1437: {
! 1438: zlog_debug ("ISIS-Snp (%s): %cSNP entry %s, seq 0x%08x,"
! 1439: " cksum 0x%04x, lifetime %us",
! 1440: circuit->area->area_tag,
! 1441: typechar,
! 1442: rawlspid_print (entry->lsp_id),
! 1443: ntohl (entry->seq_num),
! 1444: ntohs (entry->checksum), ntohs (entry->rem_lifetime));
! 1445: }
! 1446: }
! 1447: }
! 1448:
! 1449: /* 7.3.15.2 b) Actions on LSP_ENTRIES reported */
! 1450: if (tlvs.lsp_entries)
! 1451: {
! 1452: for (ALL_LIST_ELEMENTS_RO (tlvs.lsp_entries, node, entry))
! 1453: {
! 1454: lsp = lsp_search (entry->lsp_id, circuit->area->lspdb[level - 1]);
! 1455: own_lsp = !memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN);
! 1456: if (lsp)
! 1457: {
! 1458: /* 7.3.15.2 b) 1) is this LSP newer */
! 1459: cmp = lsp_compare (circuit->area->area_tag, lsp, entry->seq_num,
! 1460: entry->checksum, entry->rem_lifetime);
! 1461: /* 7.3.15.2 b) 2) if it equals, clear SRM on p2p */
! 1462: if (cmp == LSP_EQUAL)
! 1463: {
! 1464: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1465: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1466: /* 7.3.15.2 b) 3) if it is older, clear SSN and set SRM */
! 1467: }
! 1468: else if (cmp == LSP_OLDER)
! 1469: {
! 1470: ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
! 1471: ISIS_SET_FLAG (lsp->SRMflags, circuit);
! 1472: }
! 1473: else
! 1474: {
! 1475: /* 7.3.15.2 b) 4) if it is newer, set SSN and clear SRM
! 1476: * on p2p */
! 1477: if (own_lsp)
! 1478: {
! 1479: lsp_inc_seqnum (lsp, ntohl (entry->seq_num));
! 1480: ISIS_SET_FLAG (lsp->SRMflags, circuit);
! 1481: }
! 1482: else
! 1483: {
! 1484: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1485: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 1486: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 1487: }
! 1488: }
! 1489: }
! 1490: else
! 1491: {
! 1492: /* 7.3.15.2 b) 5) if it was not found, and all of those are not 0,
! 1493: * insert it and set SSN on it */
! 1494: if (entry->rem_lifetime && entry->checksum && entry->seq_num &&
! 1495: memcmp (entry->lsp_id, isis->sysid, ISIS_SYS_ID_LEN))
! 1496: {
! 1497: lsp = lsp_new (entry->lsp_id, ntohs (entry->rem_lifetime),
! 1498: 0, 0, entry->checksum, level);
! 1499: lsp_insert (lsp, circuit->area->lspdb[level - 1]);
! 1500: ISIS_SET_FLAG (lsp->SSNflags, circuit);
! 1501: }
! 1502: }
! 1503: }
! 1504: }
! 1505:
! 1506: /* 7.3.15.2 c) on CSNP set SRM for all in range which were not reported */
! 1507: if (snp_type == ISIS_SNP_CSNP_FLAG)
! 1508: {
! 1509: /*
! 1510: * Build a list from our own LSP db bounded with start_ and stop_lsp_id
! 1511: */
! 1512: lsp_list = list_new ();
! 1513: lsp_build_list_nonzero_ht (chdr->start_lsp_id, chdr->stop_lsp_id,
! 1514: lsp_list, circuit->area->lspdb[level - 1]);
! 1515:
! 1516: /* Fixme: Find a better solution */
! 1517: if (tlvs.lsp_entries)
! 1518: {
! 1519: for (ALL_LIST_ELEMENTS (tlvs.lsp_entries, node, nnode, entry))
! 1520: {
! 1521: for (ALL_LIST_ELEMENTS (lsp_list, node2, nnode2, lsp))
! 1522: {
! 1523: if (lsp_id_cmp (lsp->lsp_header->lsp_id, entry->lsp_id) == 0)
! 1524: {
! 1525: list_delete_node (lsp_list, node2);
! 1526: break;
! 1527: }
! 1528: }
! 1529: }
! 1530: }
! 1531: /* on remaining LSPs we set SRM (neighbor knew not of) */
! 1532: for (ALL_LIST_ELEMENTS_RO (lsp_list, node, lsp))
! 1533: {
! 1534: ISIS_SET_FLAG (lsp->SRMflags, circuit);
! 1535: }
! 1536: /* lets free it */
! 1537: list_free (lsp_list);
! 1538: }
! 1539:
! 1540: free_tlvs (&tlvs);
! 1541: return retval;
! 1542: }
! 1543:
! 1544: static int
! 1545: process_csnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
! 1546: {
! 1547: /* Sanity check - FIXME: move to correct place */
! 1548: if ((stream_get_endp (circuit->rcv_stream) -
! 1549: stream_get_getp (circuit->rcv_stream)) < ISIS_CSNP_HDRLEN)
! 1550: {
! 1551: zlog_warn ("Packet too short ( < %d)", ISIS_CSNP_HDRLEN);
! 1552: return ISIS_WARNING;
! 1553: }
! 1554:
! 1555: return process_snp (ISIS_SNP_CSNP_FLAG, level, circuit, ssnpa);
! 1556: }
! 1557:
! 1558: static int
! 1559: process_psnp (int level, struct isis_circuit *circuit, u_char * ssnpa)
! 1560: {
! 1561: if ((stream_get_endp (circuit->rcv_stream) -
! 1562: stream_get_getp (circuit->rcv_stream)) < ISIS_PSNP_HDRLEN)
! 1563: {
! 1564: zlog_warn ("Packet too short");
! 1565: return ISIS_WARNING;
! 1566: }
! 1567:
! 1568: return process_snp (ISIS_SNP_PSNP_FLAG, level, circuit, ssnpa);
! 1569: }
! 1570:
! 1571: /*
! 1572: * Process ISH
! 1573: * ISO - 10589
! 1574: * Section 8.2.2 - Receiving ISH PDUs by an intermediate system
! 1575: * FIXME: sample packet dump, need to figure 0x81 - looks like NLPid
! 1576: * 0x82 0x15 0x01 0x00 0x04 0x01 0x2c 0x59
! 1577: * 0x38 0x08 0x47 0x00 0x01 0x00 0x02 0x00
! 1578: * 0x03 0x00 0x81 0x01 0xcc
! 1579: */
! 1580: static int
! 1581: process_is_hello (struct isis_circuit *circuit)
! 1582: {
! 1583: struct isis_adjacency *adj;
! 1584: int retval = ISIS_OK;
! 1585: u_char neigh_len;
! 1586: u_char *sysid;
! 1587:
! 1588: /* In this point in time we are not yet able to handle is_hellos
! 1589: * on lan - Sorry juniper...
! 1590: */
! 1591: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 1592: return retval;
! 1593:
! 1594: neigh_len = stream_getc (circuit->rcv_stream);
! 1595: sysid = STREAM_PNT (circuit->rcv_stream) + neigh_len - 1 - ISIS_SYS_ID_LEN;
! 1596: adj = circuit->u.p2p.neighbor;
! 1597: if (!adj)
! 1598: {
! 1599: /* 8.2.2 */
! 1600: adj = isis_new_adj (sysid, NULL, 0, circuit);
! 1601: if (adj == NULL)
! 1602: return ISIS_ERROR;
! 1603:
! 1604: isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
! 1605: adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
! 1606: circuit->u.p2p.neighbor = adj;
! 1607: }
! 1608: /* 8.2.2 a) */
! 1609: if ((adj->adj_state == ISIS_ADJ_UP) && memcmp (adj->sysid, sysid,
! 1610: ISIS_SYS_ID_LEN))
! 1611: {
! 1612: /* 8.2.2 a) 1) FIXME: adjStateChange(down) event */
! 1613: /* 8.2.2 a) 2) delete the adj */
! 1614: XFREE (MTYPE_ISIS_ADJACENCY, adj);
! 1615: /* 8.2.2 a) 3) create a new adj */
! 1616: adj = isis_new_adj (sysid, NULL, 0, circuit);
! 1617: if (adj == NULL)
! 1618: return ISIS_ERROR;
! 1619:
! 1620: /* 8.2.2 a) 3) i */
! 1621: isis_adj_state_change (adj, ISIS_ADJ_INITIALIZING, NULL);
! 1622: /* 8.2.2 a) 3) ii */
! 1623: adj->sys_type = ISIS_SYSTYPE_UNKNOWN;
! 1624: /* 8.2.2 a) 4) quite meaningless */
! 1625: }
! 1626: /* 8.2.2 b) ignore on condition */
! 1627: if ((adj->adj_state == ISIS_ADJ_INITIALIZING) &&
! 1628: (adj->sys_type == ISIS_SYSTYPE_IS))
! 1629: {
! 1630: /* do nothing */
! 1631: }
! 1632: else
! 1633: {
! 1634: /* 8.2.2 c) respond with a p2p IIH */
! 1635: send_hello (circuit, 1);
! 1636: }
! 1637: /* 8.2.2 d) type is IS */
! 1638: adj->sys_type = ISIS_SYSTYPE_IS;
! 1639: /* 8.2.2 e) FIXME: Circuit type of? */
! 1640:
! 1641: return retval;
! 1642: }
! 1643:
! 1644: /*
! 1645: * PDU Dispatcher
! 1646: */
! 1647:
! 1648: static int
! 1649: isis_handle_pdu (struct isis_circuit *circuit, u_char * ssnpa)
! 1650: {
! 1651: struct isis_fixed_hdr *hdr;
! 1652: struct esis_fixed_hdr *esis_hdr;
! 1653:
! 1654: int retval = ISIS_OK;
! 1655:
! 1656: /*
! 1657: * Let's first read data from stream to the header
! 1658: */
! 1659: hdr = (struct isis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
! 1660:
! 1661: if ((hdr->idrp != ISO10589_ISIS) && (hdr->idrp != ISO9542_ESIS))
! 1662: {
! 1663: zlog_warn ("Not an IS-IS or ES-IS packet IDRP=%02x", hdr->idrp);
! 1664: return ISIS_ERROR;
! 1665: }
! 1666:
! 1667: /* now we need to know if this is an ISO 9542 packet and
! 1668: * take real good care of it, waaa!
! 1669: */
! 1670: if (hdr->idrp == ISO9542_ESIS)
! 1671: {
! 1672: esis_hdr = (struct esis_fixed_hdr *) STREAM_DATA (circuit->rcv_stream);
! 1673: stream_set_getp (circuit->rcv_stream, ESIS_FIXED_HDR_LEN);
! 1674: /* FIXME: Need to do some acceptence tests */
! 1675: /* example length... */
! 1676: switch (esis_hdr->pdu_type)
! 1677: {
! 1678: case ESH_PDU:
! 1679: /* FIXME */
! 1680: break;
! 1681: case ISH_PDU:
! 1682: zlog_debug ("AN ISH PDU!!");
! 1683: retval = process_is_hello (circuit);
! 1684: break;
! 1685: default:
! 1686: return ISIS_ERROR;
! 1687: }
! 1688: return retval;
! 1689: }
! 1690: else
! 1691: {
! 1692: stream_set_getp (circuit->rcv_stream, ISIS_FIXED_HDR_LEN);
! 1693: }
! 1694: /*
! 1695: * and then process it
! 1696: */
! 1697:
! 1698: if (hdr->length < ISIS_MINIMUM_FIXED_HDR_LEN)
! 1699: {
! 1700: zlog_err ("Fixed header length = %d", hdr->length);
! 1701: return ISIS_ERROR;
! 1702: }
! 1703:
! 1704: if (hdr->version1 != 1)
! 1705: {
! 1706: zlog_warn ("Unsupported ISIS version %u", hdr->version1);
! 1707: return ISIS_WARNING;
! 1708: }
! 1709: /* either 6 or 0 */
! 1710: if ((hdr->id_len != 0) && (hdr->id_len != ISIS_SYS_ID_LEN))
! 1711: {
! 1712: zlog_err
! 1713: ("IDFieldLengthMismatch: ID Length field in a received PDU %u, "
! 1714: "while the parameter for this IS is %u", hdr->id_len,
! 1715: ISIS_SYS_ID_LEN);
! 1716: return ISIS_ERROR;
! 1717: }
! 1718:
! 1719: if (hdr->version2 != 1)
! 1720: {
! 1721: zlog_warn ("Unsupported ISIS version %u", hdr->version2);
! 1722: return ISIS_WARNING;
! 1723: }
! 1724: /* either 3 or 0 */
! 1725: if ((hdr->max_area_addrs != 0)
! 1726: && (hdr->max_area_addrs != isis->max_area_addrs))
! 1727: {
! 1728: zlog_err ("maximumAreaAddressesMismatch: maximumAreaAdresses in a "
! 1729: "received PDU %u while the parameter for this IS is %u",
! 1730: hdr->max_area_addrs, isis->max_area_addrs);
! 1731: return ISIS_ERROR;
! 1732: }
! 1733:
! 1734: switch (hdr->pdu_type)
! 1735: {
! 1736: case L1_LAN_HELLO:
! 1737: retval = process_lan_hello (ISIS_LEVEL1, circuit, ssnpa);
! 1738: break;
! 1739: case L2_LAN_HELLO:
! 1740: retval = process_lan_hello (ISIS_LEVEL2, circuit, ssnpa);
! 1741: break;
! 1742: case P2P_HELLO:
! 1743: retval = process_p2p_hello (circuit);
! 1744: break;
! 1745: case L1_LINK_STATE:
! 1746: retval = process_lsp (ISIS_LEVEL1, circuit, ssnpa);
! 1747: break;
! 1748: case L2_LINK_STATE:
! 1749: retval = process_lsp (ISIS_LEVEL2, circuit, ssnpa);
! 1750: break;
! 1751: case L1_COMPLETE_SEQ_NUM:
! 1752: retval = process_csnp (ISIS_LEVEL1, circuit, ssnpa);
! 1753: break;
! 1754: case L2_COMPLETE_SEQ_NUM:
! 1755: retval = process_csnp (ISIS_LEVEL2, circuit, ssnpa);
! 1756: break;
! 1757: case L1_PARTIAL_SEQ_NUM:
! 1758: retval = process_psnp (ISIS_LEVEL1, circuit, ssnpa);
! 1759: break;
! 1760: case L2_PARTIAL_SEQ_NUM:
! 1761: retval = process_psnp (ISIS_LEVEL2, circuit, ssnpa);
! 1762: break;
! 1763: default:
! 1764: return ISIS_ERROR;
! 1765: }
! 1766:
! 1767: return retval;
! 1768: }
! 1769:
! 1770: #ifdef GNU_LINUX
! 1771: int
! 1772: isis_receive (struct thread *thread)
! 1773: {
! 1774: struct isis_circuit *circuit;
! 1775: u_char ssnpa[ETH_ALEN];
! 1776: int retval;
! 1777:
! 1778: /*
! 1779: * Get the circuit
! 1780: */
! 1781: circuit = THREAD_ARG (thread);
! 1782: assert (circuit);
! 1783:
! 1784: if (!circuit->area)
! 1785: return ISIS_OK;
! 1786:
! 1787: if (circuit->rcv_stream == NULL)
! 1788: circuit->rcv_stream = stream_new (ISO_MTU (circuit));
! 1789: else
! 1790: stream_reset (circuit->rcv_stream);
! 1791:
! 1792: retval = circuit->rx (circuit, ssnpa);
! 1793: circuit->t_read = NULL;
! 1794:
! 1795: if (retval == ISIS_OK)
! 1796: retval = isis_handle_pdu (circuit, ssnpa);
! 1797:
! 1798: /*
! 1799: * prepare for next packet.
! 1800: */
! 1801: THREAD_READ_ON (master, circuit->t_read, isis_receive, circuit,
! 1802: circuit->fd);
! 1803:
! 1804: return retval;
! 1805: }
! 1806:
! 1807: #else
! 1808: int
! 1809: isis_receive (struct thread *thread)
! 1810: {
! 1811: struct isis_circuit *circuit;
! 1812: u_char ssnpa[ETH_ALEN];
! 1813: int retval;
! 1814:
! 1815: /*
! 1816: * Get the circuit
! 1817: */
! 1818: circuit = THREAD_ARG (thread);
! 1819: assert (circuit);
! 1820:
! 1821: circuit->t_read = NULL;
! 1822:
! 1823: if (circuit->rcv_stream == NULL)
! 1824: circuit->rcv_stream = stream_new (ISO_MTU (circuit));
! 1825: else
! 1826: stream_reset (circuit->rcv_stream);
! 1827:
! 1828: retval = circuit->rx (circuit, ssnpa);
! 1829:
! 1830: if (retval == ISIS_OK)
! 1831: retval = isis_handle_pdu (circuit, ssnpa);
! 1832:
! 1833: /*
! 1834: * prepare for next packet.
! 1835: */
! 1836: circuit->t_read = thread_add_timer_msec (master, isis_receive, circuit,
! 1837: listcount
! 1838: (circuit->area->circuit_list) *
! 1839: 100);
! 1840:
! 1841: return retval;
! 1842: }
! 1843:
! 1844: #endif
! 1845:
! 1846: /* filling of the fixed isis header */
! 1847: void
! 1848: fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type)
! 1849: {
! 1850: memset (hdr, 0, sizeof (struct isis_fixed_hdr));
! 1851:
! 1852: hdr->idrp = ISO10589_ISIS;
! 1853:
! 1854: switch (pdu_type)
! 1855: {
! 1856: case L1_LAN_HELLO:
! 1857: case L2_LAN_HELLO:
! 1858: hdr->length = ISIS_LANHELLO_HDRLEN;
! 1859: break;
! 1860: case P2P_HELLO:
! 1861: hdr->length = ISIS_P2PHELLO_HDRLEN;
! 1862: break;
! 1863: case L1_LINK_STATE:
! 1864: case L2_LINK_STATE:
! 1865: hdr->length = ISIS_LSP_HDR_LEN;
! 1866: break;
! 1867: case L1_COMPLETE_SEQ_NUM:
! 1868: case L2_COMPLETE_SEQ_NUM:
! 1869: hdr->length = ISIS_CSNP_HDRLEN;
! 1870: break;
! 1871: case L1_PARTIAL_SEQ_NUM:
! 1872: case L2_PARTIAL_SEQ_NUM:
! 1873: hdr->length = ISIS_PSNP_HDRLEN;
! 1874: break;
! 1875: default:
! 1876: zlog_warn ("fill_fixed_hdr(): unknown pdu type %d", pdu_type);
! 1877: return;
! 1878: }
! 1879: hdr->length += ISIS_FIXED_HDR_LEN;
! 1880: hdr->pdu_type = pdu_type;
! 1881: hdr->version1 = 1;
! 1882: hdr->id_len = 0; /* ISIS_SYS_ID_LEN - 0==6 */
! 1883: hdr->version2 = 1;
! 1884: hdr->max_area_addrs = 0; /* isis->max_area_addrs - 0==3 */
! 1885: }
! 1886:
! 1887: /*
! 1888: * SEND SIDE
! 1889: */
! 1890: static void
! 1891: fill_fixed_hdr_andstream (struct isis_fixed_hdr *hdr, u_char pdu_type,
! 1892: struct stream *stream)
! 1893: {
! 1894: fill_fixed_hdr (hdr, pdu_type);
! 1895:
! 1896: stream_putc (stream, hdr->idrp);
! 1897: stream_putc (stream, hdr->length);
! 1898: stream_putc (stream, hdr->version1);
! 1899: stream_putc (stream, hdr->id_len);
! 1900: stream_putc (stream, hdr->pdu_type);
! 1901: stream_putc (stream, hdr->version2);
! 1902: stream_putc (stream, hdr->reserved);
! 1903: stream_putc (stream, hdr->max_area_addrs);
! 1904:
! 1905: return;
! 1906: }
! 1907:
! 1908: int
! 1909: send_hello (struct isis_circuit *circuit, int level)
! 1910: {
! 1911: struct isis_fixed_hdr fixed_hdr;
! 1912: struct isis_lan_hello_hdr hello_hdr;
! 1913: struct isis_p2p_hello_hdr p2p_hello_hdr;
! 1914:
! 1915: u_int32_t interval;
! 1916: unsigned long len_pointer, length;
! 1917: int retval;
! 1918:
! 1919: if (circuit->interface->mtu == 0)
! 1920: {
! 1921: zlog_warn ("circuit has zero MTU");
! 1922: return ISIS_WARNING;
! 1923: }
! 1924:
! 1925: if (!circuit->snd_stream)
! 1926: circuit->snd_stream = stream_new (ISO_MTU (circuit));
! 1927: else
! 1928: stream_reset (circuit->snd_stream);
! 1929:
! 1930: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 1931: if (level == 1)
! 1932: fill_fixed_hdr_andstream (&fixed_hdr, L1_LAN_HELLO,
! 1933: circuit->snd_stream);
! 1934: else
! 1935: fill_fixed_hdr_andstream (&fixed_hdr, L2_LAN_HELLO,
! 1936: circuit->snd_stream);
! 1937: else
! 1938: fill_fixed_hdr_andstream (&fixed_hdr, P2P_HELLO, circuit->snd_stream);
! 1939:
! 1940: /*
! 1941: * Fill LAN Level 1 or 2 Hello PDU header
! 1942: */
! 1943: memset (&hello_hdr, 0, sizeof (struct isis_lan_hello_hdr));
! 1944: interval = circuit->hello_multiplier[level - 1] *
! 1945: circuit->hello_interval[level - 1];
! 1946: /* If we are the DIS then hello interval is divided by three, as is the hold-timer */
! 1947: if (circuit->u.bc.is_dr[level - 1])
! 1948: interval=interval/3;
! 1949: if (interval > USHRT_MAX)
! 1950: interval = USHRT_MAX;
! 1951: hello_hdr.circuit_t = circuit->circuit_is_type;
! 1952: memcpy (hello_hdr.source_id, isis->sysid, ISIS_SYS_ID_LEN);
! 1953: hello_hdr.hold_time = htons ((u_int16_t) interval);
! 1954:
! 1955: hello_hdr.pdu_len = 0; /* Update the PDU Length later */
! 1956: len_pointer = stream_get_endp (circuit->snd_stream) + 3 + ISIS_SYS_ID_LEN;
! 1957:
! 1958: /* copy the shared part of the hello to the p2p hello if needed */
! 1959: if (circuit->circ_type == CIRCUIT_T_P2P)
! 1960: {
! 1961: memcpy (&p2p_hello_hdr, &hello_hdr, 5 + ISIS_SYS_ID_LEN);
! 1962: p2p_hello_hdr.local_id = circuit->circuit_id;
! 1963: /* FIXME: need better understanding */
! 1964: stream_put (circuit->snd_stream, &p2p_hello_hdr, ISIS_P2PHELLO_HDRLEN);
! 1965: }
! 1966: else
! 1967: {
! 1968: hello_hdr.prio = circuit->u.bc.priority[level - 1];
! 1969: if (level == 1 && circuit->u.bc.l1_desig_is)
! 1970: {
! 1971: memcpy (hello_hdr.lan_id, circuit->u.bc.l1_desig_is,
! 1972: ISIS_SYS_ID_LEN + 1);
! 1973: }
! 1974: else if (level == 2 && circuit->u.bc.l2_desig_is)
! 1975: {
! 1976: memcpy (hello_hdr.lan_id, circuit->u.bc.l2_desig_is,
! 1977: ISIS_SYS_ID_LEN + 1);
! 1978: }
! 1979: stream_put (circuit->snd_stream, &hello_hdr, ISIS_LANHELLO_HDRLEN);
! 1980: }
! 1981:
! 1982: /*
! 1983: * Then the variable length part
! 1984: */
! 1985: /* add circuit password */
! 1986: if (circuit->passwd.type)
! 1987: if (tlv_add_authinfo (circuit->passwd.type, circuit->passwd.len,
! 1988: circuit->passwd.passwd, circuit->snd_stream))
! 1989: return ISIS_WARNING;
! 1990: /* Area Addresses TLV */
! 1991: assert (circuit->area);
! 1992: if (circuit->area->area_addrs && circuit->area->area_addrs->count > 0)
! 1993: if (tlv_add_area_addrs (circuit->area->area_addrs, circuit->snd_stream))
! 1994: return ISIS_WARNING;
! 1995:
! 1996: /* LAN Neighbors TLV */
! 1997: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 1998: {
! 1999: if (level == 1 && circuit->u.bc.lan_neighs[0]->count > 0)
! 2000: if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[0],
! 2001: circuit->snd_stream))
! 2002: return ISIS_WARNING;
! 2003: if (level == 2 && circuit->u.bc.lan_neighs[1]->count > 0)
! 2004: if (tlv_add_lan_neighs (circuit->u.bc.lan_neighs[1],
! 2005: circuit->snd_stream))
! 2006: return ISIS_WARNING;
! 2007: }
! 2008:
! 2009: /* Protocols Supported TLV */
! 2010: if (circuit->nlpids.count > 0)
! 2011: if (tlv_add_nlpid (&circuit->nlpids, circuit->snd_stream))
! 2012: return ISIS_WARNING;
! 2013: /* IP interface Address TLV */
! 2014: if (circuit->ip_router && circuit->ip_addrs && circuit->ip_addrs->count > 0)
! 2015: if (tlv_add_ip_addrs (circuit->ip_addrs, circuit->snd_stream))
! 2016: return ISIS_WARNING;
! 2017:
! 2018: #ifdef HAVE_IPV6
! 2019: /* IPv6 Interface Address TLV */
! 2020: if (circuit->ipv6_router && circuit->ipv6_link &&
! 2021: circuit->ipv6_link->count > 0)
! 2022: if (tlv_add_ipv6_addrs (circuit->ipv6_link, circuit->snd_stream))
! 2023: return ISIS_WARNING;
! 2024: #endif /* HAVE_IPV6 */
! 2025:
! 2026: if (circuit->u.bc.pad_hellos)
! 2027: if (tlv_add_padding (circuit->snd_stream))
! 2028: return ISIS_WARNING;
! 2029:
! 2030: length = stream_get_endp (circuit->snd_stream);
! 2031: /* Update PDU length */
! 2032: stream_putw_at (circuit->snd_stream, len_pointer, (u_int16_t) length);
! 2033:
! 2034: retval = circuit->tx (circuit, level);
! 2035: if (retval)
! 2036: zlog_warn ("sending of LAN Level %d Hello failed", level);
! 2037:
! 2038: /* DEBUG_ADJ_PACKETS */
! 2039: if (isis->debugs & DEBUG_ADJ_PACKETS)
! 2040: {
! 2041: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 2042: {
! 2043: zlog_debug ("ISIS-Adj (%s): Sent L%d LAN IIH on %s, length %ld",
! 2044: circuit->area->area_tag, level, circuit->interface->name,
! 2045: /* FIXME: use %z when we stop supporting old compilers. */
! 2046: (unsigned long) STREAM_SIZE (circuit->snd_stream));
! 2047: }
! 2048: else
! 2049: {
! 2050: zlog_debug ("ISIS-Adj (%s): Sent P2P IIH on %s, length %ld",
! 2051: circuit->area->area_tag, circuit->interface->name,
! 2052: /* FIXME: use %z when we stop supporting old compilers. */
! 2053: (unsigned long) STREAM_SIZE (circuit->snd_stream));
! 2054: }
! 2055: }
! 2056:
! 2057: return retval;
! 2058: }
! 2059:
! 2060: static int
! 2061: send_lan_hello (struct isis_circuit *circuit, int level)
! 2062: {
! 2063: return send_hello (circuit, level);
! 2064: }
! 2065:
! 2066: int
! 2067: send_lan_l1_hello (struct thread *thread)
! 2068: {
! 2069: struct isis_circuit *circuit;
! 2070: int retval;
! 2071: unsigned long next_hello;
! 2072:
! 2073: circuit = THREAD_ARG (thread);
! 2074: assert (circuit);
! 2075:
! 2076: if (!circuit->area) {
! 2077: return ISIS_OK;
! 2078: }
! 2079:
! 2080: /* Pseudonode sends hellos three times more than the other nodes */
! 2081: if (circuit->u.bc.is_dr[0])
! 2082: next_hello=circuit->hello_interval[0]/3+1;
! 2083: else
! 2084: next_hello=circuit->hello_interval[0];
! 2085:
! 2086: circuit->u.bc.t_send_lan_hello[0] = NULL;
! 2087:
! 2088: if (circuit->u.bc.run_dr_elect[0])
! 2089: retval = isis_dr_elect (circuit, 1);
! 2090:
! 2091: retval = send_lan_hello (circuit, 1);
! 2092:
! 2093: /* set next timer thread */
! 2094: THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[0],
! 2095: send_lan_l1_hello, circuit,
! 2096: isis_jitter (next_hello, IIH_JITTER));
! 2097:
! 2098: return retval;
! 2099: }
! 2100:
! 2101: int
! 2102: send_lan_l2_hello (struct thread *thread)
! 2103: {
! 2104: struct isis_circuit *circuit;
! 2105: int retval;
! 2106: unsigned long next_hello;
! 2107:
! 2108: circuit = THREAD_ARG (thread);
! 2109: assert (circuit);
! 2110:
! 2111: if (!circuit->area) {
! 2112: return ISIS_OK;
! 2113: }
! 2114:
! 2115: /* Pseudonode sends hellos three times more than the other nodes */
! 2116: if (circuit->u.bc.is_dr[1])
! 2117: next_hello=circuit->hello_interval[1]/3+1;
! 2118: else
! 2119: next_hello=circuit->hello_interval[1];
! 2120:
! 2121: circuit->u.bc.t_send_lan_hello[1] = NULL;
! 2122:
! 2123: if (circuit->u.bc.run_dr_elect[1])
! 2124: retval = isis_dr_elect (circuit, 2);
! 2125:
! 2126: retval = send_lan_hello (circuit, 2);
! 2127:
! 2128: /* set next timer thread */
! 2129: THREAD_TIMER_ON (master, circuit->u.bc.t_send_lan_hello[1],
! 2130: send_lan_l2_hello, circuit,
! 2131: isis_jitter (next_hello, IIH_JITTER));
! 2132:
! 2133: return retval;
! 2134: }
! 2135:
! 2136: int
! 2137: send_p2p_hello (struct thread *thread)
! 2138: {
! 2139: struct isis_circuit *circuit;
! 2140:
! 2141: circuit = THREAD_ARG (thread);
! 2142: assert (circuit);
! 2143: circuit->u.p2p.t_send_p2p_hello = NULL;
! 2144:
! 2145: send_hello (circuit, 1);
! 2146:
! 2147: /* set next timer thread */
! 2148: THREAD_TIMER_ON (master, circuit->u.p2p.t_send_p2p_hello, send_p2p_hello,
! 2149: circuit, isis_jitter (circuit->hello_interval[1],
! 2150: IIH_JITTER));
! 2151:
! 2152: return ISIS_OK;
! 2153: }
! 2154:
! 2155: static int
! 2156: build_csnp (int level, u_char * start, u_char * stop, struct list *lsps,
! 2157: struct isis_circuit *circuit)
! 2158: {
! 2159: struct isis_fixed_hdr fixed_hdr;
! 2160: struct isis_passwd *passwd;
! 2161: int retval = ISIS_OK;
! 2162: unsigned long lenp;
! 2163: u_int16_t length;
! 2164:
! 2165: if (level == 1)
! 2166: fill_fixed_hdr_andstream (&fixed_hdr, L1_COMPLETE_SEQ_NUM,
! 2167: circuit->snd_stream);
! 2168: else
! 2169: fill_fixed_hdr_andstream (&fixed_hdr, L2_COMPLETE_SEQ_NUM,
! 2170: circuit->snd_stream);
! 2171:
! 2172: /*
! 2173: * Fill Level 1 or 2 Complete Sequence Numbers header
! 2174: */
! 2175:
! 2176: lenp = stream_get_endp (circuit->snd_stream);
! 2177: stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
! 2178: /* no need to send the source here, it is always us if we csnp */
! 2179: stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
! 2180: /* with zero circuit id - ref 9.10, 9.11 */
! 2181: stream_putc (circuit->snd_stream, 0x00);
! 2182:
! 2183: stream_put (circuit->snd_stream, start, ISIS_SYS_ID_LEN + 2);
! 2184: stream_put (circuit->snd_stream, stop, ISIS_SYS_ID_LEN + 2);
! 2185:
! 2186: /*
! 2187: * And TLVs
! 2188: */
! 2189: if (level == 1)
! 2190: passwd = &circuit->area->area_passwd;
! 2191: else
! 2192: passwd = &circuit->area->domain_passwd;
! 2193:
! 2194: if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_SEND))
! 2195: if (passwd->type)
! 2196: retval = tlv_add_authinfo (passwd->type, passwd->len,
! 2197: passwd->passwd, circuit->snd_stream);
! 2198:
! 2199: if (!retval && lsps)
! 2200: {
! 2201: retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
! 2202: }
! 2203: length = (u_int16_t) stream_get_endp (circuit->snd_stream);
! 2204: assert (length >= ISIS_CSNP_HDRLEN);
! 2205: /* Update PU length */
! 2206: stream_putw_at (circuit->snd_stream, lenp, length);
! 2207:
! 2208: return retval;
! 2209: }
! 2210:
! 2211: /*
! 2212: * FIXME: support multiple CSNPs
! 2213: */
! 2214:
! 2215: int
! 2216: send_csnp (struct isis_circuit *circuit, int level)
! 2217: {
! 2218: int retval = ISIS_OK;
! 2219: u_char start[ISIS_SYS_ID_LEN + 2];
! 2220: u_char stop[ISIS_SYS_ID_LEN + 2];
! 2221: struct list *list = NULL;
! 2222: struct listnode *node;
! 2223: struct isis_lsp *lsp;
! 2224:
! 2225: memset (start, 0x00, ISIS_SYS_ID_LEN + 2);
! 2226: memset (stop, 0xff, ISIS_SYS_ID_LEN + 2);
! 2227:
! 2228: if (circuit->area->lspdb[level - 1] &&
! 2229: dict_count (circuit->area->lspdb[level - 1]) > 0)
! 2230: {
! 2231: list = list_new ();
! 2232: lsp_build_list (start, stop, list, circuit->area->lspdb[level - 1]);
! 2233:
! 2234: if (circuit->snd_stream == NULL)
! 2235: circuit->snd_stream = stream_new (ISO_MTU (circuit));
! 2236: else
! 2237: stream_reset (circuit->snd_stream);
! 2238:
! 2239: retval = build_csnp (level, start, stop, list, circuit);
! 2240:
! 2241: if (isis->debugs & DEBUG_SNP_PACKETS)
! 2242: {
! 2243: zlog_debug ("ISIS-Snp (%s): Sent L%d CSNP on %s, length %ld",
! 2244: circuit->area->area_tag, level, circuit->interface->name,
! 2245: /* FIXME: use %z when we stop supporting old compilers. */
! 2246: (unsigned long) STREAM_SIZE (circuit->snd_stream));
! 2247: for (ALL_LIST_ELEMENTS_RO (list, node, lsp))
! 2248: {
! 2249: zlog_debug ("ISIS-Snp (%s): CSNP entry %s, seq 0x%08x,"
! 2250: " cksum 0x%04x, lifetime %us",
! 2251: circuit->area->area_tag,
! 2252: rawlspid_print (lsp->lsp_header->lsp_id),
! 2253: ntohl (lsp->lsp_header->seq_num),
! 2254: ntohs (lsp->lsp_header->checksum),
! 2255: ntohs (lsp->lsp_header->rem_lifetime));
! 2256: }
! 2257: }
! 2258:
! 2259: list_delete (list);
! 2260:
! 2261: if (retval == ISIS_OK)
! 2262: retval = circuit->tx (circuit, level);
! 2263: }
! 2264: return retval;
! 2265: }
! 2266:
! 2267: int
! 2268: send_l1_csnp (struct thread *thread)
! 2269: {
! 2270: struct isis_circuit *circuit;
! 2271: int retval = ISIS_OK;
! 2272:
! 2273: circuit = THREAD_ARG (thread);
! 2274: assert (circuit);
! 2275:
! 2276: circuit->t_send_csnp[0] = NULL;
! 2277:
! 2278: if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[0])
! 2279: {
! 2280: send_csnp (circuit, 1);
! 2281: }
! 2282: /* set next timer thread */
! 2283: THREAD_TIMER_ON (master, circuit->t_send_csnp[0], send_l1_csnp, circuit,
! 2284: isis_jitter (circuit->csnp_interval[0], CSNP_JITTER));
! 2285:
! 2286: return retval;
! 2287: }
! 2288:
! 2289: int
! 2290: send_l2_csnp (struct thread *thread)
! 2291: {
! 2292: struct isis_circuit *circuit;
! 2293: int retval = ISIS_OK;
! 2294:
! 2295: circuit = THREAD_ARG (thread);
! 2296: assert (circuit);
! 2297:
! 2298: circuit->t_send_csnp[1] = NULL;
! 2299:
! 2300: if (circuit->circ_type == CIRCUIT_T_BROADCAST && circuit->u.bc.is_dr[1])
! 2301: {
! 2302: send_csnp (circuit, 2);
! 2303: }
! 2304: /* set next timer thread */
! 2305: THREAD_TIMER_ON (master, circuit->t_send_csnp[1], send_l2_csnp, circuit,
! 2306: isis_jitter (circuit->csnp_interval[1], CSNP_JITTER));
! 2307:
! 2308: return retval;
! 2309: }
! 2310:
! 2311: static int
! 2312: build_psnp (int level, struct isis_circuit *circuit, struct list *lsps)
! 2313: {
! 2314: struct isis_fixed_hdr fixed_hdr;
! 2315: unsigned long lenp;
! 2316: u_int16_t length;
! 2317: int retval = 0;
! 2318: struct isis_lsp *lsp;
! 2319: struct isis_passwd *passwd;
! 2320: struct listnode *node;
! 2321:
! 2322: if (level == 1)
! 2323: fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
! 2324: circuit->snd_stream);
! 2325: else
! 2326: fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
! 2327: circuit->snd_stream);
! 2328:
! 2329: /*
! 2330: * Fill Level 1 or 2 Partial Sequence Numbers header
! 2331: */
! 2332: lenp = stream_get_endp (circuit->snd_stream);
! 2333: stream_putw (circuit->snd_stream, 0); /* PDU length - when we know it */
! 2334: stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
! 2335: stream_putc (circuit->snd_stream, circuit->idx);
! 2336:
! 2337: /*
! 2338: * And TLVs
! 2339: */
! 2340:
! 2341: if (level == 1)
! 2342: passwd = &circuit->area->area_passwd;
! 2343: else
! 2344: passwd = &circuit->area->domain_passwd;
! 2345:
! 2346: if (CHECK_FLAG(passwd->snp_auth, SNP_AUTH_SEND))
! 2347: if (passwd->type)
! 2348: retval = tlv_add_authinfo (passwd->type, passwd->len,
! 2349: passwd->passwd, circuit->snd_stream);
! 2350:
! 2351: if (!retval && lsps)
! 2352: {
! 2353: retval = tlv_add_lsp_entries (lsps, circuit->snd_stream);
! 2354: }
! 2355:
! 2356: if (isis->debugs & DEBUG_SNP_PACKETS)
! 2357: {
! 2358: for (ALL_LIST_ELEMENTS_RO (lsps, node, lsp))
! 2359: {
! 2360: zlog_debug ("ISIS-Snp (%s): PSNP entry %s, seq 0x%08x,"
! 2361: " cksum 0x%04x, lifetime %us",
! 2362: circuit->area->area_tag,
! 2363: rawlspid_print (lsp->lsp_header->lsp_id),
! 2364: ntohl (lsp->lsp_header->seq_num),
! 2365: ntohs (lsp->lsp_header->checksum),
! 2366: ntohs (lsp->lsp_header->rem_lifetime));
! 2367: }
! 2368: }
! 2369:
! 2370: length = (u_int16_t) stream_get_endp (circuit->snd_stream);
! 2371: assert (length >= ISIS_PSNP_HDRLEN);
! 2372: /* Update PDU length */
! 2373: stream_putw_at (circuit->snd_stream, lenp, length);
! 2374:
! 2375: return ISIS_OK;
! 2376: }
! 2377:
! 2378: /*
! 2379: * 7.3.15.4 action on expiration of partial SNP interval
! 2380: * level 1
! 2381: */
! 2382: static int
! 2383: send_psnp (int level, struct isis_circuit *circuit)
! 2384: {
! 2385: int retval = ISIS_OK;
! 2386: struct isis_lsp *lsp;
! 2387: struct list *list = NULL;
! 2388: struct listnode *node;
! 2389:
! 2390: if ((circuit->circ_type == CIRCUIT_T_BROADCAST &&
! 2391: !circuit->u.bc.is_dr[level - 1]) ||
! 2392: circuit->circ_type != CIRCUIT_T_BROADCAST)
! 2393: {
! 2394:
! 2395: if (circuit->area->lspdb[level - 1] &&
! 2396: dict_count (circuit->area->lspdb[level - 1]) > 0)
! 2397: {
! 2398: list = list_new ();
! 2399: lsp_build_list_ssn (circuit, list, circuit->area->lspdb[level - 1]);
! 2400:
! 2401: if (listcount (list) > 0)
! 2402: {
! 2403: if (circuit->snd_stream == NULL)
! 2404: circuit->snd_stream = stream_new (ISO_MTU (circuit));
! 2405: else
! 2406: stream_reset (circuit->snd_stream);
! 2407:
! 2408:
! 2409: if (isis->debugs & DEBUG_SNP_PACKETS)
! 2410: zlog_debug ("ISIS-Snp (%s): Sent L%d PSNP on %s, length %ld",
! 2411: circuit->area->area_tag, level,
! 2412: circuit->interface->name,
! 2413: /* FIXME: use %z when we stop supporting old
! 2414: * compilers. */
! 2415: (unsigned long) STREAM_SIZE (circuit->snd_stream));
! 2416:
! 2417: retval = build_psnp (level, circuit, list);
! 2418: if (retval == ISIS_OK)
! 2419: retval = circuit->tx (circuit, level);
! 2420:
! 2421: if (retval == ISIS_OK)
! 2422: {
! 2423: /*
! 2424: * sending succeeded, we can clear SSN flags of this circuit
! 2425: * for the LSPs in list
! 2426: */
! 2427: for (ALL_LIST_ELEMENTS_RO (list, node, lsp))
! 2428: ISIS_CLEAR_FLAG (lsp->SSNflags, circuit);
! 2429: }
! 2430: }
! 2431: list_delete (list);
! 2432: }
! 2433: }
! 2434:
! 2435: return retval;
! 2436: }
! 2437:
! 2438: int
! 2439: send_l1_psnp (struct thread *thread)
! 2440: {
! 2441:
! 2442: struct isis_circuit *circuit;
! 2443: int retval = ISIS_OK;
! 2444:
! 2445: circuit = THREAD_ARG (thread);
! 2446: assert (circuit);
! 2447:
! 2448: circuit->t_send_psnp[0] = NULL;
! 2449:
! 2450: send_psnp (1, circuit);
! 2451: /* set next timer thread */
! 2452: THREAD_TIMER_ON (master, circuit->t_send_psnp[0], send_l1_psnp, circuit,
! 2453: isis_jitter (circuit->psnp_interval[0], PSNP_JITTER));
! 2454:
! 2455: return retval;
! 2456: }
! 2457:
! 2458: /*
! 2459: * 7.3.15.4 action on expiration of partial SNP interval
! 2460: * level 2
! 2461: */
! 2462: int
! 2463: send_l2_psnp (struct thread *thread)
! 2464: {
! 2465: struct isis_circuit *circuit;
! 2466: int retval = ISIS_OK;
! 2467:
! 2468: circuit = THREAD_ARG (thread);
! 2469: assert (circuit);
! 2470:
! 2471: circuit->t_send_psnp[1] = NULL;
! 2472:
! 2473: send_psnp (2, circuit);
! 2474:
! 2475: /* set next timer thread */
! 2476: THREAD_TIMER_ON (master, circuit->t_send_psnp[1], send_l2_psnp, circuit,
! 2477: isis_jitter (circuit->psnp_interval[1], PSNP_JITTER));
! 2478:
! 2479: return retval;
! 2480: }
! 2481:
! 2482: /*
! 2483: * ISO 10589 - 7.3.14.3
! 2484: */
! 2485: int
! 2486: send_lsp (struct thread *thread)
! 2487: {
! 2488: struct isis_circuit *circuit;
! 2489: struct isis_lsp *lsp;
! 2490: struct listnode *node;
! 2491: int retval = 0;
! 2492:
! 2493: circuit = THREAD_ARG (thread);
! 2494: assert (circuit);
! 2495:
! 2496: if (circuit->state == C_STATE_UP)
! 2497: {
! 2498: lsp = listgetdata ((node = listhead (circuit->lsp_queue)));
! 2499:
! 2500: /*
! 2501: * Do not send if levels do not match
! 2502: */
! 2503: if (!(lsp->level & circuit->circuit_is_type))
! 2504: goto dontsend;
! 2505:
! 2506: /*
! 2507: * Do not send if we do not have adjacencies in state up on the circuit
! 2508: */
! 2509: if (circuit->upadjcount[lsp->level - 1] == 0)
! 2510: goto dontsend;
! 2511: /* only send if it needs sending */
! 2512: if ((time (NULL) - lsp->last_sent) >=
! 2513: circuit->area->lsp_gen_interval[lsp->level - 1])
! 2514: {
! 2515:
! 2516: if (isis->debugs & DEBUG_UPDATE_PACKETS)
! 2517: {
! 2518: zlog_debug
! 2519: ("ISIS-Upd (%s): Sent L%d LSP %s, seq 0x%08x, cksum 0x%04x,"
! 2520: " lifetime %us on %s", circuit->area->area_tag, lsp->level,
! 2521: rawlspid_print (lsp->lsp_header->lsp_id),
! 2522: ntohl (lsp->lsp_header->seq_num),
! 2523: ntohs (lsp->lsp_header->checksum),
! 2524: ntohs (lsp->lsp_header->rem_lifetime),
! 2525: circuit->interface->name);
! 2526: }
! 2527: /* copy our lsp to the send buffer */
! 2528: stream_copy (circuit->snd_stream, lsp->pdu);
! 2529:
! 2530: retval = circuit->tx (circuit, lsp->level);
! 2531:
! 2532: /*
! 2533: * If the sending succeeded, we can del the lsp from circuits
! 2534: * lsp_queue
! 2535: */
! 2536: if (retval == ISIS_OK)
! 2537: {
! 2538: list_delete_node (circuit->lsp_queue, node);
! 2539:
! 2540: /*
! 2541: * On broadcast circuits also the SRMflag can be cleared
! 2542: */
! 2543: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 2544: ISIS_CLEAR_FLAG (lsp->SRMflags, circuit);
! 2545:
! 2546: if (flags_any_set (lsp->SRMflags) == 0)
! 2547: {
! 2548: /*
! 2549: * need to remember when we were last sent
! 2550: */
! 2551: lsp->last_sent = time (NULL);
! 2552: }
! 2553: }
! 2554: else
! 2555: {
! 2556: zlog_debug ("sending of level %d link state failed", lsp->level);
! 2557: }
! 2558: }
! 2559: else
! 2560: {
! 2561: /* my belief is that if it wasn't his time, the lsp can be removed
! 2562: * from the queue
! 2563: */
! 2564: dontsend:
! 2565: list_delete_node (circuit->lsp_queue, node);
! 2566: }
! 2567: #if 0
! 2568: /*
! 2569: * If there are still LSPs send next one after lsp-interval (33 msecs)
! 2570: */
! 2571: if (listcount (circuit->lsp_queue) > 0)
! 2572: thread_add_timer (master, send_lsp, circuit, 1);
! 2573: #endif
! 2574: }
! 2575:
! 2576: return retval;
! 2577: }
! 2578:
! 2579: int
! 2580: ack_lsp (struct isis_link_state_hdr *hdr, struct isis_circuit *circuit,
! 2581: int level)
! 2582: {
! 2583: unsigned long lenp;
! 2584: int retval;
! 2585: u_int16_t length;
! 2586: struct isis_fixed_hdr fixed_hdr;
! 2587:
! 2588: if (!circuit->snd_stream)
! 2589: circuit->snd_stream = stream_new (ISO_MTU (circuit));
! 2590: else
! 2591: stream_reset (circuit->snd_stream);
! 2592:
! 2593: // fill_llc_hdr (stream);
! 2594: if (level == 1)
! 2595: fill_fixed_hdr_andstream (&fixed_hdr, L1_PARTIAL_SEQ_NUM,
! 2596: circuit->snd_stream);
! 2597: else
! 2598: fill_fixed_hdr_andstream (&fixed_hdr, L2_PARTIAL_SEQ_NUM,
! 2599: circuit->snd_stream);
! 2600:
! 2601:
! 2602: lenp = stream_get_endp (circuit->snd_stream);
! 2603: stream_putw (circuit->snd_stream, 0); /* PDU length */
! 2604: stream_put (circuit->snd_stream, isis->sysid, ISIS_SYS_ID_LEN);
! 2605: stream_putc (circuit->snd_stream, circuit->idx);
! 2606: stream_putc (circuit->snd_stream, 9); /* code */
! 2607: stream_putc (circuit->snd_stream, 16); /* len */
! 2608:
! 2609: stream_putw (circuit->snd_stream, ntohs (hdr->rem_lifetime));
! 2610: stream_put (circuit->snd_stream, hdr->lsp_id, ISIS_SYS_ID_LEN + 2);
! 2611: stream_putl (circuit->snd_stream, ntohl (hdr->seq_num));
! 2612: stream_putw (circuit->snd_stream, ntohs (hdr->checksum));
! 2613:
! 2614: length = (u_int16_t) stream_get_endp (circuit->snd_stream);
! 2615: /* Update PDU length */
! 2616: stream_putw_at (circuit->snd_stream, lenp, length);
! 2617:
! 2618: retval = circuit->tx (circuit, level);
! 2619:
! 2620: return retval;
! 2621: }
! 2622:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_pdu.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