Annotation of embedaddon/quagga/isisd/isis_tlv.c, revision 1.1
1.1 ! misho 1: /*
! 2: * IS-IS Rout(e)ing protocol - isis_tlv.c
! 3: * IS-IS TLV related routines
! 4: *
! 5: * Copyright (C) 2001,2002 Sampo Saaristo
! 6: * Tampere University of Technology
! 7: * Institute of Communications Engineering
! 8: *
! 9: * This program is free software; you can redistribute it and/or modify it
! 10: * under the terms of the GNU General Public Licenseas published by the Free
! 11: * Software Foundation; either version 2 of the License, or (at your option)
! 12: * any later version.
! 13: *
! 14: * This program is distributed in the hope that it will be useful,but WITHOUT
! 15: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 16: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
! 17: * more details.
! 18:
! 19: * You should have received a copy of the GNU General Public License along
! 20: * with this program; if not, write to the Free Software Foundation, Inc.,
! 21: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
! 22: */
! 23:
! 24: #include <zebra.h>
! 25:
! 26: #include "log.h"
! 27: #include "linklist.h"
! 28: #include "stream.h"
! 29: #include "memory.h"
! 30: #include "prefix.h"
! 31: #include "vty.h"
! 32: #include "if.h"
! 33:
! 34: #include "isisd/dict.h"
! 35: #include "isisd/isis_constants.h"
! 36: #include "isisd/isis_common.h"
! 37: #include "isisd/isis_flags.h"
! 38: #include "isisd/isis_circuit.h"
! 39: #include "isisd/isis_tlv.h"
! 40: #include "isisd/isisd.h"
! 41: #include "isisd/isis_dynhn.h"
! 42: #include "isisd/isis_misc.h"
! 43: #include "isisd/isis_pdu.h"
! 44: #include "isisd/isis_lsp.h"
! 45:
! 46: extern struct isis *isis;
! 47:
! 48: /*
! 49: * Prototypes.
! 50: */
! 51: int add_tlv (u_char, u_char, u_char *, struct stream *);
! 52:
! 53: void
! 54: free_tlv (void *val)
! 55: {
! 56: XFREE (MTYPE_ISIS_TLV, val);
! 57:
! 58: return;
! 59: }
! 60:
! 61: /*
! 62: * Called after parsing of a PDU. There shouldn't be any tlv's left, so this
! 63: * is only a caution to avoid memory leaks
! 64: */
! 65: void
! 66: free_tlvs (struct tlvs *tlvs)
! 67: {
! 68: if (tlvs->area_addrs)
! 69: list_delete (tlvs->area_addrs);
! 70: if (tlvs->is_neighs)
! 71: list_delete (tlvs->is_neighs);
! 72: if (tlvs->te_is_neighs)
! 73: list_delete (tlvs->te_is_neighs);
! 74: if (tlvs->es_neighs)
! 75: list_delete (tlvs->es_neighs);
! 76: if (tlvs->lsp_entries)
! 77: list_delete (tlvs->lsp_entries);
! 78: if (tlvs->lan_neighs)
! 79: list_delete (tlvs->lan_neighs);
! 80: if (tlvs->prefix_neighs)
! 81: list_delete (tlvs->prefix_neighs);
! 82: if (tlvs->ipv4_addrs)
! 83: list_delete (tlvs->ipv4_addrs);
! 84: if (tlvs->ipv4_int_reachs)
! 85: list_delete (tlvs->ipv4_int_reachs);
! 86: if (tlvs->ipv4_ext_reachs)
! 87: list_delete (tlvs->ipv4_ext_reachs);
! 88: if (tlvs->te_ipv4_reachs)
! 89: list_delete (tlvs->te_ipv4_reachs);
! 90: #ifdef HAVE_IPV6
! 91: if (tlvs->ipv6_addrs)
! 92: list_delete (tlvs->ipv6_addrs);
! 93: if (tlvs->ipv6_reachs)
! 94: list_delete (tlvs->ipv6_reachs);
! 95: #endif /* HAVE_IPV6 */
! 96:
! 97: return;
! 98: }
! 99:
! 100: /*
! 101: * Parses the tlvs found in the variant length part of the PDU.
! 102: * Caller tells with flags in "expected" which TLV's it is interested in.
! 103: */
! 104: int
! 105: parse_tlvs (char *areatag, u_char * stream, int size, u_int32_t * expected,
! 106: u_int32_t * found, struct tlvs *tlvs)
! 107: {
! 108: u_char type, length;
! 109: struct lan_neigh *lan_nei;
! 110: struct area_addr *area_addr;
! 111: struct is_neigh *is_nei;
! 112: struct te_is_neigh *te_is_nei;
! 113: struct es_neigh *es_nei;
! 114: struct lsp_entry *lsp_entry;
! 115: struct in_addr *ipv4_addr;
! 116: struct ipv4_reachability *ipv4_reach;
! 117: struct te_ipv4_reachability *te_ipv4_reach;
! 118: #ifdef HAVE_IPV6
! 119: struct in6_addr *ipv6_addr;
! 120: struct ipv6_reachability *ipv6_reach;
! 121: int prefix_octets;
! 122: #endif /* HAVE_IPV6 */
! 123: u_char virtual;
! 124: int value_len, retval = ISIS_OK;
! 125: u_char *pnt = stream;
! 126:
! 127: *found = 0;
! 128: memset (tlvs, 0, sizeof (struct tlvs));
! 129:
! 130: while (pnt < stream + size - 2)
! 131: {
! 132: type = *pnt;
! 133: length = *(pnt + 1);
! 134: pnt += 2;
! 135: value_len = 0;
! 136: if (pnt + length > stream + size)
! 137: {
! 138: zlog_warn ("ISIS-TLV (%s): TLV (type %d, length %d) exceeds packet "
! 139: "boundaries", areatag, type, length);
! 140: retval = ISIS_WARNING;
! 141: break;
! 142: }
! 143: switch (type)
! 144: {
! 145: case AREA_ADDRESSES:
! 146: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 147: * | Address Length |
! 148: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 149: * | Area Address |
! 150: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 151: * : :
! 152: */
! 153: *found |= TLVFLAG_AREA_ADDRS;
! 154: #ifdef EXTREME_TLV_DEBUG
! 155: zlog_debug ("TLV Area Adresses len %d", length);
! 156: #endif /* EXTREME_TLV_DEBUG */
! 157: if (*expected & TLVFLAG_AREA_ADDRS)
! 158: {
! 159: while (length > value_len)
! 160: {
! 161: area_addr = (struct area_addr *) pnt;
! 162: value_len += area_addr->addr_len + 1;
! 163: pnt += area_addr->addr_len + 1;
! 164: if (!tlvs->area_addrs)
! 165: tlvs->area_addrs = list_new ();
! 166: listnode_add (tlvs->area_addrs, area_addr);
! 167: }
! 168: }
! 169: else
! 170: {
! 171: pnt += length;
! 172: }
! 173: break;
! 174:
! 175: case IS_NEIGHBOURS:
! 176: *found |= TLVFLAG_IS_NEIGHS;
! 177: #ifdef EXTREME_TLV_DEBUG
! 178: zlog_debug ("ISIS-TLV (%s): IS Neighbours length %d",
! 179: areatag, length);
! 180: #endif /* EXTREME_TLV_DEBUG */
! 181: if (TLVFLAG_IS_NEIGHS & *expected)
! 182: {
! 183: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 184: * | Virtual Flag |
! 185: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 186: */
! 187: virtual = *pnt; /* FIXME: what is the use for this? */
! 188: pnt++;
! 189: value_len++;
! 190: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 191: * | 0 | I/E | Default Metric |
! 192: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 193: * | S | I/E | Delay Metric |
! 194: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 195: * | S | I/E | Expense Metric |
! 196: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 197: * | S | I/E | Error Metric |
! 198: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 199: * | Neighbour ID |
! 200: * +---------------------------------------------------------------+
! 201: * : :
! 202: */
! 203: while (length > value_len)
! 204: {
! 205: is_nei = (struct is_neigh *) pnt;
! 206: value_len += 4 + ISIS_SYS_ID_LEN + 1;
! 207: pnt += 4 + ISIS_SYS_ID_LEN + 1;
! 208: if (!tlvs->is_neighs)
! 209: tlvs->is_neighs = list_new ();
! 210: listnode_add (tlvs->is_neighs, is_nei);
! 211: }
! 212: }
! 213: else
! 214: {
! 215: pnt += length;
! 216: }
! 217: break;
! 218:
! 219: case TE_IS_NEIGHBOURS:
! 220: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 221: * | Neighbour ID | 7
! 222: * +---------------------------------------------------------------+
! 223: * | TE Metric | 3
! 224: * +---------------------------------------------------------------+
! 225: * | SubTLVs Length | 1
! 226: * +---------------------------------------------------------------+
! 227: * : :
! 228: */
! 229: *found |= TLVFLAG_TE_IS_NEIGHS;
! 230: #ifdef EXTREME_TLV_DEBUG
! 231: zlog_debug ("ISIS-TLV (%s): Extended IS Neighbours length %d",
! 232: areatag, length);
! 233: #endif /* EXTREME_TLV_DEBUG */
! 234: if (TLVFLAG_TE_IS_NEIGHS & *expected)
! 235: {
! 236: while (length > value_len)
! 237: {
! 238: te_is_nei = (struct te_is_neigh *) pnt;
! 239: value_len += 11;
! 240: pnt += 11;
! 241: /* FIXME - subtlvs are handled here, for now we skip */
! 242: value_len += te_is_nei->sub_tlvs_length;
! 243: pnt += te_is_nei->sub_tlvs_length;
! 244:
! 245: if (!tlvs->te_is_neighs)
! 246: tlvs->te_is_neighs = list_new ();
! 247: listnode_add (tlvs->te_is_neighs, te_is_nei);
! 248: }
! 249: }
! 250: else
! 251: {
! 252: pnt += length;
! 253: }
! 254: break;
! 255:
! 256: case ES_NEIGHBOURS:
! 257: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 258: * | 0 | I/E | Default Metric |
! 259: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 260: * | S | I/E | Delay Metric |
! 261: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 262: * | S | I/E | Expense Metric |
! 263: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 264: * | S | I/E | Error Metric |
! 265: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 266: * | Neighbour ID |
! 267: * +---------------------------------------------------------------+
! 268: * | Neighbour ID |
! 269: * +---------------------------------------------------------------+
! 270: * : :
! 271: */
! 272: #ifdef EXTREME_TLV_DEBUG
! 273: zlog_debug ("ISIS-TLV (%s): ES Neighbours length %d",
! 274: areatag, length);
! 275: #endif /* EXTREME_TLV_DEBUG */
! 276: *found |= TLVFLAG_ES_NEIGHS;
! 277: if (*expected & TLVFLAG_ES_NEIGHS)
! 278: {
! 279: es_nei = (struct es_neigh *) pnt;
! 280: value_len += 4;
! 281: pnt += 4;
! 282: while (length > value_len)
! 283: {
! 284: /* FIXME FIXME FIXME - add to the list */
! 285: /* sys_id->id = pnt; */
! 286: value_len += ISIS_SYS_ID_LEN;
! 287: pnt += ISIS_SYS_ID_LEN;
! 288: /* if (!es_nei->neigh_ids) es_nei->neigh_ids = sysid; */
! 289: }
! 290: if (!tlvs->es_neighs)
! 291: tlvs->es_neighs = list_new ();
! 292: listnode_add (tlvs->es_neighs, es_nei);
! 293: }
! 294: else
! 295: {
! 296: pnt += length;
! 297: }
! 298: break;
! 299:
! 300: case LAN_NEIGHBOURS:
! 301: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 302: * | LAN Address |
! 303: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 304: * : :
! 305: */
! 306: *found |= TLVFLAG_LAN_NEIGHS;
! 307: #ifdef EXTREME_TLV_DEBUG
! 308: zlog_debug ("ISIS-TLV (%s): LAN Neigbours length %d",
! 309: areatag, length);
! 310: #endif /* EXTREME_TLV_DEBUG */
! 311: if (TLVFLAG_LAN_NEIGHS & *expected)
! 312: {
! 313: while (length > value_len)
! 314: {
! 315: lan_nei = (struct lan_neigh *) pnt;
! 316: if (!tlvs->lan_neighs)
! 317: tlvs->lan_neighs = list_new ();
! 318: listnode_add (tlvs->lan_neighs, lan_nei);
! 319: value_len += ETH_ALEN;
! 320: pnt += ETH_ALEN;
! 321: }
! 322: }
! 323: else
! 324: {
! 325: pnt += length;
! 326: }
! 327: break;
! 328:
! 329: case PADDING:
! 330: #ifdef EXTREME_TLV_DEBUG
! 331: zlog_debug ("TLV padding %d", length);
! 332: #endif /* EXTREME_TLV_DEBUG */
! 333: pnt += length;
! 334: break;
! 335:
! 336: case LSP_ENTRIES:
! 337: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 338: * | Remaining Lifetime | 2
! 339: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 340: * | LSP ID | id+2
! 341: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 342: * | LSP Sequence Number | 4
! 343: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 344: * | Checksum | 2
! 345: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 346: */
! 347: #ifdef EXTREME_TLV_DEBUG
! 348: zlog_debug ("ISIS-TLV (%s): LSP Entries length %d", areatag, length);
! 349: #endif /* EXTREME_TLV_DEBUG */
! 350: *found |= TLVFLAG_LSP_ENTRIES;
! 351: if (TLVFLAG_LSP_ENTRIES & *expected)
! 352: {
! 353: while (length > value_len)
! 354: {
! 355: lsp_entry = (struct lsp_entry *) pnt;
! 356: value_len += 10 + ISIS_SYS_ID_LEN;
! 357: pnt += 10 + ISIS_SYS_ID_LEN;
! 358: if (!tlvs->lsp_entries)
! 359: tlvs->lsp_entries = list_new ();
! 360: listnode_add (tlvs->lsp_entries, lsp_entry);
! 361: }
! 362: }
! 363: else
! 364: {
! 365: pnt += length;
! 366: }
! 367: break;
! 368:
! 369: case CHECKSUM:
! 370: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 371: * | 16 bit fletcher CHECKSUM |
! 372: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 373: * : :
! 374: */
! 375: *found |= TLVFLAG_CHECKSUM;
! 376: #ifdef EXTREME_TLV_DEBUG
! 377: zlog_debug ("ISIS-TLV (%s): Checksum length %d", areatag, length);
! 378: #endif /* EXTREME_TLV_DEBUG */
! 379: if (*expected & TLVFLAG_CHECKSUM)
! 380: {
! 381: tlvs->checksum = (struct checksum *) pnt;
! 382: }
! 383: pnt += length;
! 384: break;
! 385:
! 386: case PROTOCOLS_SUPPORTED:
! 387: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 388: * | NLPID |
! 389: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 390: * : :
! 391: */
! 392: *found |= TLVFLAG_NLPID;
! 393: #ifdef EXTREME_TLV_DEBUG
! 394: zlog_debug ("ISIS-TLV (%s): Protocols Supported length %d",
! 395: areatag, length);
! 396: #endif /* EXTREME_TLV_DEBUG */
! 397: if (*expected & TLVFLAG_NLPID)
! 398: {
! 399: tlvs->nlpids = (struct nlpids *) (pnt - 1);
! 400: }
! 401: pnt += length;
! 402: break;
! 403:
! 404: case IPV4_ADDR:
! 405: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 406: * + IP version 4 address + 4
! 407: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 408: * : :
! 409: */
! 410: *found |= TLVFLAG_IPV4_ADDR;
! 411: #ifdef EXTREME_TLV_DEBUG
! 412: zlog_debug ("ISIS-TLV (%s): IPv4 Address length %d",
! 413: areatag, length);
! 414: #endif /* EXTREME_TLV_DEBUG */
! 415: if (*expected & TLVFLAG_IPV4_ADDR)
! 416: {
! 417: while (length > value_len)
! 418: {
! 419: ipv4_addr = (struct in_addr *) pnt;
! 420: #ifdef EXTREME_TLV_DEBUG
! 421: zlog_debug ("ISIS-TLV (%s) : IP ADDR %s, pnt %p", areatag,
! 422: inet_ntoa (*ipv4_addr), pnt);
! 423: #endif /* EXTREME_TLV_DEBUG */
! 424: if (!tlvs->ipv4_addrs)
! 425: tlvs->ipv4_addrs = list_new ();
! 426: listnode_add (tlvs->ipv4_addrs, ipv4_addr);
! 427: value_len += 4;
! 428: pnt += 4;
! 429: }
! 430: }
! 431: else
! 432: {
! 433: pnt += length;
! 434: }
! 435: break;
! 436:
! 437: case AUTH_INFO:
! 438: *found |= TLVFLAG_AUTH_INFO;
! 439: #ifdef EXTREME_TLV_DEBUG
! 440: zlog_debug ("ISIS-TLV (%s): IS-IS Authentication Information",
! 441: areatag);
! 442: #endif
! 443: if (*expected & TLVFLAG_AUTH_INFO)
! 444: {
! 445: tlvs->auth_info.type = *pnt;
! 446: tlvs->auth_info.len = length-1;
! 447: pnt++;
! 448: memcpy (tlvs->auth_info.passwd, pnt, length - 1);
! 449: pnt += length - 1;
! 450: }
! 451: else
! 452: {
! 453: pnt += length;
! 454: }
! 455: break;
! 456:
! 457: case DYNAMIC_HOSTNAME:
! 458: *found |= TLVFLAG_DYN_HOSTNAME;
! 459: #ifdef EXTREME_TLV_DEBUG
! 460: zlog_debug ("ISIS-TLV (%s): Dynamic Hostname length %d",
! 461: areatag, length);
! 462: #endif /* EXTREME_TLV_DEBUG */
! 463: if (*expected & TLVFLAG_DYN_HOSTNAME)
! 464: {
! 465: /* the length is also included in the pointed struct */
! 466: tlvs->hostname = (struct hostname *) (pnt - 1);
! 467: }
! 468: pnt += length;
! 469: break;
! 470:
! 471: case TE_ROUTER_ID:
! 472: /* +---------------------------------------------------------------+
! 473: * + Router ID + 4
! 474: * +---------------------------------------------------------------+
! 475: */
! 476: *found |= TLVFLAG_TE_ROUTER_ID;
! 477: #ifdef EXTREME_TLV_DEBUG
! 478: zlog_debug ("ISIS-TLV (%s): TE Router ID %d", areatag, length);
! 479: #endif /* EXTREME_TLV_DEBUG */
! 480: if (*expected & TLVFLAG_TE_ROUTER_ID)
! 481: tlvs->router_id = (struct te_router_id *) (pnt);
! 482: pnt += length;
! 483: break;
! 484:
! 485: case IPV4_INT_REACHABILITY:
! 486: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 487: * | 0 | I/E | Default Metric | 1
! 488: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 489: * | S | I/E | Delay Metric | 1
! 490: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 491: * | S | I/E | Expense Metric | 1
! 492: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 493: * | S | I/E | Error Metric | 1
! 494: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 495: * | ip address | 4
! 496: * +---------------------------------------------------------------+
! 497: * | address mask | 4
! 498: * +---------------------------------------------------------------+
! 499: * : :
! 500: */
! 501: *found |= TLVFLAG_IPV4_INT_REACHABILITY;
! 502: #ifdef EXTREME_TLV_DEBUG
! 503: zlog_debug ("ISIS-TLV (%s): IPv4 internal Reachability length %d",
! 504: areatag, length);
! 505: #endif /* EXTREME_TLV_DEBUG */
! 506: if (*expected & TLVFLAG_IPV4_INT_REACHABILITY)
! 507: {
! 508: while (length > value_len)
! 509: {
! 510: ipv4_reach = (struct ipv4_reachability *) pnt;
! 511: if (!tlvs->ipv4_int_reachs)
! 512: tlvs->ipv4_int_reachs = list_new ();
! 513: listnode_add (tlvs->ipv4_int_reachs, ipv4_reach);
! 514: value_len += 12;
! 515: pnt += 12;
! 516: }
! 517: }
! 518: else
! 519: {
! 520: pnt += length;
! 521: }
! 522: break;
! 523:
! 524: case IPV4_EXT_REACHABILITY:
! 525: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 526: * | 0 | I/E | Default Metric | 1
! 527: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 528: * | S | I/E | Delay Metric | 1
! 529: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 530: * | S | I/E | Expense Metric | 1
! 531: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 532: * | S | I/E | Error Metric | 1
! 533: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 534: * | ip address | 4
! 535: * +---------------------------------------------------------------+
! 536: * | address mask | 4
! 537: * +---------------------------------------------------------------+
! 538: * : :
! 539: */
! 540: *found |= TLVFLAG_IPV4_EXT_REACHABILITY;
! 541: #ifdef EXTREME_TLV_DEBUG
! 542: zlog_debug ("ISIS-TLV (%s): IPv4 external Reachability length %d",
! 543: areatag, length);
! 544: #endif /* EXTREME_TLV_DEBUG */
! 545: if (*expected & TLVFLAG_IPV4_EXT_REACHABILITY)
! 546: {
! 547: while (length > value_len)
! 548: {
! 549: ipv4_reach = (struct ipv4_reachability *) pnt;
! 550: if (!tlvs->ipv4_ext_reachs)
! 551: tlvs->ipv4_ext_reachs = list_new ();
! 552: listnode_add (tlvs->ipv4_ext_reachs, ipv4_reach);
! 553: value_len += 12;
! 554: pnt += 12;
! 555: }
! 556: }
! 557: else
! 558: {
! 559: pnt += length;
! 560: }
! 561: break;
! 562:
! 563: case TE_IPV4_REACHABILITY:
! 564: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 565: * | TE Metric | 4
! 566: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 567: * | U/D | sTLV? | Prefix Mask Len | 1
! 568: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 569: * | Prefix | 0-4
! 570: * +---------------------------------------------------------------+
! 571: * | sub tlvs |
! 572: * +---------------------------------------------------------------+
! 573: * : :
! 574: */
! 575: *found |= TLVFLAG_TE_IPV4_REACHABILITY;
! 576: #ifdef EXTREME_TLV_DEBUG
! 577: zlog_debug ("ISIS-TLV (%s): IPv4 extended Reachability length %d",
! 578: areatag, length);
! 579: #endif /* EXTREME_TLV_DEBUG */
! 580: if (*expected & TLVFLAG_TE_IPV4_REACHABILITY)
! 581: {
! 582: while (length > value_len)
! 583: {
! 584: te_ipv4_reach = (struct te_ipv4_reachability *) pnt;
! 585: if (!tlvs->te_ipv4_reachs)
! 586: tlvs->te_ipv4_reachs = list_new ();
! 587: listnode_add (tlvs->te_ipv4_reachs, te_ipv4_reach);
! 588: /* this trickery is permitable since no subtlvs are defined */
! 589: value_len += 5 + ((te_ipv4_reach->control & 0x3F) ?
! 590: ((((te_ipv4_reach->control & 0x3F) -
! 591: 1) >> 3) + 1) : 0);
! 592: pnt += 5 + ((te_ipv4_reach->control & 0x3F) ?
! 593: ((((te_ipv4_reach->control & 0x3F) - 1) >> 3) + 1) : 0);
! 594: }
! 595: }
! 596: else
! 597: {
! 598: pnt += length;
! 599: }
! 600: break;
! 601:
! 602: #ifdef HAVE_IPV6
! 603: case IPV6_ADDR:
! 604: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 605: * + IP version 6 address + 16
! 606: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 607: * : :
! 608: */
! 609: *found |= TLVFLAG_IPV6_ADDR;
! 610: #ifdef EXTREME_TLV_DEBUG
! 611: zlog_debug ("ISIS-TLV (%s): IPv6 Address length %d",
! 612: areatag, length);
! 613: #endif /* EXTREME_TLV_DEBUG */
! 614: if (*expected & TLVFLAG_IPV6_ADDR)
! 615: {
! 616: while (length > value_len)
! 617: {
! 618: ipv6_addr = (struct in6_addr *) pnt;
! 619: if (!tlvs->ipv6_addrs)
! 620: tlvs->ipv6_addrs = list_new ();
! 621: listnode_add (tlvs->ipv6_addrs, ipv6_addr);
! 622: value_len += 16;
! 623: pnt += 16;
! 624: }
! 625: }
! 626: else
! 627: {
! 628: pnt += length;
! 629: }
! 630: break;
! 631:
! 632: case IPV6_REACHABILITY:
! 633: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 634: * | Default Metric | 4
! 635: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 636: * | Control Informantion |
! 637: * +---------------------------------------------------------------+
! 638: * | IPv6 Prefix Length |--+
! 639: * +---------------------------------------------------------------+ |
! 640: * | IPv6 Prefix |<-+
! 641: * +---------------------------------------------------------------+
! 642: */
! 643: *found |= TLVFLAG_IPV6_REACHABILITY;
! 644: if (*expected & TLVFLAG_IPV6_REACHABILITY)
! 645: {
! 646: while (length > value_len)
! 647: {
! 648: ipv6_reach = (struct ipv6_reachability *) pnt;
! 649: prefix_octets = ((ipv6_reach->prefix_len + 7) / 8);
! 650: value_len += prefix_octets + 6;
! 651: pnt += prefix_octets + 6;
! 652: /* FIXME: sub-tlvs */
! 653: if (!tlvs->ipv6_reachs)
! 654: tlvs->ipv6_reachs = list_new ();
! 655: listnode_add (tlvs->ipv6_reachs, ipv6_reach);
! 656: }
! 657: }
! 658: else
! 659: {
! 660: pnt += length;
! 661: }
! 662: break;
! 663: #endif /* HAVE_IPV6 */
! 664:
! 665: case WAY3_HELLO:
! 666: /* +---------------------------------------------------------------+
! 667: * | Adjacency state | 1
! 668: * +---------------------------------------------------------------+
! 669: * | Extended Local Circuit ID | 4
! 670: * +---------------------------------------------------------------+
! 671: * | Neighbor System ID (If known) | 0-8
! 672: * (probably 6)
! 673: * +---------------------------------------------------------------+
! 674: * | Neighbor Local Circuit ID (If known) | 4
! 675: * +---------------------------------------------------------------+
! 676: */
! 677: *found |= TLVFLAG_3WAY_HELLO;
! 678: if (*expected & TLVFLAG_3WAY_HELLO)
! 679: {
! 680: while (length > value_len)
! 681: {
! 682: /* FIXME: make this work */
! 683: /* Adjacency State (one octet):
! 684: 0 = Up
! 685: 1 = Initializing
! 686: 2 = Down
! 687: Extended Local Circuit ID (four octets)
! 688: Neighbor System ID if known (zero to eight octets)
! 689: Neighbor Extended Local Circuit ID (four octets, if Neighbor
! 690: System ID is present) */
! 691: pnt += length;
! 692: }
! 693: }
! 694: else
! 695: {
! 696: pnt += length;
! 697: }
! 698:
! 699: break;
! 700: case GRACEFUL_RESTART:
! 701: /* +-------+-------+-------+-------+-------+-------+-------+-------+
! 702: * | Reserved | SA | RA | RR | 1
! 703: * +-------+-------+-------+-------+-------+-------+-------+-------+
! 704: * | Remaining Time | 2
! 705: * +---------------------------------------------------------------+
! 706: * | Restarting Neighbor ID (If known) | 0-8
! 707: * +---------------------------------------------------------------+
! 708: */
! 709: *found |= TLVFLAG_GRACEFUL_RESTART;
! 710: if (*expected & TLVFLAG_GRACEFUL_RESTART)
! 711: {
! 712: /* FIXME: make this work */
! 713: }
! 714: pnt += length;
! 715: break;
! 716:
! 717: default:
! 718: zlog_warn ("ISIS-TLV (%s): unsupported TLV type %d, length %d",
! 719: areatag, type, length);
! 720:
! 721: retval = ISIS_WARNING;
! 722: pnt += length;
! 723: break;
! 724: }
! 725: }
! 726:
! 727: return retval;
! 728: }
! 729:
! 730: int
! 731: add_tlv (u_char tag, u_char len, u_char * value, struct stream *stream)
! 732: {
! 733:
! 734: if (STREAM_SIZE (stream) - stream_get_endp (stream) < (unsigned) len + 2)
! 735: {
! 736: zlog_warn ("No room for TLV of type %d", tag);
! 737: return ISIS_WARNING;
! 738: }
! 739:
! 740: stream_putc (stream, tag); /* TAG */
! 741: stream_putc (stream, len); /* LENGTH */
! 742: stream_put (stream, value, (int) len); /* VALUE */
! 743:
! 744: #ifdef EXTREME_DEBUG
! 745: zlog_debug ("Added TLV %d len %d", tag, len);
! 746: #endif /* EXTREME DEBUG */
! 747: return ISIS_OK;
! 748: }
! 749:
! 750: int
! 751: tlv_add_area_addrs (struct list *area_addrs, struct stream *stream)
! 752: {
! 753: struct listnode *node;
! 754: struct area_addr *area_addr;
! 755:
! 756: u_char value[255];
! 757: u_char *pos = value;
! 758:
! 759: for (ALL_LIST_ELEMENTS_RO (area_addrs, node, area_addr))
! 760: {
! 761: if (pos - value + area_addr->addr_len > 255)
! 762: goto err;
! 763: *pos = area_addr->addr_len;
! 764: pos++;
! 765: memcpy (pos, area_addr->area_addr, (int) area_addr->addr_len);
! 766: pos += area_addr->addr_len;
! 767: }
! 768:
! 769: return add_tlv (AREA_ADDRESSES, pos - value, value, stream);
! 770:
! 771: err:
! 772: zlog_warn ("tlv_add_area_addrs(): TLV longer than 255");
! 773: return ISIS_WARNING;
! 774: }
! 775:
! 776: int
! 777: tlv_add_is_neighs (struct list *is_neighs, struct stream *stream)
! 778: {
! 779: struct listnode *node;
! 780: struct is_neigh *is_neigh;
! 781: u_char value[255];
! 782: u_char *pos = value;
! 783: int retval;
! 784:
! 785: *pos = 0; /*is_neigh->virtual; */
! 786: pos++;
! 787:
! 788: for (ALL_LIST_ELEMENTS_RO (is_neighs, node, is_neigh))
! 789: {
! 790: if (pos - value + IS_NEIGHBOURS_LEN > 255)
! 791: {
! 792: retval = add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
! 793: if (retval != ISIS_OK)
! 794: return retval;
! 795: pos = value;
! 796: }
! 797: *pos = is_neigh->metrics.metric_default;
! 798: pos++;
! 799: *pos = is_neigh->metrics.metric_delay;
! 800: pos++;
! 801: *pos = is_neigh->metrics.metric_expense;
! 802: pos++;
! 803: *pos = is_neigh->metrics.metric_error;
! 804: pos++;
! 805: memcpy (pos, is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
! 806: pos += ISIS_SYS_ID_LEN + 1;
! 807: }
! 808:
! 809: return add_tlv (IS_NEIGHBOURS, pos - value, value, stream);
! 810: }
! 811:
! 812: int
! 813: tlv_add_te_is_neighs (struct list *te_is_neighs, struct stream *stream)
! 814: {
! 815: struct listnode *node;
! 816: struct te_is_neigh *te_is_neigh;
! 817: u_char value[255];
! 818: u_char *pos = value;
! 819: int retval;
! 820:
! 821: for (ALL_LIST_ELEMENTS_RO (te_is_neighs, node, te_is_neigh))
! 822: {
! 823: /* FIXME: This will be wrong if we are going to add TE sub TLVs. */
! 824: if (pos - value + IS_NEIGHBOURS_LEN > 255)
! 825: {
! 826: retval = add_tlv (TE_IS_NEIGHBOURS, pos - value, value, stream);
! 827: if (retval != ISIS_OK)
! 828: return retval;
! 829: pos = value;
! 830: }
! 831:
! 832: memcpy (pos, te_is_neigh->neigh_id, ISIS_SYS_ID_LEN + 1);
! 833: pos += ISIS_SYS_ID_LEN + 1;
! 834: memcpy (pos, te_is_neigh->te_metric, 3);
! 835: pos += 3;
! 836: /* Sub TLVs length. */
! 837: *pos = 0;
! 838: pos++;
! 839: }
! 840:
! 841: return add_tlv (TE_IS_NEIGHBOURS, pos - value, value, stream);
! 842: }
! 843:
! 844: int
! 845: tlv_add_lan_neighs (struct list *lan_neighs, struct stream *stream)
! 846: {
! 847: struct listnode *node;
! 848: u_char *snpa;
! 849: u_char value[255];
! 850: u_char *pos = value;
! 851: int retval;
! 852:
! 853: for (ALL_LIST_ELEMENTS_RO (lan_neighs, node, snpa))
! 854: {
! 855: if (pos - value + ETH_ALEN > 255)
! 856: {
! 857: retval = add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
! 858: if (retval != ISIS_OK)
! 859: return retval;
! 860: pos = value;
! 861: }
! 862: memcpy (pos, snpa, ETH_ALEN);
! 863: pos += ETH_ALEN;
! 864: }
! 865:
! 866: return add_tlv (LAN_NEIGHBOURS, pos - value, value, stream);
! 867: }
! 868:
! 869: int
! 870: tlv_add_nlpid (struct nlpids *nlpids, struct stream *stream)
! 871: {
! 872: return add_tlv (PROTOCOLS_SUPPORTED, nlpids->count, nlpids->nlpids, stream);
! 873: }
! 874:
! 875: int
! 876: tlv_add_authinfo (char auth_type, char auth_len, u_char *auth_value,
! 877: struct stream *stream)
! 878: {
! 879: u_char value[255];
! 880: u_char *pos = value;
! 881: *pos++ = ISIS_PASSWD_TYPE_CLEARTXT;
! 882: memcpy (pos, auth_value, auth_len);
! 883:
! 884: return add_tlv (AUTH_INFO, auth_len + 1, value, stream);
! 885: }
! 886:
! 887: int
! 888: tlv_add_checksum (struct checksum *checksum, struct stream *stream)
! 889: {
! 890: u_char value[255];
! 891: u_char *pos = value;
! 892: return add_tlv (CHECKSUM, pos - value, value, stream);
! 893: }
! 894:
! 895: int
! 896: tlv_add_ip_addrs (struct list *ip_addrs, struct stream *stream)
! 897: {
! 898: struct listnode *node;
! 899: struct prefix_ipv4 *ipv4;
! 900: u_char value[255];
! 901: u_char *pos = value;
! 902: int retval;
! 903:
! 904: for (ALL_LIST_ELEMENTS_RO (ip_addrs, node, ipv4))
! 905: {
! 906: if (pos - value + IPV4_MAX_BYTELEN > 255)
! 907: {
! 908: retval = add_tlv (IPV4_ADDR, pos - value, value, stream);
! 909: if (retval != ISIS_OK)
! 910: return retval;
! 911: pos = value;
! 912: }
! 913: *(u_int32_t *) pos = ipv4->prefix.s_addr;
! 914: pos += IPV4_MAX_BYTELEN;
! 915: }
! 916:
! 917: return add_tlv (IPV4_ADDR, pos - value, value, stream);
! 918: }
! 919:
! 920: /* Used to add TLV containing just one IPv4 address - either IPv4 address TLV
! 921: * (in case of LSP) or TE router ID TLV. */
! 922: int
! 923: tlv_add_in_addr (struct in_addr *addr, struct stream *stream, u_char tag)
! 924: {
! 925: u_char value[255];
! 926: u_char *pos = value;
! 927:
! 928: memcpy (pos, addr, IPV4_MAX_BYTELEN);
! 929: pos += IPV4_MAX_BYTELEN;
! 930:
! 931: return add_tlv (tag, pos - value, value, stream);
! 932: }
! 933:
! 934: int
! 935: tlv_add_dynamic_hostname (struct hostname *hostname, struct stream *stream)
! 936: {
! 937: return add_tlv (DYNAMIC_HOSTNAME, hostname->namelen, hostname->name,
! 938: stream);
! 939: }
! 940:
! 941: int
! 942: tlv_add_lsp_entries (struct list *lsps, struct stream *stream)
! 943: {
! 944: struct listnode *node;
! 945: struct isis_lsp *lsp;
! 946: u_char value[255];
! 947: u_char *pos = value;
! 948: int retval;
! 949:
! 950: for (ALL_LIST_ELEMENTS_RO (lsps, node, lsp))
! 951: {
! 952: if (pos - value + LSP_ENTRIES_LEN > 255)
! 953: {
! 954: retval = add_tlv (LSP_ENTRIES, pos - value, value, stream);
! 955: if (retval != ISIS_OK)
! 956: return retval;
! 957: pos = value;
! 958: }
! 959: *((u_int16_t *) pos) = lsp->lsp_header->rem_lifetime;
! 960: pos += 2;
! 961: memcpy (pos, lsp->lsp_header->lsp_id, ISIS_SYS_ID_LEN + 2);
! 962: pos += ISIS_SYS_ID_LEN + 2;
! 963: *((u_int32_t *) pos) = lsp->lsp_header->seq_num;
! 964: pos += 4;
! 965: *((u_int16_t *) pos) = lsp->lsp_header->checksum;
! 966: pos += 2;
! 967: }
! 968:
! 969: return add_tlv (LSP_ENTRIES, pos - value, value, stream);
! 970: }
! 971:
! 972: int
! 973: tlv_add_ipv4_reachs (struct list *ipv4_reachs, struct stream *stream)
! 974: {
! 975: struct listnode *node;
! 976: struct ipv4_reachability *reach;
! 977: u_char value[255];
! 978: u_char *pos = value;
! 979: int retval;
! 980:
! 981: for (ALL_LIST_ELEMENTS_RO (ipv4_reachs, node, reach))
! 982: {
! 983: if (pos - value + IPV4_REACH_LEN > 255)
! 984: {
! 985: retval =
! 986: add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
! 987: if (retval != ISIS_OK)
! 988: return retval;
! 989: pos = value;
! 990: }
! 991: *pos = reach->metrics.metric_default;
! 992: pos++;
! 993: *pos = reach->metrics.metric_delay;
! 994: pos++;
! 995: *pos = reach->metrics.metric_expense;
! 996: pos++;
! 997: *pos = reach->metrics.metric_error;
! 998: pos++;
! 999: *(u_int32_t *) pos = reach->prefix.s_addr;
! 1000: pos += IPV4_MAX_BYTELEN;
! 1001: *(u_int32_t *) pos = reach->mask.s_addr;
! 1002: pos += IPV4_MAX_BYTELEN;
! 1003: }
! 1004:
! 1005:
! 1006: return add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
! 1007: }
! 1008:
! 1009: int
! 1010: tlv_add_te_ipv4_reachs (struct list *te_ipv4_reachs, struct stream *stream)
! 1011: {
! 1012: struct listnode *node;
! 1013: struct te_ipv4_reachability *te_reach;
! 1014: u_char value[255];
! 1015: u_char *pos = value;
! 1016: u_char prefix_size;
! 1017: int retval;
! 1018:
! 1019: for (ALL_LIST_ELEMENTS_RO (te_ipv4_reachs, node, te_reach))
! 1020: {
! 1021: prefix_size = ((((te_reach->control & 0x3F) - 1) >> 3) + 1);
! 1022:
! 1023: if (pos - value + (5 + prefix_size) > 255)
! 1024: {
! 1025: retval =
! 1026: add_tlv (IPV4_INT_REACHABILITY, pos - value, value, stream);
! 1027: if (retval != ISIS_OK)
! 1028: return retval;
! 1029: pos = value;
! 1030: }
! 1031: *(u_int32_t *) pos = te_reach->te_metric;
! 1032: pos += 4;
! 1033: *pos = te_reach->control;
! 1034: pos++;
! 1035: memcpy (pos, &te_reach->prefix_start, prefix_size);
! 1036: pos += prefix_size;
! 1037: }
! 1038:
! 1039: return add_tlv (TE_IPV4_REACHABILITY, pos - value, value, stream);
! 1040: }
! 1041:
! 1042: #ifdef HAVE_IPV6
! 1043: int
! 1044: tlv_add_ipv6_addrs (struct list *ipv6_addrs, struct stream *stream)
! 1045: {
! 1046: struct listnode *node;
! 1047: struct prefix_ipv6 *ipv6;
! 1048: u_char value[255];
! 1049: u_char *pos = value;
! 1050: int retval;
! 1051:
! 1052: for (ALL_LIST_ELEMENTS_RO (ipv6_addrs, node, ipv6))
! 1053: {
! 1054: if (pos - value + IPV6_MAX_BYTELEN > 255)
! 1055: {
! 1056: retval = add_tlv (IPV6_ADDR, pos - value, value, stream);
! 1057: if (retval != ISIS_OK)
! 1058: return retval;
! 1059: pos = value;
! 1060: }
! 1061: memcpy (pos, ipv6->prefix.s6_addr, IPV6_MAX_BYTELEN);
! 1062: pos += IPV6_MAX_BYTELEN;
! 1063: }
! 1064:
! 1065: return add_tlv (IPV6_ADDR, pos - value, value, stream);
! 1066: }
! 1067:
! 1068: int
! 1069: tlv_add_ipv6_reachs (struct list *ipv6_reachs, struct stream *stream)
! 1070: {
! 1071: struct listnode *node;
! 1072: struct ipv6_reachability *ip6reach;
! 1073: u_char value[255];
! 1074: u_char *pos = value;
! 1075: int retval, prefix_octets;
! 1076:
! 1077: for (ALL_LIST_ELEMENTS_RO (ipv6_reachs, node, ip6reach))
! 1078: {
! 1079: if (pos - value + IPV6_MAX_BYTELEN + 6 > 255)
! 1080: {
! 1081: retval = add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
! 1082: if (retval != ISIS_OK)
! 1083: return retval;
! 1084: pos = value;
! 1085: }
! 1086: *(uint32_t *) pos = ip6reach->metric;
! 1087: pos += 4;
! 1088: *pos = ip6reach->control_info;
! 1089: pos++;
! 1090: prefix_octets = ((ip6reach->prefix_len + 7) / 8);
! 1091: *pos = ip6reach->prefix_len;
! 1092: pos++;
! 1093: memcpy (pos, ip6reach->prefix, prefix_octets);
! 1094: pos += prefix_octets;
! 1095: }
! 1096:
! 1097: return add_tlv (IPV6_REACHABILITY, pos - value, value, stream);
! 1098: }
! 1099: #endif /* HAVE_IPV6 */
! 1100:
! 1101: int
! 1102: tlv_add_padding (struct stream *stream)
! 1103: {
! 1104: int fullpads, i, left;
! 1105:
! 1106: /*
! 1107: * How many times can we add full padding ?
! 1108: */
! 1109: fullpads = (STREAM_SIZE (stream) - stream_get_endp (stream)) / 257;
! 1110: for (i = 0; i < fullpads; i++)
! 1111: {
! 1112: if (!stream_putc (stream, (u_char) PADDING)) /* TAG */
! 1113: goto err;
! 1114: if (!stream_putc (stream, (u_char) 255)) /* LENGHT */
! 1115: goto err;
! 1116: stream_put (stream, NULL, 255); /* zero padding */
! 1117: }
! 1118:
! 1119: left = STREAM_SIZE (stream) - stream_get_endp (stream);
! 1120:
! 1121: if (left < 2)
! 1122: return ISIS_OK;
! 1123:
! 1124: if (left == 2)
! 1125: {
! 1126: stream_putc (stream, PADDING);
! 1127: stream_putc (stream, 0);
! 1128: return ISIS_OK;
! 1129: }
! 1130:
! 1131: stream_putc (stream, PADDING);
! 1132: stream_putc (stream, left - 2);
! 1133: stream_put (stream, NULL, left-2);
! 1134:
! 1135: return ISIS_OK;
! 1136:
! 1137: err:
! 1138: zlog_warn ("tlv_add_padding(): no room for tlv");
! 1139: return ISIS_WARNING;
! 1140: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_tlv.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