fix typo from previous commit

[tcpdump] / print-isoclns.c

diff --git a/print-isoclns.c b/print-isoclns.c
index 6fbb020c69cc0e0edde0d9ee6d334993f3cbf337..9f512b4253566adfa16310cf3ba952c9ad1ac58e 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -26,18 +26,14 @@
 
 #ifndef lint
 static const char rcsid[] =
 
 #ifndef lint
 static const char rcsid[] =

-    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.41 2002-03-20 07:00:03 guy Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.82 2003-05-01 18:04:41 guy Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 

-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-
-#include <netinet/in.h>
+#include <tcpdump-stdinc.h>

 
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>


@@ -52,14 +48,20 @@ static const char rcsid[] =
 #define        NLPID_ESIS      130     /* 0x82 */
 #define        NLPID_ISIS      131     /* 0x83 */
 #define NLPID_IP6       0x8e
 #define        NLPID_ESIS      130     /* 0x82 */
 #define        NLPID_ISIS      131     /* 0x83 */
 #define NLPID_IP6       0x8e

-#define NLPID_IP        0xcc  
+#define NLPID_IP        0xcc

 #define        NLPID_NULLNS    0
 
 #define        NLPID_NULLNS    0
 

+#define IPV4            1       /* AFI value */
+#define IPV6            2       /* AFI value */
+

 /*
  * IS-IS is defined in ISO 10589.  Look there for protocol definitions.
  */
 
 #define SYSTEM_ID_LEN  ETHER_ADDR_LEN
 /*
  * IS-IS is defined in ISO 10589.  Look there for protocol definitions.
  */
 
 #define SYSTEM_ID_LEN  ETHER_ADDR_LEN

+#define NODE_ID_LEN     SYSTEM_ID_LEN+1
+#define LSP_ID_LEN      SYSTEM_ID_LEN+2
+

 #define ISIS_VERSION   1
 #define PDU_TYPE_MASK  0x1F
 #define PRIORITY_MASK  0x7F
 #define ISIS_VERSION   1
 #define PDU_TYPE_MASK  0x1F
 #define PRIORITY_MASK  0x7F


@@ -74,40 +76,109 @@ static const char rcsid[] =
 #define L1_PSNP                26
 #define L2_PSNP                27
 
 #define L1_PSNP                26
 #define L2_PSNP                27
 

+static struct tok isis_pdu_values[] = {
+    { L1_LAN_IIH,       "L1 Lan IIH"},
+    { L2_LAN_IIH,       "L2 Lan IIH"},
+    { PTP_IIH,          "p2p IIH"},
+    { L1_LSP,           "L1 LSP"},
+    { L2_LSP,           "L2 LSP"},
+    { L1_CSNP,          "L1 CSNP"},
+    { L2_CSNP,          "L2 CSNP"},
+    { L1_PSNP,          "L1 PSNP"},
+    { L2_PSNP,          "L2 PSNP"},
+    { 0, NULL}
+};

 
 /*
  * A TLV is a tuple of a type, length and a value and is normally used for
  * encoding information in all sorts of places.  This is an enumeration of
  * the well known types.
 
 /*
  * A TLV is a tuple of a type, length and a value and is normally used for
  * encoding information in all sorts of places.  This is an enumeration of
  * the well known types.

+ *
+ * list taken from rfc3359 plus some memory from veterans ;-)

  */
 
  */
 

-#define TLV_AREA_ADDR           1
-#define TLV_IS_REACH            2
-#define TLV_ES_REACH            3
-#define TLV_SUMMARY             5
-#define TLV_ISNEIGH            6
-#define TLV_PADDING             8
-#define TLV_LSP                 9
-#define TLV_AUTH                10
-#define TLV_CHECKSUM           12
-#define TLV_EXT_IS_REACH       22
-#define TLV_IP_REACH           128
-#define TLV_PROTOCOLS          129
-#define TLV_IP_REACH_EXT       130
-#define TLV_IDRP_INFO          131
-#define TLV_IPADDR              132
-#define TLV_IPAUTH              133
-#define TLV_TE_ROUTER_ID       134
-#define TLV_EXT_IP_REACH       135
-#define        TLV_HOSTNAME            137
-#define TLV_SHARED_RISK_GROUP   138
-#define TLV_RESTART_SIGNALING   211
-#define        TLV_MT_IS_REACH         222
-#define        TLV_MT_SUPPORTED        229
-#define TLV_IP6ADDR             232
-#define        TLV_MT_REACH            235
-#define        TLV_IP6_REACH           236
-#define TLV_PTP_ADJ            240
+#define TLV_AREA_ADDR           1   /* iso10589 */
+#define TLV_IS_REACH            2   /* iso10589 */
+#define TLV_ESNEIGH             3   /* iso10589 */
+#define TLV_PART_DIS            4   /* iso10589 */
+#define TLV_PREFIX_NEIGH        5   /* iso10589 */
+#define TLV_ISNEIGH             6   /* iso10589 */
+#define TLV_ISNEIGH_VARLEN      7   /* iso10589 */
+#define TLV_PADDING             8   /* iso10589 */
+#define TLV_LSP                 9   /* iso10589 */
+#define TLV_AUTH                10  /* iso10589, draft-ietf-isis-hmac-03 */
+#define TLV_CHECKSUM            12  /* rfc3358 */
+#define TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
+#define TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-04 */
+#define TLV_IS_ALIAS_ID         24  /* draft-ietf-isis-ext-lsp-frags-02 */
+#define TLV_DECNET_PHASE4       42
+#define TLV_LUCENT_PRIVATE      66
+#define TLV_IP_REACH            128 /* rfc1195, rfc2966 */
+#define TLV_PROTOCOLS           129 /* rfc1195 */
+#define TLV_IP_REACH_EXT        130 /* rfc1195, rfc2966 */
+#define TLV_IDRP_INFO           131 /* rfc1195 */
+#define TLV_IPADDR              132 /* rfc1195 */
+#define TLV_IPAUTH              133 /* rfc1195 */
+#define TLV_TE_ROUTER_ID        134 /* draft-ietf-isis-traffic-04 */
+#define TLV_EXT_IP_REACH        135 /* draft-ietf-isis-traffic-04 */
+#define TLV_HOSTNAME            137 /* rfc2763 */
+#define TLV_SHARED_RISK_GROUP   138 /* draft-ietf-isis-gmpls-extensions-14 */
+#define TLV_NORTEL_PRIVATE1     176
+#define TLV_NORTEL_PRIVATE2     177
+#define TLV_HOLDTIME            198 /* ES-IS */
+#define TLV_RESTART_SIGNALING   211 /* draft-ietf-isis-restart-01 */
+#define TLV_MT_IS_REACH         222 /* draft-ietf-isis-wg-multi-topology-05 */
+#define TLV_MT_SUPPORTED        229 /* draft-ietf-isis-wg-multi-topology-05 */
+#define TLV_IP6ADDR             232 /* draft-ietf-isis-ipv6-02 */
+#define TLV_MT_IP_REACH         235 /* draft-ietf-isis-wg-multi-topology-05 */
+#define TLV_IP6_REACH           236 /* draft-ietf-isis-ipv6-02 */
+#define TLV_MT_IP6_REACH        237 /* draft-ietf-isis-wg-multi-topology-05 */
+#define TLV_PTP_ADJ             240 /* rfc3373 */
+#define TLV_IIH_SEQNR           241 /* draft-shen-isis-iih-sequence-00 */
+#define TLV_VENDOR_PRIVATE      250 /* draft-ietf-isis-proprietary-tlv-00 */
+
+static struct tok isis_tlv_values[] = {
+    { TLV_AREA_ADDR,        "Area address(es)"},
+    { TLV_IS_REACH,          "IS Reachability"},
+    { TLV_ESNEIGH,           "ES Neighbor(s)"},
+    { TLV_PART_DIS,          "Partition DIS"},
+    { TLV_PREFIX_NEIGH,      "Prefix Neighbors"},
+    { TLV_ISNEIGH,           "IS Neighbor(s)"},
+    { TLV_ISNEIGH_VARLEN,    "IS Neighbor(s) (variable length)"},
+    { TLV_PADDING,           "Padding"},
+    { TLV_LSP,               "LSP entries"},
+    { TLV_AUTH,              "Authentication"},
+    { TLV_CHECKSUM,          "Checksum"},
+    { TLV_LSP_BUFFERSIZE,    "LSP Buffersize"},
+    { TLV_EXT_IS_REACH,      "Extended IS Reachability"},
+    { TLV_IS_ALIAS_ID,       "IS Alias ID"},
+    { TLV_DECNET_PHASE4,     "DECnet Phase IV"},
+    { TLV_LUCENT_PRIVATE,    "Lucent Proprietary"},
+    { TLV_IP_REACH,          "IPv4 Internal reachability"},
+    { TLV_PROTOCOLS,         "Protocols supported"},
+    { TLV_IP_REACH_EXT,      "IPv4 External reachability"},
+    { TLV_IDRP_INFO,         "Inter-Domain Information Type"},
+    { TLV_IPADDR,            "IPv4 Interface address(es)"},
+    { TLV_IPAUTH,            "IPv4 authentication (deprecated)"},
+    { TLV_TE_ROUTER_ID,      "Traffic Engineering Router ID"},
+    { TLV_EXT_IP_REACH,      "Extended IPv4 reachability"},
+    { TLV_HOSTNAME,          "Hostname"},
+    { TLV_SHARED_RISK_GROUP, "Shared Risk Link Group"},
+    { TLV_NORTEL_PRIVATE1,   "Nortel Proprietary"},
+    { TLV_NORTEL_PRIVATE2,   "Nortel Proprietary"},
+    { TLV_HOLDTIME,          "Holdtime"},
+    { TLV_RESTART_SIGNALING, "Restart Signaling"},
+    { TLV_MT_IS_REACH,       "Multi Topology IS Reachability"},
+    { TLV_MT_SUPPORTED,      "Multi Topology"},
+    { TLV_IP6ADDR,           "IPv6 Interface address(es)"},
+    { TLV_MT_IP_REACH,       "Multi-Topology IPv4 reachability"},
+    { TLV_IP6_REACH,         "IPv6 reachability"},
+    { TLV_MT_IP6_REACH,      "Multi-Topology IP6 reachability"},
+    { TLV_PTP_ADJ,           "Point-to-point Adjacency State"},
+    { TLV_IIH_SEQNR,         "Hello PDU Sequence Number"},
+    { TLV_VENDOR_PRIVATE,    "Vendor Private"},
+    { 0, NULL }
+};

 
 #define SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3
 #define SUBTLV_EXT_IS_REACH_LINK_LOCAL_ID         4
 
 #define SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3
 #define SUBTLV_EXT_IS_REACH_LINK_LOCAL_ID         4


@@ -121,14 +192,33 @@ static const char rcsid[] =
 #define SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20
 #define SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21
 
 #define SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20
 #define SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21
 

+#define SUBTLV_IP_REACH_ADMIN_TAG32               1
+#define SUBTLV_IP_REACH_ADMIN_TAG64               2
+

 #define SUBTLV_AUTH_SIMPLE        1
 #define SUBTLV_AUTH_MD5          54
 #define SUBTLV_AUTH_MD5_LEN      16
 #define SUBTLV_AUTH_PRIVATE     255
 
 #define SUBTLV_AUTH_SIMPLE        1
 #define SUBTLV_AUTH_MD5          54
 #define SUBTLV_AUTH_MD5_LEN      16
 #define SUBTLV_AUTH_PRIVATE     255
 

-#define ISIS_8BIT_MASK(x)                  ((x)&0xff) 
+static struct tok isis_subtlv_auth_values[] = {
+    { SUBTLV_AUTH_SIMPLE,      "simple text password"},
+    { SUBTLV_AUTH_MD5,         "HMAC-MD5 password"},
+    { SUBTLV_AUTH_PRIVATE,     "Routing Domain private password"},
+    { 0, NULL }
+};
+
+#define SUBTLV_IDRP_RES           0
+#define SUBTLV_IDRP_LOCAL         1
+#define SUBTLV_IDRP_ASN           2
+
+static struct tok isis_subtlv_idrp_values[] = {
+    { SUBTLV_IDRP_RES,         "Reserved"},
+    { SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
+    { SUBTLV_IDRP_ASN,         "AS Number Tag"},
+    { 0, NULL}
+};

 
 

-#define ISIS_MASK_LEVEL_BITS(x)            ((x)&0x1) 
+#define ISIS_8BIT_MASK(x)                  ((x)&0xff)

 
 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
 
 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)


@@ -139,12 +229,20 @@ static const char rcsid[] =
 #define ISIS_MASK_LSP_ATT_DELAY_BIT(x)     ((x)&0x10)
 #define ISIS_MASK_LSP_ATT_DEFAULT_BIT(x)   ((x)&0x8)
 
 #define ISIS_MASK_LSP_ATT_DELAY_BIT(x)     ((x)&0x10)
 #define ISIS_MASK_LSP_ATT_DEFAULT_BIT(x)   ((x)&0x8)
 

+#define ISIS_MASK_MTID(x)                  ((x)&0x0fff)
+#define ISIS_MASK_MTFLAGS(x)               ((x)&0xf000)
+
+static struct tok isis_mt_flag_values[] = {
+    { 0x4000,                  "sub-TLVs present"},
+    { 0x8000,                  "ATT bit set"},
+    { 0, NULL}
+};
+

 #define ISIS_MASK_TLV_EXT_IP_UPDOWN(x)     ((x)&0x80)
 #define ISIS_MASK_TLV_EXT_IP_SUBTLV(x)     ((x)&0x40)
 
 #define ISIS_MASK_TLV_EXT_IP_UPDOWN(x)     ((x)&0x80)
 #define ISIS_MASK_TLV_EXT_IP_SUBTLV(x)     ((x)&0x40)
 

-#define ISIS_MASK_TLV_IP6_UPDOWN(x)        ((x)&0x80)
-#define ISIS_MASK_TLV_IP6_IE(x)            ((x)&0x40)
-#define ISIS_MASK_TLV_IP6_SUBTLV(x)        ((x)&0x20)
+#define ISIS_MASK_TLV_EXT_IP6_IE(x)        ((x)&0x40)
+#define ISIS_MASK_TLV_EXT_IP6_SUBTLV(x)    ((x)&0x20)

 
 #define ISIS_MASK_TLV_RESTART_RR(x)        ((x)&0x1)
 #define ISIS_MASK_TLV_RESTART_RA(x)        ((x)&0x2)
 
 #define ISIS_MASK_TLV_RESTART_RR(x)        ((x)&0x1)
 #define ISIS_MASK_TLV_RESTART_RA(x)        ((x)&0x2)


@@ -156,42 +254,59 @@ static const char rcsid[] =
 
 #define ISIS_MASK_TLV_SHARED_RISK_GROUP(x) ((x)&0x1)
 
 
 #define ISIS_MASK_TLV_SHARED_RISK_GROUP(x) ((x)&0x1)
 

-static const char *isis_gmpls_link_prot_values[] = {
-       "Extra",
-       "Unprotected",
-       "Shared",
-       "Dedicated 1:1",
-       "Dedicated 1+1",
-       "Enhanced",
-       "Reserved",
-       "Reserved"
+static struct tok isis_gmpls_link_prot_values[] = {
+    { 0x01, "Extra Traffic"},
+    { 0x02, "Unprotected"},
+    { 0x04, "Shared"},
+    { 0x08, "Dedicated 1:1"},
+    { 0x10, "Dedicated 1+1"},
+    { 0x20, "Enhanced"},
+    { 0x40, "Reserved"},
+    { 0x80, "Reserved"},
+    { 0, NULL }

 };
 
 static struct tok isis_gmpls_sw_cap_values[] = {
 };
 
 static struct tok isis_gmpls_sw_cap_values[] = {

-       { 1,    "Packet-Switch Capable-1"},
-       { 2,    "Packet-Switch Capable-2"},
-       { 3,    "Packet-Switch Capable-3"},
-       { 4,    "Packet-Switch Capable-4"},
-       { 51,   "Layer-2 Switch Capable"},
-       { 100,  "Time-Division-Multiplex"},
-       { 150,  "Lambda-Switch Capable"},
-       { 200,  "Fiber-Switch Capable"},
-       { 0,    "unknown" }
+    { 1,       "Packet-Switch Capable-1"},
+    { 2,       "Packet-Switch Capable-2"},
+    { 3,       "Packet-Switch Capable-3"},
+    { 4,       "Packet-Switch Capable-4"},
+    { 51,      "Layer-2 Switch Capable"},
+    { 100,     "Time-Division-Multiplex"},
+    { 150,     "Lambda-Switch Capable"},
+    { 200,     "Fiber-Switch Capable"},
+    { 0, NULL }

 };
 
 static struct tok isis_gmpls_lsp_enc_values[] = {
 };
 
 static struct tok isis_gmpls_lsp_enc_values[] = {

-        { 1,    "Packet"},
-       { 2,    "Ethernet V2/DIX"},
-       { 3,    "ANSI PDH"},
-       { 4,    "ETSI PDH"},
-       { 5,    "SDH ITU-T G.707"},
-       { 6,    "SONET ANSI T1.105"},
-       { 7,    "Digital Wrapper"},
-       { 8,    "Lambda (photonic)"},
-       { 9,    "Fiber"},
-       { 10,   "Ethernet 802.3"},
-       { 11,   "FiberChannel"},
-       { 0,    "unknown" }
+    { 1,    "Packet"},
+    { 2,    "Ethernet V2/DIX"},
+    { 3,    "ANSI PDH"},
+    { 4,    "ETSI PDH"},
+    { 5,    "SDH ITU-T G.707"},
+    { 6,    "SONET ANSI T1.105"},
+    { 7,    "Digital Wrapper"},
+    { 8,    "Lambda (photonic)"},
+    { 9,    "Fiber"},
+    { 10,   "Ethernet 802.3"},
+    { 11,   "FiberChannel"},
+    { 0, NULL }
+};
+
+static struct tok isis_mt_values[] = {
+    { 0,    "IPv4 unicast"},
+    { 1,    "In-Band Management"},
+    { 2,    "IPv6 unicast"},
+    { 3,    "Multicast"},
+    { 4095, "Development, Experimental or Proprietary"},
+    { 0, NULL }
+};
+
+static struct tok isis_iih_circuit_type_values[] = {
+    { 1,    "Level 1 only"},
+    { 2,    "Level 2 only"},
+    { 3,    "Level 1, Level 2"},
+    { 0, NULL}

 };
 
 #define ISIS_LSP_TYPE_UNUSED0   0
 };
 
 #define ISIS_LSP_TYPE_UNUSED0   0


@@ -200,18 +315,18 @@ static struct tok isis_gmpls_lsp_enc_values[] = {
 #define ISIS_LSP_TYPE_LEVEL_2   3
 
 static struct tok isis_lsp_istype_values[] = {
 #define ISIS_LSP_TYPE_LEVEL_2   3
 
 static struct tok isis_lsp_istype_values[] = {

-       { ISIS_LSP_TYPE_UNUSED0,        "Unused 0x0 (invalid)"},
-       { ISIS_LSP_TYPE_LEVEL_1,        "L1 IS"},
-       { ISIS_LSP_TYPE_UNUSED2,        "Unused 0x2 (invalid)"},
-       { ISIS_LSP_TYPE_LEVEL_2,        "L1L2 IS"},
-       { 0, NULL }
+    { ISIS_LSP_TYPE_UNUSED0,   "Unused 0x0 (invalid)"},
+    { ISIS_LSP_TYPE_LEVEL_1,   "L1 IS"},
+    { ISIS_LSP_TYPE_UNUSED2,   "Unused 0x2 (invalid)"},
+    { ISIS_LSP_TYPE_LEVEL_2,   "L1L2 IS"},
+    { 0, NULL }

 };
 
 };
 

-static struct tok isis_nlpid_values[] = {
-       { NLPID_CLNS,   "CLNS"},
-       { NLPID_IP,     "IPv4"},
-       { NLPID_IP6,    "IPv6"},
-       { 0,            "unknown" }
+static struct tok osi_nlpid_values[] = {
+    { NLPID_CLNS,   "CLNS"},
+    { NLPID_IP,     "IPv4"},
+    { NLPID_IP6,    "IPv6"},
+    { 0, NULL }

 };
 
 /*
 };
 
 /*


@@ -223,98 +338,140 @@ static struct tok isis_nlpid_values[] = {
 #define ISIS_PTP_ADJ_INIT 1
 #define ISIS_PTP_ADJ_DOWN 2
 
 #define ISIS_PTP_ADJ_INIT 1
 #define ISIS_PTP_ADJ_DOWN 2
 

-static int osi_cksum(const u_char *, u_int, u_char *);
-static void esis_print(const u_char *, u_int);
-static int isis_print(const u_char *, u_int);
-

 
 static struct tok isis_ptp_adjancey_values[] = {
 
 static struct tok isis_ptp_adjancey_values[] = {

-       { ISIS_PTP_ADJ_UP,    "Up" },
-       { ISIS_PTP_ADJ_INIT,  "Initializing" },
-       { ISIS_PTP_ADJ_DOWN,  "Down" }
+    { ISIS_PTP_ADJ_UP,    "Up" },
+    { ISIS_PTP_ADJ_INIT,  "Initializing" },
+    { ISIS_PTP_ADJ_DOWN,  "Down" },
+    { 0, NULL}

 };
 
 struct isis_tlv_ptp_adj {
 };
 
 struct isis_tlv_ptp_adj {

-    u_char adjacency_state;
-    u_char ext_local_circuit_id[4];
-    u_char neighbor_sysid[SYSTEM_ID_LEN];
-    u_char neighbor_ext_local_circuit_id[4]; 
+    u_int8_t adjacency_state;
+    u_int8_t extd_local_circuit_id[4];
+    u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
+    u_int8_t neighbor_extd_local_circuit_id[4];

 };
 
 };
 

-struct isis_tlv_ip_reach {
-    u_char metric_default;
-    u_char metric_delay;
-    u_char metric_expense;
-    u_char metric_error;
-    u_char prefix[4];
-    u_char mask[4];
+static int osi_cksum(const u_int8_t *, u_int);
+static void esis_print(const u_int8_t *, u_int);
+static int isis_print(const u_int8_t *, u_int);
+
+struct isis_metric_block {
+    u_int8_t metric_default;
+    u_int8_t metric_delay;
+    u_int8_t metric_expense;
+    u_int8_t metric_error;

 };
 
 struct isis_tlv_is_reach {
 };
 
 struct isis_tlv_is_reach {

-    u_char metric_default;
-    u_char metric_delay;
-    u_char metric_expense;
-    u_char metric_error;
-    u_char neighbor_nodeid[SYSTEM_ID_LEN+1];
+    struct isis_metric_block isis_metric_block;
+    u_int8_t neighbor_nodeid[NODE_ID_LEN];
+};
+
+struct isis_tlv_es_reach {
+    struct isis_metric_block isis_metric_block;
+    u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
+};
+
+struct isis_tlv_ip_reach {
+    struct isis_metric_block isis_metric_block;
+    u_int8_t prefix[4];
+    u_int8_t mask[4];

 };
 
 };
 

+static struct tok isis_is_reach_virtual_values[] = {
+    { 0,    "IsNotVirtual"},
+    { 1,    "IsVirtual"},
+    { 0, NULL }
+};

 
 struct isis_common_header {
 
 struct isis_common_header {

-    u_char nlpid;
-    u_char fixed_len;
-    u_char version;                    /* Protocol version? */
-    u_char id_length;
-    u_char pdu_type;                   /* 3 MSbs are reserved */
-    u_char pkt_version;                        /* Packet format version? */
-    u_char reserved;
-    u_char max_area;
+    u_int8_t nlpid;
+    u_int8_t fixed_len;
+    u_int8_t version;                  /* Protocol version */
+    u_int8_t id_length;
+    u_int8_t pdu_type;                 /* 3 MSbits are reserved */
+    u_int8_t pdu_version;              /* Packet format version */
+    u_int8_t reserved;
+    u_int8_t max_area;

 };
 
 struct isis_iih_lan_header {
 };
 
 struct isis_iih_lan_header {

-    u_char circuit_type;
-    u_char source_id[SYSTEM_ID_LEN];
-    u_char holding_time[2];
-    u_char pdu_len[2];
-    u_char priority;
-    u_char lan_id[SYSTEM_ID_LEN+1];
+    u_int8_t circuit_type;
+    u_int8_t source_id[SYSTEM_ID_LEN];
+    u_int8_t holding_time[2];
+    u_int8_t pdu_len[2];
+    u_int8_t priority;
+    u_int8_t lan_id[NODE_ID_LEN];

 };
 
 struct isis_iih_ptp_header {
 };
 
 struct isis_iih_ptp_header {

-    u_char circuit_type;
-    u_char source_id[SYSTEM_ID_LEN];
-    u_char holding_time[2];
-    u_char pdu_len[2];
-    u_char circuit_id;
+    u_int8_t circuit_type;
+    u_int8_t source_id[SYSTEM_ID_LEN];
+    u_int8_t holding_time[2];
+    u_int8_t pdu_len[2];
+    u_int8_t circuit_id;

 };
 
 struct isis_lsp_header {
 };
 
 struct isis_lsp_header {

-    u_char pdu_len[2];
-    u_char remaining_lifetime[2];
-    u_char lsp_id[SYSTEM_ID_LEN+2];
-    u_char sequence_number[4];
-    u_char checksum[2];
-    u_char typeblock;
+    u_int8_t pdu_len[2];
+    u_int8_t remaining_lifetime[2];
+    u_int8_t lsp_id[LSP_ID_LEN];
+    u_int8_t sequence_number[4];
+    u_int8_t checksum[2];
+    u_int8_t typeblock;

 };
 
 struct isis_csnp_header {
 };
 
 struct isis_csnp_header {

-    u_char pdu_len[2];
-    u_char source_id[SYSTEM_ID_LEN+1];
-    u_char start_lsp_id[SYSTEM_ID_LEN+2];
-    u_char end_lsp_id[SYSTEM_ID_LEN+2];
+    u_int8_t pdu_len[2];
+    u_int8_t source_id[NODE_ID_LEN];
+    u_int8_t start_lsp_id[LSP_ID_LEN];
+    u_int8_t end_lsp_id[LSP_ID_LEN];

 };
 
 struct isis_psnp_header {
 };
 
 struct isis_psnp_header {

-    u_char pdu_len[2];
-    u_char source_id[SYSTEM_ID_LEN+1];
+    u_int8_t pdu_len[2];
+    u_int8_t source_id[NODE_ID_LEN];

 };
 
 struct isis_tlv_lsp {
 };
 
 struct isis_tlv_lsp {

-    u_char remaining_lifetime[2];
-    u_char lsp_id[SYSTEM_ID_LEN+2];
-    u_char sequence_number[4];
-    u_char checksum[2];
+    u_int8_t remaining_lifetime[2];
+    u_int8_t lsp_id[LSP_ID_LEN];
+    u_int8_t sequence_number[4];
+    u_int8_t checksum[2];

 };
 };

-    
+
+
+/* allocate space for the following string
+ * xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx
+ * 32 bytes plus one termination byte */
+static char *
+print_nsap(register const u_int8_t *pptr, register int nsap_length)
+{
+       int nsap_idx;
+       static char nsap_ascii_output[33];
+        char *junk_buf = nsap_ascii_output;
+
+        if (nsap_length < 1 || nsap_length > 13) {
+                sprintf(junk_buf, "illegal length");
+                return (nsap_ascii_output);
+        }
+
+       for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {
+               if (!TTEST2(*pptr, 1))
+                       return (0);
+               sprintf(junk_buf, "%02x", *pptr++);
+               junk_buf += strlen(junk_buf);
+               if (((nsap_idx & 1) == 0) &&
+                     (nsap_idx + 1 < nsap_length)) {
+                       *junk_buf++ = '.';
+               }
+       }
+        *(junk_buf) = '\0';
+       return (nsap_ascii_output);
+}
+

 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))


@@ -322,69 +479,47 @@ struct isis_tlv_lsp {
 #define ISIS_CSNP_HEADER_SIZE (sizeof(struct isis_csnp_header))
 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
 
 #define ISIS_CSNP_HEADER_SIZE (sizeof(struct isis_csnp_header))
 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
 

-void isoclns_print(const u_char *p, u_int length, u_int caplen,
-             const u_char *esrc, const u_char *edst)
+void isoclns_print(const u_int8_t *p, u_int length, u_int caplen,
+             const u_int8_t *esrc, const u_int8_t *edst)

 {
 {

-       u_char pdu_type;
+       u_int8_t pdu_type;

        const struct isis_common_header *header;
        const struct isis_common_header *header;

-       
+

        header = (const struct isis_common_header *)p;
        pdu_type = header->pdu_type & PDU_TYPE_MASK;
 
        header = (const struct isis_common_header *)p;
        pdu_type = header->pdu_type & PDU_TYPE_MASK;
 

-       if (caplen < 1) {
-               printf("[|iso-clns] ");
-               if (!eflag && esrc != NULL && edst != NULL)
-                       printf("%s > %s",
-                              etheraddr_string(esrc),
-                              etheraddr_string(edst));
-               return;
-       }
+        printf("%sOSI ", caplen < 1 ? "|" : "");
+        if (!eflag && esrc != NULL && edst != NULL)
+                (void)printf("%s > %s, ",
+                         etheraddr_string(esrc),
+                         etheraddr_string(edst));
+
+        if (caplen < 1) /* enough bytes on the wire ? */
+                return;

 
        switch (*p) {
 
        case NLPID_CLNS:
 
        switch (*p) {
 
        case NLPID_CLNS:

-               (void)printf("CLNS(%d)", length);
-               if (!eflag && esrc != NULL && edst != NULL)
-                       (void)printf(", %s > %s",
-                                    etheraddr_string(esrc),
-                                    etheraddr_string(edst));
+               (void)printf("CLNS, length: %u", length);

                break;
 
        case NLPID_ESIS:
                break;
 
        case NLPID_ESIS:

-               (void)printf("ESIS");
-               if (!eflag && esrc != NULL && edst != NULL)
-                       (void)printf(", %s > %s",
-                                    etheraddr_string(esrc),
-                                    etheraddr_string(edst));

                esis_print(p, length);
                return;
 
        case NLPID_ISIS:
                esis_print(p, length);
                return;
 
        case NLPID_ISIS:

-               (void)printf("ISIS(%d)", length);
-               if (!eflag && esrc != NULL && edst != NULL)
-                       (void)printf(", %s > %s",
-                            etheraddr_string(esrc),
-                            etheraddr_string(edst));

                if (!isis_print(p, length))
                if (!isis_print(p, length))

-                       default_print_unaligned(p, caplen);
+                        print_unknown_data(p,"\n\t",caplen);

                break;
 
        case NLPID_NULLNS:
                break;
 
        case NLPID_NULLNS:

-               (void)printf("ISO NULLNS(%d)", length);
-               if (!eflag && esrc != NULL && edst != NULL)
-                       (void)printf(", %s > %s",
-                                    etheraddr_string(esrc),
-                                    etheraddr_string(edst));
+               (void)printf("ISO NULLNS, length: %u", length);

                break;
 
        default:
                break;
 
        default:

-               (void)printf("CLNS %02x(%d)", p[0], length);
-               if (!eflag && esrc != NULL && edst != NULL)
-                       (void)printf(", %s > %s",
-                                    etheraddr_string(esrc),
-                                    etheraddr_string(edst));
+               (void)printf("Unknown NLPID 0x%02x, length: %u", p[0], length);

                if (caplen > 1)
                if (caplen > 1)

-                       default_print_unaligned(p, caplen);
+                        print_unknown_data(p,"\n\t",caplen);

                break;
        }
 }
                break;
        }
 }


@@ -393,21 +528,27 @@ void isoclns_print(const u_char *p, u_int length, u_int caplen,
 #define        ESIS_ESH        2
 #define        ESIS_ISH        4
 
 #define        ESIS_ESH        2
 #define        ESIS_ISH        4
 

+static struct tok esis_values[] = {
+    { ESIS_REDIRECT, "redirect"},
+    { ESIS_ESH,      "ESH"},
+    { ESIS_ISH,      "ISH"},
+    { 0, NULL }
+};
+

 struct esis_hdr {
 struct esis_hdr {

-       u_char version;
-       u_char reserved;
-       u_char type;
-       u_char tmo[2];
-       u_char cksum[2];
+       u_int8_t version;
+       u_int8_t reserved;
+       u_int8_t type;
+       u_int8_t tmo[2];
+       u_int8_t cksum[2];

 };
 
 static void
 };
 
 static void

-esis_print(const u_char *p, u_int length)
+esis_print(const u_int8_t *p, u_int length)

 {
 {

-       const u_char *ep;
+       const u_int8_t *ep;

        u_int li;
        const struct esis_hdr *eh;
        u_int li;
        const struct esis_hdr *eh;

-       u_char off[2];

 
        if (length <= 2) {
                if (qflag)
 
        if (length <= 2) {
                if (qflag)


@@ -436,28 +577,16 @@ esis_print(const u_char *p, u_int length)
                }
                return;
        }
                }
                return;
        }

-       switch (eh->type & 0x1f) {

 
 

-       case ESIS_REDIRECT:
-               printf(" redirect");
-               break;
+        printf("ES-IS, %s, length: %u",
+               tok2str(esis_values,"unknown type: %u",eh->type & 0x1f),
+               length);

 
 

-       case ESIS_ESH:
-               printf(" esh");
-               break;
-
-       case ESIS_ISH:
-               printf(" ish");
-               break;
+        if(vflag < 1)
+               return;

 
 

-       default:
-               printf(" type %d", eh->type & 0x1f);
-               break;
-       }
-       off[0] = eh->cksum[0];
-       off[1] = eh->cksum[1];
-       if (vflag && osi_cksum(p, li, off)) {
-               printf(" bad cksum (got %02x%02x)",
+       if (vflag && osi_cksum(p, li)) {
+               printf(" bad cksum (got 0x%02x%02x)",

                       eh->cksum[1], eh->cksum[0]);
                default_print(p, length);
                return;
                       eh->cksum[1], eh->cksum[0]);
                default_print(p, length);
                return;


@@ -471,12 +600,12 @@ esis_print(const u_char *p, u_int length)
 
        switch (eh->type & 0x1f) {
        case ESIS_REDIRECT: {
 
        switch (eh->type & 0x1f) {
        case ESIS_REDIRECT: {

-               const u_char *dst, *snpa, *is;
+               const u_int8_t *dst, *snpa, *is;

 
                dst = p; p += *p + 1;
                if (p > snapend)
                        return;
 
                dst = p; p += *p + 1;
                if (p > snapend)
                        return;

-               printf("\n\t\t\t %s", isonsap_string(dst));
+               printf("\n\t\t %s", isonsap_string(dst));

                snpa = p; p += *p + 1;
                is = p;   p += *p + 1;
                if (p > snapend)
                snpa = p; p += *p + 1;
                is = p;   p += *p + 1;
                if (p > snapend)


@@ -492,13 +621,12 @@ esis_print(const u_char *p, u_int length)
                li = ep - p;
                break;
        }
                li = ep - p;
                break;
        }

-#if 0
+

        case ESIS_ESH:
        case ESIS_ESH:

-               printf(" esh");

                break;
                break;

-#endif
+

        case ESIS_ISH: {
        case ESIS_ISH: {

-               const u_char *is;
+               const u_int8_t *is;

 
                is = p; p += *p + 1;
                if (p > ep) {
 
                is = p; p += *p + 1;
                if (p > ep) {


@@ -508,233 +636,560 @@ esis_print(const u_char *p, u_int length)
                if (p > snapend)
                        return;
                if (!qflag)
                if (p > snapend)
                        return;
                if (!qflag)

-                       printf("\n\t\t\t %s", isonsap_string(is));
+                       printf("\n\tNET: %s", print_nsap(is+1,*is));

                li = ep - p;
                break;
        }
 
        default:
                li = ep - p;
                break;
        }
 
        default:

-               (void)printf(" len=%d", length);
-               if (length && p < snapend) {
-                       length = snapend - p;
-                       default_print(p, length);
-               }
-               return;
+            if (vflag <= 1) {
+                   if (p < snapend) 
+                            print_unknown_data(p,"\n\t  ",snapend-p);
+            }
+            return;

        }
        }

+
+        /* hexdump - FIXME ? */
+        if (vflag > 1) {
+                    if (p < snapend)
+                            print_unknown_data(p,"\n\t  ",snapend-p);
+        }

        if (vflag)
                while (p < ep && li) {
                        u_int op, opli;
        if (vflag)
                while (p < ep && li) {
                        u_int op, opli;

-                       const u_char *q;
+                       const u_int8_t *q;

 
                        if (snapend - p < 2)
                                return;
                        if (li < 2) {
 
                        if (snapend - p < 2)
                                return;
                        if (li < 2) {

-                               printf(" bad opts/li");
+                               printf(", bad opts/li");

                                return;
                        }
                        op = *p++;
                        opli = *p++;
                        li -= 2;
                        if (opli > li) {
                                return;
                        }
                        op = *p++;
                        opli = *p++;
                        li -= 2;
                        if (opli > li) {

-                               printf(" opt (%d) too long", op);
+                               printf(", opt (%d) too long", op);

                                return;
                        }
                        li -= opli;
                        q = p;
                        p += opli;
                                return;
                        }
                        li -= opli;
                        q = p;
                        p += opli;

+

                        if (snapend < p)
                                return;
                        if (snapend < p)
                                return;

-                       if (op == 198 && opli == 2) {
-                               printf(" tmo=%d", q[0] * 256 + q[1]);
+
+                       if (op == TLV_HOLDTIME && opli == 2) {
+                               printf("\n\tholdtime: %us", EXTRACT_16BITS(q));

                                continue;
                        }
                                continue;
                        }

-                       printf (" %d:<", op);
-                       while (opli-- > 0)
-                               printf("%02x", *q++);
-                       printf (">");
+
+                       if (op == TLV_PROTOCOLS && opli >= 1) {
+                               printf("\n\t%s (length: %u): %s",
+                                       tok2str(isis_tlv_values, "unknown", op),
+                                       opli,
+                                       tok2str(osi_nlpid_values,"Unknown 0x%02x",*q));
+                               continue;
+                       }
+
+                        print_unknown_data(q,"\n\t  ",opli);

                }
 }
 
                }
 }
 

-/*
- * print_nsap
- * Print out an NSAP. 
- */
-static int
-print_nsap(register const u_char *cp, register int length)
+/* shared routine for printing system, node and lsp-ids
+ * allocate space for the worst-case string
+ * xxxx.xxxx.xxxx.yy-zz
+ * 20 bytes plus one termination byte */
+static char *
+isis_print_id(const u_int8_t *cp, int id_len)

 {
 {

-       int i;
-
-       for (i = 0; i < length; i++) {
-               if (!TTEST2(*cp, 1))
-                       return (0);
-               printf("%02x", *cp++);
-               if (((i & 1) == 0) && (i + 1 < length)) {
-                       printf(".");
-               }
+    int i;
+    static char id[21];
+    char *pos = id;
+
+    for (i = 1; i <= SYSTEM_ID_LEN; i++) {
+        sprintf(pos, "%02x", *cp++);
+       pos += strlen(pos);
+       if (i == 2 || i == 4)
+           *pos++ = '.';

        }
        }

-       return (1);
+    if (id_len == NODE_ID_LEN) {
+        sprintf(pos, ".%02x", *cp++);
+       pos += strlen(pos);
+    }
+    if (id_len == LSP_ID_LEN)
+        sprintf(pos, "-%02x", *cp);
+    return (id);

 }
 
 }
 

+/* print the 4-byte metric block which is common found in the old-style TLVs */

 static int
 static int

-isis_print_sysid(const u_char *cp)
+isis_print_metric_block (const struct isis_metric_block *isis_metric_block)

 {
 {

-       int i;
-
-       for (i = 1; i <= 6; i++) {
-               if (!TTEST2(*cp, 1))
-                       return (0);
-               printf("%02x", *cp++);
-               if ((i==2)^(i==4)) {
-                       printf(".");
-               }
-       }
-       return (1);
+    printf(", Default Metric: %d, %s",
+           ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_default),
+           ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_default) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_delay))
+        printf("\n\t\t  Delay Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_delay),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_delay) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_expense))
+        printf("\n\t\t  Expense Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_expense),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_expense) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_error))
+        printf("\n\t\t  Error Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_error),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_error) ? "External" : "Internal");
+
+    return(1); /* everything is ok */

 }
 
 static int
 }
 
 static int

-isis_print_nodeid(const u_char *cp)
+isis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length)

 {
 {

-       int i;
+       int prefix_len;
+       const struct isis_tlv_ip_reach *tlv_ip_reach;

 
 

-       for (i = 1; i <= 7; i++) {
-               if (!TTEST2(*cp, 1))
+       tlv_ip_reach = (const struct isis_tlv_ip_reach *)cp;
+
+       while (length > 0) {
+               if ((size_t)length < sizeof(*tlv_ip_reach)) {
+                       printf("short IPv4 reachability (%d vs %lu)",
+                               length,
+                               (unsigned long)sizeof(*tlv_ip_reach));

                        return (0);
                        return (0);

-               printf("%02x", *cp++);
-               if ((i & 1) == 0) {
-                       printf(".");

                }
                }

+
+               if (!TTEST(*tlv_ip_reach))
+                   return (0);
+
+               prefix_len = mask2plen(EXTRACT_32BITS(tlv_ip_reach->mask));
+
+               if (prefix_len == -1)
+                       printf("%sIPv4 prefix: %s mask %s",
+                               ident,
+                              ipaddr_string((tlv_ip_reach->prefix)),
+                              ipaddr_string((tlv_ip_reach->mask)));
+               else
+                       printf("%sIPv4 prefix: %15s/%u",
+                               ident,
+                              ipaddr_string((tlv_ip_reach->prefix)),
+                              prefix_len);
+
+               printf(", Distribution: %s, Metric: %u, %s",
+                       ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->isis_metric_block.metric_default) ? "down" : "up",
+                       ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_default),
+                       ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_default) ? "External" : "Internal");
+
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_delay))
+                    printf("%s  Delay Metric: %u, %s",
+                           ident,
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_delay),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_delay) ? "External" : "Internal");
+                
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_expense))
+                    printf("%s  Expense Metric: %u, %s",
+                           ident,
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_expense),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_expense) ? "External" : "Internal");
+                
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_error))
+                    printf("%s  Error Metric: %u, %s",
+                           ident,
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_error),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_error) ? "External" : "Internal");
+
+               length -= sizeof(struct isis_tlv_ip_reach);
+               tlv_ip_reach++;

        }
        return (1);
 }
 
        }
        return (1);
 }
 

-static void
-isis_print_lspid(const u_char *cp)
-{
-       int i;
+/*
+ * this is the common IP-REACH subTLV decoder it is called
+ * from various EXTD-IP REACH TLVs (135,235,236,237)
+ */
+
+static int
+isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {

 
 

-       for (i = 1; i <= 7; i++) {
-               printf("%02x", *cp++);
-               if ((i & 1) == 0)
-                       printf(".");
+    switch(subt) {
+    case SUBTLV_IP_REACH_ADMIN_TAG32:
+        while (subl >= 4) {
+           if (!TTEST2(*tptr,4))
+               goto trunctlv;
+           printf("%s32-Bit Administrative tag: 0x%08x (=%u)",
+                  ident,
+                  EXTRACT_32BITS(tptr),
+                  EXTRACT_32BITS(tptr));
+           tptr+=4;
+           subl-=4;

        }
        }

-       printf("-%02x", *cp);
+       break;
+    case SUBTLV_IP_REACH_ADMIN_TAG64:
+        while (subl >= 8) {
+           if (!TTEST2(*tptr,8))
+               goto trunctlv;
+           printf("%s64-Bit Administrative tag: 0x%08x%08x",
+                  ident,
+                  EXTRACT_32BITS(tptr),
+                  EXTRACT_32BITS(tptr+4));
+           tptr+=8;
+           subl-=8;
+       }
+       break;
+    default:
+        printf("%sunknown subTLV, type %d, length %d",
+              ident,
+              subt,
+              subl);
+       if(!print_unknown_data(tptr,"\n\t\t    ",
+                              subl))
+         return(0);
+       break;
+    }
+    return(1);
+       
+trunctlv:
+    printf("%spacket exceeded snapshot",ident);
+    return(0);

 }
 
 /*
 }
 
 /*

- *  this is a generic routine for printing unknown data;
- *  as it is called from various places (TLV and subTLV parsing routines)
- *  we pass on the linefeed plus indentation string to
- *  get a proper output
+ * this is the common IS-REACH subTLV decoder it is called
+ * from isis_print_ext_is_reach()

  */
 
 static int
  */
 
 static int

-isis_print_unknown_data(const u_char *cp,const u_char *lf,int len)
-{
+isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
+

         int i;
         int i;

-       
-       printf("%s0x0000: ",lf);
-       for(i=0;i<len;i++) {
-           if (!TTEST2(*(cp+i), 1))
-             goto trunctlv;
-           printf("%02x",*(cp+i));
-           if (i%2)
-               printf(" ");
-           if (i/16!=(i+1)/16) {
-               if (i<(len-1))
-                   printf("%s0x%04x: ",lf,i);
-           }
-       }
-       return(0); /* everything is ok */
+        union { /* int to float conversion buffer for several subTLVs */
+            float f; 
+            u_int32_t i;
+        } bw;
+
+        switch(subt) {
+        case SUBTLV_EXT_IS_REACH_ADMIN_GROUP:
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            printf("%sAdministrative groups: 0x%08x",
+                   ident,
+                   EXTRACT_32BITS(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_LINK_LOCAL_ID:
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            printf("%sLink Local Identifier: 0x%08x",
+                   ident,
+                   EXTRACT_32BITS(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            printf("%sLink Remote Identifier: 0x%08x",
+                   ident,
+                   EXTRACT_32BITS(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            bw.i = EXTRACT_32BITS(tptr);
+            printf("%sMaximum link bandwidth : %.3f Mbps",
+                   ident,
+                   bw.f*8/1000000 );
+            break;
+        case SUBTLV_EXT_IS_REACH_RESERVABLE_BW :
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            bw.i = EXTRACT_32BITS(tptr);
+            printf("%sReservable link bandwidth: %.3f Mbps",
+                   ident,
+                   bw.f*8/1000000  );
+            break;
+        case SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
+            printf("%sUnreserved bandwidth:",ident);
+            for (i = 0; i < 8; i++) {
+                if (!TTEST2(*(tptr+i*4),4))
+                    goto trunctlv;
+                bw.i = EXTRACT_32BITS(tptr);
+                printf("%s  priority level %d: %.3f Mbps",
+                       ident,
+                       i,
+                       bw.f*8/1000000 );
+            }
+            break;
+        case SUBTLV_EXT_IS_REACH_TE_METRIC:
+            if (!TTEST2(*tptr,3))
+                goto trunctlv;
+            printf("%sTraffic Engineering Metric: %d",
+                   ident,
+                   EXTRACT_24BITS(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            printf("%sIPv4 interface address: %s",
+                   ident,
+                   ipaddr_string(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
+            if (!TTEST2(*tptr,4))
+                goto trunctlv;
+            printf("%sIPv4 neighbor address: %s",
+                   ident,
+                   ipaddr_string(tptr));
+            break;
+        case SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
+            if (!TTEST2(*tptr,2))
+                goto trunctlv;
+            printf("%sLink Protection Type: %s, Priority %u",
+                   ident,
+                   bittok2str(isis_gmpls_link_prot_values, "none", *tptr),
+                   *(tptr+1));
+            break;
+        case SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
+            printf("%sInterface Switching Capability",ident);
+
+            if (!TTEST2(*tptr,1))
+                goto trunctlv;
+            printf("%s  Interface Switching Capability:%s",
+                   ident,
+                   tok2str(isis_gmpls_sw_cap_values, "Unknown", *(tptr)));
+
+            if (!TTEST2(*(tptr+1),1))
+                goto trunctlv;
+            printf(", LSP Encoding: %s",
+                   tok2str(isis_gmpls_lsp_enc_values, "Unknown", *(tptr+1)));
+
+            if (!TTEST2(*(tptr+2),2)) /* skip 2 res. bytes */
+                goto trunctlv;
+
+            printf("%s  Max LSP Bandwidth:",ident);
+            for (i = 0; i < 8; i++) {
+                if (!TTEST2(*(tptr+(i*4)+4),4))
+                    goto trunctlv;
+                bw.i = EXTRACT_32BITS(tptr);
+                printf("%s    priority level %d: %.3f Mbps",
+                       ident,
+                       i,
+                       bw.f*8/1000000 );
+            }
+            subl-=36;
+            /* there is some optional stuff left to decode but this is as of yet
+               not specified so just lets hexdump what is left */
+            if(subl>0){
+                if(!print_unknown_data(tptr,"\n\t\t    ",
+                                           subl-36))
+                    return(0);
+            }
+            break;
+        case 250:
+        case 251:
+        case 252:
+        case 253:
+        case 254:
+            printf("%sReserved for cisco specific extensions, type %d, length %d",
+                   ident,
+                   subt,
+                   subl);
+            break;
+        case 255:
+            printf("%sReserved for future expansion, type %d, length %d",
+                   ident,
+                   subt,
+                   subl);
+            break;
+        default:
+            printf("%sunknown subTLV, type %d, length %d",
+                   ident,
+                   subt,
+                   subl);
+            if(!print_unknown_data(tptr,"\n\t\t    ",
+                                       subl))
+                return(0);
+            break;
+        }
+        return(1);

 
 trunctlv:
 
 trunctlv:

-    printf("%spacket exceeded snapshot",lf);
-    return(1);
+    printf("%spacket exceeded snapshot",ident);
+    return(0);
+}
+
+
+/*
+ * this is the common IS-REACH decoder it is called
+ * from various EXTD-IS REACH style TLVs (22,24,222)
+ */
+
+static int
+isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv) {
+
+    char ident_buffer[20];
+    int subt,subl,tslen;
+    int proc_bytes = 0; /* how many bytes did we process ? */
+    
+    if (!TTEST2(*tptr, NODE_ID_LEN))
+        return(0);

 
 

+    printf("%sIS Neighbor: %s", ident, isis_print_id(tptr, NODE_ID_LEN));
+    tptr+=(NODE_ID_LEN);
+
+    if (tlv != TLV_IS_ALIAS_ID) {
+        if (!TTEST2(*tptr, 3))
+           return(0);
+       printf(", Metric: %d",EXTRACT_24BITS(tptr));
+       tptr+=3;
+    }
+        
+    if (!TTEST2(*tptr, 1))
+        return(0);
+    tslen=*(tptr++); /* read out subTLV length */
+    proc_bytes=NODE_ID_LEN+3+1;
+    printf(", %ssub-TLVs present",tslen ? "" : "no ");
+    if (tslen) {
+        printf(" (%u)",tslen);
+        while (tslen>0) {
+            if (!TTEST2(*tptr,2))
+                return(0);
+            subt=*(tptr++);
+            subl=*(tptr++);
+            /* prepend the ident string */
+            snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
+            if(!isis_print_is_reach_subtlv(tptr,subt,subl,ident_buffer))
+                return(0);
+            tptr+=subl;
+            tslen-=(subl+2);
+            proc_bytes+=(subl+2);
+        }
+    }
+    return(proc_bytes);

 }
 
 }
 

+/*
+ * this is the common Multi Topology ID decoder
+ * it is called from various MT-TLVs (222,229,235,237)
+ */
+

 static int
 static int

-isis_print_tlv_ip_reach (const u_char *cp, int length)
-{
-       u_int bitmasks[33] = {
-               0x00000000,
-               0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
-               0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
-               0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
-               0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
-               0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
-               0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
-               0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
-               0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
-       };
-       u_int mask;
-       int prefix_len;
-       const struct isis_tlv_ip_reach *tlv_ip_reach;
+isis_print_mtid (const u_int8_t *tptr,const char *ident) {
+    
+    if (!TTEST2(*tptr, 2))
+        return(0);

 
 

-       tlv_ip_reach = (const struct isis_tlv_ip_reach *)cp;
+    printf("%s%s",
+           ident,
+           tok2str(isis_mt_values,
+                   "Reserved for IETF Consensus",
+                   ISIS_MASK_MTID(EXTRACT_16BITS(tptr))));

 
 

-       while (length > 0) {
-               if (length < sizeof(*tlv_ip_reach)) {
-                       printf("short IP reachability (%d vs %lu)", length,
-                           (unsigned long)sizeof(*tlv_ip_reach));
-                       return (0);
-               }
+    printf(" Topology (0x%03x), Flags: [%s]",
+           ISIS_MASK_MTID(EXTRACT_16BITS(tptr)),
+           bittok2str(isis_mt_flag_values, "none",ISIS_MASK_MTFLAGS(EXTRACT_16BITS(tptr))));

 
 

-               if (!TTEST(*tlv_ip_reach))
-                   return (0);
+    return(2);
+}

 
 

-               mask = EXTRACT_32BITS(tlv_ip_reach->mask);
-               prefix_len = 0;
+/*
+ * this is the common extended IP reach decoder
+ * it is called from TLVs (135,235,236,237)
+ * we process the TLV and optional subTLVs and return
+ * the amount of processed bytes
+ */

 
 

-               while (prefix_len <= 33) {
-                       if (bitmasks[prefix_len++] == mask) {
-                               prefix_len--;
-                               break;
-                       }
-               }
+static int
+isis_print_extd_ip_reach (const u_int8_t *tptr, const char *ident, u_int16_t afi) {

 
 

-               /*
-                * 34 indicates no match -> must be a discontiguous netmask
-                * lets dump the mask, otherwise print the prefix_len
-                */
-               if (prefix_len == 34) 
-                       printf("\n\t\t\tIPv4 prefix: %u.%u.%u.%u mask %u.%u.%u.%u",
-                           (tlv_ip_reach->prefix)[0],
-                           (tlv_ip_reach->prefix)[1],
-                           (tlv_ip_reach->prefix)[2],
-                           (tlv_ip_reach->prefix)[3],
-                           (tlv_ip_reach->mask)[0], (tlv_ip_reach->mask)[1],
-                           (tlv_ip_reach->mask)[2], (tlv_ip_reach->mask)[3]);
-               else 
-                       printf("\n\t\t\tIPv4 prefix: %u.%u.%u.%u/%u",
-                           (tlv_ip_reach->prefix)[0],
-                           (tlv_ip_reach->prefix)[1],
-                           (tlv_ip_reach->prefix)[2],
-                           (tlv_ip_reach->prefix)[3], prefix_len);
-
-               printf("\n\t\t\t  Default Metric: %02d, %s, Distribution: %s",
-                   ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_default),
-                   ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_default) ? "External" : "Internal",
-                   ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->metric_default) ? "down" : "up");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_delay))
-                       printf("\n\t\t\t  Delay Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_delay),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_delay) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_expense))
-                       printf("\n\t\t\t  Expense Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_expense),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_expense) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_error))
-                       printf("\n\t\t\t  Error Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_error),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_error) ? "External" : "Internal");
+    char ident_buffer[20];
+    u_int8_t prefix[16]; /* shared copy buffer for IPv4 and IPv6 prefixes */
+    u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;

 
 

-               length -= sizeof(struct isis_tlv_ip_reach);
-               tlv_ip_reach++;
-       }
-       return (1);
+    if (!TTEST2(*tptr, 4))
+        return (0);
+    metric = EXTRACT_32BITS(tptr);
+    processed=4;
+    tptr+=4;
+    
+    if (afi == IPV4) {
+        if (!TTEST2(*tptr, 1)) /* fetch status byte */
+            return (0);
+        status_byte=*(tptr++);
+        bit_length = status_byte&0x3f;
+        processed++;
+#ifdef INET6
+    } else if (afi == IPV6) {
+        if (!TTEST2(*tptr, 1)) /* fetch status & prefix_len byte */
+            return (0);
+        status_byte=*(tptr++);
+        bit_length=*(tptr++);
+        processed+=2;
+#endif
+    } else
+        return (0); /* somebody is fooling us */
+
+    byte_length = (bit_length + 7) / 8; /* prefix has variable length encoding */
+   
+    if (!TTEST2(*tptr, byte_length))
+        return (0);
+    memset(prefix, 0, 16);              /* clear the copy buffer */
+    memcpy(prefix,tptr,byte_length);    /* copy as much as is stored in the TLV */
+    tptr+=byte_length;
+    processed+=byte_length;
+
+    if (afi == IPV4)
+        printf("%sIPv4 prefix: %15s/%u",
+               ident,
+               ipaddr_string(prefix),
+               bit_length);
+#ifdef INET6
+    if (afi == IPV6)
+        printf("%sIPv6 prefix: %s/%u",
+               ident,
+               ip6addr_string(prefix),
+               bit_length);
+#endif 
+   
+    printf(", Distribution: %s, Metric: %u",
+           ISIS_MASK_TLV_EXT_IP_UPDOWN(status_byte) ? "down" : "up",
+           metric);
+
+    if (afi == IPV4 && ISIS_MASK_TLV_EXT_IP_SUBTLV(status_byte))
+        printf(", sub-TLVs present");
+#ifdef INET6
+    if (afi == IPV6)
+        printf(", %s%s",
+               ISIS_MASK_TLV_EXT_IP6_IE(status_byte) ? "External" : "Internal",
+               ISIS_MASK_TLV_EXT_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : "");
+#endif
+    
+    if ((ISIS_MASK_TLV_EXT_IP_SUBTLV(status_byte)  && afi == IPV4) ||
+        (ISIS_MASK_TLV_EXT_IP6_SUBTLV(status_byte) && afi == IPV6)) {
+        /* assume that one prefix can hold more
+           than one subTLV - therefore the first byte must reflect
+           the aggregate bytecount of the subTLVs for this prefix
+        */
+        if (!TTEST2(*tptr, 1))
+            return (0);
+        sublen=*(tptr++);
+        processed+=sublen+1;
+        printf(" (%u)",sublen);   /* print out subTLV length */
+        
+        while (sublen>0) {
+            if (!TTEST2(*tptr,2))
+                return (0);
+            subtlvtype=*(tptr++);
+            subtlvlen=*(tptr++);
+            /* prepend the ident string */
+            snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
+            if(!isis_print_ip_reach_subtlv(tptr,subtlvtype,subtlvlen,ident_buffer))
+                return(0);
+            tptr+=subtlvlen;
+            sublen-=(subtlvlen+2);
+        }
+    }
+    return (processed);

 }
 
 /*
 }
 
 /*


@@ -742,7 +1197,7 @@ isis_print_tlv_ip_reach (const u_char *cp, int length)
  * Decode IS-IS packets.  Return 0 on error.
  */
 
  * Decode IS-IS packets.  Return 0 on error.
  */
 

-static int isis_print (const u_char *p, u_int length)
+static int isis_print (const u_int8_t *p, u_int length)

 {
     const struct isis_common_header *header;
 
 {
     const struct isis_common_header *header;
 


@@ -755,36 +1210,29 @@ static int isis_print (const u_char *p, u_int length)
     const struct isis_tlv_lsp *tlv_lsp;
     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
     const struct isis_tlv_is_reach *tlv_is_reach;
     const struct isis_tlv_lsp *tlv_lsp;
     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
     const struct isis_tlv_is_reach *tlv_is_reach;

+    const struct isis_tlv_es_reach *tlv_es_reach;

 
 

-    u_char pdu_type, max_area, id_length, type, len, tmp, alen, subl, subt, tslen;
-    const u_char *optr, *pptr, *tptr;
+    u_int8_t pdu_type, max_area, id_length, tlv_type, tlv_len, tmp, alen, lan_alen, prefix_len;
+    u_int8_t ext_is_len, ext_ip_len, mt_len;
+    const u_int8_t *optr, *pptr, *tptr;

     u_short packet_len,pdu_len,time_remain;
     u_short packet_len,pdu_len,time_remain;

-    u_int i,j,bit_length,byte_length,metric,ra,rr;
-    u_char prefix[4]; /* copy buffer for ipv4 prefixes */
-#ifdef INET6
-    u_char prefix6[16]; /* copy buffer for ipv6 prefixes */
-#endif
-    u_char off[2];
-    float bw; /* copy buffer for several subTLVs of the extended IS reachability TLV */
+    u_int i,ra,rr;

 
     packet_len=length;
 
     packet_len=length;

-    optr = p; /* initialize the _o_riginal pointer - need it for parsing the checksum TLV */
-    header = (const struct isis_common_header *)p; 
+    optr = p; /* initialize the _o_riginal pointer to the packet start -
+                 need it for parsing the checksum TLV */
+    header = (const struct isis_common_header *)p;

     TCHECK(*header);
     TCHECK(*header);

-    pptr = p+(ISIS_COMMON_HEADER_SIZE);    
+    pptr = p+(ISIS_COMMON_HEADER_SIZE);

     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
     header_lsp = (const struct isis_lsp_header *)pptr;
     header_csnp = (const struct isis_csnp_header *)pptr;
     header_psnp = (const struct isis_psnp_header *)pptr;
     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
     header_lsp = (const struct isis_lsp_header *)pptr;
     header_csnp = (const struct isis_csnp_header *)pptr;
     header_psnp = (const struct isis_psnp_header *)pptr;

-    
+

     /*
      * Sanity checking of the header.
      */
     /*
      * Sanity checking of the header.
      */

-    if (header->nlpid != NLPID_ISIS) {
-       printf(", coding error!");
-       return (0);
-    }

 
     if (header->version != ISIS_VERSION) {
        printf(", version %d packet not supported", header->version);
 
     if (header->version != ISIS_VERSION) {
        printf(", version %d packet not supported", header->version);


@@ -796,9 +1244,9 @@ static int isis_print (const u_char *p, u_int length)
               header->id_length);
        return (0);
     }
               header->id_length);
        return (0);
     }

-    
-    if (header->pkt_version != ISIS_VERSION) {
-       printf(", version %d packet not supported", header->pkt_version);
+
+    if (header->pdu_version != ISIS_VERSION) {
+       printf(", version %d packet not supported", header->pdu_version);

        return (0);
     }
 
        return (0);
     }
 


@@ -819,7 +1267,7 @@ static int isis_print (const u_char *p, u_int length)
     case 0:
         id_length = 6;  /* silly shit again */
        break;
     case 0:
         id_length = 6;  /* silly shit again */
        break;

-    case 1:              /* 1-8 are valid sys-ID lenghts */               
+    case 1:              /* 1-8 are valid sys-ID lenghts */

     case 2:
     case 3:
     case 4:
     case 2:
     case 3:
     case 4:


@@ -832,24 +1280,51 @@ static int isis_print (const u_char *p, u_int length)
         id_length = 0;   /* entirely useless */
        break;
     default:
         id_length = 0;   /* entirely useless */
        break;
     default:

-       printf(", bad packet -- illegal sys-ID length (%u)", id_length);      
+        break;
+    }
+
+    /* toss any non 6-byte sys-ID len PDUs */
+    if (id_length != 6 ) { 
+       printf(", bad packet -- illegal sys-ID length (%u)", id_length);

        return (0);
        return (0);

-       break;

     }
 
     }
 

-    printf(", hlen: %u, v: %u, sys-id-len: %u (%u), max-area: %u (%u)",
+    pdu_type=header->pdu_type;
+
+    /* in non-verbose mode just lets print the basic PDU Type*/
+    if (vflag < 1) {
+        printf("IS-IS, %s, length: %u",
+               tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type),
+               length);
+        return(1);
+    }
+
+    /* ok they seem to want to know everything - lets fully decode it */
+    printf("IS-IS, length: %u",length);
+
+    printf("\n\thlen: %u, v: %u, pdu-v: %u, sys-id-len: %u (%u), max-area: %u (%u)",

            header->fixed_len,
            header->version,
            header->fixed_len,
            header->version,

+           header->pdu_version,

           id_length,
           header->id_length,
            max_area,
            header->max_area);
           id_length,
           header->id_length,
            max_area,
            header->max_area);

-           
-    pdu_type=header->pdu_type;
-     
+
+    /* first lets see if we know the PDU name*/
+    printf(", pdu-type: %s",
+           tok2str(isis_pdu_values,
+                   "unknown, type %u",
+                   pdu_type));
+
+    if (vflag > 1) {
+        if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
+            return(0);                         /* for optionally debugging the common header */
+    }
+

     switch (pdu_type) {
 
     switch (pdu_type) {
 

-    case L1_LAN_IIH:    
+    case L1_LAN_IIH:

     case L2_LAN_IIH:
        if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
            printf(", bogus fixed header length %u should be %lu",
     case L2_LAN_IIH:
        if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
            printf(", bogus fixed header length %u should be %lu",


@@ -859,39 +1334,27 @@ static int isis_print (const u_char *p, u_int length)
 
        pdu_len=EXTRACT_16BITS(header_iih_lan->pdu_len);
        if (packet_len>pdu_len) {
 
        pdu_len=EXTRACT_16BITS(header_iih_lan->pdu_len);
        if (packet_len>pdu_len) {

-         packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
-         length=pdu_len;
+            packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
+            length=pdu_len;

        }
 
        }
 

-       printf(", L%s Lan IIH (%u)",
-              ISIS_MASK_LEVEL_BITS(pdu_type) ? "1" : "2",
-              pdu_len);
- 

        TCHECK(*header_iih_lan);
        TCHECK(*header_iih_lan);

-       printf("\n\t\t  source-id: ");
-       isis_print_sysid(header_iih_lan->source_id);
-       printf(", holding time: %us",EXTRACT_16BITS(header_iih_lan->holding_time));
-       switch(header_iih_lan->circuit_type) {
-
-       case 1:
-           printf(", Level 1 only");
-           break;
-
-       case 2:
-           printf(", Level 2 only");
-           break;
-
-       case 3:
-           printf(", Level 1, Level 2");
-           break; 
-
-       default:
-           printf(", unknown 0x%02x", header_iih_lan->circuit_type);     
-           break;
-       }
-       printf("\n\t\t  lan-id:    ");
-       isis_print_nodeid(header_iih_lan->lan_id);
-       printf(", Priority: %u",(header_iih_lan->priority) & PRIORITY_MASK);            
+       printf("\n\t  source-id: %s,  holding time: %us, Flags: [%s]",
+               isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN),
+               EXTRACT_16BITS(header_iih_lan->holding_time),
+               tok2str(isis_iih_circuit_type_values,
+                       "unknown circuit type 0x%02x",
+                       header_iih_lan->circuit_type));
+
+       printf("\n\t  lan-id:    %s, Priority: %u, PDU length: %u",
+               isis_print_id(header_iih_lan->lan_id, NODE_ID_LEN),
+               (header_iih_lan->priority) & PRIORITY_MASK,
+               pdu_len);
+
+        if (vflag > 1) {
+            if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_LAN_HEADER_SIZE))
+                return(0);
+        }

 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);


@@ -903,37 +1366,27 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
            return (0);
        }

-       
+

        pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
        if (packet_len>pdu_len) {
        pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
        if (packet_len>pdu_len) {

-         packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
-         length=pdu_len;
+            packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
+            length=pdu_len;

        }
        }

-       
-       printf(", PTP IIH (%u)",pdu_len);
-       TCHECK(*header_iih_ptp);
-       printf("\n\t\t  source-id: ");
-       isis_print_sysid(header_iih_ptp->source_id);
-       printf(", holding time: %us",EXTRACT_16BITS(header_iih_ptp->holding_time));
-       printf(", circuit-id: 0x%02x", header_iih_ptp->circuit_id);
-       switch(header_iih_ptp->circuit_type) {
-
-       case 1:
-           printf(", Level 1 only");
-           break;
-
-       case 2:
-           printf(", Level 2 only");
-           break;
-
-       case 3:
-           printf(", Level 1, Level 2");
-           break; 

 
 

-       default:
-           printf(", unknown 0x%02x", header_iih_ptp->circuit_type);     
-           break;
-       }
+       TCHECK(*header_iih_ptp);
+       printf("\n\t  source-id: %s, holding time: %us, circuit-id: 0x%02x, %s, PDU length: %u",
+               isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN),
+               EXTRACT_16BITS(header_iih_ptp->holding_time),
+               header_iih_ptp->circuit_id,
+               tok2str(isis_iih_circuit_type_values,
+                       "unknown circuit type 0x%02x",
+                       header_iih_ptp->circuit_type),
+               pdu_len);
+
+        if (vflag > 1) {
+            if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_PTP_HEADER_SIZE))
+                return(0);
+        }

 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);


@@ -946,25 +1399,26 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
            return (0);
        }

-       
+

        pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
        if (packet_len>pdu_len) {
        pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
        if (packet_len>pdu_len) {

-         packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
-         length=pdu_len;
+            packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
+            length=pdu_len;

        }
 
        }
 

-       if (pdu_type == L1_LSP) 
-           printf(", L1 LSP (%u)",pdu_len);
-       else if (pdu_type == L2_LSP)    
-           printf(", L2 LSP (%u)",pdu_len);   
-

        TCHECK(*header_lsp);
        TCHECK(*header_lsp);

-       printf("\n\t\t  lsp-id: ");
-       isis_print_lspid(header_lsp->lsp_id);
-       printf(", sequence number: 0x%08x",EXTRACT_32BITS(header_lsp->sequence_number));
-       printf(", lifetime: %5us",EXTRACT_16BITS(header_lsp->remaining_lifetime));
-       printf("\n\t\t  checksum: 0x%04x",EXTRACT_16BITS(header_lsp->checksum));
-             
+       printf("\n\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us",
+               isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
+               EXTRACT_32BITS(header_lsp->sequence_number),
+               EXTRACT_16BITS(header_lsp->remaining_lifetime));
+        /* verify the checksum -
+         * checking starts at the lsp-id field
+         * which is 12 bytes after the packet start*/
+       printf("\n\t  chksum: 0x%04x (%s), PDU length: %u",
+               EXTRACT_16BITS(header_lsp->checksum),
+               (osi_cksum(optr+12, length-12)) ? "incorrect" : "correct",
+               pdu_len);
+

        printf(", %s", ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
 
        if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
        printf(", %s", ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
 
        if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {


@@ -977,6 +1431,11 @@ static int isis_print (const u_char *p, u_int length)
        printf("%s", ISIS_MASK_LSP_PARTITION_BIT(header_lsp->typeblock) ? "P bit set, " : "");
        printf("%s", tok2str(isis_lsp_istype_values,"Unknown(0x%x)",ISIS_MASK_LSP_ISTYPE_BITS(header_lsp->typeblock)));
 
        printf("%s", ISIS_MASK_LSP_PARTITION_BIT(header_lsp->typeblock) ? "P bit set, " : "");
        printf("%s", tok2str(isis_lsp_istype_values,"Unknown(0x%x)",ISIS_MASK_LSP_ISTYPE_BITS(header_lsp->typeblock)));
 

+        if (vflag > 1) {
+            if(!print_unknown_data(pptr,"\n\t  ",ISIS_LSP_HEADER_SIZE))
+                return(0);
+        }
+

        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
        break;
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
        break;


@@ -988,21 +1447,26 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
            return (0);
        }

-       
+

        pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
        if (packet_len>pdu_len) {
        pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
        if (packet_len>pdu_len) {

-         packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
-         length=pdu_len;
+            packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
+            length=pdu_len;

        }
 
        }
 

-       printf(", L%s CSNP (%u)", ISIS_MASK_LEVEL_BITS(pdu_type) ? "2" : "1", pdu_len);

        TCHECK(*header_csnp);
        TCHECK(*header_csnp);

-       printf("\n\t\t  source-id:    ");
-       isis_print_nodeid(header_csnp->source_id);              
-       printf("\n\t\t  start lsp-id: ");
-       isis_print_lspid(header_csnp->start_lsp_id);    
-       printf("\n\t\t  end lsp-id:   ");
-       isis_print_lspid(header_csnp->end_lsp_id);
+       printf("\n\t  source-id:    %s, PDU length: %u",
+               isis_print_id(header_csnp->source_id, NODE_ID_LEN),
+               pdu_len);
+       printf("\n\t  start lsp-id: %s",
+               isis_print_id(header_csnp->start_lsp_id, LSP_ID_LEN));
+       printf("\n\t  end lsp-id:   %s",
+               isis_print_id(header_csnp->end_lsp_id, LSP_ID_LEN));
+
+        if (vflag > 1) {
+            if(!print_unknown_data(pptr,"\n\t  ",ISIS_CSNP_HEADER_SIZE))
+                return(0);
+        }

 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);


@@ -1018,664 +1482,396 @@ static int isis_print (const u_char *p, u_int length)
 
        pdu_len=EXTRACT_16BITS(header_psnp->pdu_len);
        if (packet_len>pdu_len) {
 
        pdu_len=EXTRACT_16BITS(header_psnp->pdu_len);
        if (packet_len>pdu_len) {

-         packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
-         length=pdu_len;
+            packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
+            length=pdu_len;

        }
 
        }
 

-       printf(", L%s PSNP (%u)", ISIS_MASK_LEVEL_BITS(pdu_type) ? "2" : "1", pdu_len);

        TCHECK(*header_psnp);
        TCHECK(*header_psnp);

-       printf("\n\t\t  source-id:    ");
-       isis_print_nodeid(header_psnp->source_id); 
- 
+       printf("\n\t  source-id:    %s",
+               isis_print_id(header_psnp->source_id, NODE_ID_LEN));
+
+        if (vflag > 1) {
+            if(!print_unknown_data(pptr,"\n\t  ",ISIS_PSNP_HEADER_SIZE))
+                return(0);
+        }
+

        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        break;
 
     default:
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        break;
 
     default:

-       printf(", PDU type (0x%02x) not supported", pdu_type);
-       if(isis_print_unknown_data(pptr,"\n\t\t  ",length))
-           return(1);  
-       return (1);
+       if(!print_unknown_data(pptr,"\n\t  ",length))
+           return(0);
+       return (0);

     }
 
     /*
      * Now print the TLV's.
      */
     }
 
     /*
      * Now print the TLV's.
      */

-    
+

     while (packet_len >= 2) {
         if (pptr == snapend) {
            return (1);
         }
 
        if (!TTEST2(*pptr, 2)) {
     while (packet_len >= 2) {
         if (pptr == snapend) {
            return (1);
         }
 
        if (!TTEST2(*pptr, 2)) {

-           printf("\n\t\t\t packet exceeded snapshot (%ld) bytes",
-                 (long)(pptr-snapend));
+           printf("\n\t\t packet exceeded snapshot (%ld) bytes",
+                   (long)(pptr-snapend));

            return (1);
        }
            return (1);
        }

-       type = *pptr++;
-       len = *pptr++;
+       tlv_type = *pptr++;
+       tlv_len = *pptr++;
+        tmp =tlv_len; /* copy temporary len & pointer to packet data */
+        tptr = pptr;

        packet_len -= 2;
        packet_len -= 2;

-       if (len > packet_len) {
+       if (tlv_len > packet_len) {

            break;
        }
            break;
        }

-       printf("\n\t\t    ");

 
 

-       switch (type) {
+        /* first lets see if we know the TLVs name*/
+       printf("\n\t    %s TLV #%u, length: %u",
+               tok2str(isis_tlv_values,
+                       "unknown",
+                       tlv_type),
+               tlv_type,
+               tlv_len);
+
+        /* now check if we have a decoder otherwise do a hexdump at the end*/
+       switch (tlv_type) {

        case TLV_AREA_ADDR:
        case TLV_AREA_ADDR:

-           printf("Area address(es) (%u)",len);
-           tmp = len;
-           tptr = pptr;

            if (!TTEST2(*tptr, 1))
                goto trunctlv;
            alen = *tptr++;
            while (tmp && alen < tmp) {
            if (!TTEST2(*tptr, 1))
                goto trunctlv;
            alen = *tptr++;
            while (tmp && alen < tmp) {

-               printf("\n\t\t\tArea address (%u): ",alen);
-               if (!print_nsap(tptr, alen))
-                   return (1);
+               printf("\n\t      Area address (length: %u): %s",
+                       alen,
+                       print_nsap(tptr, alen));

                tptr += alen;
                tmp -= alen + 1;
                if (tmp==0) /* if this is the last area address do not attemt a boundary check */
                tptr += alen;
                tmp -= alen + 1;
                if (tmp==0) /* if this is the last area address do not attemt a boundary check */

-                 break;
+                    break;

                if (!TTEST2(*tptr, 1))
                    goto trunctlv;
                alen = *tptr++;
            }
            break;
        case TLV_ISNEIGH:
                if (!TTEST2(*tptr, 1))
                    goto trunctlv;
                alen = *tptr++;
            }
            break;
        case TLV_ISNEIGH:

-           printf("IS Neighbor(s) (%u)",len);
-           tmp = len;
-           tptr = pptr;

            while (tmp >= ETHER_ADDR_LEN) {
            while (tmp >= ETHER_ADDR_LEN) {

-               printf("\n\t\t\tIS Neighbor: ");
-               if (!isis_print_sysid(tptr))
-                   return (1);
-               tmp -= ETHER_ADDR_LEN;
-               tptr += ETHER_ADDR_LEN;
+                if (!TTEST2(*tptr, ETHER_ADDR_LEN))
+                    goto trunctlv;
+                printf("\n\t      IS Neighbor: %s",isis_print_id(tptr,ETHER_ADDR_LEN));
+                tmp -= ETHER_ADDR_LEN;
+                tptr += ETHER_ADDR_LEN;

            }
            break;
 
            }
            break;
 

+        case TLV_ISNEIGH_VARLEN:
+            if (!TTEST2(*tptr, 1))
+               goto trunctlv;
+           lan_alen = *tptr++; /* LAN adress length */
+            tmp --;
+            printf("\n\t      LAN address length %u bytes ",lan_alen);
+           while (tmp >= lan_alen) {
+                if (!TTEST2(*tptr, lan_alen))
+                    goto trunctlv;
+                printf("\n\t\tIS Neighbor: %s",isis_print_id(tptr,lan_alen));
+                tmp -= lan_alen;
+                tptr +=lan_alen;
+            }
+            break;
+

        case TLV_PADDING:
        case TLV_PADDING:

-           printf("Padding (%u)", len);

            break;
 
         case TLV_MT_IS_REACH:
            break;
 
         case TLV_MT_IS_REACH:

-            printf("Multi Topology IS Reachability (%u)",len);
-            tptr=pptr;
-            tmp=len;
-            while (tmp>0) {
-                printf("\n\t\t\t");
-                if (!TTEST2(*tptr, 2))
-                   goto trunctlv;
-               switch(EXTRACT_16BITS(tptr)&0x0fff) {
-
-               case 0:
-                       printf("IPv4 unicast");
-                       break;
-
-               case 1:
-                       printf("In-Band Management");
-                       break;
-
-               case 2:
-                       printf("IPv6 unicast");
-                       break;
-
-               case 3:
-                       printf("Multicast");
-                       break;
-
-               case 4095:
-                       printf("Development, Experimental or Proprietary");
-                       break;
-
-               default:
-                       printf("Reserved for IETF Consensus");
-                       break;
-               }
-               printf(" Topology (0x%03x)",EXTRACT_16BITS(tptr)&0x0fff);
-                tptr+=2;
-               printf("\n\t\t\t  IS Neighbor: ");
-                if (!isis_print_nodeid(tptr))
-                    return (1);
-                tptr+=(SYSTEM_ID_LEN+1);
-                if (!TTEST2(*tptr, 3))
+            while (tmp >= 2+NODE_ID_LEN+3+1) {
+                mt_len = isis_print_mtid(tptr, "\n\t      ");
+                if (mt_len == 0) /* did something go wrong ? */

                     goto trunctlv;
                     goto trunctlv;

-                printf(", Metric: %d",EXTRACT_24BITS(tptr));
-                tptr+=3;
-                if (!TTEST2(*tptr, 1))
+                tptr+=mt_len;
+                tmp-=mt_len;
+
+                ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
+                if (ext_is_len == 0) /* did something go wrong ? */

                     goto trunctlv;
                     goto trunctlv;

-                tslen=*(tptr++);
-                printf(", %ssub-TLVs present",tslen ? "" : "no ");
-               /* so far no decoding of subTLVs is supported
-                * so lets print out a hexdump of the unknown subTLV data
-                */
-               if(!tslen){
-                    if(isis_print_unknown_data(tptr,"\n\t\t\t    ",tslen))
-                         return(1);
-               }
-                tptr+=tslen;
-                tmp-=(13+tslen);
+                   
+                tmp-=ext_is_len;
+                tptr+=ext_is_len;

             }
             break;
 
             }
             break;
 

+        case TLV_IS_ALIAS_ID:
+           while (tmp >= NODE_ID_LEN+1) { /* is it worth attempting a decode ? */
+               ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
+               if (ext_is_len == 0) /* did something go wrong ? */
+                   goto trunctlv;
+               tmp-=ext_is_len;
+               tptr+=ext_is_len;
+           }
+           break;
+

         case TLV_EXT_IS_REACH:
         case TLV_EXT_IS_REACH:

-            printf("Extended IS Reachability (%u)",len);
-            tptr=pptr;
-            tmp=len;
-            while (tmp>0) {
-                if (!TTEST2(*tptr, 7))
-                    goto trunctlv;
-               printf("\n\t\t\tIS Neighbor: ");
-                if (!isis_print_nodeid(tptr))
-                    return (1);
-                tptr+=(SYSTEM_ID_LEN+1);
-                if (!TTEST2(*tptr, 3))
-                    goto trunctlv;
-                printf(", Metric: %d",EXTRACT_24BITS(tptr));
-                tptr+=3;
-                if (!TTEST2(*tptr, 1))
-                    goto trunctlv;
-                tslen=*(tptr++);
-                printf(", %ssub-TLVs present",tslen ? "" : "no ");
-                if (tslen) {
-                    printf(" (%u)",tslen);                    
-                    while (tslen>0) {
-                        if (!TTEST2(*tptr,2))
-                            goto trunctlv;
-                        printf("\n\t\t\t  ");
-                       subt=*(tptr++);
-                       subl=*(tptr++);
-                        switch(subt) {
-                        case SUBTLV_EXT_IS_REACH_ADMIN_GROUP:
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                            printf("Administrative groups: 0x%08x", EXTRACT_32BITS(tptr));
-                            break;
-                       case SUBTLV_EXT_IS_REACH_LINK_LOCAL_ID:
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                           printf("Link Local Identifier: 0x%08x", EXTRACT_32BITS(tptr));
-                           break;
-                       case SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                           printf("Link Remote Identifier: 0x%08x", EXTRACT_32BITS(tptr));
-                           break;
-                        case SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                            j = EXTRACT_32BITS(tptr);
-                            memcpy (&bw, &j, 4);            
-                            printf("Maximum link bandwidth : %.3f Mbps",
-                                   bw*8/1000000 );
-                            break;                            
-                        case SUBTLV_EXT_IS_REACH_RESERVABLE_BW :
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                            j = EXTRACT_32BITS(tptr);
-                            memcpy (&bw, &j, 4); 
-                            printf("Reservable link bandwidth: %.3f Mbps",
-                                   bw*8/1000000  );
-                            break;
-                        case SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
-                            printf("Unreserved bandwidth:");
-                            for (i = 0; i < 8; i++) {
-                                if (!TTEST2(*(tptr+i*4),4))
-                                    goto trunctlv;
-                                j = EXTRACT_32BITS(tptr);
-                                memcpy (&bw, &j, 4);   
-                                printf("\n\t\t\t    priority level %d: %.3f Mbps",
-                                       i, bw*8/1000000 );
-                            }
-                            break;      
-                        case SUBTLV_EXT_IS_REACH_TE_METRIC:
-                            if (!TTEST2(*tptr,3))
-                                goto trunctlv;
-                            printf("Traffic Engineering Metric: %d", EXTRACT_24BITS(tptr));
-                            break;                            
-                        case SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                            printf("IPv4 interface address: %s", ipaddr_string(tptr));
-                            break;     
-                        case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
-                            if (!TTEST2(*tptr,4))
-                                goto trunctlv;
-                            printf("IPv4 neighbor address: %s", ipaddr_string(tptr));
-                            break;
-                        case SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
-                            if (!TTEST2(*tptr,2))
-                                goto trunctlv;
-                           i = 0;
-                            j = (ISIS_8BIT_MASK(*tptr)); /* fetch the typecode and make sure
-                                                           that no high-order LSBs are set */
-                            printf("Link Protection Type: %s",(j) ? "" : "none" );
-                           /* scan through the bits until the typecode is zero */
-                           while(!j) {
-                               printf("%s", isis_gmpls_link_prot_values[i]);
-                               j=j>>1;
-                               if (j) /*any other bit set ?*/
-                                   printf(", ");
-                               i++;
-                           }
-                           printf(", Priority %u", *(tptr+1));
-                            break;
-                       case SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
-                           printf("Interface Switching Capability");
-
-                           if (!TTEST2(*tptr,1))
-                             goto trunctlv;
-                           printf("\n\t\t\t  Interface Switching Capability:%s",
-                                  tok2str(isis_gmpls_sw_cap_values, "Unknown", *(tptr)));
-
-                           if (!TTEST2(*(tptr+1),1))
-                             goto trunctlv;
-                           printf(", LSP Encoding: %s",
-                                  tok2str(isis_gmpls_lsp_enc_values, "Unknown", *(tptr+1)));
-
-                           if (!TTEST2(*(tptr+2),2)) /* skip 2 res. bytes */
-                             goto trunctlv;
-
-                           printf("\n\t\t\t  Max LSP Bandwidth:");
-                           for (i = 0; i < 8; i++) {
-                             if (!TTEST2(*(tptr+(i*4)+4),4))
-                               goto trunctlv;
-                             j = EXTRACT_32BITS(tptr);
-                             memcpy (&bw, &j, 4);      
-                             printf("\n\t\t\t    priority level %d: %.3f Mbps",
-                                    i, bw*8/1000000 );
-                            }
-                           /* there is some optional stuff left to decode but this is as of yet
-                              not specified so just lets hexdump what is left */
-                           if(!subl){
-                             if(isis_print_unknown_data(tptr,"\n\t\t\t    ",subl-36))
-                                 return(1);
-                           }
-                           break;
-                        case 250:
-                        case 251:
-                        case 252:
-                        case 253:
-                        case 254:
-                             printf("Reserved for cisco specific extensions, type %d, length %d", subt, subl);
-                             break;
-                        case 255:
-                             printf("Reserved for future expansion, type %d, length %d", subt, subl);
-                             break;                                 
-                        default:
-                            printf("unknown subTLV, type %d, length %d", subt, subl);
-                           if(isis_print_unknown_data(tptr,"\n\t\t\t    ",subl))
-                               return(1);
-                           break;
-                        }      
-                   tptr+=subl;
-                   tslen-=(subl+2);
-                    }
-                }      
-                tmp-=(11+tslen);
+            while (tmp >= NODE_ID_LEN+3+1) { /* is it worth attempting a decode ? */
+                ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
+                if (ext_is_len == 0) /* did something go wrong ? */
+                    goto trunctlv;                   
+                tmp-=ext_is_len;
+                tptr+=ext_is_len;

             }
             break;
         case TLV_IS_REACH:
             }
             break;
         case TLV_IS_REACH:

-            printf("IS Reachability (%u)",len);
-
-           tptr=pptr;
-

            if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
            if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */

-                goto trunctlv;
-
-           switch (*tptr) {
-           case 0:
-             printf("\n\t\t\tIsNotVirtual");
-             break;
-           case 1:
-             printf("\n\t\t\tIsVirtual");
-             break;
-           default:
-             printf("\n\t\t\tbogus virtual flag 0x%02x",(*tptr));
-             break;     
-           }
-
-           tptr++;
-
+                goto trunctlv;
+            printf("\n\t      %s",
+                   tok2str(isis_is_reach_virtual_values,
+                           "bogus virtual flag 0x%02x",
+                           *tptr++));

            tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;
            tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;

-
-           tmp = len;

             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
                if (!TTEST(*tlv_is_reach))
                    goto trunctlv;
             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
                if (!TTEST(*tlv_is_reach))
                    goto trunctlv;

-
-               printf("\n\t\t\tIS Neighbor: ");
-               isis_print_nodeid(tlv_is_reach->neighbor_nodeid);
-
-               printf(", Default Metric: %d, %s",
-                          ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_default),
-                          ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_default) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_delay))
-                   printf("\n\t\t\t  Delay Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_delay),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_delay) ? "External" : "Internal");
-               
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_expense))
-                   printf("\n\t\t\t  Expense Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_expense),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_expense) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_error))
-                   printf("\n\t\t\t  Error Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_error),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_error) ? "External" : "Internal");
-
+               printf("\n\t      IS Neighbor: %s",
+                      isis_print_id(tlv_is_reach->neighbor_nodeid, NODE_ID_LEN));
+                isis_print_metric_block(&tlv_is_reach->isis_metric_block);

                tmp -= sizeof(struct isis_tlv_is_reach);
                tlv_is_reach++;
            }
             break;
 
                tmp -= sizeof(struct isis_tlv_is_reach);
                tlv_is_reach++;
            }
             break;
 

-       case TLV_IP_REACH:
-           printf("IP Internal reachability (%u)",len); 
-           if (!isis_print_tlv_ip_reach(pptr, len))
-               return (1);
-           break;
+        case TLV_ESNEIGH:
+           tlv_es_reach = (const struct isis_tlv_es_reach *)tptr;
+            while (tmp >= sizeof(struct isis_tlv_es_reach)) {
+               if (!TTEST(*tlv_es_reach))
+                   goto trunctlv;
+               printf("\n\t      ES Neighbor: %s",
+                       isis_print_id(tlv_es_reach->neighbor_sysid,SYSTEM_ID_LEN));
+                isis_print_metric_block(&tlv_es_reach->isis_metric_block);
+               tmp -= sizeof(struct isis_tlv_es_reach);
+               tlv_es_reach++;
+           }
+            break;

 
 

+            /* those two TLVs share the same format */
+       case TLV_IP_REACH:

        case TLV_IP_REACH_EXT:
        case TLV_IP_REACH_EXT:

-           printf("IP External reachability (%u)",len);
-           if (!isis_print_tlv_ip_reach(pptr, len))
+           if (!isis_print_tlv_ip_reach(pptr, "\n\t      ", tlv_len))

                return (1);
            break;
 
        case TLV_EXT_IP_REACH:
                return (1);
            break;
 
        case TLV_EXT_IP_REACH:

-           printf("Extended IP reachability (%u)",len);
-           i=len;
-           tptr=pptr;
-               
-           while (i>0) {
-               memset (prefix, 0, 4);
-               if (!TTEST2(*tptr, 4))
-                   return (1);
-               metric = EXTRACT_32BITS(tptr);
-               tptr+=4;
+           while (tmp>0) {
+                ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV4);
+                if (ext_ip_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=ext_ip_len;
+               tmp-=ext_ip_len;
+           }
+           break;

 
 

-               if (!TTEST2(*tptr, 1))
-                   return (1);
-               j=*(tptr);
-               bit_length = (*(tptr)++&0x3f);
-               byte_length = (bit_length + 7) / 8;
-               if (!TTEST2(*tptr, byte_length))
-                   return (1);
-
-               memcpy(prefix,tptr,byte_length);
-
-               printf("\n\t\t\tIPv4 prefix: %u.%u.%u.%u/%d", 
-                      prefix[0],
-                      prefix[1],
-                      prefix[2],
-                      prefix[3],
-                      bit_length);
-
-               printf("\n\t\t\t  Metric: %u, Distribution: %s",
-                      metric,
-                      ISIS_MASK_TLV_EXT_IP_UPDOWN(j) ? "down" : "up");
-
-               printf(", %ssub-TLVs present",
-                      ISIS_MASK_TLV_EXT_IP_SUBTLV(j) ? "" : "no ");
-
-               if (ISIS_MASK_TLV_EXT_IP_SUBTLV(j)) {
-                   if (!TTEST2(*tptr, 1))
-                     return (1);                 
-                   printf(" (%u)",*tptr);   /* print out subTLV length */          
-
-                   /* so far no decoding of subTLVs is supported
-                     * so lets print out a hexdump of the unknown subTLV data
-                    */
-                   if(isis_print_unknown_data(tptr,"\n\t\t\t    ",*tptr))
-                     return(1);
-
-                   i-=*tptr;
-                   tptr = tptr + *tptr;
-                   tptr++;
-               }
+        case TLV_MT_IP_REACH:
+           while (tmp>0) {
+                mt_len = isis_print_mtid(tptr, "\n\t      ");
+                if (mt_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=mt_len;
+                tmp-=mt_len;

 
 

-               i-=(5+byte_length);
-               tptr+=byte_length;
+                ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV4);
+                if (ext_ip_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=ext_ip_len;
+               tmp-=ext_ip_len;

            }
            break;
 
 #ifdef INET6
            }
            break;
 
 #ifdef INET6

-

        case TLV_IP6_REACH:
        case TLV_IP6_REACH:

-           printf("IP6 reachability (%u)",len);
-           i=len;
-           tptr=pptr;
-               
-           while (i>0) {
-               if (!TTEST2(*tptr, 4))
-                   return (1);
-               metric = EXTRACT_32BITS(tptr);
-               tptr+=4;
-
-               if (!TTEST2(*tptr, 2))
-                   return (1);
-               j=*(tptr++);
-               bit_length = (*(tptr)++);
-               byte_length = (bit_length + 7) / 8;
-               if (!TTEST2(*tptr, byte_length))
-                   return (1);
-
-               memset(prefix6, 0, 16);
-               memcpy(prefix6,tptr,byte_length);
-
-               printf("\n\t\t\tIPv6 prefix: %s/%u",
-                      ip6addr_string(prefix6),
-                      bit_length);
-
-               printf("\n\t\t\t  Metric: %u, %s, Distribution: %s, %ssub-TLVs present",
-                   metric,
-                   ISIS_MASK_TLV_IP6_IE(j) ? "External" : "Internal",
-                   ISIS_MASK_TLV_IP6_UPDOWN(j) ? "down" : "up",
-                   ISIS_MASK_TLV_IP6_SUBTLV(j) ? "" : "no ");
-
-               if (ISIS_MASK_TLV_IP6_SUBTLV(j)) {
-                   if (!TTEST2(*tptr, 1))
-                     return (1);                 
-                   printf(" (%u)",*tptr);   /* print out subTLV length */          
-
-                   /* so far no decoding of subTLVs is supported
-                     * so lets print out a hexdump of the unknown subTLV data
-                    */
-                   if(isis_print_unknown_tlv(tptr,"\n\t\t\t    ",*tptr))
-                     return(1);
-
-                   i-=*tptr;
-                   tptr = tptr + *tptr;
-                   tptr++;
-               }
-
-               i-=(6+byte_length);
-                tptr+=byte_length;
+           while (tmp>0) {
+                ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV6);
+                if (ext_ip_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=ext_ip_len;
+               tmp-=ext_ip_len;

            }
            }

+           break;

 
 

+       case TLV_MT_IP6_REACH:
+           while (tmp>0) {
+                mt_len = isis_print_mtid(tptr, "\n\t      ");
+                if (mt_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=mt_len;
+                tmp-=mt_len;
+
+                ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV6);
+                if (ext_ip_len == 0) /* did something go wrong ? */
+                    goto trunctlv;
+                tptr+=ext_ip_len;
+               tmp-=ext_ip_len;
+           }

            break;
            break;

-#endif

 
 

-#ifdef INET6

        case TLV_IP6ADDR:
        case TLV_IP6ADDR:

-           printf("IPv6 Interface address(es) (%u)",len); 
-           i=len;
-           tptr=pptr;
-           while (i>0) {
+           while (tmp>0) {

                if (!TTEST2(*tptr, 16))
                    goto trunctlv;
 
                if (!TTEST2(*tptr, 16))
                    goto trunctlv;
 

-                printf("\n\t\t\tIPv6 interface address: %s",
+                printf("\n\t      IPv6 interface address: %s",

                       ip6addr_string(tptr));
 
                tptr += 16;
                       ip6addr_string(tptr));
 
                tptr += 16;

-               i -= 16;
+               tmp -= 16;

            }
            break;
 #endif
        case TLV_AUTH:
            }
            break;
 #endif
        case TLV_AUTH:

-           if (!TTEST2(*pptr, 1))
+           if (!TTEST2(*tptr, 1))

                goto trunctlv;
 
                goto trunctlv;
 

-           printf("Authentication (%u)",len);
-           switch (*pptr) {
+            printf("\n\t      %s: ",
+                   tok2str(isis_subtlv_auth_values,
+                           "unknown Authentication type 0x%02x",
+                           *tptr));
+
+           switch (*tptr) {

            case SUBTLV_AUTH_SIMPLE:
            case SUBTLV_AUTH_SIMPLE:

-               printf("\n\t\t\tsimple text password: ");
-               for(i=1;i<len;i++) {
-                   if (!TTEST2(*(pptr+i), 1))
+               for(i=1;i<tlv_len;i++) {
+                   if (!TTEST2(*(tptr+i), 1))

                        goto trunctlv;
                        goto trunctlv;

-                   printf("%c",*(pptr+i));
+                   printf("%c",*(tptr+i));

                }
                break;
            case SUBTLV_AUTH_MD5:
                }
                break;
            case SUBTLV_AUTH_MD5:

-               printf("\n\t\t\tHMAC-MD5 password: ");
-               for(i=1;i<len;i++) {
-                   if (!TTEST2(*(pptr+i), 1))
+               for(i=1;i<tlv_len;i++) {
+                   if (!TTEST2(*(tptr+i), 1))

                        goto trunctlv;
                        goto trunctlv;

-                   printf("%02x",*(pptr+i));
+                   printf("%02x",*(tptr+i));

                }
                }

-               if (len != SUBTLV_AUTH_MD5_LEN+1)
-                 printf(", (malformed subTLV) ");
+               if (tlv_len != SUBTLV_AUTH_MD5_LEN+1)
+                    printf(", (malformed subTLV) ");

                break;
            case SUBTLV_AUTH_PRIVATE:
                break;
            case SUBTLV_AUTH_PRIVATE:

-               printf("\n\t\t\tRouting Domain private password: ");
-               if(isis_print_unknown_data(pptr+1,"\n\t\t\t    ",len-1))
-                   return(1);  
-               break;

            default:
            default:

-               printf("\n\t\t\tunknown Authentication method");
-               if(isis_print_unknown_data(pptr+1,"\n\t\t\t    ",len-1))
-                   return(1);  
+               if(!print_unknown_data(tptr+1,"\n\t\t  ",tlv_len-1))
+                   return(0);

                break;
            }
            break;
 
        case TLV_PTP_ADJ:
                break;
            }
            break;
 
        case TLV_PTP_ADJ:

-           printf("Point-to-point Adjacency State (%u)",len);
-           tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)pptr;
-           i=len;
-           if(i>=1) {
-               if (!TTEST2(*pptr, 1))
+           tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)tptr;
+           if(tmp>=1) {
+               if (!TTEST2(*tptr, 1))

                    goto trunctlv;
                    goto trunctlv;

-               printf("\n\t\t\tAdjacency State: %s",
-                      tok2str(isis_ptp_adjancey_values, "#0x%x", *pptr));
-               i--;
+               printf("\n\t      Adjacency State: %s",
+                      tok2str(isis_ptp_adjancey_values, "0x%02x", *tptr));
+               tmp--;

            }
            }

-           if(i>=4) {
-               if (!TTEST2(tlv_ptp_adj->ext_local_circuit_id, 4))
+           if(tmp>sizeof(tlv_ptp_adj->extd_local_circuit_id)) {
+               if (!TTEST2(tlv_ptp_adj->extd_local_circuit_id,
+                            sizeof(tlv_ptp_adj->extd_local_circuit_id)))

                    goto trunctlv;
                    goto trunctlv;

-               printf("\n\t\t\tExtended Local circuit ID: 0x%08x",
-                      EXTRACT_32BITS(tlv_ptp_adj->ext_local_circuit_id));
-               i-=4;
+               printf("\n\t      Extended Local circuit ID: 0x%08x",
+                      EXTRACT_32BITS(tlv_ptp_adj->extd_local_circuit_id));
+               tmp-=sizeof(tlv_ptp_adj->extd_local_circuit_id);

            }
            }

-           if(i>=6) {
-               if (!TTEST2(tlv_ptp_adj->neighbor_sysid, 6))
+           if(tmp>=SYSTEM_ID_LEN) {
+               if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))

                    goto trunctlv;
                    goto trunctlv;

-               printf("\n\t\t\tNeighbor SystemID: ");
-                      isis_print_sysid(tlv_ptp_adj->neighbor_sysid);
-               i-=6;
+               printf("\n\t      Neighbor SystemID: %s",
+                      isis_print_id(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
+               tmp-=SYSTEM_ID_LEN;

            }
            }

-           if(i>=4) {
-               if (!TTEST2(tlv_ptp_adj->neighbor_ext_local_circuit_id, 4))
+           if(tmp>=sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)) {
+               if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
+                            sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))

                    goto trunctlv;
                    goto trunctlv;

-               printf("\n\t\t\tNeighbor Extended Local circuit ID: 0x%08x",
-                      EXTRACT_32BITS(tlv_ptp_adj->neighbor_ext_local_circuit_id));
+               printf("\n\t      Neighbor Extended Local circuit ID: 0x%08x",
+                      EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));

            }
            break;
 
        case TLV_PROTOCOLS:
            }
            break;
 
        case TLV_PROTOCOLS:

-           printf("Protocols supported (%u)", len);
-           printf("\n\t\t\tNLPID(s): ");
-           for (i = 0; i < len; i++) {
-               if (!TTEST2(*(pptr+i), 1))
+           printf("\n\t      NLPID(s): ");
+           while (tmp>0) {
+               if (!TTEST2(*(tptr), 1))

                    goto trunctlv;
                    goto trunctlv;

-               printf("%s (0x%02x)",tok2str(isis_nlpid_values, "Unknown", *(pptr+i)),*(pptr+i));
-               if (i<len-1)
+               printf("%s",
+                       tok2str(osi_nlpid_values,
+                               "Unknown 0x%02x",
+                               *tptr++));
+               if (tmp>1) /* further NPLIDs ? - put comma */

                    printf(", ");
                    printf(", ");

+                tmp--;

            }
            break;
 
        case TLV_TE_ROUTER_ID:
            }
            break;
 
        case TLV_TE_ROUTER_ID:

-           printf("Traffic Engineering Router ID (%u)",len); 

            if (!TTEST2(*pptr, 4))
                goto trunctlv;
            if (!TTEST2(*pptr, 4))
                goto trunctlv;

-           printf("\n\t\t\tTraffic Engineering Router ID: %s", ipaddr_string(pptr));
+           printf("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(pptr));

            break;
 
        case TLV_IPADDR:
            break;
 
        case TLV_IPADDR:

-           printf("IPv4 Interface address(es) (%u)",len); 
-           i=len;
-           tptr=pptr;
-           while (i>0) {
+           while (tmp>0) {

                if (!TTEST2(*tptr, 4))
                    goto trunctlv;
                if (!TTEST2(*tptr, 4))
                    goto trunctlv;

-               printf("\n\t\t\tIPv4 interface address: %s", ipaddr_string(tptr));
+               printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));

                tptr += 4;
                tptr += 4;

-               i -= 4;
+               tmp -= 4;

            }
            break;
 
        case TLV_HOSTNAME:
            }
            break;
 
        case TLV_HOSTNAME:

-           printf("Hostname (%u)", len);
-           printf("\n\t\t\tHostname: ");
-           for(i = 0; i < len; i++) {
-               if (!TTEST2(*(pptr+i), 1))
+           printf("\n\t      Hostname: ");
+           while (tmp>0) {
+               if (!TTEST2(*tptr, 1))

                    goto trunctlv;
                    goto trunctlv;

-               printf("%c",*(pptr+i));
+               printf("%c",*tptr++);
+                tmp--;

            }
            break;
 
        case TLV_SHARED_RISK_GROUP:
            }
            break;
 
        case TLV_SHARED_RISK_GROUP:

-            printf("Shared Risk Link Group (%u)",len);
-            tptr=pptr;
-            tmp=len;
-
-           if (!TTEST2(*tptr, 7))
-             goto trunctlv;
-           printf("\n\t\t\tIS Neighbor: ");
-           if (!isis_print_nodeid(tptr))
-             return (1);
-           tptr+=(SYSTEM_ID_LEN+1);
-           len-=(SYSTEM_ID_LEN+1);
+           if (!TTEST2(*tptr, NODE_ID_LEN))
+                goto trunctlv;
+           printf("\n\t      IS Neighbor: %s", isis_print_id(tptr, NODE_ID_LEN));
+           tptr+=(NODE_ID_LEN);
+           tmp-=(NODE_ID_LEN);

 
            if (!TTEST2(*tptr, 1))
 
            if (!TTEST2(*tptr, 1))

-             goto trunctlv;
+                goto trunctlv;

            printf(", %s", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");
            printf(", %s", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");

-           len--;
+           tmp--;

 
            if (!TTEST2(*tptr,4))
 
            if (!TTEST2(*tptr,4))

-             goto trunctlv;
-           printf("\n\t\t\tIPv4 interface address: %s", ipaddr_string(tptr));
+                goto trunctlv;
+           printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));

            tptr+=4;
            tptr+=4;

-           len-=4;
+           tmp-=4;

 
            if (!TTEST2(*tptr,4))
 
            if (!TTEST2(*tptr,4))

-             goto trunctlv;
-           printf("\n\t\t\tIPv4 neighbor address: %s", ipaddr_string(tptr));
+                goto trunctlv;
+           printf("\n\t      IPv4 neighbor address: %s", ipaddr_string(tptr));

            tptr+=4;
            tptr+=4;

-           len-=4;         
+           tmp-=4;

 
            while (tmp>0) {
 
            while (tmp>0) {

-             if (!TTEST2(*tptr, 4))
-               goto trunctlv;      
-             printf("\n\t\t\tLink-ID: 0x%08x", EXTRACT_32BITS(tptr));
-             tptr+=4;
-             len-=4;   
+                if (!TTEST2(*tptr, 4))
+                    goto trunctlv;
+                printf("\n\t      Link-ID: 0x%08x", EXTRACT_32BITS(tptr));
+                tptr+=4;
+                tmp-=4;

            }
            break;
 
            }
            break;
 

-       case TLV_LSP:    
-           tlv_lsp = (const struct isis_tlv_lsp *)pptr;
-           printf("LSP entries (%u)", len); 
-           i=0;
-           while(i<len) {
-               printf("\n\t\t\tlsp-id: ");
-               if (!isis_print_nodeid(tlv_lsp->lsp_id))
-                   return (1);
-               if (!TTEST((tlv_lsp->lsp_id)[SYSTEM_ID_LEN+1]))
+       case TLV_LSP:
+           tlv_lsp = (const struct isis_tlv_lsp *)tptr;
+           while(tmp>0) {
+               if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN]))

                    goto trunctlv;
                    goto trunctlv;

-               printf("-%02x",(tlv_lsp->lsp_id)[SYSTEM_ID_LEN+1]);
+               printf("\n\t      lsp-id: %s",
+                       isis_print_id(tlv_lsp->lsp_id, LSP_ID_LEN));

                if (!TTEST2(tlv_lsp->sequence_number, 4))
                    goto trunctlv;
                printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));
                if (!TTEST2(tlv_lsp->sequence_number, 4))
                    goto trunctlv;
                printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));


@@ -1685,111 +1881,163 @@ static int isis_print (const u_char *p, u_int length)
                if (!TTEST2(tlv_lsp->checksum, 2))
                    goto trunctlv;
                printf(", chksum: 0x%04x",EXTRACT_16BITS(tlv_lsp->checksum));
                if (!TTEST2(tlv_lsp->checksum, 2))
                    goto trunctlv;
                printf(", chksum: 0x%04x",EXTRACT_16BITS(tlv_lsp->checksum));

-               i+=sizeof(struct isis_tlv_lsp);
+               tmp-=sizeof(struct isis_tlv_lsp);

                tlv_lsp++;
            }
            break;
 
        case TLV_CHECKSUM:
                tlv_lsp++;
            }
            break;
 
        case TLV_CHECKSUM:

-           if (!TTEST2(*pptr, 2))
+           if (!TTEST2(*tptr, 2))

                goto trunctlv;
                goto trunctlv;

-           printf("Checksum (%u)", len);
-           printf("\n\t\t\tchecksum: 0x%04x", 
-                  EXTRACT_16BITS(pptr));
-
-           if (osi_cksum(optr, length, off))
-               printf(" (incorrect)");
-           else
-               printf(" (correct)");
+           printf("\n\t      checksum: 0x%04x (%s)",
+                  EXTRACT_16BITS(tptr),
+                   (osi_cksum(optr, length)) ? "incorrect" : "correct");

            break;
 
        case TLV_MT_SUPPORTED:
            break;
 
        case TLV_MT_SUPPORTED:

-           printf("Multi Topology (%u)",len); 
-           i=len;
-           tptr=pptr;
-           while (i>1) {
-               /* length can only be a multiple of 2, otherwise there is 
+           while (tmp>1) {
+               /* length can only be a multiple of 2, otherwise there is

                   something broken -> so decode down until length is 1 */
                   something broken -> so decode down until length is 1 */

-               if (i!=1) {
-                   if (!TTEST2(*tptr, 2))
-                       goto trunctlv;
-                   printf("\n\t\t\t");
-                   switch(EXTRACT_16BITS(tptr)&0x0fff) {
-
-                   case 0:
-                       printf("IPv4 unicast");
-                       break;
-
-                   case 1:
-                       printf("In-Band Management");
-                       break;
-
-                   case 2:
-                       printf("IPv6 unicast");
-                       break;
-
-                   case 3:
-                       printf("Multicast");
-                       break;
-
-                   case 4095:
-                       printf("Development, Experimental or Proprietary");
-                       break;
-
-                   default:
-                       printf("Reserved for IETF Consensus");
-                       break;
-                   }
-                   printf(" Topology (0x%03x)%s%s",
-                          EXTRACT_16BITS(tptr)&0xfff,
-                          (EXTRACT_16BITS(tptr)&0x8000) ? "" : ", no sub-TLVs present",
-                          (EXTRACT_16BITS(tptr)&0x4000) ? ", ATT bit set" : "" );
+               if (tmp!=1) {
+                    mt_len = isis_print_mtid(tptr, "\n\t      ");
+                    if (mt_len == 0) /* did something go wrong ? */
+                        goto trunctlv;
+                    tptr+=mt_len;
+                    tmp-=mt_len;

                } else {
                } else {

-                   printf("\n\t\t\tmalformed MT-ID");
+                   printf("\n\t      malformed MT-ID");

                    break;
                }
                    break;
                }

-               i-=2;
-               tptr+=2;

            }
            break;
 
        case TLV_RESTART_SIGNALING:
            }
            break;
 
        case TLV_RESTART_SIGNALING:

-           tptr=pptr;
-           printf("Restart Signaling (%u)",len);
-                   if (!TTEST2(*tptr, 3))
-                       goto trunctlv;
-                   
+            if (!TTEST2(*tptr, 3))
+                goto trunctlv;

            rr = ISIS_MASK_TLV_RESTART_RR(*tptr);
            ra = ISIS_MASK_TLV_RESTART_RA(*tptr);
            tptr++;
            time_remain = EXTRACT_16BITS(tptr);
            rr = ISIS_MASK_TLV_RESTART_RR(*tptr);
            ra = ISIS_MASK_TLV_RESTART_RA(*tptr);
            tptr++;
            time_remain = EXTRACT_16BITS(tptr);

-           printf("\n\t\t\tRestart Request bit %s, Restart Acknowledgement bit %s\n\t\t\tRemaining holding time: %us",
+           printf("\n\t      Restart Request bit %s, Restart Acknowledgement bit %s\n\t      Remaining holding time: %us",

                   rr ? "set" : "clear", ra ? "set" : "clear", time_remain);
                   rr ? "set" : "clear", ra ? "set" : "clear", time_remain);

-

            break;
 
            break;
 

+        case TLV_IDRP_INFO:
+            if (!TTEST2(*tptr, 1))
+                goto trunctlv;
+            printf("\n\t      Inter-Domain Information Type: %s",
+                   tok2str(isis_subtlv_idrp_values,
+                           "Unknown (0x%02x)",
+                           *tptr));
+            switch (*tptr++) {
+            case SUBTLV_IDRP_ASN:
+                if (!TTEST2(*tptr, 2)) /* fetch AS number */
+                    goto trunctlv;
+                printf("AS Number: %u",EXTRACT_16BITS(tptr));
+                break;
+            case SUBTLV_IDRP_LOCAL:
+            case SUBTLV_IDRP_RES:
+            default:
+                if(!print_unknown_data(tptr,"\n\t      ",tlv_len-1))
+                    return(0);
+                break;
+            }
+            break;
+
+        case TLV_LSP_BUFFERSIZE:
+            if (!TTEST2(*tptr, 2))
+                goto trunctlv;
+            printf("\n\t      LSP Buffersize: %u",EXTRACT_16BITS(tptr));
+            break;
+
+        case TLV_PART_DIS:
+            while (tmp >= SYSTEM_ID_LEN) {
+                if (!TTEST2(*tptr, SYSTEM_ID_LEN))
+                    goto trunctlv;
+                printf("\n\t      %s",isis_print_id(tptr,SYSTEM_ID_LEN));
+                tptr+=SYSTEM_ID_LEN;
+                tmp-=SYSTEM_ID_LEN;
+            }
+            break;
+
+        case TLV_PREFIX_NEIGH:
+            if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
+                goto trunctlv;
+            printf("\n\t      Metric Block");
+            isis_print_metric_block((const struct isis_metric_block *)tptr);
+            tptr+=sizeof(struct isis_metric_block);
+            tmp-=sizeof(struct isis_metric_block);
+
+            while(tmp>0) {
+                if (!TTEST2(*tptr, 1))
+                    goto trunctlv;
+                prefix_len=*tptr++; /* read out prefix length in semioctets*/
+                tmp--;
+                if (!TTEST2(*tptr, prefix_len/2))
+                    goto trunctlv;
+                printf("\n\t\tAddress: %s/%u",
+                       print_nsap(tptr,prefix_len/2),
+                       prefix_len*4);
+                tptr+=prefix_len/2;
+                tmp-=prefix_len/2;
+            }
+            break;
+
+        case TLV_IIH_SEQNR:
+            if (!TTEST2(*tptr, 4)) /* check if four bytes are on the wire */
+                goto trunctlv;
+            printf("\n\t      Sequence number: %u", EXTRACT_32BITS(tptr) );
+            break;
+
+        case TLV_VENDOR_PRIVATE:
+            if (!TTEST2(*tptr, 3)) /* check if enough byte for a full oui */
+                goto trunctlv;
+            printf("\n\t      Vendor OUI Code: 0x%06x", EXTRACT_24BITS(tptr) );
+            tptr+=3;
+            tmp-=3;
+            if (tmp > 0) /* hexdump the rest */
+                if(!print_unknown_data(tptr,"\n\t\t",tmp))
+                    return(0);
+            break;
+            /*
+             * FIXME those are the defined TLVs that lack a decoder
+             * you are welcome to contribute code ;-)
+             */
+
+        case TLV_DECNET_PHASE4:
+        case TLV_LUCENT_PRIVATE:
+        case TLV_IPAUTH:
+        case TLV_NORTEL_PRIVATE1:
+        case TLV_NORTEL_PRIVATE2:
+

        default:
        default:

-           printf("unknown TLV, type %d, length %d", type, len);
-           if(isis_print_unknown_data(pptr,"\n\t\t\t",len))
-               return(1);
+            if (vflag <= 1) {
+                if(!print_unknown_data(pptr,"\n\t\t",tlv_len))
+                    return(0);
+            }

            break;
        }
            break;
        }

+        /* do we want to see an additionally hexdump ? */
+        if (vflag> 1) {
+           if(!print_unknown_data(pptr,"\n\t      ",tlv_len))
+               return(0);
+        }

 
 

-       pptr += len;
-       packet_len -= len;
+       pptr += tlv_len;
+       packet_len -= tlv_len;

     }
 
     if (packet_len != 0) {
     }
 
     if (packet_len != 0) {

-       printf("\n\t\t\t %d straggler bytes", packet_len);
+       printf("\n\t      %u straggler bytes", packet_len);

     }
     return (1);
 
     }
     return (1);
 

-trunc:
+ trunc:

     fputs("[|isis]", stdout);
     return (1);
 
     fputs("[|isis]", stdout);
     return (1);
 

-trunctlv:
-    printf("\n\t\t\t packet exceeded snapshot");
+ trunctlv:
+    printf("\n\t\t packet exceeded snapshot");

     return(1);
 }
 
     return(1);
 }
 


@@ -1798,20 +2046,15 @@ trunctlv:
  */
 
 static int
  */
 
 static int

-osi_cksum(register const u_char *p, register u_int len, u_char *off)
+osi_cksum(const u_int8_t *tptr, u_int len)

 {
        int32_t c0 = 0, c1 = 0;
 
 {
        int32_t c0 = 0, c1 = 0;
 

-       if ((off[0] == 0) && (off[1] == 0))
-               return 0;
-
-       off[0] = off[1] = 0;

        while ((int)--len >= 0) {
        while ((int)--len >= 0) {

-               c0 += *p++;
+               c0 += *tptr++;

                c0 %= 255;
                c1 += c0;
                c1 %= 255;
        }
        return (c0 | c1);
 }
                c0 %= 255;
                c1 += c0;
                c1 %= 255;
        }
        return (c0 | c1);
 }

-