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