contrib/tcpdump/print-isoclns.c

   1 /*
   2  * Copyright (c) 1992, 1993, 1994, 1995, 1996
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * Original code by Matt Thomas, Digital Equipment Corporation
  22  *
  23  * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
  24  * complete IS-IS & CLNP support.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #ifndef lint
  30 static const char rcsid[] _U_ =
  31     "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.165 2008-08-16 13:38:15 hannes Exp $ (LBL)";
  32 #endif
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <tcpdump-stdinc.h>
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42
  43 #include "interface.h"
  44 #include "addrtoname.h"
  45 #include "ethertype.h"
  46 #include "ether.h"
  47 #include "nlpid.h"
  48 #include "extract.h"
  49 #include "gmpls.h"
  50 #include "oui.h"
  51 #include "signature.h"
  52
  53 /*
  54  * IS-IS is defined in ISO 10589.  Look there for protocol definitions.
  55  */
  56
  57 #define SYSTEM_ID_LEN   ETHER_ADDR_LEN
  58 #define NODE_ID_LEN     SYSTEM_ID_LEN+1
  59 #define LSP_ID_LEN      SYSTEM_ID_LEN+2
  60
  61 #define ISIS_VERSION    1
  62 #define ESIS_VERSION    1
  63 #define CLNP_VERSION    1
  64
  65 #define ISIS_PDU_TYPE_MASK      0x1F
  66 #define ESIS_PDU_TYPE_MASK      0x1F
  67 #define CLNP_PDU_TYPE_MASK      0x1F
  68 #define CLNP_FLAG_MASK          0xE0
  69 #define ISIS_LAN_PRIORITY_MASK  0x7F
  70
  71 #define ISIS_PDU_L1_LAN_IIH     15
  72 #define ISIS_PDU_L2_LAN_IIH     16
  73 #define ISIS_PDU_PTP_IIH        17
  74 #define ISIS_PDU_L1_LSP         18
  75 #define ISIS_PDU_L2_LSP         20
  76 #define ISIS_PDU_L1_CSNP        24
  77 #define ISIS_PDU_L2_CSNP        25
  78 #define ISIS_PDU_L1_PSNP        26
  79 #define ISIS_PDU_L2_PSNP        27
  80
  81 static struct tok isis_pdu_values[] = {
  82     { ISIS_PDU_L1_LAN_IIH,       "L1 Lan IIH"},
  83     { ISIS_PDU_L2_LAN_IIH,       "L2 Lan IIH"},
  84     { ISIS_PDU_PTP_IIH,          "p2p IIH"},
  85     { ISIS_PDU_L1_LSP,           "L1 LSP"},
  86     { ISIS_PDU_L2_LSP,           "L2 LSP"},
  87     { ISIS_PDU_L1_CSNP,          "L1 CSNP"},
  88     { ISIS_PDU_L2_CSNP,          "L2 CSNP"},
  89     { ISIS_PDU_L1_PSNP,          "L1 PSNP"},
  90     { ISIS_PDU_L2_PSNP,          "L2 PSNP"},
  91     { 0, NULL}
  92 };
  93
  94 /*
  95  * A TLV is a tuple of a type, length and a value and is normally used for
  96  * encoding information in all sorts of places.  This is an enumeration of
  97  * the well known types.
  98  *
  99  * list taken from rfc3359 plus some memory from veterans ;-)
 100  */
 101
 102 #define ISIS_TLV_AREA_ADDR           1   /* iso10589 */
 103 #define ISIS_TLV_IS_REACH            2   /* iso10589 */
 104 #define ISIS_TLV_ESNEIGH             3   /* iso10589 */
 105 #define ISIS_TLV_PART_DIS            4   /* iso10589 */
 106 #define ISIS_TLV_PREFIX_NEIGH        5   /* iso10589 */
 107 #define ISIS_TLV_ISNEIGH             6   /* iso10589 */
 108 #define ISIS_TLV_ISNEIGH_VARLEN      7   /* iso10589 */
 109 #define ISIS_TLV_PADDING             8   /* iso10589 */
 110 #define ISIS_TLV_LSP                 9   /* iso10589 */
 111 #define ISIS_TLV_AUTH                10  /* iso10589, rfc3567 */
 112 #define ISIS_TLV_CHECKSUM            12  /* rfc3358 */
 113 #define ISIS_TLV_CHECKSUM_MINLEN 2
 114 #define ISIS_TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
 115 #define ISIS_TLV_LSP_BUFFERSIZE_MINLEN 2
 116 #define ISIS_TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */
 117 #define ISIS_TLV_IS_ALIAS_ID         24  /* draft-ietf-isis-ext-lsp-frags-02 */
 118 #define ISIS_TLV_DECNET_PHASE4       42
 119 #define ISIS_TLV_LUCENT_PRIVATE      66
 120 #define ISIS_TLV_INT_IP_REACH        128 /* rfc1195, rfc2966 */
 121 #define ISIS_TLV_PROTOCOLS           129 /* rfc1195 */
 122 #define ISIS_TLV_EXT_IP_REACH        130 /* rfc1195, rfc2966 */
 123 #define ISIS_TLV_IDRP_INFO           131 /* rfc1195 */
 124 #define ISIS_TLV_IDRP_INFO_MINLEN      1
 125 #define ISIS_TLV_IPADDR              132 /* rfc1195 */
 126 #define ISIS_TLV_IPAUTH              133 /* rfc1195 */
 127 #define ISIS_TLV_TE_ROUTER_ID        134 /* draft-ietf-isis-traffic-05 */
 128 #define ISIS_TLV_EXTD_IP_REACH       135 /* draft-ietf-isis-traffic-05 */
 129 #define ISIS_TLV_HOSTNAME            137 /* rfc2763 */
 130 #define ISIS_TLV_SHARED_RISK_GROUP   138 /* draft-ietf-isis-gmpls-extensions */
 131 #define ISIS_TLV_MT_PORT_CAP         143 /* rfc6165 */
 132 #define ISIS_TLV_MT_CAPABILITY       144 /* rfc6329 */
 133 #define ISIS_TLV_NORTEL_PRIVATE1     176
 134 #define ISIS_TLV_NORTEL_PRIVATE2     177
 135 #define ISIS_TLV_RESTART_SIGNALING   211 /* rfc3847 */
 136 #define ISIS_TLV_RESTART_SIGNALING_FLAGLEN 1
 137 #define ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN 2
 138 #define ISIS_TLV_MT_IS_REACH         222 /* draft-ietf-isis-wg-multi-topology-05 */
 139 #define ISIS_TLV_MT_SUPPORTED        229 /* draft-ietf-isis-wg-multi-topology-05 */
 140 #define ISIS_TLV_MT_SUPPORTED_MINLEN 2
 141 #define ISIS_TLV_IP6ADDR             232 /* draft-ietf-isis-ipv6-02 */
 142 #define ISIS_TLV_MT_IP_REACH         235 /* draft-ietf-isis-wg-multi-topology-05 */
 143 #define ISIS_TLV_IP6_REACH           236 /* draft-ietf-isis-ipv6-02 */
 144 #define ISIS_TLV_MT_IP6_REACH        237 /* draft-ietf-isis-wg-multi-topology-05 */
 145 #define ISIS_TLV_PTP_ADJ             240 /* rfc3373 */
 146 #define ISIS_TLV_IIH_SEQNR           241 /* draft-shen-isis-iih-sequence-00 */
 147 #define ISIS_TLV_IIH_SEQNR_MINLEN 4
 148 #define ISIS_TLV_VENDOR_PRIVATE      250 /* draft-ietf-isis-experimental-tlv-01 */
 149 #define ISIS_TLV_VENDOR_PRIVATE_MINLEN 3
 150
 151 static struct tok isis_tlv_values[] = {
 152     { ISIS_TLV_AREA_ADDR,          "Area address(es)"},
 153     { ISIS_TLV_IS_REACH,           "IS Reachability"},
 154     { ISIS_TLV_ESNEIGH,            "ES Neighbor(s)"},
 155     { ISIS_TLV_PART_DIS,           "Partition DIS"},
 156     { ISIS_TLV_PREFIX_NEIGH,       "Prefix Neighbors"},
 157     { ISIS_TLV_ISNEIGH,            "IS Neighbor(s)"},
 158     { ISIS_TLV_ISNEIGH_VARLEN,     "IS Neighbor(s) (variable length)"},
 159     { ISIS_TLV_PADDING,            "Padding"},
 160     { ISIS_TLV_LSP,                "LSP entries"},
 161     { ISIS_TLV_AUTH,               "Authentication"},
 162     { ISIS_TLV_CHECKSUM,           "Checksum"},
 163     { ISIS_TLV_LSP_BUFFERSIZE,     "LSP Buffersize"},
 164     { ISIS_TLV_EXT_IS_REACH,       "Extended IS Reachability"},
 165     { ISIS_TLV_IS_ALIAS_ID,        "IS Alias ID"},
 166     { ISIS_TLV_DECNET_PHASE4,      "DECnet Phase IV"},
 167     { ISIS_TLV_LUCENT_PRIVATE,     "Lucent Proprietary"},
 168     { ISIS_TLV_INT_IP_REACH,       "IPv4 Internal Reachability"},
 169     { ISIS_TLV_PROTOCOLS,          "Protocols supported"},
 170     { ISIS_TLV_EXT_IP_REACH,       "IPv4 External Reachability"},
 171     { ISIS_TLV_IDRP_INFO,          "Inter-Domain Information Type"},
 172     { ISIS_TLV_IPADDR,             "IPv4 Interface address(es)"},
 173     { ISIS_TLV_IPAUTH,             "IPv4 authentication (deprecated)"},
 174     { ISIS_TLV_TE_ROUTER_ID,       "Traffic Engineering Router ID"},
 175     { ISIS_TLV_EXTD_IP_REACH,      "Extended IPv4 Reachability"},
 176     { ISIS_TLV_SHARED_RISK_GROUP,  "Shared Risk Link Group"},
 177     { ISIS_TLV_MT_PORT_CAP,        "Multi-Topology-Aware Port Capability"},
 178     { ISIS_TLV_MT_CAPABILITY,      "Multi-Topology Capability"},
 179     { ISIS_TLV_NORTEL_PRIVATE1,    "Nortel Proprietary"},
 180     { ISIS_TLV_NORTEL_PRIVATE2,    "Nortel Proprietary"},
 181     { ISIS_TLV_HOSTNAME,           "Hostname"},
 182     { ISIS_TLV_RESTART_SIGNALING,  "Restart Signaling"},
 183     { ISIS_TLV_MT_IS_REACH,        "Multi Topology IS Reachability"},
 184     { ISIS_TLV_MT_SUPPORTED,       "Multi Topology"},
 185     { ISIS_TLV_IP6ADDR,            "IPv6 Interface address(es)"},
 186     { ISIS_TLV_MT_IP_REACH,        "Multi-Topology IPv4 Reachability"},
 187     { ISIS_TLV_IP6_REACH,          "IPv6 reachability"},
 188     { ISIS_TLV_MT_IP6_REACH,       "Multi-Topology IP6 Reachability"},
 189     { ISIS_TLV_PTP_ADJ,            "Point-to-point Adjacency State"},
 190     { ISIS_TLV_IIH_SEQNR,          "Hello PDU Sequence Number"},
 191     { ISIS_TLV_VENDOR_PRIVATE,     "Vendor Private"},
 192     { 0, NULL }
 193 };
 194
 195 #define ESIS_OPTION_PROTOCOLS        129
 196 #define ESIS_OPTION_QOS_MAINTENANCE  195 /* iso9542 */
 197 #define ESIS_OPTION_SECURITY         197 /* iso9542 */
 198 #define ESIS_OPTION_ES_CONF_TIME     198 /* iso9542 */
 199 #define ESIS_OPTION_PRIORITY         205 /* iso9542 */
 200 #define ESIS_OPTION_ADDRESS_MASK     225 /* iso9542 */
 201 #define ESIS_OPTION_SNPA_MASK        226 /* iso9542 */
 202
 203 static struct tok esis_option_values[] = {
 204     { ESIS_OPTION_PROTOCOLS,       "Protocols supported"},
 205     { ESIS_OPTION_QOS_MAINTENANCE, "QoS Maintenance" },
 206     { ESIS_OPTION_SECURITY,        "Security" },
 207     { ESIS_OPTION_ES_CONF_TIME,    "ES Configuration Time" },
 208     { ESIS_OPTION_PRIORITY,        "Priority" },
 209     { ESIS_OPTION_ADDRESS_MASK,    "Addressk Mask" },
 210     { ESIS_OPTION_SNPA_MASK,       "SNPA Mask" },
 211     { 0, NULL }
 212 };
 213
 214 #define CLNP_OPTION_DISCARD_REASON   193
 215 #define CLNP_OPTION_QOS_MAINTENANCE  195 /* iso8473 */
 216 #define CLNP_OPTION_SECURITY         197 /* iso8473 */
 217 #define CLNP_OPTION_SOURCE_ROUTING   200 /* iso8473 */
 218 #define CLNP_OPTION_ROUTE_RECORDING  203 /* iso8473 */
 219 #define CLNP_OPTION_PADDING          204 /* iso8473 */
 220 #define CLNP_OPTION_PRIORITY         205 /* iso8473 */
 221
 222 static struct tok clnp_option_values[] = {
 223     { CLNP_OPTION_DISCARD_REASON,  "Discard Reason"},
 224     { CLNP_OPTION_PRIORITY,        "Priority"},
 225     { CLNP_OPTION_QOS_MAINTENANCE, "QoS Maintenance"},
 226     { CLNP_OPTION_SECURITY, "Security"},
 227     { CLNP_OPTION_SOURCE_ROUTING, "Source Routing"},
 228     { CLNP_OPTION_ROUTE_RECORDING, "Route Recording"},
 229     { CLNP_OPTION_PADDING, "Padding"},
 230     { 0, NULL }
 231 };
 232
 233 static struct tok clnp_option_rfd_class_values[] = {
 234     { 0x0, "General"},
 235     { 0x8, "Address"},
 236     { 0x9, "Source Routeing"},
 237     { 0xa, "Lifetime"},
 238     { 0xb, "PDU Discarded"},
 239     { 0xc, "Reassembly"},
 240     { 0, NULL }
 241 };
 242
 243 static struct tok clnp_option_rfd_general_values[] = {
 244     { 0x0, "Reason not specified"},
 245     { 0x1, "Protocol procedure error"},
 246     { 0x2, "Incorrect checksum"},
 247     { 0x3, "PDU discarded due to congestion"},
 248     { 0x4, "Header syntax error (cannot be parsed)"},
 249     { 0x5, "Segmentation needed but not permitted"},
 250     { 0x6, "Incomplete PDU received"},
 251     { 0x7, "Duplicate option"},
 252     { 0, NULL }
 253 };
 254
 255 static struct tok clnp_option_rfd_address_values[] = {
 256     { 0x0, "Destination address unreachable"},
 257     { 0x1, "Destination address unknown"},
 258     { 0, NULL }
 259 };
 260
 261 static struct tok clnp_option_rfd_source_routeing_values[] = {
 262     { 0x0, "Unspecified source routeing error"},
 263     { 0x1, "Syntax error in source routeing field"},
 264     { 0x2, "Unknown address in source routeing field"},
 265     { 0x3, "Path not acceptable"},
 266     { 0, NULL }
 267 };
 268
 269 static struct tok clnp_option_rfd_lifetime_values[] = {
 270     { 0x0, "Lifetime expired while data unit in transit"},
 271     { 0x1, "Lifetime expired during reassembly"},
 272     { 0, NULL }
 273 };
 274
 275 static struct tok clnp_option_rfd_pdu_discard_values[] = {
 276     { 0x0, "Unsupported option not specified"},
 277     { 0x1, "Unsupported protocol version"},
 278     { 0x2, "Unsupported security option"},
 279     { 0x3, "Unsupported source routeing option"},
 280     { 0x4, "Unsupported recording of route option"},
 281     { 0, NULL }
 282 };
 283
 284 static struct tok clnp_option_rfd_reassembly_values[] = {
 285     { 0x0, "Reassembly interference"},
 286     { 0, NULL }
 287 };
 288
 289 /* array of 16 error-classes */
 290 static struct tok *clnp_option_rfd_error_class[] = {
 291     clnp_option_rfd_general_values,
 292     NULL,
 293     NULL,
 294     NULL,
 295     NULL,
 296     NULL,
 297     NULL,
 298     NULL,
 299     clnp_option_rfd_address_values,
 300     clnp_option_rfd_source_routeing_values,
 301     clnp_option_rfd_lifetime_values,
 302     clnp_option_rfd_pdu_discard_values,
 303     clnp_option_rfd_reassembly_values,
 304     NULL,
 305     NULL,
 306     NULL
 307 };
 308
 309 #define CLNP_OPTION_OPTION_QOS_MASK 0x3f
 310 #define CLNP_OPTION_SCOPE_MASK      0xc0
 311 #define CLNP_OPTION_SCOPE_SA_SPEC   0x40
 312 #define CLNP_OPTION_SCOPE_DA_SPEC   0x80
 313 #define CLNP_OPTION_SCOPE_GLOBAL    0xc0
 314
 315 static struct tok clnp_option_scope_values[] = {
 316     { CLNP_OPTION_SCOPE_SA_SPEC, "Source Address Specific"},
 317     { CLNP_OPTION_SCOPE_DA_SPEC, "Destination Address Specific"},
 318     { CLNP_OPTION_SCOPE_GLOBAL, "Globally unique"},
 319     { 0, NULL }
 320 };
 321
 322 static struct tok clnp_option_sr_rr_values[] = {
 323     { 0x0, "partial"},
 324     { 0x1, "complete"},
 325     { 0, NULL }
 326 };
 327
 328 static struct tok clnp_option_sr_rr_string_values[] = {
 329     { CLNP_OPTION_SOURCE_ROUTING, "source routing"},
 330     { CLNP_OPTION_ROUTE_RECORDING, "recording of route in progress"},
 331     { 0, NULL }
 332 };
 333
 334 static struct tok clnp_option_qos_global_values[] = {
 335     { 0x20, "reserved"},
 336     { 0x10, "sequencing vs. delay"},
 337     { 0x08, "congested"},
 338     { 0x04, "delay vs. cost"},
 339     { 0x02, "error vs. delay"},
 340     { 0x01, "error vs. cost"},
 341     { 0, NULL }
 342 };
 343
 344 #define ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3 /* draft-ietf-isis-traffic-05 */
 345 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID  4 /* rfc4205 */
 346 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID        5 /* draft-ietf-isis-traffic-05 */
 347 #define ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR        6 /* draft-ietf-isis-traffic-05 */
 348 #define ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR    8 /* draft-ietf-isis-traffic-05 */
 349 #define ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW           9 /* draft-ietf-isis-traffic-05 */
 350 #define ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW        10 /* draft-ietf-isis-traffic-05 */
 351 #define ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW        11 /* rfc4124 */
 352 #define ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD   12 /* draft-ietf-tewg-diff-te-proto-06 */
 353 #define ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC            18 /* draft-ietf-isis-traffic-05 */
 354 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE       19 /* draft-ietf-isis-link-attr-01 */
 355 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20 /* rfc4205 */
 356 #define ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21 /* rfc4205 */
 357 #define ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS       22 /* rfc4124 */
 358
 359 #define ISIS_SUBTLV_SPB_METRIC                        29 /* rfc6329 */
 360
 361 static struct tok isis_ext_is_reach_subtlv_values[] = {
 362     { ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP,            "Administrative groups" },
 363     { ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID,   "Link Local/Remote Identifier" },
 364     { ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID,         "Link Remote Identifier" },
 365     { ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR,         "IPv4 interface address" },
 366     { ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR,     "IPv4 neighbor address" },
 367     { ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW,            "Maximum link bandwidth" },
 368     { ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW,          "Reservable link bandwidth" },
 369     { ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW,          "Unreserved bandwidth" },
 370     { ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC,              "Traffic Engineering Metric" },
 371     { ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE,         "Link Attribute" },
 372     { ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE,   "Link Protection Type" },
 373     { ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR,      "Interface Switching Capability" },
 374     { ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD,     "Bandwidth Constraints (old)" },
 375     { ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS,         "Bandwidth Constraints" },
 376     { ISIS_SUBTLV_SPB_METRIC,                          "SPB Metric" },
 377     { 250,                                             "Reserved for cisco specific extensions" },
 378     { 251,                                             "Reserved for cisco specific extensions" },
 379     { 252,                                             "Reserved for cisco specific extensions" },
 380     { 253,                                             "Reserved for cisco specific extensions" },
 381     { 254,                                             "Reserved for cisco specific extensions" },
 382     { 255,                                             "Reserved for future expansion" },
 383     { 0, NULL }
 384 };
 385
 386 #define ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32          1 /* draft-ietf-isis-admin-tags-01 */
 387 #define ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64          2 /* draft-ietf-isis-admin-tags-01 */
 388 #define ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR  117 /* draft-ietf-isis-wg-multi-topology-05 */
 389
 390 static struct tok isis_ext_ip_reach_subtlv_values[] = {
 391     { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32,           "32-Bit Administrative tag" },
 392     { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64,           "64-Bit Administrative tag" },
 393     { ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR,     "Management Prefix Color" },
 394     { 0, NULL }
 395 };
 396
 397 static struct tok isis_subtlv_link_attribute_values[] = {
 398     { 0x01, "Local Protection Available" },
 399     { 0x02, "Link excluded from local protection path" },
 400     { 0x04, "Local maintenance required"},
 401     { 0, NULL }
 402 };
 403
 404 #define ISIS_SUBTLV_AUTH_SIMPLE        1
 405 #define ISIS_SUBTLV_AUTH_GENERIC       3 /* rfc 5310 */
 406 #define ISIS_SUBTLV_AUTH_MD5          54
 407 #define ISIS_SUBTLV_AUTH_MD5_LEN      16
 408 #define ISIS_SUBTLV_AUTH_PRIVATE     255
 409
 410 static struct tok isis_subtlv_auth_values[] = {
 411     { ISIS_SUBTLV_AUTH_SIMPLE,  "simple text password"},
 412     { ISIS_SUBTLV_AUTH_GENERIC, "Generic Crypto key-id"},
 413     { ISIS_SUBTLV_AUTH_MD5,     "HMAC-MD5 password"},
 414     { ISIS_SUBTLV_AUTH_PRIVATE, "Routing Domain private password"},
 415     { 0, NULL }
 416 };
 417
 418 #define ISIS_SUBTLV_IDRP_RES           0
 419 #define ISIS_SUBTLV_IDRP_LOCAL         1
 420 #define ISIS_SUBTLV_IDRP_ASN           2
 421
 422 static struct tok isis_subtlv_idrp_values[] = {
 423     { ISIS_SUBTLV_IDRP_RES,         "Reserved"},
 424     { ISIS_SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
 425     { ISIS_SUBTLV_IDRP_ASN,         "AS Number Tag"},
 426     { 0, NULL}
 427 };
 428
 429 #define ISIS_SUBTLV_SPB_MCID          4
 430 #define ISIS_SUBTLV_SPB_DIGEST        5
 431 #define ISIS_SUBTLV_SPB_BVID          6
 432
 433 #define ISIS_SUBTLV_SPB_INSTANCE      1
 434 #define ISIS_SUBTLV_SPBM_SI           3
 435
 436 #define ISIS_SPB_MCID_LEN                         51
 437 #define ISIS_SUBTLV_SPB_MCID_MIN_LEN              102
 438 #define ISIS_SUBTLV_SPB_DIGEST_MIN_LEN            33
 439 #define ISIS_SUBTLV_SPB_BVID_MIN_LEN              6
 440 #define ISIS_SUBTLV_SPB_INSTANCE_MIN_LEN          19
 441 #define ISIS_SUBTLV_SPB_INSTANCE_VLAN_TUPLE_LEN   8
 442
 443 static struct tok isis_mt_port_cap_subtlv_values[] = {
 444     { ISIS_SUBTLV_SPB_MCID,           "SPB MCID" },
 445     { ISIS_SUBTLV_SPB_DIGEST,         "SPB Digest" },
 446     { ISIS_SUBTLV_SPB_BVID,           "SPB BVID" },
 447     { 0, NULL }
 448 };
 449
 450 static struct tok isis_mt_capability_subtlv_values[] = {
 451     { ISIS_SUBTLV_SPB_INSTANCE,      "SPB Instance" },
 452     { ISIS_SUBTLV_SPBM_SI,      "SPBM Service Identifier and Unicast Address" },
 453     { 0, NULL }
 454 };
 455
 456 struct isis_spb_mcid {
 457   u_int8_t  format_id;
 458   u_int8_t  name[32];
 459   u_int8_t  revision_lvl[2];
 460   u_int8_t  digest[16];
 461 };
 462
 463 struct isis_subtlv_spb_mcid {
 464   struct isis_spb_mcid mcid;
 465   struct isis_spb_mcid aux_mcid;
 466 };
 467
 468 struct isis_subtlv_spb_instance {
 469   u_int8_t cist_root_id[8];
 470   u_int8_t cist_external_root_path_cost[4];
 471   u_int8_t bridge_priority[2];
 472   u_int8_t spsourceid[4];
 473   u_int8_t no_of_trees;
 474 };
 475
 476 #define CLNP_SEGMENT_PART  0x80
 477 #define CLNP_MORE_SEGMENTS 0x40
 478 #define CLNP_REQUEST_ER    0x20
 479
 480 static struct tok clnp_flag_values[] = {
 481     { CLNP_SEGMENT_PART, "Segmentation permitted"},
 482     { CLNP_MORE_SEGMENTS, "more Segments"},
 483     { CLNP_REQUEST_ER, "request Error Report"},
 484     { 0, NULL}
 485 };
 486
 487 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 488 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
 489 #define ISIS_MASK_LSP_PARTITION_BIT(x)     ((x)&0x80)
 490 #define ISIS_MASK_LSP_ATT_BITS(x)          ((x)&0x78)
 491 #define ISIS_MASK_LSP_ATT_ERROR_BIT(x)     ((x)&0x40)
 492 #define ISIS_MASK_LSP_ATT_EXPENSE_BIT(x)   ((x)&0x20)
 493 #define ISIS_MASK_LSP_ATT_DELAY_BIT(x)     ((x)&0x10)
 494 #define ISIS_MASK_LSP_ATT_DEFAULT_BIT(x)   ((x)&0x8)
 495
 496 #define ISIS_MASK_MTID(x)                  ((x)&0x0fff)
 497 #define ISIS_MASK_MTFLAGS(x)               ((x)&0xf000)
 498
 499 static struct tok isis_mt_flag_values[] = {
 500     { 0x4000,                  "ATT bit set"},
 501     { 0x8000,                  "Overload bit set"},
 502     { 0, NULL}
 503 };
 504
 505 #define ISIS_MASK_TLV_EXTD_IP_UPDOWN(x)     ((x)&0x80)
 506 #define ISIS_MASK_TLV_EXTD_IP_SUBTLV(x)     ((x)&0x40)
 507
 508 #define ISIS_MASK_TLV_EXTD_IP6_IE(x)        ((x)&0x40)
 509 #define ISIS_MASK_TLV_EXTD_IP6_SUBTLV(x)    ((x)&0x20)
 510
 511 #define ISIS_LSP_TLV_METRIC_SUPPORTED(x)   ((x)&0x80)
 512 #define ISIS_LSP_TLV_METRIC_IE(x)          ((x)&0x40)
 513 #define ISIS_LSP_TLV_METRIC_UPDOWN(x)      ((x)&0x80)
 514 #define ISIS_LSP_TLV_METRIC_VALUE(x)       ((x)&0x3f)
 515
 516 #define ISIS_MASK_TLV_SHARED_RISK_GROUP(x) ((x)&0x1)
 517
 518 static struct tok isis_mt_values[] = {
 519     { 0,    "IPv4 unicast"},
 520     { 1,    "In-Band Management"},
 521     { 2,    "IPv6 unicast"},
 522     { 3,    "Multicast"},
 523     { 4095, "Development, Experimental or Proprietary"},
 524     { 0, NULL }
 525 };
 526
 527 static struct tok isis_iih_circuit_type_values[] = {
 528     { 1,    "Level 1 only"},
 529     { 2,    "Level 2 only"},
 530     { 3,    "Level 1, Level 2"},
 531     { 0, NULL}
 532 };
 533
 534 #define ISIS_LSP_TYPE_UNUSED0   0
 535 #define ISIS_LSP_TYPE_LEVEL_1   1
 536 #define ISIS_LSP_TYPE_UNUSED2   2
 537 #define ISIS_LSP_TYPE_LEVEL_2   3
 538
 539 static struct tok isis_lsp_istype_values[] = {
 540     { ISIS_LSP_TYPE_UNUSED0,    "Unused 0x0 (invalid)"},
 541     { ISIS_LSP_TYPE_LEVEL_1,    "L1 IS"},
 542     { ISIS_LSP_TYPE_UNUSED2,    "Unused 0x2 (invalid)"},
 543     { ISIS_LSP_TYPE_LEVEL_2,    "L2 IS"},
 544     { 0, NULL }
 545 };
 546
 547 /*
 548  * Katz's point to point adjacency TLV uses codes to tell us the state of
 549  * the remote adjacency.  Enumerate them.
 550  */
 551
 552 #define ISIS_PTP_ADJ_UP   0
 553 #define ISIS_PTP_ADJ_INIT 1
 554 #define ISIS_PTP_ADJ_DOWN 2
 555
 556 static struct tok isis_ptp_adjancey_values[] = {
 557     { ISIS_PTP_ADJ_UP,    "Up" },
 558     { ISIS_PTP_ADJ_INIT,  "Initializing" },
 559     { ISIS_PTP_ADJ_DOWN,  "Down" },
 560     { 0, NULL}
 561 };
 562
 563 struct isis_tlv_ptp_adj {
 564     u_int8_t adjacency_state;
 565     u_int8_t extd_local_circuit_id[4];
 566     u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
 567     u_int8_t neighbor_extd_local_circuit_id[4];
 568 };
 569
 570 static void osi_print_cksum(const u_int8_t *pptr, u_int16_t checksum,
 571                             u_int checksum_offset, u_int length);
 572 static int clnp_print(const u_int8_t *, u_int);
 573 static void esis_print(const u_int8_t *, u_int);
 574 static int isis_print(const u_int8_t *, u_int);
 575
 576 struct isis_metric_block {
 577     u_int8_t metric_default;
 578     u_int8_t metric_delay;
 579     u_int8_t metric_expense;
 580     u_int8_t metric_error;
 581 };
 582
 583 struct isis_tlv_is_reach {
 584     struct isis_metric_block isis_metric_block;
 585     u_int8_t neighbor_nodeid[NODE_ID_LEN];
 586 };
 587
 588 struct isis_tlv_es_reach {
 589     struct isis_metric_block isis_metric_block;
 590     u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
 591 };
 592
 593 struct isis_tlv_ip_reach {
 594     struct isis_metric_block isis_metric_block;
 595     u_int8_t prefix[4];
 596     u_int8_t mask[4];
 597 };
 598
 599 static struct tok isis_is_reach_virtual_values[] = {
 600     { 0,    "IsNotVirtual"},
 601     { 1,    "IsVirtual"},
 602     { 0, NULL }
 603 };
 604
 605 static struct tok isis_restart_flag_values[] = {
 606     { 0x1,  "Restart Request"},
 607     { 0x2,  "Restart Acknowledgement"},
 608     { 0x4,  "Suppress adjacency advertisement"},
 609     { 0, NULL }
 610 };
 611
 612 struct isis_common_header {
 613     u_int8_t nlpid;
 614     u_int8_t fixed_len;
 615     u_int8_t version;                   /* Protocol version */
 616     u_int8_t id_length;
 617     u_int8_t pdu_type;                  /* 3 MSbits are reserved */
 618     u_int8_t pdu_version;               /* Packet format version */
 619     u_int8_t reserved;
 620     u_int8_t max_area;
 621 };
 622
 623 struct isis_iih_lan_header {
 624     u_int8_t circuit_type;
 625     u_int8_t source_id[SYSTEM_ID_LEN];
 626     u_int8_t holding_time[2];
 627     u_int8_t pdu_len[2];
 628     u_int8_t priority;
 629     u_int8_t lan_id[NODE_ID_LEN];
 630 };
 631
 632 struct isis_iih_ptp_header {
 633     u_int8_t circuit_type;
 634     u_int8_t source_id[SYSTEM_ID_LEN];
 635     u_int8_t holding_time[2];
 636     u_int8_t pdu_len[2];
 637     u_int8_t circuit_id;
 638 };
 639
 640 struct isis_lsp_header {
 641     u_int8_t pdu_len[2];
 642     u_int8_t remaining_lifetime[2];
 643     u_int8_t lsp_id[LSP_ID_LEN];
 644     u_int8_t sequence_number[4];
 645     u_int8_t checksum[2];
 646     u_int8_t typeblock;
 647 };
 648
 649 struct isis_csnp_header {
 650     u_int8_t pdu_len[2];
 651     u_int8_t source_id[NODE_ID_LEN];
 652     u_int8_t start_lsp_id[LSP_ID_LEN];
 653     u_int8_t end_lsp_id[LSP_ID_LEN];
 654 };
 655
 656 struct isis_psnp_header {
 657     u_int8_t pdu_len[2];
 658     u_int8_t source_id[NODE_ID_LEN];
 659 };
 660
 661 struct isis_tlv_lsp {
 662     u_int8_t remaining_lifetime[2];
 663     u_int8_t lsp_id[LSP_ID_LEN];
 664     u_int8_t sequence_number[4];
 665     u_int8_t checksum[2];
 666 };
 667
 668 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 669 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 670 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
 671 #define ISIS_LSP_HEADER_SIZE (sizeof(struct isis_lsp_header))
 672 #define ISIS_CSNP_HEADER_SIZE (sizeof(struct isis_csnp_header))
 673 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
 674
 675 void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
 676 {
 677         if (caplen <= 1) { /* enough bytes on the wire ? */
 678             printf("|OSI");
 679             return;
 680         }
 681
 682         if (eflag)
 683             printf("OSI NLPID %s (0x%02x): ",
 684                    tok2str(nlpid_values,"Unknown",*p),
 685                    *p);
 686
 687         switch (*p) {
 688
 689         case NLPID_CLNP:
 690                 if (!clnp_print(p, length))
 691                         print_unknown_data(p,"\n\t",caplen);
 692                 break;
 693
 694         case NLPID_ESIS:
 695                 esis_print(p, length);
 696                 return;
 697
 698         case NLPID_ISIS:
 699                 if (!isis_print(p, length))
 700                         print_unknown_data(p,"\n\t",caplen);
 701                 break;
 702
 703         case NLPID_NULLNS:
 704                 (void)printf("%slength: %u",
 705                              eflag ? "" : ", ",
 706                              length);
 707                 break;
 708
 709         case NLPID_Q933:
 710                 q933_print(p+1, length-1);
 711                 break;
 712
 713         case NLPID_IP:
 714                 ip_print(gndo, p+1, length-1);
 715                 break;
 716
 717 #ifdef INET6
 718         case NLPID_IP6:
 719                 ip6_print(gndo, p+1, length-1);
 720                 break;
 721 #endif
 722
 723         case NLPID_PPP:
 724                 ppp_print(p+1, length-1);
 725                 break;
 726
 727         default:
 728                 if (!eflag)
 729                     printf("OSI NLPID 0x%02x unknown",*p);
 730                 (void)printf("%slength: %u",
 731                              eflag ? "" : ", ",
 732                              length);
 733                 if (caplen > 1)
 734                         print_unknown_data(p,"\n\t",caplen);
 735                 break;
 736         }
 737 }
 738
 739 #define CLNP_PDU_ER      1
 740 #define CLNP_PDU_DT     28
 741 #define CLNP_PDU_MD     29
 742 #define CLNP_PDU_ERQ    30
 743 #define CLNP_PDU_ERP    31
 744
 745 static struct tok clnp_pdu_values[] = {
 746     { CLNP_PDU_ER,  "Error Report"},
 747     { CLNP_PDU_MD,  "MD"},
 748     { CLNP_PDU_DT,  "Data"},
 749     { CLNP_PDU_ERQ, "Echo Request"},
 750     { CLNP_PDU_ERP, "Echo Response"},
 751     { 0, NULL }
 752 };
 753
 754 struct clnp_header_t {
 755     u_int8_t nlpid;
 756     u_int8_t length_indicator;
 757     u_int8_t version;
 758     u_int8_t lifetime; /* units of 500ms */
 759     u_int8_t type;
 760     u_int8_t segment_length[2];
 761     u_int8_t cksum[2];
 762 };
 763
 764 struct clnp_segment_header_t {
 765     u_int8_t data_unit_id[2];
 766     u_int8_t segment_offset[2];
 767     u_int8_t total_length[2];
 768 };
 769
 770 /*
 771  * clnp_print
 772  * Decode CLNP packets.  Return 0 on error.
 773  */
 774
 775 static int clnp_print (const u_int8_t *pptr, u_int length)
 776 {
 777         const u_int8_t *optr,*source_address,*dest_address;
 778         u_int li,tlen,nsap_offset,source_address_length,dest_address_length, clnp_pdu_type, clnp_flags;
 779         const struct clnp_header_t *clnp_header;
 780         const struct clnp_segment_header_t *clnp_segment_header;
 781         u_int8_t rfd_error_major,rfd_error_minor;
 782
 783         clnp_header = (const struct clnp_header_t *) pptr;
 784         TCHECK(*clnp_header);
 785
 786         li = clnp_header->length_indicator;
 787         optr = pptr;
 788
 789         if (!eflag)
 790             printf("CLNP");
 791
 792         /*
 793          * Sanity checking of the header.
 794          */
 795
 796         if (clnp_header->version != CLNP_VERSION) {
 797             printf("version %d packet not supported", clnp_header->version);
 798             return (0);
 799         }
 800
 801         /* FIXME further header sanity checking */
 802
 803         clnp_pdu_type = clnp_header->type & CLNP_PDU_TYPE_MASK;
 804         clnp_flags = clnp_header->type & CLNP_FLAG_MASK;
 805
 806         pptr += sizeof(struct clnp_header_t);
 807         li -= sizeof(struct clnp_header_t);
 808         dest_address_length = *pptr;
 809         dest_address = pptr + 1;
 810
 811         pptr += (1 + dest_address_length);
 812         li -= (1 + dest_address_length);
 813         source_address_length = *pptr;
 814         source_address = pptr +1;
 815
 816         pptr += (1 + source_address_length);
 817         li -= (1 + source_address_length);
 818
 819         if (vflag < 1) {
 820             printf("%s%s > %s, %s, length %u",
 821                    eflag ? "" : ", ",
 822                    isonsap_string(source_address, source_address_length),
 823                    isonsap_string(dest_address, dest_address_length),
 824                    tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
 825                    length);
 826             return (1);
 827         }
 828         printf("%slength %u",eflag ? "" : ", ",length);
 829
 830         printf("\n\t%s PDU, hlen: %u, v: %u, lifetime: %u.%us, Segment PDU length: %u, checksum: 0x%04x",
 831                tok2str(clnp_pdu_values, "unknown (%u)",clnp_pdu_type),
 832                clnp_header->length_indicator,
 833                clnp_header->version,
 834                clnp_header->lifetime/2,
 835                (clnp_header->lifetime%2)*5,
 836                EXTRACT_16BITS(clnp_header->segment_length),
 837                EXTRACT_16BITS(clnp_header->cksum));
 838
 839         osi_print_cksum(optr, EXTRACT_16BITS(clnp_header->cksum), 7,
 840                         clnp_header->length_indicator);
 841
 842         printf("\n\tFlags [%s]",
 843                bittok2str(clnp_flag_values,"none",clnp_flags));
 844
 845         printf("\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
 846                source_address_length,
 847                isonsap_string(source_address, source_address_length),
 848                dest_address_length,
 849                isonsap_string(dest_address,dest_address_length));
 850
 851         if (clnp_flags & CLNP_SEGMENT_PART) {
 852                 clnp_segment_header = (const struct clnp_segment_header_t *) pptr;
 853                 TCHECK(*clnp_segment_header);
 854                 printf("\n\tData Unit ID: 0x%04x, Segment Offset: %u, Total PDU Length: %u",
 855                        EXTRACT_16BITS(clnp_segment_header->data_unit_id),
 856                        EXTRACT_16BITS(clnp_segment_header->segment_offset),
 857                        EXTRACT_16BITS(clnp_segment_header->total_length));
 858                 pptr+=sizeof(const struct clnp_segment_header_t);
 859                 li-=sizeof(const struct clnp_segment_header_t);
 860         }
 861
 862         /* now walk the options */
 863         while (li >= 2) {
 864             u_int op, opli;
 865             const u_int8_t *tptr;
 866
 867             TCHECK2(*pptr, 2);
 868             if (li < 2) {
 869                 printf(", bad opts/li");
 870                 return (0);
 871             }
 872             op = *pptr++;
 873             opli = *pptr++;
 874             li -= 2;
 875             TCHECK2(*pptr, opli);
 876             if (opli > li) {
 877                 printf(", opt (%d) too long", op);
 878                 return (0);
 879             }
 880             li -= opli;
 881             tptr = pptr;
 882             tlen = opli;
 883
 884             printf("\n\t  %s Option #%u, length %u, value: ",
 885                    tok2str(clnp_option_values,"Unknown",op),
 886                    op,
 887                    opli);
 888
 889             switch (op) {
 890
 891
 892             case CLNP_OPTION_ROUTE_RECORDING: /* those two options share the format */
 893             case CLNP_OPTION_SOURCE_ROUTING:
 894                     printf("%s %s",
 895                            tok2str(clnp_option_sr_rr_values,"Unknown",*tptr),
 896                            tok2str(clnp_option_sr_rr_string_values,"Unknown Option %u",op));
 897                     nsap_offset=*(tptr+1);
 898                     if (nsap_offset == 0) {
 899                             printf(" Bad NSAP offset (0)");
 900                             break;
 901                     }
 902                     nsap_offset-=1; /* offset to nsap list */
 903                     if (nsap_offset > tlen) {
 904                             printf(" Bad NSAP offset (past end of option)");
 905                             break;
 906                     }
 907                     tptr+=nsap_offset;
 908                     tlen-=nsap_offset;
 909                     while (tlen > 0) {
 910                             source_address_length=*tptr;
 911                             if (tlen < source_address_length+1) {
 912                                     printf("\n\t    NSAP address goes past end of option");
 913                                     break;
 914                             }
 915                             if (source_address_length > 0) {
 916                                     source_address=(tptr+1);
 917                                     TCHECK2(*source_address, source_address_length);
 918                                     printf("\n\t    NSAP address (length %u): %s",
 919                                            source_address_length,
 920                                            isonsap_string(source_address, source_address_length));
 921                             }
 922                             tlen-=source_address_length+1;
 923                     }
 924                     break;
 925
 926             case CLNP_OPTION_PRIORITY:
 927                     printf("0x%1x", *tptr&0x0f);
 928                     break;
 929
 930             case CLNP_OPTION_QOS_MAINTENANCE:
 931                     printf("\n\t    Format Code: %s",
 932                            tok2str(clnp_option_scope_values,"Reserved",*tptr&CLNP_OPTION_SCOPE_MASK));
 933
 934                     if ((*tptr&CLNP_OPTION_SCOPE_MASK) == CLNP_OPTION_SCOPE_GLOBAL)
 935                             printf("\n\t    QoS Flags [%s]",
 936                                    bittok2str(clnp_option_qos_global_values,
 937                                               "none",
 938                                               *tptr&CLNP_OPTION_OPTION_QOS_MASK));
 939                     break;
 940
 941             case CLNP_OPTION_SECURITY:
 942                     printf("\n\t    Format Code: %s, Security-Level %u",
 943                            tok2str(clnp_option_scope_values,"Reserved",*tptr&CLNP_OPTION_SCOPE_MASK),
 944                            *(tptr+1));
 945                     break;
 946
 947             case CLNP_OPTION_DISCARD_REASON:
 948                 rfd_error_major = (*tptr&0xf0) >> 4;
 949                 rfd_error_minor = *tptr&0x0f;
 950                 printf("\n\t    Class: %s Error (0x%01x), %s (0x%01x)",
 951                        tok2str(clnp_option_rfd_class_values,"Unknown",rfd_error_major),
 952                        rfd_error_major,
 953                        tok2str(clnp_option_rfd_error_class[rfd_error_major],"Unknown",rfd_error_minor),
 954                        rfd_error_minor);
 955                 break;
 956
 957             case CLNP_OPTION_PADDING:
 958                     printf("padding data");
 959                 break;
 960
 961                 /*
 962                  * FIXME those are the defined Options that lack a decoder
 963                  * you are welcome to contribute code ;-)
 964                  */
 965
 966             default:
 967                 print_unknown_data(tptr,"\n\t  ",opli);
 968                 break;
 969             }
 970             if (vflag > 1)
 971                 print_unknown_data(pptr,"\n\t  ",opli);
 972             pptr += opli;
 973         }
 974
 975         switch (clnp_pdu_type) {
 976
 977         case    CLNP_PDU_ER: /* fall through */
 978         case    CLNP_PDU_ERP:
 979             TCHECK(*pptr);
 980             if (*(pptr) == NLPID_CLNP) {
 981                 printf("\n\t-----original packet-----\n\t");
 982                 /* FIXME recursion protection */
 983                 clnp_print(pptr, length-clnp_header->length_indicator);
 984                 break;
 985             }
 986
 987         case    CLNP_PDU_DT:
 988         case    CLNP_PDU_MD:
 989         case    CLNP_PDU_ERQ:
 990
 991         default:
 992             /* dump the PDU specific data */
 993             if (length-(pptr-optr) > 0) {
 994                 printf("\n\t  undecoded non-header data, length %u",length-clnp_header->length_indicator);
 995                 print_unknown_data(pptr,"\n\t  ",length-(pptr-optr));
 996             }
 997         }
 998
 999         return (1);
1000
1001  trunc:
1002     fputs("[|clnp]", stdout);
1003     return (1);
1004
1005 }
1006
1007
1008 #define ESIS_PDU_REDIRECT       6
1009 #define ESIS_PDU_ESH            2
1010 #define ESIS_PDU_ISH            4
1011
1012 static struct tok esis_pdu_values[] = {
1013     { ESIS_PDU_REDIRECT, "redirect"},
1014     { ESIS_PDU_ESH,      "ESH"},
1015     { ESIS_PDU_ISH,      "ISH"},
1016     { 0, NULL }
1017 };
1018
1019 struct esis_header_t {
1020         u_int8_t nlpid;
1021         u_int8_t length_indicator;
1022         u_int8_t version;
1023         u_int8_t reserved;
1024         u_int8_t type;
1025         u_int8_t holdtime[2];
1026         u_int8_t cksum[2];
1027 };
1028
1029 static void
1030 esis_print(const u_int8_t *pptr, u_int length)
1031 {
1032         const u_int8_t *optr;
1033         u_int li,esis_pdu_type,source_address_length, source_address_number;
1034         const struct esis_header_t *esis_header;
1035
1036         if (!eflag)
1037             printf("ES-IS");
1038
1039         if (length <= 2) {
1040                 if (qflag)
1041                         printf("bad pkt!");
1042                 else
1043                         printf("no header at all!");
1044                 return;
1045         }
1046
1047         esis_header = (const struct esis_header_t *) pptr;
1048         TCHECK(*esis_header);
1049         li = esis_header->length_indicator;
1050         optr = pptr;
1051
1052         /*
1053          * Sanity checking of the header.
1054          */
1055
1056         if (esis_header->nlpid != NLPID_ESIS) {
1057             printf(" nlpid 0x%02x packet not supported", esis_header->nlpid);
1058             return;
1059         }
1060
1061         if (esis_header->version != ESIS_VERSION) {
1062             printf(" version %d packet not supported", esis_header->version);
1063             return;
1064         }
1065
1066         if (li > length) {
1067             printf(" length indicator(%d) > PDU size (%d)!", li, length);
1068             return;
1069         }
1070
1071         if (li < sizeof(struct esis_header_t) + 2) {
1072             printf(" length indicator < min PDU size %d:", li);
1073             while (--length != 0)
1074                 printf("%02X", *pptr++);
1075             return;
1076         }
1077
1078         esis_pdu_type = esis_header->type & ESIS_PDU_TYPE_MASK;
1079
1080         if (vflag < 1) {
1081             printf("%s%s, length %u",
1082                    eflag ? "" : ", ",
1083                    tok2str(esis_pdu_values,"unknown type (%u)",esis_pdu_type),
1084                    length);
1085             return;
1086         } else
1087             printf("%slength %u\n\t%s (%u)",
1088                    eflag ? "" : ", ",
1089                    length,
1090                    tok2str(esis_pdu_values,"unknown type: %u", esis_pdu_type),
1091                    esis_pdu_type);
1092
1093         printf(", v: %u%s", esis_header->version, esis_header->version == ESIS_VERSION ? "" : "unsupported" );
1094         printf(", checksum: 0x%04x", EXTRACT_16BITS(esis_header->cksum));
1095
1096         osi_print_cksum(pptr, EXTRACT_16BITS(esis_header->cksum), 7, li);
1097
1098         printf(", holding time: %us, length indicator: %u",EXTRACT_16BITS(esis_header->holdtime),li);
1099
1100         if (vflag > 1)
1101             print_unknown_data(optr,"\n\t",sizeof(struct esis_header_t));
1102
1103         pptr += sizeof(struct esis_header_t);
1104         li -= sizeof(struct esis_header_t);
1105
1106         switch (esis_pdu_type) {
1107         case ESIS_PDU_REDIRECT: {
1108                 const u_int8_t *dst, *snpa, *neta;
1109                 u_int dstl, snpal, netal;
1110
1111                 TCHECK(*pptr);
1112                 if (li < 1) {
1113                         printf(", bad redirect/li");
1114                         return;
1115                 }
1116                 dstl = *pptr;
1117                 pptr++;
1118                 li--;
1119                 TCHECK2(*pptr, dstl);
1120                 if (li < dstl) {
1121                         printf(", bad redirect/li");
1122                         return;
1123                 }
1124                 dst = pptr;
1125                 pptr += dstl;
1126                 li -= dstl;
1127                 printf("\n\t  %s", isonsap_string(dst,dstl));
1128
1129                 TCHECK(*pptr);
1130                 if (li < 1) {
1131                         printf(", bad redirect/li");
1132                         return;
1133                 }
1134                 snpal = *pptr;
1135                 pptr++;
1136                 li--;
1137                 TCHECK2(*pptr, snpal);
1138                 if (li < snpal) {
1139                         printf(", bad redirect/li");
1140                         return;
1141                 }
1142                 snpa = pptr;
1143                 pptr += snpal;
1144                 li -= snpal;
1145                 TCHECK(*pptr);
1146                 if (li < 1) {
1147                         printf(", bad redirect/li");
1148                         return;
1149                 }
1150                 netal = *pptr;
1151                 pptr++;
1152                 TCHECK2(*pptr, netal);
1153                 if (li < netal) {
1154                         printf(", bad redirect/li");
1155                         return;
1156                 }
1157                 neta = pptr;
1158                 pptr += netal;
1159                 li -= netal;
1160
1161                 if (netal == 0)
1162                         printf("\n\t  %s", etheraddr_string(snpa));
1163                 else
1164                         printf("\n\t  %s", isonsap_string(neta,netal));
1165                 break;
1166         }
1167
1168         case ESIS_PDU_ESH:
1169             TCHECK(*pptr);
1170             if (li < 1) {
1171                 printf(", bad esh/li");
1172                 return;
1173             }
1174             source_address_number = *pptr;
1175             pptr++;
1176             li--;
1177
1178             printf("\n\t  Number of Source Addresses: %u", source_address_number);
1179
1180             while (source_address_number > 0) {
1181                 TCHECK(*pptr);
1182                 if (li < 1) {
1183                     printf(", bad esh/li");
1184                     return;
1185                 }
1186                 source_address_length = *pptr;
1187                 pptr++;
1188                 li--;
1189
1190                 TCHECK2(*pptr, source_address_length);
1191                 if (li < source_address_length) {
1192                     printf(", bad esh/li");
1193                     return;
1194                 }
1195                 printf("\n\t  NET (length: %u): %s",
1196                        source_address_length,
1197                        isonsap_string(pptr,source_address_length));
1198                 pptr += source_address_length;
1199                 li -= source_address_length;
1200                 source_address_number--;
1201             }
1202
1203             break;
1204
1205         case ESIS_PDU_ISH: {
1206             TCHECK(*pptr);
1207             if (li < 1) {
1208                 printf(", bad ish/li");
1209                 return;
1210             }
1211             source_address_length = *pptr;
1212             pptr++;
1213             li--;
1214             TCHECK2(*pptr, source_address_length);
1215             if (li < source_address_length) {
1216                 printf(", bad ish/li");
1217                 return;
1218             }
1219             printf("\n\t  NET (length: %u): %s", source_address_length, isonsap_string(pptr, source_address_length));
1220             pptr += source_address_length;
1221             li -= source_address_length;
1222             break;
1223         }
1224
1225         default:
1226             if (vflag <= 1) {
1227                     if (pptr < snapend)
1228                             print_unknown_data(pptr,"\n\t  ",snapend-pptr);
1229             }
1230             return;
1231         }
1232
1233         /* now walk the options */
1234         while (li != 0) {
1235             u_int op, opli;
1236             const u_int8_t *tptr;
1237
1238             if (li < 2) {
1239                 printf(", bad opts/li");
1240                 return;
1241             }
1242             TCHECK2(*pptr, 2);
1243             op = *pptr++;
1244             opli = *pptr++;
1245             li -= 2;
1246             if (opli > li) {
1247                 printf(", opt (%d) too long", op);
1248                 return;
1249             }
1250             li -= opli;
1251             tptr = pptr;
1252
1253             printf("\n\t  %s Option #%u, length %u, value: ",
1254                    tok2str(esis_option_values,"Unknown",op),
1255                    op,
1256                    opli);
1257
1258             switch (op) {
1259
1260             case ESIS_OPTION_ES_CONF_TIME:
1261                 if (opli == 2) {
1262                     TCHECK2(*pptr, 2);
1263                     printf("%us", EXTRACT_16BITS(tptr));
1264                 } else
1265                     printf("(bad length)");
1266                 break;
1267
1268             case ESIS_OPTION_PROTOCOLS:
1269                 while (opli>0) {
1270                     TCHECK(*pptr);
1271                     printf("%s (0x%02x)",
1272                            tok2str(nlpid_values,
1273                                    "unknown",
1274                                    *tptr),
1275                            *tptr);
1276                     if (opli>1) /* further NPLIDs ? - put comma */
1277                         printf(", ");
1278                     tptr++;
1279                     opli--;
1280                 }
1281                 break;
1282
1283                 /*
1284                  * FIXME those are the defined Options that lack a decoder
1285                  * you are welcome to contribute code ;-)
1286                  */
1287
1288             case ESIS_OPTION_QOS_MAINTENANCE:
1289             case ESIS_OPTION_SECURITY:
1290             case ESIS_OPTION_PRIORITY:
1291             case ESIS_OPTION_ADDRESS_MASK:
1292             case ESIS_OPTION_SNPA_MASK:
1293
1294             default:
1295                 print_unknown_data(tptr,"\n\t  ",opli);
1296                 break;
1297             }
1298             if (vflag > 1)
1299                 print_unknown_data(pptr,"\n\t  ",opli);
1300             pptr += opli;
1301         }
1302 trunc:
1303         return;
1304 }
1305
1306
1307 static void
1308 isis_print_mcid (const struct isis_spb_mcid *mcid)
1309 {
1310   int i;
1311
1312   printf( "ID: %d, Name: ", mcid->format_id);
1313
1314   for(i=0; i<32; i++)
1315   {
1316     printf("%c", mcid->name[i]);
1317     if(mcid->name[i] == '\0')
1318         break;
1319   }
1320
1321   printf("\n\t              Lvl: %d",
1322           EXTRACT_16BITS(mcid->revision_lvl));
1323
1324   printf( ", Digest: ");
1325
1326   for(i=0;i<16;i++)
1327     printf("%.2x ",mcid->digest[i]);
1328 }
1329
1330 static int
1331 isis_print_mt_port_cap_subtlv (const u_int8_t *tptr, int len)
1332 {
1333   int stlv_type, stlv_len;
1334   const struct isis_subtlv_spb_mcid *subtlv_spb_mcid;
1335   int i;
1336
1337   while (len > 0)
1338   {
1339     stlv_type = *(tptr++);
1340     stlv_len  = *(tptr++);
1341
1342     /* first lets see if we know the subTLVs name*/
1343     printf("\n\t       %s subTLV #%u, length: %u",
1344                tok2str(isis_mt_port_cap_subtlv_values, "unknown", stlv_type),
1345                stlv_type,
1346                stlv_len);
1347
1348     /*len -= TLV_TYPE_LEN_OFFSET;*/
1349     len = len -2;
1350
1351     switch (stlv_type)
1352     {
1353       case ISIS_SUBTLV_SPB_MCID:
1354       {
1355         if (!TTEST2(*(tptr), ISIS_SUBTLV_SPB_MCID_MIN_LEN))
1356           goto trunctlv;
1357
1358         subtlv_spb_mcid = (struct isis_subtlv_spb_mcid *)tptr;
1359
1360         printf( "\n\t         MCID: ");
1361         isis_print_mcid (&(subtlv_spb_mcid->mcid));
1362
1363           /*tptr += SPB_MCID_MIN_LEN;
1364             len -= SPB_MCID_MIN_LEN; */
1365
1366         printf( "\n\t         AUX-MCID: ");
1367         isis_print_mcid (&(subtlv_spb_mcid->aux_mcid));
1368
1369           /*tptr += SPB_MCID_MIN_LEN;
1370             len -= SPB_MCID_MIN_LEN; */
1371         tptr = tptr + sizeof(struct isis_subtlv_spb_mcid);
1372         len = len - sizeof(struct isis_subtlv_spb_mcid);
1373
1374         break;
1375       }
1376
1377       case ISIS_SUBTLV_SPB_DIGEST:
1378       {
1379         if (!TTEST2(*(tptr), ISIS_SUBTLV_SPB_DIGEST_MIN_LEN))
1380           goto trunctlv;
1381
1382         printf ("\n\t        RES: %d V: %d A: %d D: %d",
1383                         (*(tptr) >> 5), (((*tptr)>> 4) & 0x01),
1384                         ((*(tptr) >> 2) & 0x03), ((*tptr) & 0x03));
1385
1386         tptr++;
1387
1388         printf( "\n\t         Digest: ");
1389
1390         for(i=1;i<=8; i++)
1391         {
1392             printf("%08x ", EXTRACT_32BITS(tptr));
1393             if (i%4 == 0 && i != 8)
1394               printf("\n\t                 ");
1395             tptr = tptr + 4;
1396         }
1397
1398         len = len - ISIS_SUBTLV_SPB_DIGEST_MIN_LEN;
1399
1400         break;
1401       }
1402
1403       case ISIS_SUBTLV_SPB_BVID:
1404       {
1405         if (!TTEST2(*(tptr), stlv_len))
1406           goto trunctlv;
1407
1408         while (len)
1409         {
1410           if (!TTEST2(*(tptr), ISIS_SUBTLV_SPB_BVID_MIN_LEN))
1411             goto trunctlv;
1412
1413           printf("\n\t           ECT: %08x",
1414                       EXTRACT_32BITS(tptr));
1415
1416           tptr = tptr+4;
1417
1418           printf(" BVID: %d, U:%01x M:%01x ",
1419                      (EXTRACT_16BITS (tptr) >> 4) ,
1420                      (EXTRACT_16BITS (tptr) >> 3) & 0x01,
1421                      (EXTRACT_16BITS (tptr) >> 2) & 0x01);
1422
1423           tptr = tptr + 2;
1424           len = len - ISIS_SUBTLV_SPB_BVID_MIN_LEN;
1425         }
1426
1427         break;
1428       }
1429
1430       default:
1431           break;
1432     }
1433   }
1434
1435   return 0;
1436
1437   trunctlv:
1438     printf("\n\t\t packet exceeded snapshot");
1439     return(1);
1440 }
1441
1442 static int
1443 isis_print_mt_capability_subtlv (const u_int8_t *tptr, int len)
1444 {
1445   int stlv_type, stlv_len, tmp;
1446
1447   while (len > 0)
1448   {
1449     stlv_type = *(tptr++);
1450     stlv_len  = *(tptr++);
1451
1452     /* first lets see if we know the subTLVs name*/
1453     printf("\n\t      %s subTLV #%u, length: %u",
1454                tok2str(isis_mt_capability_subtlv_values, "unknown", stlv_type),
1455                stlv_type,
1456                stlv_len);
1457
1458     len = len - 2;
1459
1460     switch (stlv_type)
1461     {
1462       case ISIS_SUBTLV_SPB_INSTANCE:
1463
1464           if (!TTEST2(*(tptr), ISIS_SUBTLV_SPB_INSTANCE_MIN_LEN))
1465             goto trunctlv;
1466
1467           printf("\n\t        CIST Root-ID: %08x", EXTRACT_32BITS(tptr));
1468           tptr = tptr+4;
1469           printf(" %08x", EXTRACT_32BITS(tptr));
1470           tptr = tptr+4;
1471           printf(", Path Cost: %08x", EXTRACT_32BITS(tptr));
1472           tptr = tptr+4;
1473           printf(", Prio: %d", EXTRACT_16BITS(tptr));
1474           tptr = tptr + 2;
1475           printf("\n\t        RES: %d",
1476                     EXTRACT_16BITS(tptr) >> 5);
1477           printf(", V: %d",
1478                     (EXTRACT_16BITS(tptr) >> 4) & 0x0001);
1479           printf(", SPSource-ID: %d",
1480                     (EXTRACT_32BITS(tptr) & 0x000fffff));
1481           tptr = tptr+4;
1482           printf(", No of Trees: %x", *(tptr));
1483
1484           tmp = *(tptr++);
1485
1486           len = len - ISIS_SUBTLV_SPB_INSTANCE_MIN_LEN;
1487
1488           while (tmp)
1489           {
1490             if (!TTEST2(*(tptr), ISIS_SUBTLV_SPB_INSTANCE_VLAN_TUPLE_LEN))
1491               goto trunctlv;
1492
1493             printf ("\n\t         U:%d, M:%d, A:%d, RES:%d",
1494                       *(tptr) >> 7, (*(tptr) >> 6) & 0x01,
1495                       (*(tptr) >> 5) & 0x01, (*(tptr) & 0x1f));
1496
1497             tptr++;
1498
1499             printf (", ECT: %08x", EXTRACT_32BITS(tptr));
1500
1501             tptr = tptr + 4;
1502
1503             printf (", BVID: %d, SPVID: %d",
1504                       (EXTRACT_24BITS(tptr) >> 12) & 0x000fff,
1505                       EXTRACT_24BITS(tptr) & 0x000fff);
1506
1507             tptr = tptr + 3;
1508             len = len - ISIS_SUBTLV_SPB_INSTANCE_VLAN_TUPLE_LEN;
1509             tmp--;
1510           }
1511
1512           break;
1513
1514       case ISIS_SUBTLV_SPBM_SI:
1515
1516           if (!TTEST2(*(tptr), 6))
1517             goto trunctlv;
1518
1519           printf("\n\t        BMAC: %08x", EXTRACT_32BITS(tptr));
1520           tptr = tptr+4;
1521           printf("%04x", EXTRACT_16BITS(tptr));
1522           tptr = tptr+2;
1523
1524           printf (", RES: %d, VID: %d", EXTRACT_16BITS(tptr) >> 12,
1525                     (EXTRACT_16BITS(tptr)) & 0x0fff);
1526
1527           tptr = tptr+2;
1528           len = len - 8;
1529           stlv_len = stlv_len - 8;
1530
1531           while (stlv_len)
1532           {
1533             printf("\n\t        T: %d, R: %d, RES: %d, ISID: %d",
1534                     (EXTRACT_32BITS(tptr) >> 31),
1535                     (EXTRACT_32BITS(tptr) >> 30) & 0x01,
1536                     (EXTRACT_32BITS(tptr) >> 24) & 0x03f,
1537                     (EXTRACT_32BITS(tptr)) & 0x0ffffff);
1538
1539             tptr = tptr + 4;
1540             len = len - 4;
1541             stlv_len = stlv_len - 4;
1542           }
1543
1544         break;
1545
1546       default:
1547         break;
1548     }
1549   }
1550   return 0;
1551
1552   trunctlv:
1553     printf("\n\t\t packet exceeded snapshot");
1554     return(1);
1555 }
1556
1557
1558 /* shared routine for printing system, node and lsp-ids */
1559 static char *
1560 isis_print_id(const u_int8_t *cp, int id_len)
1561 {
1562     int i;
1563     static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];
1564     char *pos = id;
1565
1566     for (i = 1; i <= SYSTEM_ID_LEN; i++) {
1567         snprintf(pos, sizeof(id) - (pos - id), "%02x", *cp++);
1568         pos += strlen(pos);
1569         if (i == 2 || i == 4)
1570             *pos++ = '.';
1571         }
1572     if (id_len >= NODE_ID_LEN) {
1573         snprintf(pos, sizeof(id) - (pos - id), ".%02x", *cp++);
1574         pos += strlen(pos);
1575     }
1576     if (id_len == LSP_ID_LEN)
1577         snprintf(pos, sizeof(id) - (pos - id), "-%02x", *cp);
1578     return (id);
1579 }
1580
1581 /* print the 4-byte metric block which is common found in the old-style TLVs */
1582 static int
1583 isis_print_metric_block (const struct isis_metric_block *isis_metric_block)
1584 {
1585     printf(", Default Metric: %d, %s",
1586            ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_default),
1587            ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_default) ? "External" : "Internal");
1588     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_delay))
1589         printf("\n\t\t  Delay Metric: %d, %s",
1590                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_delay),
1591                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_delay) ? "External" : "Internal");
1592     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_expense))
1593         printf("\n\t\t  Expense Metric: %d, %s",
1594                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_expense),
1595                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_expense) ? "External" : "Internal");
1596     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_error))
1597         printf("\n\t\t  Error Metric: %d, %s",
1598                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_error),
1599                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_error) ? "External" : "Internal");
1600
1601     return(1); /* everything is ok */
1602 }
1603
1604 static int
1605 isis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length)
1606 {
1607         int prefix_len;
1608         const struct isis_tlv_ip_reach *tlv_ip_reach;
1609
1610         tlv_ip_reach = (const struct isis_tlv_ip_reach *)cp;
1611
1612         while (length > 0) {
1613                 if ((size_t)length < sizeof(*tlv_ip_reach)) {
1614                         printf("short IPv4 Reachability (%d vs %lu)",
1615                                length,
1616                                (unsigned long)sizeof(*tlv_ip_reach));
1617                         return (0);
1618                 }
1619
1620                 if (!TTEST(*tlv_ip_reach))
1621                     return (0);
1622
1623                 prefix_len = mask2plen(EXTRACT_32BITS(tlv_ip_reach->mask));
1624
1625                 if (prefix_len == -1)
1626                         printf("%sIPv4 prefix: %s mask %s",
1627                                ident,
1628                                ipaddr_string((tlv_ip_reach->prefix)),
1629                                ipaddr_string((tlv_ip_reach->mask)));
1630                 else
1631                         printf("%sIPv4 prefix: %15s/%u",
1632                                ident,
1633                                ipaddr_string((tlv_ip_reach->prefix)),
1634                                prefix_len);
1635
1636                 printf(", Distribution: %s, Metric: %u, %s",
1637                        ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->isis_metric_block.metric_default) ? "down" : "up",
1638                        ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_default),
1639                        ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_default) ? "External" : "Internal");
1640
1641                 if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_delay))
1642                     printf("%s  Delay Metric: %u, %s",
1643                            ident,
1644                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_delay),
1645                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_delay) ? "External" : "Internal");
1646
1647                 if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_expense))
1648                     printf("%s  Expense Metric: %u, %s",
1649                            ident,
1650                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_expense),
1651                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_expense) ? "External" : "Internal");
1652
1653                 if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_error))
1654                     printf("%s  Error Metric: %u, %s",
1655                            ident,
1656                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_error),
1657                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_error) ? "External" : "Internal");
1658
1659                 length -= sizeof(struct isis_tlv_ip_reach);
1660                 tlv_ip_reach++;
1661         }
1662         return (1);
1663 }
1664
1665 /*
1666  * this is the common IP-REACH subTLV decoder it is called
1667  * from various EXTD-IP REACH TLVs (135,235,236,237)
1668  */
1669
1670 static int
1671 isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
1672
1673         /* first lets see if we know the subTLVs name*/
1674         printf("%s%s subTLV #%u, length: %u",
1675                ident,
1676                tok2str(isis_ext_ip_reach_subtlv_values,
1677                        "unknown",
1678                        subt),
1679                subt,
1680                subl);
1681
1682         if (!TTEST2(*tptr,subl))
1683             goto trunctlv;
1684
1685     switch(subt) {
1686     case ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR: /* fall through */
1687     case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32:
1688         while (subl >= 4) {
1689             printf(", 0x%08x (=%u)",
1690                    EXTRACT_32BITS(tptr),
1691                    EXTRACT_32BITS(tptr));
1692             tptr+=4;
1693             subl-=4;
1694         }
1695         break;
1696     case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:
1697         while (subl >= 8) {
1698             printf(", 0x%08x%08x",
1699                    EXTRACT_32BITS(tptr),
1700                    EXTRACT_32BITS(tptr+4));
1701             tptr+=8;
1702             subl-=8;
1703         }
1704         break;
1705     default:
1706         if(!print_unknown_data(tptr,"\n\t\t    ",
1707                                subl))
1708           return(0);
1709         break;
1710     }
1711     return(1);
1712
1713 trunctlv:
1714     printf("%spacket exceeded snapshot",ident);
1715     return(0);
1716 }
1717
1718 /*
1719  * this is the common IS-REACH subTLV decoder it is called
1720  * from isis_print_ext_is_reach()
1721  */
1722
1723 static int
1724 isis_print_is_reach_subtlv (const u_int8_t *tptr,u_int subt,u_int subl,const char *ident) {
1725
1726         u_int te_class,priority_level,gmpls_switch_cap;
1727         union { /* int to float conversion buffer for several subTLVs */
1728             float f;
1729             u_int32_t i;
1730         } bw;
1731
1732         /* first lets see if we know the subTLVs name*/
1733         printf("%s%s subTLV #%u, length: %u",
1734                ident,
1735                tok2str(isis_ext_is_reach_subtlv_values,
1736                        "unknown",
1737                        subt),
1738                subt,
1739                subl);
1740
1741         if (!TTEST2(*tptr,subl))
1742             goto trunctlv;
1743
1744         switch(subt) {
1745         case ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP:
1746         case ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:
1747         case ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
1748             if (subl >= 4) {
1749               printf(", 0x%08x", EXTRACT_32BITS(tptr));
1750               if (subl == 8) /* rfc4205 */
1751                 printf(", 0x%08x", EXTRACT_32BITS(tptr+4));
1752             }
1753             break;
1754         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
1755         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
1756             if (subl >= sizeof(struct in_addr))
1757               printf(", %s", ipaddr_string(tptr));
1758             break;
1759         case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
1760         case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:
1761             if (subl >= 4) {
1762               bw.i = EXTRACT_32BITS(tptr);
1763               printf(", %.3f Mbps", bw.f*8/1000000 );
1764             }
1765             break;
1766         case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
1767             if (subl >= 32) {
1768               for (te_class = 0; te_class < 8; te_class++) {
1769                 bw.i = EXTRACT_32BITS(tptr);
1770                 printf("%s  TE-Class %u: %.3f Mbps",
1771                        ident,
1772                        te_class,
1773                        bw.f*8/1000000 );
1774                 tptr+=4;
1775               }
1776             }
1777             break;
1778         case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS: /* fall through */
1779         case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD:
1780             printf("%sBandwidth Constraints Model ID: %s (%u)",
1781                    ident,
1782                    tok2str(diffserv_te_bc_values, "unknown", *tptr),
1783                    *tptr);
1784             tptr++;
1785             /* decode BCs until the subTLV ends */
1786             for (te_class = 0; te_class < (subl-1)/4; te_class++) {
1787                 bw.i = EXTRACT_32BITS(tptr);
1788                 printf("%s  Bandwidth constraint CT%u: %.3f Mbps",
1789                        ident,
1790                        te_class,
1791                        bw.f*8/1000000 );
1792                 tptr+=4;
1793             }
1794             break;
1795         case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:
1796             if (subl >= 3)
1797               printf(", %u", EXTRACT_24BITS(tptr));
1798             break;
1799         case ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE:
1800             if (subl == 2) {
1801                printf(", [ %s ] (0x%04x)",
1802                       bittok2str(isis_subtlv_link_attribute_values,
1803                                  "Unknown",
1804                                  EXTRACT_16BITS(tptr)),
1805                       EXTRACT_16BITS(tptr));
1806             }
1807             break;
1808         case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
1809             if (subl >= 2) {
1810               printf(", %s, Priority %u",
1811                    bittok2str(gmpls_link_prot_values, "none", *tptr),
1812                    *(tptr+1));
1813             }
1814             break;
1815         case ISIS_SUBTLV_SPB_METRIC:
1816             if (subl >= 6) {
1817               printf (", LM: %u", EXTRACT_24BITS(tptr));
1818               tptr=tptr+3;
1819               printf (", P: %u", *(tptr));
1820               printf (", P-ID: %u", EXTRACT_16BITS(++tptr));
1821             }
1822             break;
1823         case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
1824             if (subl >= 36) {
1825               gmpls_switch_cap = *tptr;
1826               printf("%s  Interface Switching Capability:%s",
1827                    ident,
1828                    tok2str(gmpls_switch_cap_values, "Unknown", gmpls_switch_cap));
1829               printf(", LSP Encoding: %s",
1830                    tok2str(gmpls_encoding_values, "Unknown", *(tptr+1)));
1831               tptr+=4;
1832               printf("%s  Max LSP Bandwidth:",ident);
1833               for (priority_level = 0; priority_level < 8; priority_level++) {
1834                 bw.i = EXTRACT_32BITS(tptr);
1835                 printf("%s    priority level %d: %.3f Mbps",
1836                        ident,
1837                        priority_level,
1838                        bw.f*8/1000000 );
1839                 tptr+=4;
1840               }
1841               subl-=36;
1842               switch (gmpls_switch_cap) {
1843               case GMPLS_PSC1:
1844               case GMPLS_PSC2:
1845               case GMPLS_PSC3:
1846               case GMPLS_PSC4:
1847                 bw.i = EXTRACT_32BITS(tptr);
1848                 printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);
1849                 printf("%s  Interface MTU: %u", ident, EXTRACT_16BITS(tptr+4));
1850                 break;
1851               case GMPLS_TSC:
1852                 bw.i = EXTRACT_32BITS(tptr);
1853                 printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);
1854                 printf("%s  Indication %s", ident,
1855                        tok2str(gmpls_switch_cap_tsc_indication_values, "Unknown (%u)", *(tptr+4)));
1856                 break;
1857               default:
1858                 /* there is some optional stuff left to decode but this is as of yet
1859                    not specified so just lets hexdump what is left */
1860                 if(subl>0){
1861                   if(!print_unknown_data(tptr,"\n\t\t    ",
1862                                          subl))
1863                     return(0);
1864                 }
1865               }
1866             }
1867             break;
1868         default:
1869             if(!print_unknown_data(tptr,"\n\t\t    ",
1870                                    subl))
1871                 return(0);
1872             break;
1873         }
1874         return(1);
1875
1876 trunctlv:
1877     printf("%spacket exceeded snapshot",ident);
1878     return(0);
1879 }
1880
1881
1882 /*
1883  * this is the common IS-REACH decoder it is called
1884  * from various EXTD-IS REACH style TLVs (22,24,222)
1885  */
1886
1887 static int
1888 isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv_type) {
1889
1890     char ident_buffer[20];
1891     int subtlv_type,subtlv_len,subtlv_sum_len;
1892     int proc_bytes = 0; /* how many bytes did we process ? */
1893
1894     if (!TTEST2(*tptr, NODE_ID_LEN))
1895         return(0);
1896
1897     printf("%sIS Neighbor: %s", ident, isis_print_id(tptr, NODE_ID_LEN));
1898     tptr+=(NODE_ID_LEN);
1899
1900     if (tlv_type != ISIS_TLV_IS_ALIAS_ID) { /* the Alias TLV Metric field is implicit 0 */
1901         if (!TTEST2(*tptr, 3))    /* and is therefore skipped */
1902             return(0);
1903         printf(", Metric: %d",EXTRACT_24BITS(tptr));
1904         tptr+=3;
1905     }
1906
1907     if (!TTEST2(*tptr, 1))
1908         return(0);
1909     subtlv_sum_len=*(tptr++); /* read out subTLV length */
1910     proc_bytes=NODE_ID_LEN+3+1;
1911     printf(", %ssub-TLVs present",subtlv_sum_len ? "" : "no ");
1912     if (subtlv_sum_len) {
1913         printf(" (%u)",subtlv_sum_len);
1914         while (subtlv_sum_len>0) {
1915             if (!TTEST2(*tptr,2))
1916                 return(0);
1917             subtlv_type=*(tptr++);
1918             subtlv_len=*(tptr++);
1919             /* prepend the ident string */
1920             snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
1921             if(!isis_print_is_reach_subtlv(tptr,subtlv_type,subtlv_len,ident_buffer))
1922                 return(0);
1923             tptr+=subtlv_len;
1924             subtlv_sum_len-=(subtlv_len+2);
1925             proc_bytes+=(subtlv_len+2);
1926         }
1927     }
1928     return(proc_bytes);
1929 }
1930
1931 /*
1932  * this is the common Multi Topology ID decoder
1933  * it is called from various MT-TLVs (222,229,235,237)
1934  */
1935
1936 static int
1937 isis_print_mtid (const u_int8_t *tptr,const char *ident) {
1938
1939     if (!TTEST2(*tptr, 2))
1940         return(0);
1941
1942     printf("%s%s",
1943            ident,
1944            tok2str(isis_mt_values,
1945                    "Reserved for IETF Consensus",
1946                    ISIS_MASK_MTID(EXTRACT_16BITS(tptr))));
1947
1948     printf(" Topology (0x%03x), Flags: [%s]",
1949            ISIS_MASK_MTID(EXTRACT_16BITS(tptr)),
1950            bittok2str(isis_mt_flag_values, "none",ISIS_MASK_MTFLAGS(EXTRACT_16BITS(tptr))));
1951
1952     return(2);
1953 }
1954
1955 /*
1956  * this is the common extended IP reach decoder
1957  * it is called from TLVs (135,235,236,237)
1958  * we process the TLV and optional subTLVs and return
1959  * the amount of processed bytes
1960  */
1961
1962 static int
1963 isis_print_extd_ip_reach (const u_int8_t *tptr, const char *ident, u_int16_t afi) {
1964
1965     char ident_buffer[20];
1966 #ifdef INET6
1967     u_int8_t prefix[sizeof(struct in6_addr)]; /* shared copy buffer for IPv4 and IPv6 prefixes */
1968 #else
1969     u_int8_t prefix[sizeof(struct in_addr)]; /* shared copy buffer for IPv4 prefixes */
1970 #endif
1971     u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;
1972
1973     if (!TTEST2(*tptr, 4))
1974         return (0);
1975     metric = EXTRACT_32BITS(tptr);
1976     processed=4;
1977     tptr+=4;
1978
1979     if (afi == AF_INET) {
1980         if (!TTEST2(*tptr, 1)) /* fetch status byte */
1981             return (0);
1982         status_byte=*(tptr++);
1983         bit_length = status_byte&0x3f;
1984         if (bit_length > 32) {
1985             printf("%sIPv4 prefix: bad bit length %u",
1986                    ident,
1987                    bit_length);
1988             return (0);
1989         }
1990         processed++;
1991 #ifdef INET6
1992     } else if (afi == AF_INET6) {
1993         if (!TTEST2(*tptr, 1)) /* fetch status & prefix_len byte */
1994             return (0);
1995         status_byte=*(tptr++);
1996         bit_length=*(tptr++);
1997         if (bit_length > 128) {
1998             printf("%sIPv6 prefix: bad bit length %u",
1999                    ident,
2000                    bit_length);
2001             return (0);
2002         }
2003         processed+=2;
2004 #endif
2005     } else
2006         return (0); /* somebody is fooling us */
2007
2008     byte_length = (bit_length + 7) / 8; /* prefix has variable length encoding */
2009
2010     if (!TTEST2(*tptr, byte_length))
2011         return (0);
2012     memset(prefix, 0, sizeof prefix);   /* clear the copy buffer */
2013     memcpy(prefix,tptr,byte_length);    /* copy as much as is stored in the TLV */
2014     tptr+=byte_length;
2015     processed+=byte_length;
2016
2017     if (afi == AF_INET)
2018         printf("%sIPv4 prefix: %15s/%u",
2019                ident,
2020                ipaddr_string(prefix),
2021                bit_length);
2022 #ifdef INET6
2023     if (afi == AF_INET6)
2024         printf("%sIPv6 prefix: %s/%u",
2025                ident,
2026                ip6addr_string(prefix),
2027                bit_length);
2028 #endif
2029
2030     printf(", Distribution: %s, Metric: %u",
2031            ISIS_MASK_TLV_EXTD_IP_UPDOWN(status_byte) ? "down" : "up",
2032            metric);
2033
2034     if (afi == AF_INET && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
2035         printf(", sub-TLVs present");
2036 #ifdef INET6
2037     if (afi == AF_INET6)
2038         printf(", %s%s",
2039                ISIS_MASK_TLV_EXTD_IP6_IE(status_byte) ? "External" : "Internal",
2040                ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : "");
2041 #endif
2042
2043     if ((afi == AF_INET  && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
2044 #ifdef INET6
2045      || (afi == AF_INET6 && ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte))
2046 #endif
2047         ) {
2048         /* assume that one prefix can hold more
2049            than one subTLV - therefore the first byte must reflect
2050            the aggregate bytecount of the subTLVs for this prefix
2051         */
2052         if (!TTEST2(*tptr, 1))
2053             return (0);
2054         sublen=*(tptr++);
2055         processed+=sublen+1;
2056         printf(" (%u)",sublen);   /* print out subTLV length */
2057
2058         while (sublen>0) {
2059             if (!TTEST2(*tptr,2))
2060                 return (0);
2061             subtlvtype=*(tptr++);
2062             subtlvlen=*(tptr++);
2063             /* prepend the ident string */
2064             snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
2065             if(!isis_print_ip_reach_subtlv(tptr,subtlvtype,subtlvlen,ident_buffer))
2066                 return(0);
2067             tptr+=subtlvlen;
2068             sublen-=(subtlvlen+2);
2069         }
2070     }
2071     return (processed);
2072 }
2073
2074 /*
2075  * isis_print
2076  * Decode IS-IS packets.  Return 0 on error.
2077  */
2078
2079 static int isis_print (const u_int8_t *p, u_int length)
2080 {
2081     const struct isis_common_header *isis_header;
2082
2083     const struct isis_iih_lan_header *header_iih_lan;
2084     const struct isis_iih_ptp_header *header_iih_ptp;
2085     struct isis_lsp_header *header_lsp;
2086     const struct isis_csnp_header *header_csnp;
2087     const struct isis_psnp_header *header_psnp;
2088
2089     const struct isis_tlv_lsp *tlv_lsp;
2090     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
2091     const struct isis_tlv_is_reach *tlv_is_reach;
2092     const struct isis_tlv_es_reach *tlv_es_reach;
2093
2094     u_int8_t pdu_type, max_area, id_length, tlv_type, tlv_len, tmp, alen, lan_alen, prefix_len;
2095     u_int8_t ext_is_len, ext_ip_len, mt_len;
2096     const u_int8_t *optr, *pptr, *tptr;
2097     u_short packet_len,pdu_len, key_id;
2098     u_int i,vendor_id;
2099     int sigcheck;
2100
2101     packet_len=length;
2102     optr = p; /* initialize the _o_riginal pointer to the packet start -
2103                  need it for parsing the checksum TLV and authentication
2104                  TLV verification */
2105     isis_header = (const struct isis_common_header *)p;
2106     TCHECK(*isis_header);
2107     pptr = p+(ISIS_COMMON_HEADER_SIZE);
2108     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
2109     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
2110     header_lsp = (struct isis_lsp_header *)pptr;
2111     header_csnp = (const struct isis_csnp_header *)pptr;
2112     header_psnp = (const struct isis_psnp_header *)pptr;
2113
2114     if (!eflag)
2115         printf("IS-IS");
2116
2117     /*
2118      * Sanity checking of the header.
2119      */
2120
2121     if (isis_header->version != ISIS_VERSION) {
2122         printf("version %d packet not supported", isis_header->version);
2123         return (0);
2124     }
2125
2126     if ((isis_header->id_length != SYSTEM_ID_LEN) && (isis_header->id_length != 0)) {
2127         printf("system ID length of %d is not supported",
2128                isis_header->id_length);
2129         return (0);
2130     }
2131
2132     if (isis_header->pdu_version != ISIS_VERSION) {
2133         printf("version %d packet not supported", isis_header->pdu_version);
2134         return (0);
2135     }
2136
2137     max_area = isis_header->max_area;
2138     switch(max_area) {
2139     case 0:
2140         max_area = 3;    /* silly shit */
2141         break;
2142     case 255:
2143         printf("bad packet -- 255 areas");
2144         return (0);
2145     default:
2146         break;
2147     }
2148
2149     id_length = isis_header->id_length;
2150     switch(id_length) {
2151     case 0:
2152         id_length = 6;   /* silly shit again */
2153         break;
2154     case 1:              /* 1-8 are valid sys-ID lenghts */
2155     case 2:
2156     case 3:
2157     case 4:
2158     case 5:
2159     case 6:
2160     case 7:
2161     case 8:
2162         break;
2163     case 255:
2164         id_length = 0;   /* entirely useless */
2165         break;
2166     default:
2167         break;
2168     }
2169
2170     /* toss any non 6-byte sys-ID len PDUs */
2171     if (id_length != 6 ) {
2172         printf("bad packet -- illegal sys-ID length (%u)", id_length);
2173         return (0);
2174     }
2175
2176     pdu_type=isis_header->pdu_type;
2177
2178     /* in non-verbose mode print the basic PDU Type plus PDU specific brief information*/
2179     if (vflag < 1) {
2180         printf("%s%s",
2181                eflag ? "" : ", ",
2182                tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type));
2183
2184         switch (pdu_type) {
2185
2186         case ISIS_PDU_L1_LAN_IIH:
2187         case ISIS_PDU_L2_LAN_IIH:
2188             printf(", src-id %s",
2189                    isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN));
2190             printf(", lan-id %s, prio %u",
2191                    isis_print_id(header_iih_lan->lan_id,NODE_ID_LEN),
2192                    header_iih_lan->priority);
2193             break;
2194         case ISIS_PDU_PTP_IIH:
2195             printf(", src-id %s", isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN));
2196             break;
2197         case ISIS_PDU_L1_LSP:
2198         case ISIS_PDU_L2_LSP:
2199             printf(", lsp-id %s, seq 0x%08x, lifetime %5us",
2200                    isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
2201                    EXTRACT_32BITS(header_lsp->sequence_number),
2202                    EXTRACT_16BITS(header_lsp->remaining_lifetime));
2203             break;
2204         case ISIS_PDU_L1_CSNP:
2205         case ISIS_PDU_L2_CSNP:
2206             printf(", src-id %s", isis_print_id(header_csnp->source_id,NODE_ID_LEN));
2207             break;
2208         case ISIS_PDU_L1_PSNP:
2209         case ISIS_PDU_L2_PSNP:
2210             printf(", src-id %s", isis_print_id(header_psnp->source_id,NODE_ID_LEN));
2211             break;
2212
2213         }
2214         printf(", length %u", length);
2215
2216         return(1);
2217     }
2218
2219     /* ok they seem to want to know everything - lets fully decode it */
2220     printf("%slength %u", eflag ? "" : ", ",length);
2221
2222     printf("\n\t%s, hlen: %u, v: %u, pdu-v: %u, sys-id-len: %u (%u), max-area: %u (%u)",
2223            tok2str(isis_pdu_values,
2224                    "unknown, type %u",
2225                    pdu_type),
2226            isis_header->fixed_len,
2227            isis_header->version,
2228            isis_header->pdu_version,
2229            id_length,
2230            isis_header->id_length,
2231            max_area,
2232            isis_header->max_area);
2233
2234     if (vflag > 1) {
2235         if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
2236             return(0);                         /* for optionally debugging the common header */
2237     }
2238
2239     switch (pdu_type) {
2240
2241     case ISIS_PDU_L1_LAN_IIH:
2242     case ISIS_PDU_L2_LAN_IIH:
2243         if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
2244             printf(", bogus fixed header length %u should be %lu",
2245                    isis_header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
2246             return (0);
2247         }
2248
2249         pdu_len=EXTRACT_16BITS(header_iih_lan->pdu_len);
2250         if (packet_len>pdu_len) {
2251             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2252             length=pdu_len;
2253         }
2254
2255         TCHECK(*header_iih_lan);
2256         printf("\n\t  source-id: %s,  holding time: %us, Flags: [%s]",
2257                isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN),
2258                EXTRACT_16BITS(header_iih_lan->holding_time),
2259                tok2str(isis_iih_circuit_type_values,
2260                        "unknown circuit type 0x%02x",
2261                        header_iih_lan->circuit_type));
2262
2263         printf("\n\t  lan-id:    %s, Priority: %u, PDU length: %u",
2264                isis_print_id(header_iih_lan->lan_id, NODE_ID_LEN),
2265                (header_iih_lan->priority) & ISIS_LAN_PRIORITY_MASK,
2266                pdu_len);
2267
2268         if (vflag > 1) {
2269             if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_LAN_HEADER_SIZE))
2270                 return(0);
2271         }
2272
2273         packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
2274         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
2275         break;
2276
2277     case ISIS_PDU_PTP_IIH:
2278         if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE)) {
2279             printf(", bogus fixed header length %u should be %lu",
2280                    isis_header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
2281             return (0);
2282         }
2283
2284         pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
2285         if (packet_len>pdu_len) {
2286             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2287             length=pdu_len;
2288         }
2289
2290         TCHECK(*header_iih_ptp);
2291         printf("\n\t  source-id: %s, holding time: %us, Flags: [%s]",
2292                isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN),
2293                EXTRACT_16BITS(header_iih_ptp->holding_time),
2294                tok2str(isis_iih_circuit_type_values,
2295                        "unknown circuit type 0x%02x",
2296                        header_iih_ptp->circuit_type));
2297
2298         printf("\n\t  circuit-id: 0x%02x, PDU length: %u",
2299                header_iih_ptp->circuit_id,
2300                pdu_len);
2301
2302         if (vflag > 1) {
2303             if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_PTP_HEADER_SIZE))
2304                 return(0);
2305         }
2306
2307         packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
2308         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
2309         break;
2310
2311     case ISIS_PDU_L1_LSP:
2312     case ISIS_PDU_L2_LSP:
2313         if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE)) {
2314             printf(", bogus fixed header length %u should be %lu",
2315                    isis_header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
2316             return (0);
2317         }
2318
2319         pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
2320         if (packet_len>pdu_len) {
2321             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2322             length=pdu_len;
2323         }
2324
2325         TCHECK(*header_lsp);
2326         printf("\n\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us\n\t  chksum: 0x%04x",
2327                isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
2328                EXTRACT_32BITS(header_lsp->sequence_number),
2329                EXTRACT_16BITS(header_lsp->remaining_lifetime),
2330                EXTRACT_16BITS(header_lsp->checksum));
2331
2332
2333         osi_print_cksum((u_int8_t *)header_lsp->lsp_id,
2334                         EXTRACT_16BITS(header_lsp->checksum), 12, length-12);
2335
2336         /*
2337          * Clear checksum and lifetime prior to signature verification.
2338          */
2339         header_lsp->checksum[0] = 0;
2340         header_lsp->checksum[1] = 0;
2341         header_lsp->remaining_lifetime[0] = 0;
2342         header_lsp->remaining_lifetime[1] = 0;
2343
2344
2345         printf(", PDU length: %u, Flags: [ %s",
2346                pdu_len,
2347                ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
2348
2349         if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
2350             printf("%s", ISIS_MASK_LSP_ATT_DEFAULT_BIT(header_lsp->typeblock) ? "default " : "");
2351             printf("%s", ISIS_MASK_LSP_ATT_DELAY_BIT(header_lsp->typeblock) ? "delay " : "");
2352             printf("%s", ISIS_MASK_LSP_ATT_EXPENSE_BIT(header_lsp->typeblock) ? "expense " : "");
2353             printf("%s", ISIS_MASK_LSP_ATT_ERROR_BIT(header_lsp->typeblock) ? "error " : "");
2354             printf("ATT bit set, ");
2355         }
2356         printf("%s", ISIS_MASK_LSP_PARTITION_BIT(header_lsp->typeblock) ? "P bit set, " : "");
2357         printf("%s ]", tok2str(isis_lsp_istype_values,"Unknown(0x%x)",ISIS_MASK_LSP_ISTYPE_BITS(header_lsp->typeblock)));
2358
2359         if (vflag > 1) {
2360             if(!print_unknown_data(pptr,"\n\t  ",ISIS_LSP_HEADER_SIZE))
2361                 return(0);
2362         }
2363
2364         packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
2365         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
2366         break;
2367
2368     case ISIS_PDU_L1_CSNP:
2369     case ISIS_PDU_L2_CSNP:
2370         if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE)) {
2371             printf(", bogus fixed header length %u should be %lu",
2372                    isis_header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
2373             return (0);
2374         }
2375
2376         pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
2377         if (packet_len>pdu_len) {
2378             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2379             length=pdu_len;
2380         }
2381
2382         TCHECK(*header_csnp);
2383         printf("\n\t  source-id:    %s, PDU length: %u",
2384                isis_print_id(header_csnp->source_id, NODE_ID_LEN),
2385                pdu_len);
2386         printf("\n\t  start lsp-id: %s",
2387                isis_print_id(header_csnp->start_lsp_id, LSP_ID_LEN));
2388         printf("\n\t  end lsp-id:   %s",
2389                isis_print_id(header_csnp->end_lsp_id, LSP_ID_LEN));
2390
2391         if (vflag > 1) {
2392             if(!print_unknown_data(pptr,"\n\t  ",ISIS_CSNP_HEADER_SIZE))
2393                 return(0);
2394         }
2395
2396         packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
2397         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
2398         break;
2399
2400     case ISIS_PDU_L1_PSNP:
2401     case ISIS_PDU_L2_PSNP:
2402         if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE)) {
2403             printf("- bogus fixed header length %u should be %lu",
2404                    isis_header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
2405             return (0);
2406         }
2407
2408         pdu_len=EXTRACT_16BITS(header_psnp->pdu_len);
2409         if (packet_len>pdu_len) {
2410             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2411             length=pdu_len;
2412         }
2413
2414         TCHECK(*header_psnp);
2415         printf("\n\t  source-id:    %s, PDU length: %u",
2416                isis_print_id(header_psnp->source_id, NODE_ID_LEN),
2417                pdu_len);
2418
2419         if (vflag > 1) {
2420             if(!print_unknown_data(pptr,"\n\t  ",ISIS_PSNP_HEADER_SIZE))
2421                 return(0);
2422         }
2423
2424         packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
2425         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
2426         break;
2427
2428     default:
2429         if(!print_unknown_data(pptr,"\n\t  ",length))
2430             return(0);
2431         return (0);
2432     }
2433
2434     /*
2435      * Now print the TLV's.
2436      */
2437
2438     while (packet_len >= 2) {
2439         if (pptr == snapend) {
2440             return (1);
2441         }
2442
2443         if (!TTEST2(*pptr, 2)) {
2444             printf("\n\t\t packet exceeded snapshot (%ld) bytes",
2445                    (long)(pptr-snapend));
2446             return (1);
2447         }
2448         tlv_type = *pptr++;
2449         tlv_len = *pptr++;
2450         tmp =tlv_len; /* copy temporary len & pointer to packet data */
2451         tptr = pptr;
2452         packet_len -= 2;
2453         if (tlv_len > packet_len) {
2454             break;
2455         }
2456
2457         /* first lets see if we know the TLVs name*/
2458         printf("\n\t    %s TLV #%u, length: %u",
2459                tok2str(isis_tlv_values,
2460                        "unknown",
2461                        tlv_type),
2462                tlv_type,
2463                tlv_len);
2464
2465         if (tlv_len == 0) /* something is malformed */
2466             continue;
2467
2468         /* now check if we have a decoder otherwise do a hexdump at the end*/
2469         switch (tlv_type) {
2470         case ISIS_TLV_AREA_ADDR:
2471             if (!TTEST2(*tptr, 1))
2472                 goto trunctlv;
2473             alen = *tptr++;
2474             while (tmp && alen < tmp) {
2475                 printf("\n\t      Area address (length: %u): %s",
2476                        alen,
2477                        isonsap_string(tptr,alen));
2478                 tptr += alen;
2479                 tmp -= alen + 1;
2480                 if (tmp==0) /* if this is the last area address do not attemt a boundary check */
2481                     break;
2482                 if (!TTEST2(*tptr, 1))
2483                     goto trunctlv;
2484                 alen = *tptr++;
2485             }
2486             break;
2487         case ISIS_TLV_ISNEIGH:
2488             while (tmp >= ETHER_ADDR_LEN) {
2489                 if (!TTEST2(*tptr, ETHER_ADDR_LEN))
2490                     goto trunctlv;
2491                 printf("\n\t      SNPA: %s",isis_print_id(tptr,ETHER_ADDR_LEN));
2492                 tmp -= ETHER_ADDR_LEN;
2493                 tptr += ETHER_ADDR_LEN;
2494             }
2495             break;
2496
2497         case ISIS_TLV_ISNEIGH_VARLEN:
2498             if (!TTEST2(*tptr, 1) || tmp < 3) /* min. TLV length */
2499                 goto trunctlv;
2500             lan_alen = *tptr++; /* LAN address length */
2501             if (lan_alen == 0) {
2502                 printf("\n\t      LAN address length 0 bytes (invalid)");
2503                 break;
2504             }
2505             tmp --;
2506             printf("\n\t      LAN address length %u bytes ",lan_alen);
2507             while (tmp >= lan_alen) {
2508                 if (!TTEST2(*tptr, lan_alen))
2509                     goto trunctlv;
2510                 printf("\n\t\tIS Neighbor: %s",isis_print_id(tptr,lan_alen));
2511                 tmp -= lan_alen;
2512                 tptr +=lan_alen;
2513             }
2514             break;
2515
2516         case ISIS_TLV_PADDING:
2517             break;
2518
2519         case ISIS_TLV_MT_IS_REACH:
2520             mt_len = isis_print_mtid(tptr, "\n\t      ");
2521             if (mt_len == 0) /* did something go wrong ? */
2522                 goto trunctlv;
2523             tptr+=mt_len;
2524             tmp-=mt_len;
2525             while (tmp >= 2+NODE_ID_LEN+3+1) {
2526                 ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2527                 if (ext_is_len == 0) /* did something go wrong ? */
2528                     goto trunctlv;
2529
2530                 tmp-=ext_is_len;
2531                 tptr+=ext_is_len;
2532             }
2533             break;
2534
2535         case ISIS_TLV_IS_ALIAS_ID:
2536             while (tmp >= NODE_ID_LEN+1) { /* is it worth attempting a decode ? */
2537                 ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2538                 if (ext_is_len == 0) /* did something go wrong ? */
2539                     goto trunctlv;
2540                 tmp-=ext_is_len;
2541                 tptr+=ext_is_len;
2542             }
2543             break;
2544
2545         case ISIS_TLV_EXT_IS_REACH:
2546             while (tmp >= NODE_ID_LEN+3+1) { /* is it worth attempting a decode ? */
2547                 ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2548                 if (ext_is_len == 0) /* did something go wrong ? */
2549                     goto trunctlv;
2550                 tmp-=ext_is_len;
2551                 tptr+=ext_is_len;
2552             }
2553             break;
2554         case ISIS_TLV_IS_REACH:
2555             if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
2556                 goto trunctlv;
2557             printf("\n\t      %s",
2558                    tok2str(isis_is_reach_virtual_values,
2559                            "bogus virtual flag 0x%02x",
2560                            *tptr++));
2561             tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;
2562             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
2563                 if (!TTEST(*tlv_is_reach))
2564                     goto trunctlv;
2565                 printf("\n\t      IS Neighbor: %s",
2566                        isis_print_id(tlv_is_reach->neighbor_nodeid, NODE_ID_LEN));
2567                 isis_print_metric_block(&tlv_is_reach->isis_metric_block);
2568                 tmp -= sizeof(struct isis_tlv_is_reach);
2569                 tlv_is_reach++;
2570             }
2571             break;
2572
2573         case ISIS_TLV_ESNEIGH:
2574             tlv_es_reach = (const struct isis_tlv_es_reach *)tptr;
2575             while (tmp >= sizeof(struct isis_tlv_es_reach)) {
2576                 if (!TTEST(*tlv_es_reach))
2577                     goto trunctlv;
2578                 printf("\n\t      ES Neighbor: %s",
2579                        isis_print_id(tlv_es_reach->neighbor_sysid,SYSTEM_ID_LEN));
2580                 isis_print_metric_block(&tlv_es_reach->isis_metric_block);
2581                 tmp -= sizeof(struct isis_tlv_es_reach);
2582                 tlv_es_reach++;
2583             }
2584             break;
2585
2586             /* those two TLVs share the same format */
2587         case ISIS_TLV_INT_IP_REACH:
2588         case ISIS_TLV_EXT_IP_REACH:
2589             if (!isis_print_tlv_ip_reach(pptr, "\n\t      ", tlv_len))
2590                 return (1);
2591             break;
2592
2593         case ISIS_TLV_EXTD_IP_REACH:
2594             while (tmp>0) {
2595                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET);
2596                 if (ext_ip_len == 0) /* did something go wrong ? */
2597                     goto trunctlv;
2598                 tptr+=ext_ip_len;
2599                 tmp-=ext_ip_len;
2600             }
2601             break;
2602
2603         case ISIS_TLV_MT_IP_REACH:
2604             mt_len = isis_print_mtid(tptr, "\n\t      ");
2605             if (mt_len == 0) { /* did something go wrong ? */
2606                 goto trunctlv;
2607             }
2608             tptr+=mt_len;
2609             tmp-=mt_len;
2610
2611             while (tmp>0) {
2612                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET);
2613                 if (ext_ip_len == 0) /* did something go wrong ? */
2614                     goto trunctlv;
2615                 tptr+=ext_ip_len;
2616                 tmp-=ext_ip_len;
2617             }
2618             break;
2619
2620 #ifdef INET6
2621         case ISIS_TLV_IP6_REACH:
2622             while (tmp>0) {
2623                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET6);
2624                 if (ext_ip_len == 0) /* did something go wrong ? */
2625                     goto trunctlv;
2626                 tptr+=ext_ip_len;
2627                 tmp-=ext_ip_len;
2628             }
2629             break;
2630
2631         case ISIS_TLV_MT_IP6_REACH:
2632             mt_len = isis_print_mtid(tptr, "\n\t      ");
2633             if (mt_len == 0) { /* did something go wrong ? */
2634                 goto trunctlv;
2635             }
2636             tptr+=mt_len;
2637             tmp-=mt_len;
2638
2639             while (tmp>0) {
2640                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET6);
2641                 if (ext_ip_len == 0) /* did something go wrong ? */
2642                     goto trunctlv;
2643                 tptr+=ext_ip_len;
2644                 tmp-=ext_ip_len;
2645             }
2646             break;
2647
2648         case ISIS_TLV_IP6ADDR:
2649             while (tmp>=sizeof(struct in6_addr)) {
2650                 if (!TTEST2(*tptr, sizeof(struct in6_addr)))
2651                     goto trunctlv;
2652
2653                 printf("\n\t      IPv6 interface address: %s",
2654                        ip6addr_string(tptr));
2655
2656                 tptr += sizeof(struct in6_addr);
2657                 tmp -= sizeof(struct in6_addr);
2658             }
2659             break;
2660 #endif
2661         case ISIS_TLV_AUTH:
2662             if (!TTEST2(*tptr, 1))
2663                 goto trunctlv;
2664
2665             printf("\n\t      %s: ",
2666                    tok2str(isis_subtlv_auth_values,
2667                            "unknown Authentication type 0x%02x",
2668                            *tptr));
2669
2670             switch (*tptr) {
2671             case ISIS_SUBTLV_AUTH_SIMPLE:
2672                 for(i=1;i<tlv_len;i++) {
2673                     if (!TTEST2(*(tptr+i), 1))
2674                         goto trunctlv;
2675                     printf("%c",*(tptr+i));
2676                 }
2677                 break;
2678             case ISIS_SUBTLV_AUTH_MD5:
2679                 for(i=1;i<tlv_len;i++) {
2680                     if (!TTEST2(*(tptr+i), 1))
2681                         goto trunctlv;
2682                     printf("%02x",*(tptr+i));
2683                 }
2684                 if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)
2685                     printf(", (malformed subTLV) ");
2686
2687 #ifdef HAVE_LIBCRYPTO
2688                 sigcheck = signature_verify(optr, length,
2689                                             (unsigned char *)tptr + 1);
2690 #else
2691                 sigcheck = CANT_CHECK_SIGNATURE;
2692 #endif
2693                 printf(" (%s)", tok2str(signature_check_values, "Unknown", sigcheck));
2694
2695                 break;
2696             case ISIS_SUBTLV_AUTH_GENERIC:
2697                 key_id = EXTRACT_16BITS((tptr+1));
2698                 printf("%u, password: ", key_id);
2699                 for(i=1 + sizeof(u_int16_t);i<tlv_len;i++) {
2700                     if (!TTEST2(*(tptr+i), 1))
2701                         goto trunctlv;
2702                     printf("%02x",*(tptr+i));
2703                 }
2704                 break;
2705             case ISIS_SUBTLV_AUTH_PRIVATE:
2706             default:
2707                 if(!print_unknown_data(tptr+1,"\n\t\t  ",tlv_len-1))
2708                     return(0);
2709                 break;
2710             }
2711             break;
2712
2713         case ISIS_TLV_PTP_ADJ:
2714             tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)tptr;
2715             if(tmp>=1) {
2716                 if (!TTEST2(*tptr, 1))
2717                     goto trunctlv;
2718                 printf("\n\t      Adjacency State: %s (%u)",
2719                        tok2str(isis_ptp_adjancey_values, "unknown", *tptr),
2720                         *tptr);
2721                 tmp--;
2722             }
2723             if(tmp>sizeof(tlv_ptp_adj->extd_local_circuit_id)) {
2724                 if (!TTEST2(tlv_ptp_adj->extd_local_circuit_id,
2725                             sizeof(tlv_ptp_adj->extd_local_circuit_id)))
2726                     goto trunctlv;
2727                 printf("\n\t      Extended Local circuit-ID: 0x%08x",
2728                        EXTRACT_32BITS(tlv_ptp_adj->extd_local_circuit_id));
2729                 tmp-=sizeof(tlv_ptp_adj->extd_local_circuit_id);
2730             }
2731             if(tmp>=SYSTEM_ID_LEN) {
2732                 if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))
2733                     goto trunctlv;
2734                 printf("\n\t      Neighbor System-ID: %s",
2735                        isis_print_id(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
2736                 tmp-=SYSTEM_ID_LEN;
2737             }
2738             if(tmp>=sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)) {
2739                 if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
2740                             sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))
2741                     goto trunctlv;
2742                 printf("\n\t      Neighbor Extended Local circuit-ID: 0x%08x",
2743                        EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));
2744             }
2745             break;
2746
2747         case ISIS_TLV_PROTOCOLS:
2748             printf("\n\t      NLPID(s): ");
2749             while (tmp>0) {
2750                 if (!TTEST2(*(tptr), 1))
2751                     goto trunctlv;
2752                 printf("%s (0x%02x)",
2753                        tok2str(nlpid_values,
2754                                "unknown",
2755                                *tptr),
2756                        *tptr);
2757                 if (tmp>1) /* further NPLIDs ? - put comma */
2758                     printf(", ");
2759                 tptr++;
2760                 tmp--;
2761             }
2762             break;
2763
2764     case ISIS_TLV_MT_PORT_CAP:
2765     {
2766       if (!TTEST2(*(tptr), 2))
2767         goto trunctlv;
2768
2769       printf("\n\t       RES: %d, MTID(s): %d",
2770               (EXTRACT_16BITS (tptr) >> 12),
2771               (EXTRACT_16BITS (tptr) & 0x0fff));
2772
2773       tmp = tmp-2;
2774       tptr = tptr+2;
2775
2776       if (tmp)
2777         isis_print_mt_port_cap_subtlv (tptr, tmp);
2778
2779       break;
2780     }
2781
2782     case ISIS_TLV_MT_CAPABILITY:
2783
2784       if (!TTEST2(*(tptr), 2))
2785         goto trunctlv;
2786
2787       printf("\n\t      O: %d, RES: %d, MTID(s): %d",
2788                 (EXTRACT_16BITS(tptr) >> 15) & 0x01,
2789                 (EXTRACT_16BITS(tptr) >> 12) & 0x07,
2790                 EXTRACT_16BITS(tptr) & 0x0fff);
2791
2792       tmp = tmp-2;
2793       tptr = tptr+2;
2794
2795       if (tmp)
2796         isis_print_mt_capability_subtlv (tptr, tmp);
2797
2798       break;
2799
2800         case ISIS_TLV_TE_ROUTER_ID:
2801             if (!TTEST2(*pptr, sizeof(struct in_addr)))
2802                 goto trunctlv;
2803             printf("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(pptr));
2804             break;
2805
2806         case ISIS_TLV_IPADDR:
2807             while (tmp>=sizeof(struct in_addr)) {
2808                 if (!TTEST2(*tptr, sizeof(struct in_addr)))
2809                     goto trunctlv;
2810                 printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));
2811                 tptr += sizeof(struct in_addr);
2812                 tmp -= sizeof(struct in_addr);
2813             }
2814             break;
2815
2816         case ISIS_TLV_HOSTNAME:
2817             printf("\n\t      Hostname: ");
2818             while (tmp>0) {
2819                 if (!TTEST2(*tptr, 1))
2820                     goto trunctlv;
2821                 printf("%c",*tptr++);
2822                 tmp--;
2823             }
2824             break;
2825
2826         case ISIS_TLV_SHARED_RISK_GROUP:
2827             if (tmp < NODE_ID_LEN)
2828                 break;
2829             if (!TTEST2(*tptr, NODE_ID_LEN))
2830                 goto trunctlv;
2831             printf("\n\t      IS Neighbor: %s", isis_print_id(tptr, NODE_ID_LEN));
2832             tptr+=(NODE_ID_LEN);
2833             tmp-=(NODE_ID_LEN);
2834
2835             if (tmp < 1)
2836                 break;
2837             if (!TTEST2(*tptr, 1))
2838                 goto trunctlv;
2839             printf(", Flags: [%s]", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");
2840             tmp--;
2841
2842             if (tmp < sizeof(struct in_addr))
2843                 break;
2844             if (!TTEST2(*tptr,sizeof(struct in_addr)))
2845                 goto trunctlv;
2846             printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));
2847             tptr+=sizeof(struct in_addr);
2848             tmp-=sizeof(struct in_addr);
2849
2850             if (tmp < sizeof(struct in_addr))
2851                 break;
2852             if (!TTEST2(*tptr,sizeof(struct in_addr)))
2853                 goto trunctlv;
2854             printf("\n\t      IPv4 neighbor address: %s", ipaddr_string(tptr));
2855             tptr+=sizeof(struct in_addr);
2856             tmp-=sizeof(struct in_addr);
2857
2858             while (tmp>=4) {
2859                 if (!TTEST2(*tptr, 4))
2860                     goto trunctlv;
2861                 printf("\n\t      Link-ID: 0x%08x", EXTRACT_32BITS(tptr));
2862                 tptr+=4;
2863                 tmp-=4;
2864             }
2865             break;
2866
2867         case ISIS_TLV_LSP:
2868             tlv_lsp = (const struct isis_tlv_lsp *)tptr;
2869             while(tmp>=sizeof(struct isis_tlv_lsp)) {
2870                 if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN-1]))
2871                     goto trunctlv;
2872                 printf("\n\t      lsp-id: %s",
2873                        isis_print_id(tlv_lsp->lsp_id, LSP_ID_LEN));
2874                 if (!TTEST2(tlv_lsp->sequence_number, 4))
2875                     goto trunctlv;
2876                 printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));
2877                 if (!TTEST2(tlv_lsp->remaining_lifetime, 2))
2878                     goto trunctlv;
2879                 printf(", lifetime: %5ds",EXTRACT_16BITS(tlv_lsp->remaining_lifetime));
2880                 if (!TTEST2(tlv_lsp->checksum, 2))
2881                     goto trunctlv;
2882                 printf(", chksum: 0x%04x",EXTRACT_16BITS(tlv_lsp->checksum));
2883                 tmp-=sizeof(struct isis_tlv_lsp);
2884                 tlv_lsp++;
2885             }
2886             break;
2887
2888         case ISIS_TLV_CHECKSUM:
2889             if (tmp < ISIS_TLV_CHECKSUM_MINLEN)
2890                 break;
2891             if (!TTEST2(*tptr, ISIS_TLV_CHECKSUM_MINLEN))
2892                 goto trunctlv;
2893             printf("\n\t      checksum: 0x%04x ", EXTRACT_16BITS(tptr));
2894             /* do not attempt to verify the checksum if it is zero
2895              * most likely a HMAC-MD5 TLV is also present and
2896              * to avoid conflicts the checksum TLV is zeroed.
2897              * see rfc3358 for details
2898              */
2899             osi_print_cksum(optr, EXTRACT_16BITS(tptr), tptr-optr, length);
2900             break;
2901
2902         case ISIS_TLV_MT_SUPPORTED:
2903             if (tmp < ISIS_TLV_MT_SUPPORTED_MINLEN)
2904                 break;
2905             while (tmp>1) {
2906                 /* length can only be a multiple of 2, otherwise there is
2907                    something broken -> so decode down until length is 1 */
2908                 if (tmp!=1) {
2909                     mt_len = isis_print_mtid(tptr, "\n\t      ");
2910                     if (mt_len == 0) /* did something go wrong ? */
2911                         goto trunctlv;
2912                     tptr+=mt_len;
2913                     tmp-=mt_len;
2914                 } else {
2915                     printf("\n\t      malformed MT-ID");
2916                     break;
2917                 }
2918             }
2919             break;
2920
2921         case ISIS_TLV_RESTART_SIGNALING:
2922             /* first attempt to decode the flags */
2923             if (tmp < ISIS_TLV_RESTART_SIGNALING_FLAGLEN)
2924                 break;
2925             if (!TTEST2(*tptr, ISIS_TLV_RESTART_SIGNALING_FLAGLEN))
2926                 goto trunctlv;
2927             printf("\n\t      Flags [%s]",
2928                    bittok2str(isis_restart_flag_values, "none", *tptr));
2929             tptr+=ISIS_TLV_RESTART_SIGNALING_FLAGLEN;
2930             tmp-=ISIS_TLV_RESTART_SIGNALING_FLAGLEN;
2931
2932             /* is there anything other than the flags field? */
2933             if (tmp == 0)
2934                 break;
2935
2936             if (tmp < ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN)
2937                 break;
2938             if (!TTEST2(*tptr, ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN))
2939                 goto trunctlv;
2940
2941             printf(", Remaining holding time %us", EXTRACT_16BITS(tptr));
2942             tptr+=ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN;
2943             tmp-=ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN;
2944
2945             /* is there an additional sysid field present ?*/
2946             if (tmp == SYSTEM_ID_LEN) {
2947                     if (!TTEST2(*tptr, SYSTEM_ID_LEN))
2948                             goto trunctlv;
2949                     printf(", for %s",isis_print_id(tptr,SYSTEM_ID_LEN));
2950             }
2951             break;
2952
2953         case ISIS_TLV_IDRP_INFO:
2954             if (tmp < ISIS_TLV_IDRP_INFO_MINLEN)
2955                 break;
2956             if (!TTEST2(*tptr, ISIS_TLV_IDRP_INFO_MINLEN))
2957                 goto trunctlv;
2958             printf("\n\t      Inter-Domain Information Type: %s",
2959                    tok2str(isis_subtlv_idrp_values,
2960                            "Unknown (0x%02x)",
2961                            *tptr));
2962             switch (*tptr++) {
2963             case ISIS_SUBTLV_IDRP_ASN:
2964                 if (!TTEST2(*tptr, 2)) /* fetch AS number */
2965                     goto trunctlv;
2966                 printf("AS Number: %u",EXTRACT_16BITS(tptr));
2967                 break;
2968             case ISIS_SUBTLV_IDRP_LOCAL:
2969             case ISIS_SUBTLV_IDRP_RES:
2970             default:
2971                 if(!print_unknown_data(tptr,"\n\t      ",tlv_len-1))
2972                     return(0);
2973                 break;
2974             }
2975             break;
2976
2977         case ISIS_TLV_LSP_BUFFERSIZE:
2978             if (tmp < ISIS_TLV_LSP_BUFFERSIZE_MINLEN)
2979                 break;
2980             if (!TTEST2(*tptr, ISIS_TLV_LSP_BUFFERSIZE_MINLEN))
2981                 goto trunctlv;
2982             printf("\n\t      LSP Buffersize: %u",EXTRACT_16BITS(tptr));
2983             break;
2984
2985         case ISIS_TLV_PART_DIS:
2986             while (tmp >= SYSTEM_ID_LEN) {
2987                 if (!TTEST2(*tptr, SYSTEM_ID_LEN))
2988                     goto trunctlv;
2989                 printf("\n\t      %s",isis_print_id(tptr,SYSTEM_ID_LEN));
2990                 tptr+=SYSTEM_ID_LEN;
2991                 tmp-=SYSTEM_ID_LEN;
2992             }
2993             break;
2994
2995         case ISIS_TLV_PREFIX_NEIGH:
2996             if (tmp < sizeof(struct isis_metric_block))
2997                 break;
2998             if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
2999                 goto trunctlv;
3000             printf("\n\t      Metric Block");
3001             isis_print_metric_block((const struct isis_metric_block *)tptr);
3002             tptr+=sizeof(struct isis_metric_block);
3003             tmp-=sizeof(struct isis_metric_block);
3004
3005             while(tmp>0) {
3006                 if (!TTEST2(*tptr, 1))
3007                     goto trunctlv;
3008                 prefix_len=*tptr++; /* read out prefix length in semioctets*/
3009                 if (prefix_len < 2) {
3010                     printf("\n\t\tAddress: prefix length %u < 2", prefix_len);
3011                     break;
3012                 }
3013                 tmp--;
3014                 if (tmp < prefix_len/2)
3015                     break;
3016                 if (!TTEST2(*tptr, prefix_len/2))
3017                     goto trunctlv;
3018                 printf("\n\t\tAddress: %s/%u",
3019                        isonsap_string(tptr,prefix_len/2),
3020                        prefix_len*4);
3021                 tptr+=prefix_len/2;
3022                 tmp-=prefix_len/2;
3023             }
3024             break;
3025
3026         case ISIS_TLV_IIH_SEQNR:
3027             if (tmp < ISIS_TLV_IIH_SEQNR_MINLEN)
3028                 break;
3029             if (!TTEST2(*tptr, ISIS_TLV_IIH_SEQNR_MINLEN)) /* check if four bytes are on the wire */
3030                 goto trunctlv;
3031             printf("\n\t      Sequence number: %u", EXTRACT_32BITS(tptr) );
3032             break;
3033
3034         case ISIS_TLV_VENDOR_PRIVATE:
3035             if (tmp < ISIS_TLV_VENDOR_PRIVATE_MINLEN)
3036                 break;
3037             if (!TTEST2(*tptr, ISIS_TLV_VENDOR_PRIVATE_MINLEN)) /* check if enough byte for a full oui */
3038                 goto trunctlv;
3039             vendor_id = EXTRACT_24BITS(tptr);
3040             printf("\n\t      Vendor: %s (%u)",
3041                    tok2str(oui_values,"Unknown",vendor_id),
3042                    vendor_id);
3043             tptr+=3;
3044             tmp-=3;
3045             if (tmp > 0) /* hexdump the rest */
3046                 if(!print_unknown_data(tptr,"\n\t\t",tmp))
3047                     return(0);
3048             break;
3049             /*
3050              * FIXME those are the defined TLVs that lack a decoder
3051              * you are welcome to contribute code ;-)
3052              */
3053
3054         case ISIS_TLV_DECNET_PHASE4:
3055         case ISIS_TLV_LUCENT_PRIVATE:
3056         case ISIS_TLV_IPAUTH:
3057         case ISIS_TLV_NORTEL_PRIVATE1:
3058         case ISIS_TLV_NORTEL_PRIVATE2:
3059
3060         default:
3061             if (vflag <= 1) {
3062                 if(!print_unknown_data(pptr,"\n\t\t",tlv_len))
3063                     return(0);
3064             }
3065             break;
3066         }
3067         /* do we want to see an additionally hexdump ? */
3068         if (vflag> 1) {
3069             if(!print_unknown_data(pptr,"\n\t      ",tlv_len))
3070                 return(0);
3071         }
3072
3073         pptr += tlv_len;
3074         packet_len -= tlv_len;
3075     }
3076
3077     if (packet_len != 0) {
3078         printf("\n\t      %u straggler bytes", packet_len);
3079     }
3080     return (1);
3081
3082  trunc:
3083     fputs("[|isis]", stdout);
3084     return (1);
3085
3086  trunctlv:
3087     printf("\n\t\t packet exceeded snapshot");
3088     return(1);
3089 }
3090
3091 static void
3092 osi_print_cksum (const u_int8_t *pptr, u_int16_t checksum,
3093                     u_int checksum_offset, u_int length)
3094 {
3095         u_int16_t calculated_checksum;
3096
3097         /* do not attempt to verify the checksum if it is zero */
3098         if (!checksum) {
3099                 printf("(unverified)");
3100         } else {
3101                 calculated_checksum = create_osi_cksum(pptr, checksum_offset, length);
3102                 if (checksum == calculated_checksum) {
3103                         printf(" (correct)");
3104                 } else {
3105                         printf(" (incorrect should be 0x%04x)", calculated_checksum);
3106                 }
3107         }
3108 }
3109
3110 /*
3111  * Local Variables:
3112  * c-style: whitesmith
3113  * c-basic-offset: 8
3114  * End:
3115  */