provide multiline output for PIM Joins/Grafts/Graft-Acks

[tcpdump] / print-isoclns.c
diff --git a/print-isoclns.c b/print-isoclns.c

index abfb56a32605c748bbb85425a65fc54f8403252e..736555b371ec0b0068a9144242da14b564251769 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -25,8 +25,8 @@
   */
  
  #ifndef lint
   */
  
  #ifndef lint
-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.90 2003-07-01 08:34:30 guy Exp $ (LBL)";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.118 2004-03-18 10:58:17 hannes Exp $ (LBL)";
  #endif
  
  #ifdef HAVE_CONFIG_H
  #endif
  
  #ifdef HAVE_CONFIG_H
@@ -44,14 +44,25 @@ static const char rcsid[] =
  #include "ether.h"
  #include "extract.h"
  #include "gmpls.h"
  #include "ether.h"
  #include "extract.h"
  #include "gmpls.h"
+#include "oui.h"
  
  
-#define        NLPID_CLNS      129     /* 0x81 */
-#define        NLPID_ESIS      130     /* 0x82 */
-#define        NLPID_ISIS      131     /* 0x83 */
+#define        NLPID_CLNP      0x81 /* iso9577 */
+#define        NLPID_ESIS      0x82 /* iso9577 */
+#define        NLPID_ISIS      0x83 /* iso9577 */
  #define NLPID_IP6       0x8e
  #define NLPID_IP        0xcc
  #define        NLPID_NULLNS    0
  
  #define NLPID_IP6       0x8e
  #define NLPID_IP        0xcc
  #define        NLPID_NULLNS    0
  
+static struct tok osi_nlpid_values[] = {
+    { NLPID_NULLNS, "NULL-NS"},
+    { NLPID_CLNP,   "CLNP"},
+    { NLPID_ESIS,   "ES-IS"},
+    { NLPID_ISIS,   "IS-IS"},
+    { NLPID_IP,     "IPv4"},
+    { NLPID_IP6,    "IPv6"},
+    { 0, NULL }
+};
+
  #define IPV4            1       /* AFI value */
  #define IPV6            2       /* AFI value */
  
  #define IPV4            1       /* AFI value */
  #define IPV6            2       /* AFI value */
  
@@ -62,31 +73,36 @@ static const char rcsid[] =
  #define SYSTEM_ID_LEN  ETHER_ADDR_LEN
  #define NODE_ID_LEN     SYSTEM_ID_LEN+1
  #define LSP_ID_LEN      SYSTEM_ID_LEN+2
  #define SYSTEM_ID_LEN  ETHER_ADDR_LEN
  #define NODE_ID_LEN     SYSTEM_ID_LEN+1
  #define LSP_ID_LEN      SYSTEM_ID_LEN+2
+#define NSAP_MAX_LENGTH 20
  
  #define ISIS_VERSION   1
  
  #define ISIS_VERSION   1
-#define PDU_TYPE_MASK  0x1F
-#define PRIORITY_MASK  0x7F
-
-#define L1_LAN_IIH     15
-#define L2_LAN_IIH     16
-#define PTP_IIH                17
-#define L1_LSP         18
-#define L2_LSP         20
-#define L1_CSNP        24
-#define L2_CSNP        25
-#define L1_PSNP                26
-#define L2_PSNP                27
+#define ESIS_VERSION   1
+
+#define ISIS_PDU_TYPE_MASK      0x1F
+#define ESIS_PDU_TYPE_MASK      0x1F
+#define CLNP_PDU_TYPE_MASK      0x1F
+#define ISIS_LAN_PRIORITY_MASK  0x7F
+
+#define ISIS_PDU_L1_LAN_IIH    15
+#define ISIS_PDU_L2_LAN_IIH    16
+#define ISIS_PDU_PTP_IIH       17
+#define ISIS_PDU_L1_LSP        18
+#define ISIS_PDU_L2_LSP        20
+#define ISIS_PDU_L1_CSNP       24
+#define ISIS_PDU_L2_CSNP       25
+#define ISIS_PDU_L1_PSNP        26
+#define ISIS_PDU_L2_PSNP        27
  
  static struct tok isis_pdu_values[] = {
  
  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"},
+    { ISIS_PDU_L1_LAN_IIH,       "L1 Lan IIH"},
+    { ISIS_PDU_L2_LAN_IIH,       "L2 Lan IIH"},
+    { ISIS_PDU_PTP_IIH,          "p2p IIH"},
+    { ISIS_PDU_L1_LSP,           "L1 LSP"},
+    { ISIS_PDU_L2_LSP,           "L2 LSP"},
+    { ISIS_PDU_L1_CSNP,          "L1 CSNP"},
+    { ISIS_PDU_L2_CSNP,          "L2 CSNP"},
+    { ISIS_PDU_L1_PSNP,          "L1 PSNP"},
+    { ISIS_PDU_L2_PSNP,          "L2 PSNP"},
      { 0, NULL}
  };
  
      { 0, NULL}
  };
  
@@ -98,129 +114,175 @@ static struct tok isis_pdu_values[] = {
   * list taken from rfc3359 plus some memory from veterans ;-)
   */
  
   * list taken from rfc3359 plus some memory from veterans ;-)
   */
  
-#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 */
+#define ISIS_TLV_AREA_ADDR           1   /* iso10589 */
+#define ISIS_TLV_IS_REACH            2   /* iso10589 */
+#define ISIS_TLV_ESNEIGH             3   /* iso10589 */
+#define ISIS_TLV_PART_DIS            4   /* iso10589 */
+#define ISIS_TLV_PREFIX_NEIGH        5   /* iso10589 */
+#define ISIS_TLV_ISNEIGH             6   /* iso10589 */
+#define ISIS_TLV_ISNEIGH_VARLEN      7   /* iso10589 */
+#define ISIS_TLV_PADDING             8   /* iso10589 */
+#define ISIS_TLV_LSP                 9   /* iso10589 */
+#define ISIS_TLV_AUTH                10  /* iso10589, rfc3567 */
+#define ISIS_TLV_CHECKSUM            12  /* rfc3358 */
+#define ISIS_TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
+#define ISIS_TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */
+#define ISIS_TLV_IS_ALIAS_ID         24  /* draft-ietf-isis-ext-lsp-frags-02 */
+#define ISIS_TLV_DECNET_PHASE4       42
+#define ISIS_TLV_LUCENT_PRIVATE      66
+#define ISIS_TLV_INT_IP_REACH        128 /* rfc1195, rfc2966 */
+#define ISIS_TLV_PROTOCOLS           129 /* rfc1195 */
+#define ISIS_TLV_EXT_IP_REACH        130 /* rfc1195, rfc2966 */
+#define ISIS_TLV_IDRP_INFO           131 /* rfc1195 */
+#define ISIS_TLV_IPADDR              132 /* rfc1195 */
+#define ISIS_TLV_IPAUTH              133 /* rfc1195 */
+#define ISIS_TLV_TE_ROUTER_ID        134 /* draft-ietf-isis-traffic-05 */
+#define ISIS_TLV_EXTD_IP_REACH       135 /* draft-ietf-isis-traffic-05 */
+#define ISIS_TLV_HOSTNAME            137 /* rfc2763 */
+#define ISIS_TLV_SHARED_RISK_GROUP   138 /* draft-ietf-isis-gmpls-extensions */
+#define ISIS_TLV_NORTEL_PRIVATE1     176
+#define ISIS_TLV_NORTEL_PRIVATE2     177
+#define ISIS_TLV_RESTART_SIGNALING   211 /* draft-ietf-isis-restart-01 */
+#define ISIS_TLV_MT_IS_REACH         222 /* draft-ietf-isis-wg-multi-topology-05 */
+#define ISIS_TLV_MT_SUPPORTED        229 /* draft-ietf-isis-wg-multi-topology-05 */
+#define ISIS_TLV_IP6ADDR             232 /* draft-ietf-isis-ipv6-02 */
+#define ISIS_TLV_MT_IP_REACH         235 /* draft-ietf-isis-wg-multi-topology-05 */
+#define ISIS_TLV_IP6_REACH           236 /* draft-ietf-isis-ipv6-02 */
+#define ISIS_TLV_MT_IP6_REACH        237 /* draft-ietf-isis-wg-multi-topology-05 */
+#define ISIS_TLV_PTP_ADJ             240 /* rfc3373 */
+#define ISIS_TLV_IIH_SEQNR           241 /* draft-shen-isis-iih-sequence-00 */
+#define ISIS_TLV_VENDOR_PRIVATE      250 /* draft-ietf-isis-experimental-tlv-01 */
  
  static struct tok isis_tlv_values[] = {
  
  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"},
+    { ISIS_TLV_AREA_ADDR,         "Area address(es)"},
+    { ISIS_TLV_IS_REACH,           "IS Reachability"},
+    { ISIS_TLV_ESNEIGH,            "ES Neighbor(s)"},
+    { ISIS_TLV_PART_DIS,           "Partition DIS"},
+    { ISIS_TLV_PREFIX_NEIGH,       "Prefix Neighbors"},
+    { ISIS_TLV_ISNEIGH,            "IS Neighbor(s)"},
+    { ISIS_TLV_ISNEIGH_VARLEN,     "IS Neighbor(s) (variable length)"},
+    { ISIS_TLV_PADDING,            "Padding"},
+    { ISIS_TLV_LSP,                "LSP entries"},
+    { ISIS_TLV_AUTH,               "Authentication"},
+    { ISIS_TLV_CHECKSUM,           "Checksum"},
+    { ISIS_TLV_LSP_BUFFERSIZE,     "LSP Buffersize"},
+    { ISIS_TLV_EXT_IS_REACH,       "Extended IS Reachability"},
+    { ISIS_TLV_IS_ALIAS_ID,        "IS Alias ID"},
+    { ISIS_TLV_DECNET_PHASE4,      "DECnet Phase IV"},
+    { ISIS_TLV_LUCENT_PRIVATE,     "Lucent Proprietary"},
+    { ISIS_TLV_INT_IP_REACH,       "IPv4 Internal Reachability"},
+    { ISIS_TLV_PROTOCOLS,          "Protocols supported"},
+    { ISIS_TLV_EXT_IP_REACH,       "IPv4 External Reachability"},
+    { ISIS_TLV_IDRP_INFO,          "Inter-Domain Information Type"},
+    { ISIS_TLV_IPADDR,             "IPv4 Interface address(es)"},
+    { ISIS_TLV_IPAUTH,             "IPv4 authentication (deprecated)"},
+    { ISIS_TLV_TE_ROUTER_ID,       "Traffic Engineering Router ID"},
+    { ISIS_TLV_EXTD_IP_REACH,      "Extended IPv4 Reachability"},
+    { ISIS_TLV_SHARED_RISK_GROUP,  "Shared Risk Link Group"},
+    { ISIS_TLV_NORTEL_PRIVATE1,    "Nortel Proprietary"},
+    { ISIS_TLV_NORTEL_PRIVATE2,    "Nortel Proprietary"},
+    { ISIS_TLV_HOSTNAME,           "Hostname"},
+    { ISIS_TLV_RESTART_SIGNALING,  "Restart Signaling"},
+    { ISIS_TLV_MT_IS_REACH,        "Multi Topology IS Reachability"},
+    { ISIS_TLV_MT_SUPPORTED,       "Multi Topology"},
+    { ISIS_TLV_IP6ADDR,            "IPv6 Interface address(es)"},
+    { ISIS_TLV_MT_IP_REACH,        "Multi-Topology IPv4 Reachability"},
+    { ISIS_TLV_IP6_REACH,          "IPv6 reachability"},
+    { ISIS_TLV_MT_IP6_REACH,       "Multi-Topology IP6 Reachability"},
+    { ISIS_TLV_PTP_ADJ,            "Point-to-point Adjacency State"},
+    { ISIS_TLV_IIH_SEQNR,          "Hello PDU Sequence Number"},
+    { ISIS_TLV_VENDOR_PRIVATE,     "Vendor Private"},
+    { 0, NULL }
+};
+
+#define ESIS_OPTION_PROTOCOLS        129
+#define ESIS_OPTION_QOS_MAINTENANCE  195 /* iso9542 */
+#define ESIS_OPTION_SECURITY         197 /* iso9542 */
+#define ESIS_OPTION_ES_CONF_TIME     198 /* iso9542 */
+#define ESIS_OPTION_PRIORITY         205 /* iso9542 */
+#define ESIS_OPTION_ADDRESS_MASK     225 /* iso9542 */
+#define ESIS_OPTION_SNPA_MASK        226 /* iso9542 */
+
+static struct tok esis_option_values[] = {
+    { ESIS_OPTION_PROTOCOLS,       "Protocols supported"},
+    { ESIS_OPTION_QOS_MAINTENANCE, "QoS Maintenance" },
+    { ESIS_OPTION_SECURITY,        "Security" },
+    { ESIS_OPTION_ES_CONF_TIME,    "ES Configuration Time" },
+    { ESIS_OPTION_PRIORITY,        "Priority" },
+    { ESIS_OPTION_ADDRESS_MASK,    "Addressk Mask" },
+    { ESIS_OPTION_SNPA_MASK,       "SNPA Mask" },
+    { 0, NULL }
+};
+
+#define ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID  4 /* draft-ietf-isis-gmpls-extensions */
+#define ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID        5 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR        6 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR    8 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW           9 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW        10 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW        11 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_DIFFSERV_TE          12 /* draft-ietf-tewg-diff-te-proto-06 */
+#define ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC            18 /* draft-ietf-isis-traffic-05 */
+#define ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20 /* draft-ietf-isis-gmpls-extensions */
+#define ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21 /* draft-ietf-isis-gmpls-extensions */
+
+static struct tok isis_ext_is_reach_subtlv_values[] = {
+    { ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP,            "Administrative groups" },
+    { ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID,   "Link Local/Remote Identifier" },
+    { ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID,         "Link Remote Identifier" },
+    { ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR,         "IPv4 interface address" },
+    { ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR,     "IPv4 neighbor address" },
+    { ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW,            "Maximum link bandwidth" },
+    { ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW,          "Reservable link bandwidth" },
+    { ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW,          "Unreserved bandwidth" },
+    { ISIS_SUBTLV_EXT_IS_REACH_DIFFSERV_TE,            "Diffserv TE" },
+    { ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC,              "Traffic Engineering Metric" },
+    { ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE,   "Link Protection Type" },
+    { ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR,      "Interface Switching Capability" },
+    { 250,                                             "Reserved for cisco specific extensions" },
+    { 251,                                             "Reserved for cisco specific extensions" },
+    { 252,                                             "Reserved for cisco specific extensions" },
+    { 253,                                             "Reserved for cisco specific extensions" },
+    { 254,                                             "Reserved for cisco specific extensions" },
+    { 255,                                             "Reserved for future expansion" },
      { 0, NULL }
  };
  
      { 0, NULL }
  };
  
-#define SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3
-#define SUBTLV_EXT_IS_REACH_LINK_LOCAL_ID         4
-#define SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID        5
-#define SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR        6
-#define SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR    8
-#define SUBTLV_EXT_IS_REACH_MAX_LINK_BW           9
-#define SUBTLV_EXT_IS_REACH_RESERVABLE_BW        10
-#define SUBTLV_EXT_IS_REACH_UNRESERVED_BW        11
-#define SUBTLV_EXT_IS_REACH_TE_METRIC            18
-#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 ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32          1 /* draft-ietf-isis-admin-tags-01 */
+#define ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64          2 /* draft-ietf-isis-admin-tags-01 */
+#define ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR  117 /* draft-ietf-isis-wg-multi-topology-05 */
+
+static struct tok isis_ext_ip_reach_subtlv_values[] = {
+    { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32,           "32-Bit Administrative tag" },
+    { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64,           "64-Bit Administrative tag" },
+    { ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR,     "Management Prefix Color" },
+    { 0, NULL }
+};
+
+#define ISIS_SUBTLV_AUTH_SIMPLE        1
+#define ISIS_SUBTLV_AUTH_MD5          54
+#define ISIS_SUBTLV_AUTH_MD5_LEN      16
+#define ISIS_SUBTLV_AUTH_PRIVATE     255
  
  static struct tok isis_subtlv_auth_values[] = {
  
  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"},
+    { ISIS_SUBTLV_AUTH_SIMPLE, "simple text password"},
+    { ISIS_SUBTLV_AUTH_MD5,    "HMAC-MD5 password"},
+    { ISIS_SUBTLV_AUTH_PRIVATE,        "Routing Domain private password"},
      { 0, NULL }
  };
  
      { 0, NULL }
  };
  
-#define SUBTLV_IDRP_RES           0
-#define SUBTLV_IDRP_LOCAL         1
-#define SUBTLV_IDRP_ASN           2
+#define ISIS_SUBTLV_IDRP_RES           0
+#define ISIS_SUBTLV_IDRP_LOCAL         1
+#define ISIS_SUBTLV_IDRP_ASN           2
  
  static struct tok isis_subtlv_idrp_values[] = {
  
  static struct tok isis_subtlv_idrp_values[] = {
-    { SUBTLV_IDRP_RES,         "Reserved"},
-    { SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
-    { SUBTLV_IDRP_ASN,         "AS Number Tag"},
+    { ISIS_SUBTLV_IDRP_RES,         "Reserved"},
+    { ISIS_SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
+    { ISIS_SUBTLV_IDRP_ASN,         "AS Number Tag"},
      { 0, NULL}
  };
  
      { 0, NULL}
  };
  
-#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_PARTITION_BIT(x)     ((x)&0x80)
  #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
  #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
  #define ISIS_MASK_LSP_PARTITION_BIT(x)     ((x)&0x80)
@@ -239,11 +301,11 @@ static struct tok isis_mt_flag_values[] = {
      { 0, NULL}
  };
  
      { 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_EXTD_IP_UPDOWN(x)     ((x)&0x80)
+#define ISIS_MASK_TLV_EXTD_IP_SUBTLV(x)     ((x)&0x40)
  
  
-#define ISIS_MASK_TLV_EXT_IP6_IE(x)        ((x)&0x40)
-#define ISIS_MASK_TLV_EXT_IP6_SUBTLV(x)    ((x)&0x20)
+#define ISIS_MASK_TLV_EXTD_IP6_IE(x)        ((x)&0x40)
+#define ISIS_MASK_TLV_EXTD_IP6_SUBTLV(x)    ((x)&0x20)
  
  #define ISIS_LSP_TLV_METRIC_SUPPORTED(x)   ((x)&0x80)
  #define ISIS_LSP_TLV_METRIC_IE(x)          ((x)&0x40)
  
  #define ISIS_LSP_TLV_METRIC_SUPPORTED(x)   ((x)&0x80)
  #define ISIS_LSP_TLV_METRIC_IE(x)          ((x)&0x40)
@@ -281,13 +343,6 @@ static struct tok isis_lsp_istype_values[] = {
      { 0, NULL }
  };
  
      { 0, NULL }
  };
  
-static struct tok osi_nlpid_values[] = {
-    { NLPID_CLNS,   "CLNS"},
-    { NLPID_IP,     "IPv4"},
-    { NLPID_IP6,    "IPv6"},
-    { 0, NULL }
-};
-
  /*
   * Katz's point to point adjacency TLV uses codes to tell us the state of
   * the remote adjacency.  Enumerate them.
  /*
   * Katz's point to point adjacency TLV uses codes to tell us the state of
   * the remote adjacency.  Enumerate them.
@@ -297,7 +352,6 @@ static struct tok osi_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 struct tok isis_ptp_adjancey_values[] = {
      { ISIS_PTP_ADJ_UP,    "Up" },
      { ISIS_PTP_ADJ_INIT,  "Initializing" },
  static struct tok isis_ptp_adjancey_values[] = {
      { ISIS_PTP_ADJ_UP,    "Up" },
      { ISIS_PTP_ADJ_INIT,  "Initializing" },
@@ -313,6 +367,7 @@ struct isis_tlv_ptp_adj {
  };
  
  static int osi_cksum(const u_int8_t *, u_int);
  };
  
  static int osi_cksum(const u_int8_t *, u_int);
+static int clnp_print(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);
  
  static void esis_print(const u_int8_t *, u_int);
  static int isis_print(const u_int8_t *, u_int);
  
@@ -407,26 +462,25 @@ struct isis_tlv_lsp {
      u_int8_t checksum[2];
  };
  
      u_int8_t checksum[2];
  };
  
-
-/* allocate space for the following string
- * xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx
- * 50 bytes plus one termination byte */
  static char *
  print_nsap(register const u_int8_t *pptr, register int nsap_length)
  {
         int nsap_idx;
  static char *
  print_nsap(register const u_int8_t *pptr, register int nsap_length)
  {
         int nsap_idx;
-       static char nsap_ascii_output[51];
+       static char nsap_ascii_output[sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx")];
          char *junk_buf = nsap_ascii_output;
  
          char *junk_buf = nsap_ascii_output;
  
-        if (nsap_length < 1 || nsap_length > 20) {
-                sprintf(junk_buf, "illegal length");
+        if (nsap_length < 1 || nsap_length > NSAP_MAX_LENGTH) {
+                snprintf(nsap_ascii_output, sizeof(nsap_ascii_output),
+                    "illegal length");
                  return (nsap_ascii_output);
          }
  
         for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {
                 if (!TTEST2(*pptr, 1))
                         return (0);
                  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++);
+               snprintf(junk_buf,
+                   sizeof(nsap_ascii_output) - (junk_buf - nsap_ascii_output),
+                   "%02x", *pptr++);
                 junk_buf += strlen(junk_buf);
                 if (((nsap_idx & 1) == 0) &&
                       (nsap_idx + 1 < nsap_length)) {
                 junk_buf += strlen(junk_buf);
                 if (((nsap_idx & 1) == 0) &&
                       (nsap_idx + 1 < nsap_length)) {
@@ -446,21 +500,22 @@ print_nsap(register const u_int8_t *pptr, register int nsap_length)
  
  void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
  {
  
  void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
  {
-       u_int8_t pdu_type;
         const struct isis_common_header *header;
  
         header = (const struct isis_common_header *)p;
         const struct isis_common_header *header;
  
         header = (const struct isis_common_header *)p;
-       pdu_type = header->pdu_type & PDU_TYPE_MASK;
-
-        printf("%sOSI", caplen < 1 ? "|" : "");
  
  
-        if (caplen < 1) /* enough bytes on the wire ? */
-                return;
+        if (caplen <= 1) { /* enough bytes on the wire ? */
+            printf("|OSI");
+            return;
+        }
  
  
+        printf("%s",tok2str(osi_nlpid_values,"Unknown NLPID (0x%02x)",*p));
+        
         switch (*p) {
  
         switch (*p) {
  
-       case NLPID_CLNS:
-               (void)printf(", CLNS, length %u", length);
+       case NLPID_CLNP:
+               if (!clnp_print(p, length))
+                        print_unknown_data(p,"\n\t",caplen);
                 break;
  
         case NLPID_ESIS:
                 break;
  
         case NLPID_ESIS:
@@ -473,42 +528,154 @@ void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
                 break;
  
         case NLPID_NULLNS:
                 break;
  
         case NLPID_NULLNS:
-               (void)printf(", ISO NULLNS, length: %u", length);
+               (void)printf(", length: %u", length);
                 break;
  
         default:
                 break;
  
         default:
-               (void)printf(", Unknown NLPID 0x%02x, length: %u", p[0], length);
+               (void)printf(", length: %u", length);
                 if (caplen > 1)
                          print_unknown_data(p,"\n\t",caplen);
                 break;
         }
  }
  
                 if (caplen > 1)
                          print_unknown_data(p,"\n\t",caplen);
                 break;
         }
  }
  
-#define        ESIS_REDIRECT   6
-#define        ESIS_ESH        2
-#define        ESIS_ISH        4
+#define        CLNP_PDU_ER      1
+#define        CLNP_PDU_DT     28
+#define        CLNP_PDU_MD     29
+#define        CLNP_PDU_ERQ    30
+#define        CLNP_PDU_ERP    31
+
+static struct tok clnp_pdu_values[] = {
+    { CLNP_PDU_ER,  "Error Report"},
+    { CLNP_PDU_MD,  "MD"},
+    { CLNP_PDU_DT,  "Data"},
+    { CLNP_PDU_ERQ, "Echo Request"},
+    { CLNP_PDU_ERP, "Echo Response"},
+    { 0, NULL }
+};
+
+struct clnp_header_t {
+    u_int8_t nlpid;
+    u_int8_t length_indicator;
+    u_int8_t version;
+    u_int8_t lifetime; /* units of 500ms */
+    u_int8_t type;
+    u_int8_t segment_length[2];
+    u_int8_t cksum[2];
+};
+
+/*
+ * clnp_print
+ * Decode CLNP packets.  Return 0 on error.
+ */
+
+static int clnp_print (const u_int8_t *pptr, u_int length)
+{
+       const u_int8_t *optr,*source_address,*dest_address;
+        u_int li,source_address_length,dest_address_length, clnp_pdu_type;
+       const struct clnp_header_t *clnp_header;
+
+       clnp_header = (const struct clnp_header_t *) pptr;
+        li = clnp_header->length_indicator;
+        optr = pptr;
+
+        /*
+         * Sanity checking of the header.
+         */
+
+        /* FIXME */
+
+        clnp_pdu_type = clnp_header->type & CLNP_PDU_TYPE_MASK;
+
+        pptr += sizeof(struct clnp_header_t);
+        dest_address_length = *pptr;
+        dest_address = pptr + 1;
+
+        pptr += (1 + dest_address_length);
+        source_address_length = *pptr;
+        source_address = pptr +1;
  
  
-static struct tok esis_values[] = {
-    { ESIS_REDIRECT, "redirect"},
-    { ESIS_ESH,      "ESH"},
-    { ESIS_ISH,      "ISH"},
+        pptr += (1 + source_address_length);
+
+        if (vflag < 1) {
+            printf(", %s > %s, length %u",
+                   print_nsap(source_address, source_address_length),
+                   print_nsap(dest_address, dest_address_length),
+                   length);
+            return (1);
+        }
+        printf(", length %u", length);
+
+    printf("\n\t%s PDU, hlen: %u, v: %u, lifetime: %u.%us, PDU length: %u, checksum: 0x%04x ",
+           tok2str(clnp_pdu_values,
+                   "unknown (%u)",
+                   clnp_pdu_type),
+           clnp_header->length_indicator,
+           clnp_header->version,
+           clnp_header->lifetime/2,
+           (clnp_header->lifetime%2)*5,
+           EXTRACT_16BITS(clnp_header->segment_length),
+           EXTRACT_16BITS(clnp_header->cksum));
+
+        /* do not attempt to verify the checksum if it is zero */
+        if (EXTRACT_16BITS(clnp_header->cksum) == 0)
+                printf("(unverified)");
+            else printf("(%s)", osi_cksum(optr, li) ? "incorrect" : "correct");
+
+        printf("\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
+               source_address_length,
+               print_nsap(source_address, source_address_length),
+               dest_address_length,
+               print_nsap(dest_address, dest_address_length));
+
+        /* dump the remaining header data */
+        print_unknown_data(pptr,"\n\t",clnp_header->length_indicator-(pptr-optr));
+
+        switch (clnp_pdu_type) {
+
+        case   CLNP_PDU_ER:
+        case   CLNP_PDU_DT:
+        case   CLNP_PDU_MD:
+        case   CLNP_PDU_ERQ:
+        case   CLNP_PDU_ERP:
+
+        default:
+            /* dump the PDU specific data */
+            print_unknown_data(optr+clnp_header->length_indicator,"\n\t  ",length-clnp_header->length_indicator);
+
+        }
+
+        return (1);
+}
+
+
+#define        ESIS_PDU_REDIRECT       6
+#define        ESIS_PDU_ESH            2
+#define        ESIS_PDU_ISH            4
+
+static struct tok esis_pdu_values[] = {
+    { ESIS_PDU_REDIRECT, "redirect"},
+    { ESIS_PDU_ESH,      "ESH"},
+    { ESIS_PDU_ISH,      "ISH"},
      { 0, NULL }
  };
  
      { 0, NULL }
  };
  
-struct esis_hdr {
+struct esis_header_t {
+       u_int8_t nlpid;
+       u_int8_t length_indicator;
         u_int8_t version;
         u_int8_t reserved;
         u_int8_t type;
         u_int8_t version;
         u_int8_t reserved;
         u_int8_t type;
-       u_int8_t tmo[2];
+       u_int8_t holdtime[2];
         u_int8_t cksum[2];
  };
  
  static void
         u_int8_t cksum[2];
  };
  
  static void
-esis_print(const u_int8_t *p, u_int length)
+esis_print(const u_int8_t *pptr, u_int length)
  {
  {
-       const u_int8_t *ep;
-       u_int li;
-       const struct esis_hdr *eh;
+       const u_int8_t *optr;
+       u_int li,esis_pdu_type,source_address_length, source_address_number;
+       const struct esis_header_t *esis_header;
  
         if (length <= 2) {
                 if (qflag)
  
         if (length <= 2) {
                 if (qflag)
@@ -517,168 +684,212 @@ esis_print(const u_int8_t *p, u_int length)
                         printf(" no header at all!");
                 return;
         }
                         printf(" no header at all!");
                 return;
         }
-       li = p[1];
-       eh = (const struct esis_hdr *) &p[2];
-       ep = p + li;
+
+       esis_header = (const struct esis_header_t *) pptr;
+        li = esis_header->length_indicator;
+        optr = pptr;
+
+        /*
+         * Sanity checking of the header.
+         */
+
+        if (esis_header->nlpid != NLPID_ESIS) {
+            printf(", nlpid 0x%02x packet not supported", esis_header->nlpid);
+            return;
+        }
+
+        if (esis_header->version != ESIS_VERSION) {
+            printf(", version %d packet not supported", esis_header->version);
+            return;
+        }
+                
         if (li > length) {
         if (li > length) {
-               if (qflag)
-                       printf(" bad pkt!");
-               else
-                       printf(" LI(%d) > PDU size (%d)!", li, length);
-               return;
+            printf(", length indicator(%d) > PDU size (%d)!", li, length);
+            return;
         }
         }
-       if (li < sizeof(struct esis_hdr) + 2) {
-               if (qflag)
-                       printf(" bad pkt!");
-               else {
-                       printf(" too short for esis header %d:", li);
-                       while (--length != 0)
-                               printf("%02X", *p++);
-               }
-               return;
+
+       if (li < sizeof(struct esis_header_t) + 2) {
+            printf(", length indicator < min PDU size %d:", li);
+            while (--length != 0)
+                printf("%02X", *pptr++);
+            return;
         }
  
         }
  
-        printf(", ES-IS, %s, length %u",
-               tok2str(esis_values,"unknown type: %u",eh->type & 0x1f),
-               length);
+        esis_pdu_type = esis_header->type & ESIS_PDU_TYPE_MASK;
  
  
-        if(vflag < 1)
-               return;
+        if (vflag < 1) {
+            printf(", %s, length %u",
+                   tok2str(esis_pdu_values,"unknown type (%u)",esis_pdu_type),
+                   length);
+            return;
+        } else
+            printf(", length %u\n\t%s (%u)",
+                   length,
+                   tok2str(esis_pdu_values,"unknown type: %u", esis_pdu_type),
+                   esis_pdu_type);
  
  
-       if (vflag && osi_cksum(p, li)) {
-               printf(" bad cksum (got 0x%02x%02x)",
-                      eh->cksum[1], eh->cksum[0]);
-               default_print(p, length);
-               return;
-       }
-       if (eh->version != 1) {
-               printf(" unsupported version %d", eh->version);
-               return;
-       }
-       p += sizeof(*eh) + 2;
-       li -= sizeof(*eh) + 2;  /* protoid * li */
+        printf(", v: %u%s", esis_header->version, esis_header->version == ESIS_VERSION ? "" : "unsupported" );
+        printf(", checksum: 0x%04x ", EXTRACT_16BITS(esis_header->cksum));
+        /* do not attempt to verify the checksum if it is zero */
+        if (EXTRACT_16BITS(esis_header->cksum) == 0)
+                printf("(unverified)");
+            else printf("(%s)", osi_cksum(pptr, li) ? "incorrect" : "correct");
  
  
-       switch (eh->type & 0x1f) {
-       case ESIS_REDIRECT: {
-               const u_int8_t *dst, *snpa, *is;
+        printf(", holding time: %us, length indicator: %u",EXTRACT_16BITS(esis_header->holdtime),li);
  
  
-               dst = p; p += *p + 1;
-               if (p > snapend)
-                       return;
-               printf("\n\t\t %s", isonsap_string(dst));
-               snpa = p; p += *p + 1;
-               is = p;   p += *p + 1;
-               if (p > snapend)
+        if (vflag > 1)
+            print_unknown_data(optr,"\n\t",sizeof(struct esis_header_t));
+
+       pptr += sizeof(struct esis_header_t);
+       li -= sizeof(struct esis_header_t);
+
+       switch (esis_pdu_type) {
+       case ESIS_PDU_REDIRECT: {
+               const u_int8_t *dst, *snpa, *tptr;
+
+               dst = pptr; pptr += *pptr + 1;
+               if (pptr > snapend)
                         return;
                         return;
-               if (p > ep) {
-                       printf(" [bad li]");
+               printf("\n\t  %s", isonsap_string(dst));
+               snpa = pptr; pptr += *pptr + 1;
+               tptr = pptr;   pptr += *pptr + 1;
+               if (pptr > snapend)
                         return;
                         return;
-               }
-               if (is[0] == 0)
-                       printf(" > %s", etheraddr_string(&snpa[1]));
+
+               if (tptr[0] == 0)
+                       printf("\n\t  %s", etheraddr_string(&snpa[1]));
                 else
                 else
-                       printf(" > %s", isonsap_string(is));
-               li = ep - p;
+                       printf("\n\t  %s", isonsap_string(tptr));
                 break;
         }
  
                 break;
         }
  
-       case ESIS_ESH:
-               break;
+       case ESIS_PDU_ESH:
+            source_address_number = *pptr;
+            pptr++;
+            li--;
+
+            printf("\n\t  Number of Source Addresses: %u", source_address_number);
+           
+            while (source_address_number > 0) {
+                source_address_length = *pptr;
+                printf("\n\t  NET (length: %u): %s",
+                       source_address_length,
+                       print_nsap(pptr+1, source_address_length));
+
+                pptr += source_address_length+1;
+                li -= source_address_length+1;
+                source_address_number--;
+            }
  
  
-       case ESIS_ISH: {
-               const u_int8_t *is;
+            break;
  
  
-               is = p; p += *p + 1;
-               if (p > ep) {
-                       printf(" [bad li]");
-                       return;
-               }
-               if (p > snapend)
-                       return;
-               if (!qflag)
-                       printf("\n\tNET: %s", print_nsap(is+1,*is));
-               li = ep - p;
-               break;
+       case ESIS_PDU_ISH: {
+            source_address_length = *pptr;
+            printf("\n\t  NET (length: %u): %s", source_address_length, print_nsap(pptr+1, source_address_length));
+            pptr += source_address_length+1;
+            li -= source_address_length +1;
+            break;
         }
  
         default:
              if (vflag <= 1) {
         }
  
         default:
              if (vflag <= 1) {
-                   if (p < snapend) 
-                            print_unknown_data(p,"\n\t  ",snapend-p);
+                   if (pptr < snapend) 
+                            print_unknown_data(pptr,"\n\t  ",snapend-pptr);
              }
              return;
         }
  
              }
              return;
         }
  
-        /* hexdump - FIXME ? */
-        if (vflag > 1) {
-                    if (p < snapend)
-                            print_unknown_data(p,"\n\t  ",snapend-p);
+        /* now walk the options */
+        while (li >= 2) {
+            u_int op, opli;
+            const u_int8_t *tptr;
+            
+            if (snapend - pptr < 2)
+                return;
+            if (li < 2) {
+                printf(", bad opts/li");
+                return;
+            }
+            op = *pptr++;
+            opli = *pptr++;
+            li -= 2;
+            if (opli > li) {
+                printf(", opt (%d) too long", op);
+                return;
+            }
+            li -= opli;
+            tptr = pptr;
+            
+            if (snapend < pptr)
+                return;
+            
+            printf("\n\t  %s Option #%u, length %u, value: ",
+                   tok2str(esis_option_values,"Unknown",op),
+                   op,
+                   opli);
+
+            switch (op) {
+
+            case ESIS_OPTION_ES_CONF_TIME:
+                printf("%us", EXTRACT_16BITS(tptr));
+                break;
+                
+
+            case ESIS_OPTION_PROTOCOLS:
+                while (opli>0) {
+                    printf("%s (0x%02x)",
+                           tok2str(osi_nlpid_values,
+                                   "unknown",
+                                   *tptr),
+                           *tptr);
+                    if (opli>1) /* further NPLIDs ? - put comma */
+                        printf(", ");
+                    tptr++;
+                    opli--;
+                }
+                break;
+
+                /*
+                 * FIXME those are the defined Options that lack a decoder
+                 * you are welcome to contribute code ;-)
+                 */
+
+            case ESIS_OPTION_QOS_MAINTENANCE:
+            case ESIS_OPTION_SECURITY:
+            case ESIS_OPTION_PRIORITY:
+            case ESIS_OPTION_ADDRESS_MASK:
+            case ESIS_OPTION_SNPA_MASK:
+
+            default:
+                print_unknown_data(tptr,"\n\t  ",opli);
+                break;
+            }
+            if (vflag > 1)
+                print_unknown_data(pptr,"\n\t  ",opli);
+            pptr += opli;
          }
          }
-       if (vflag)
-               while (p < ep && li) {
-                       u_int op, opli;
-                       const u_int8_t *q;
-
-                       if (snapend - p < 2)
-                               return;
-                       if (li < 2) {
-                               printf(", bad opts/li");
-                               return;
-                       }
-                       op = *p++;
-                       opli = *p++;
-                       li -= 2;
-                       if (opli > li) {
-                               printf(", opt (%d) too long", op);
-                               return;
-                       }
-                       li -= opli;
-                       q = p;
-                       p += opli;
-
-                       if (snapend < p)
-                               return;
-
-                       if (op == TLV_HOLDTIME && opli == 2) {
-                               printf("\n\tholdtime: %us", EXTRACT_16BITS(q));
-                               continue;
-                       }
-
-                       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);
-               }
-}
+}   
  
  
-/* 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 */
+/* shared routine for printing system, node and lsp-ids */
  static char *
  isis_print_id(const u_int8_t *cp, int id_len)
  {
      int i;
  static char *
  isis_print_id(const u_int8_t *cp, int id_len)
  {
      int i;
-    static char id[21];
+    static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];
      char *pos = id;
  
      for (i = 1; i <= SYSTEM_ID_LEN; i++) {
      char *pos = id;
  
      for (i = 1; i <= SYSTEM_ID_LEN; i++) {
-        sprintf(pos, "%02x", *cp++);
+        snprintf(pos, sizeof(id) - (pos - id), "%02x", *cp++);
         pos += strlen(pos);
         if (i == 2 || i == 4)
             *pos++ = '.';
         }
         pos += strlen(pos);
         if (i == 2 || i == 4)
             *pos++ = '.';
         }
-    if (id_len == NODE_ID_LEN) {
-        sprintf(pos, ".%02x", *cp++);
+    if (id_len >= NODE_ID_LEN) {
+        snprintf(pos, sizeof(id) - (pos - id), ".%02x", *cp++);
         pos += strlen(pos);
      }
      if (id_len == LSP_ID_LEN)
         pos += strlen(pos);
      }
      if (id_len == LSP_ID_LEN)
-        sprintf(pos, "-%02x", *cp);
+        snprintf(pos, sizeof(id) - (pos - id), "-%02x", *cp);
      return (id);
  }
  
      return (id);
  }
  
@@ -715,7 +926,7 @@ isis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length)
  
         while (length > 0) {
                 if ((size_t)length < sizeof(*tlv_ip_reach)) {
  
         while (length > 0) {
                 if ((size_t)length < sizeof(*tlv_ip_reach)) {
-                       printf("short IPv4 reachability (%d vs %lu)",
+                       printf("short IPv4 Reachability (%d vs %lu)",
                                 length,
                                 (unsigned long)sizeof(*tlv_ip_reach));
                         return (0);
                                 length,
                                 (unsigned long)sizeof(*tlv_ip_reach));
                         return (0);
@@ -774,25 +985,32 @@ isis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length)
  static int
  isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
  
  static int
  isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
  
+        /* first lets see if we know the subTLVs name*/
+       printf("%s%s subTLV #%u, length: %u",
+              ident,
+               tok2str(isis_ext_ip_reach_subtlv_values,
+                       "unknown",
+                       subt),
+               subt,
+               subl);
+
+       if (!TTEST2(*tptr,subl))
+           goto trunctlv;
+
      switch(subt) {
      switch(subt) {
-    case SUBTLV_IP_REACH_ADMIN_TAG32:
+    case ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR: /* fall through */
+    case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32:
          while (subl >= 4) {
          while (subl >= 4) {
-           if (!TTEST2(*tptr,4))
-               goto trunctlv;
-           printf("%s32-Bit Administrative tag: 0x%08x (=%u)",
-                  ident,
+           printf(", 0x%08x (=%u)",
                    EXTRACT_32BITS(tptr),
                    EXTRACT_32BITS(tptr));
             tptr+=4;
             subl-=4;
         }
         break;
                    EXTRACT_32BITS(tptr),
                    EXTRACT_32BITS(tptr));
             tptr+=4;
             subl-=4;
         }
         break;
-    case SUBTLV_IP_REACH_ADMIN_TAG64:
+    case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:
          while (subl >= 8) {
          while (subl >= 8) {
-           if (!TTEST2(*tptr,8))
-               goto trunctlv;
-           printf("%s64-Bit Administrative tag: 0x%08x%08x",
-                  ident,
+           printf(", 0x%08x%08x",
                    EXTRACT_32BITS(tptr),
                    EXTRACT_32BITS(tptr+4));
             tptr+=8;
                    EXTRACT_32BITS(tptr),
                    EXTRACT_32BITS(tptr+4));
             tptr+=8;
@@ -800,10 +1018,6 @@ isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *i
         }
         break;
      default:
         }
         break;
      default:
-        printf("%sunknown subTLV, type %d, length %d",
-              ident,
-              subt,
-              subl);
         if(!print_unknown_data(tptr,"\n\t\t    ",
                                subl))
           return(0);
         if(!print_unknown_data(tptr,"\n\t\t    ",
                                subl))
           return(0);
@@ -824,150 +1038,102 @@ trunctlv:
  static int
  isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
  
  static int
  isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
  
-        int i;
+        int priority_level,bandwidth_constraint;
          union { /* int to float conversion buffer for several subTLVs */
              float f; 
              u_int32_t i;
          } bw;
  
          union { /* int to float conversion buffer for several subTLVs */
              float f; 
              u_int32_t i;
          } bw;
  
+        /* first lets see if we know the subTLVs name*/
+       printf("%s%s subTLV #%u, length: %u",
+              ident,
+               tok2str(isis_ext_is_reach_subtlv_values,
+                       "unknown",
+                       subt),
+               subt,
+               subl);
+
+       if (!TTEST2(*tptr,subl))
+           goto trunctlv;
+
          switch(subt) {
          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 );
+        case ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP:      
+        case ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:
+        case ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
+            printf(", 0x%08x", EXTRACT_32BITS(tptr));
+           if (subl == 8) /* draft-ietf-isis-gmpls-extensions */
+             printf(", 0x%08x", EXTRACT_32BITS(tptr+4));
+           break;
+        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
+        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
+            printf(", %s", ipaddr_string(tptr));
              break;
              break;
-        case SUBTLV_EXT_IS_REACH_RESERVABLE_BW :
-            if (!TTEST2(*tptr,4))
-                goto trunctlv;
+        case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
+       case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:  
              bw.i = EXTRACT_32BITS(tptr);
              bw.i = EXTRACT_32BITS(tptr);
-            printf("%sReservable link bandwidth: %.3f Mbps",
-                   ident,
-                   bw.f*8/1000000  );
+            printf(", %.3f Mbps", bw.f*8/1000000 );
              break;
              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;
+        case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
+            for (priority_level = 0; priority_level < 8; priority_level++) {
                  bw.i = EXTRACT_32BITS(tptr);
                  printf("%s  priority level %d: %.3f Mbps",
                         ident,
                  bw.i = EXTRACT_32BITS(tptr);
                  printf("%s  priority level %d: %.3f Mbps",
                         ident,
-                       i,
+                       priority_level,
                         bw.f*8/1000000 );
                         bw.f*8/1000000 );
+               tptr+=4;
              }
              break;
              }
              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));
+        case ISIS_SUBTLV_EXT_IS_REACH_DIFFSERV_TE:
+            printf("%sBandwidth Constraints Model ID: (%u)",ident, *tptr);
+            tptr+=4;
+            /* for now lets just print the first 8 BCs -
+             * FIXME is this dep. on the BC model ?
+             */
+            for (bandwidth_constraint = 0; bandwidth_constraint < 8; bandwidth_constraint++) {
+                bw.i = EXTRACT_32BITS(tptr);
+                printf("%s  Bandwidth constraint %d: %.3f Mbps",
+                       ident,
+                       bandwidth_constraint,
+                       bw.f*8/1000000 );
+               tptr+=4;
+            }
              break;
              break;
-        case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
-            if (!TTEST2(*tptr,4))
-                goto trunctlv;
-            printf("%sIPv4 neighbor address: %s",
-                   ident,
-                   ipaddr_string(tptr));
+        case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:
+            printf(", %u", EXTRACT_24BITS(tptr));
              break;
              break;
-        case SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
-            if (!TTEST2(*tptr,2))
-                goto trunctlv;
-            printf("%sLink Protection Type: %s, Priority %u",
-                   ident,
-                   bittok2str(gmpls_link_prot_values, "none", *tptr),
+        case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
+            printf(", %s, Priority %u",
+                  bittok2str(gmpls_link_prot_values, "none", *tptr),
                     *(tptr+1));
              break;
                     *(tptr+1));
              break;
-        case SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
-            printf("%sInterface Switching Capability",ident);
-
-            if (!TTEST2(*tptr,1))
-                goto trunctlv;
+        case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
              printf("%s  Interface Switching Capability:%s",
                     ident,
                     tok2str(gmpls_switch_cap_values, "Unknown", *(tptr)));
              printf("%s  Interface Switching Capability:%s",
                     ident,
                     tok2str(gmpls_switch_cap_values, "Unknown", *(tptr)));
-
-            if (!TTEST2(*(tptr+1),1))
-                goto trunctlv;
              printf(", LSP Encoding: %s",
                     tok2str(gmpls_encoding_values, "Unknown", *(tptr+1)));
              printf(", LSP Encoding: %s",
                     tok2str(gmpls_encoding_values, "Unknown", *(tptr+1)));
-
-            if (!TTEST2(*(tptr+2),2)) /* skip 2 res. bytes */
-                goto trunctlv;
-
+           tptr+=4;
              printf("%s  Max LSP Bandwidth:",ident);
              printf("%s  Max LSP Bandwidth:",ident);
-            for (i = 0; i < 8; i++) {
-                if (!TTEST2(*(tptr+(i*4)+4),4))
-                    goto trunctlv;
+            for (priority_level = 0; priority_level < 8; priority_level++) {
                  bw.i = EXTRACT_32BITS(tptr);
                  printf("%s    priority level %d: %.3f Mbps",
                         ident,
                  bw.i = EXTRACT_32BITS(tptr);
                  printf("%s    priority level %d: %.3f Mbps",
                         ident,
-                       i,
+                       priority_level,
                         bw.f*8/1000000 );
                         bw.f*8/1000000 );
+               tptr+=4;
              }
              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;
              /* 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))
+                                      subl-36))
                      return(0);
              }
              break;
                      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:
          default:
-            printf("%sunknown subTLV, type %d, length %d",
-                   ident,
-                   subt,
-                   subl);
              if(!print_unknown_data(tptr,"\n\t\t    ",
              if(!print_unknown_data(tptr,"\n\t\t    ",
-                                       subl))
+                                  subl))
                  return(0);
              break;
          }
                  return(0);
              break;
          }
@@ -985,10 +1151,10 @@ trunctlv:
   */
  
  static int
   */
  
  static int
-isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv) {
+isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv_type) {
  
      char ident_buffer[20];
  
      char ident_buffer[20];
-    int subt,subl,tslen;
+    int subtlv_type,subtlv_len,subtlv_sum_len;
      int proc_bytes = 0; /* how many bytes did we process ? */
      
      if (!TTEST2(*tptr, NODE_ID_LEN))
      int proc_bytes = 0; /* how many bytes did we process ? */
      
      if (!TTEST2(*tptr, NODE_ID_LEN))
@@ -997,8 +1163,8 @@ isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv) {
      printf("%sIS Neighbor: %s", ident, isis_print_id(tptr, NODE_ID_LEN));
      tptr+=(NODE_ID_LEN);
  
      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))
+    if (tlv_type != ISIS_TLV_IS_ALIAS_ID) { /* the Alias TLV Metric field is implicit 0 */
+        if (!TTEST2(*tptr, 3))    /* and is therefore skipped */
             return(0);
         printf(", Metric: %d",EXTRACT_24BITS(tptr));
         tptr+=3;
             return(0);
         printf(", Metric: %d",EXTRACT_24BITS(tptr));
         tptr+=3;
@@ -1006,23 +1172,23 @@ isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv) {
          
      if (!TTEST2(*tptr, 1))
          return(0);
          
      if (!TTEST2(*tptr, 1))
          return(0);
-    tslen=*(tptr++); /* read out subTLV length */
+    subtlv_sum_len=*(tptr++); /* read out subTLV length */
      proc_bytes=NODE_ID_LEN+3+1;
      proc_bytes=NODE_ID_LEN+3+1;
-    printf(", %ssub-TLVs present",tslen ? "" : "no ");
-    if (tslen) {
-        printf(" (%u)",tslen);
-        while (tslen>0) {
+    printf(", %ssub-TLVs present",subtlv_sum_len ? "" : "no ");
+    if (subtlv_sum_len) {
+        printf(" (%u)",subtlv_sum_len);
+        while (subtlv_sum_len>0) {
              if (!TTEST2(*tptr,2))
                  return(0);
              if (!TTEST2(*tptr,2))
                  return(0);
-            subt=*(tptr++);
-            subl=*(tptr++);
+            subtlv_type=*(tptr++);
+            subtlv_len=*(tptr++);
              /* prepend the ident string */
              snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
              /* prepend the ident string */
              snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
-            if(!isis_print_is_reach_subtlv(tptr,subt,subl,ident_buffer))
+            if(!isis_print_is_reach_subtlv(tptr,subtlv_type,subtlv_len,ident_buffer))
                  return(0);
                  return(0);
-            tptr+=subl;
-            tslen-=(subl+2);
-            proc_bytes+=(subl+2);
+            tptr+=subtlv_len;
+            subtlv_sum_len-=(subtlv_len+2);
+            proc_bytes+=(subtlv_len+2);
          }
      }
      return(proc_bytes);
          }
      }
      return(proc_bytes);
@@ -1112,20 +1278,20 @@ isis_print_extd_ip_reach (const u_int8_t *tptr, const char *ident, u_int16_t afi
  #endif 
     
      printf(", Distribution: %s, Metric: %u",
  #endif 
     
      printf(", Distribution: %s, Metric: %u",
-           ISIS_MASK_TLV_EXT_IP_UPDOWN(status_byte) ? "down" : "up",
+           ISIS_MASK_TLV_EXTD_IP_UPDOWN(status_byte) ? "down" : "up",
             metric);
  
             metric);
  
-    if (afi == IPV4 && ISIS_MASK_TLV_EXT_IP_SUBTLV(status_byte))
+    if (afi == IPV4 && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
          printf(", sub-TLVs present");
  #ifdef INET6
      if (afi == IPV6)
          printf(", %s%s",
          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" : "");
+               ISIS_MASK_TLV_EXTD_IP6_IE(status_byte) ? "External" : "Internal",
+               ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : "");
  #endif
      
  #endif
      
-    if ((ISIS_MASK_TLV_EXT_IP_SUBTLV(status_byte)  && afi == IPV4) ||
-        (ISIS_MASK_TLV_EXT_IP6_SUBTLV(status_byte) && afi == IPV6)) {
+    if ((ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte)  && afi == IPV4) ||
+        (ISIS_MASK_TLV_EXTD_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
          /* 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
@@ -1159,7 +1325,7 @@ isis_print_extd_ip_reach (const u_int8_t *tptr, const char *ident, u_int16_t afi
  
  static int isis_print (const u_int8_t *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 *isis_header;
  
      const struct isis_iih_lan_header *header_iih_lan;
      const struct isis_iih_ptp_header *header_iih_ptp;
  
      const struct isis_iih_lan_header *header_iih_lan;
      const struct isis_iih_ptp_header *header_iih_ptp;
@@ -1176,13 +1342,13 @@ static int isis_print (const u_int8_t *p, u_int length)
      u_int8_t ext_is_len, ext_ip_len, mt_len;
      const u_int8_t *optr, *pptr, *tptr;
      u_short packet_len,pdu_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;
-    u_int i;
+    u_int i,vendor_id;
  
      packet_len=length;
      optr = p; /* initialize the _o_riginal pointer to the packet start -
                   need it for parsing the checksum TLV */
  
      packet_len=length;
      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);
+    isis_header = (const struct isis_common_header *)p;
+    TCHECK(*isis_header);
      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;
      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;
@@ -1194,23 +1360,23 @@ static int isis_print (const u_int8_t *p, u_int length)
       * Sanity checking of the header.
       */
  
       * Sanity checking of the header.
       */
  
-    if (header->version != ISIS_VERSION) {
-       printf(", version %d packet not supported", header->version);
+    if (isis_header->version != ISIS_VERSION) {
+       printf(", version %d packet not supported", isis_header->version);
         return (0);
      }
  
         return (0);
      }
  
-    if ((header->id_length != SYSTEM_ID_LEN) && (header->id_length != 0)) {
+    if ((isis_header->id_length != SYSTEM_ID_LEN) && (isis_header->id_length != 0)) {
         printf(", system ID length of %d is not supported",
         printf(", system ID length of %d is not supported",
-              header->id_length);
+              isis_header->id_length);
         return (0);
      }
  
         return (0);
      }
  
-    if (header->pdu_version != ISIS_VERSION) {
-       printf(", version %d packet not supported", header->pdu_version);
+    if (isis_header->pdu_version != ISIS_VERSION) {
+       printf(", version %d packet not supported", isis_header->pdu_version);
         return (0);
      }
  
         return (0);
      }
  
-    max_area = header->max_area;
+    max_area = isis_header->max_area;
      switch(max_area) {
      case 0:
         max_area = 3;    /* silly shit */
      switch(max_area) {
      case 0:
         max_area = 3;    /* silly shit */
@@ -1222,7 +1388,7 @@ static int isis_print (const u_int8_t *p, u_int length)
         break;
      }
  
         break;
      }
  
-    id_length = header->id_length;
+    id_length = isis_header->id_length;
      switch(id_length) {
      case 0:
          id_length = 6;  /* silly shit again */
      switch(id_length) {
      case 0:
          id_length = 6;  /* silly shit again */
@@ -1249,36 +1415,39 @@ static int isis_print (const u_int8_t *p, u_int length)
         return (0);
      }
  
         return (0);
      }
  
-    pdu_type=header->pdu_type;
+    pdu_type=isis_header->pdu_type;
  
      /* in non-verbose mode print the basic PDU Type plus PDU specific brief information*/
      if (vflag < 1) {
  
      /* in non-verbose mode print the basic PDU Type plus PDU specific brief information*/
      if (vflag < 1) {
-        printf(", IS-IS, %s",
-               tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type));
+        printf(", %s", tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type));
  
         switch (pdu_type) {
  
  
         switch (pdu_type) {
  
-       case L1_LAN_IIH:
-       case L2_LAN_IIH:
-           printf(", source-id %s", isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN));
+       case ISIS_PDU_L1_LAN_IIH:
+       case ISIS_PDU_L2_LAN_IIH:
+           printf(", src-id %s",
+                   isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN));
+           printf(", lan-id %s, prio %u",
+                   isis_print_id(header_iih_lan->lan_id,NODE_ID_LEN),
+                   header_iih_lan->priority);
             break;
             break;
-       case PTP_IIH:
-           printf(", source-id %s", isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN));
+       case ISIS_PDU_PTP_IIH:
+           printf(", src-id %s", isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN));
             break;
             break;
-       case L1_LSP:
-       case L2_LSP:
+       case ISIS_PDU_L1_LSP:
+       case ISIS_PDU_L2_LSP:
             printf(", 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));
             break;
             printf(", 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));
             break;
-       case L1_CSNP:
-       case L2_CSNP:
-           printf(", source-id %s", isis_print_id(header_csnp->source_id,SYSTEM_ID_LEN));
+       case ISIS_PDU_L1_CSNP:
+       case ISIS_PDU_L2_CSNP:
+           printf(", src-id %s", isis_print_id(header_csnp->source_id,SYSTEM_ID_LEN));
             break;
             break;
-       case L1_PSNP:
-       case L2_PSNP:
-           printf(", source-id %s", isis_print_id(header_psnp->source_id,SYSTEM_ID_LEN));
+       case ISIS_PDU_L1_PSNP:
+       case ISIS_PDU_L2_PSNP:
+           printf(", src-id %s", isis_print_id(header_psnp->source_id,SYSTEM_ID_LEN));
             break;
  
         }
             break;
  
         }
@@ -1288,22 +1457,19 @@ static int isis_print (const u_int8_t *p, u_int length)
      }
  
      /* ok they seem to want to know everything - lets fully decode it */
      }
  
      /* ok they seem to want to know everything - lets fully decode it */
-    printf(", IS-IS, length: %u",length);
+    printf(", 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->pdu_version,
-          id_length,
-          header->id_length,
-           max_area,
-           header->max_area);
-
-    /* first lets see if we know the PDU name*/
-    printf(", pdu-type: %s",
+    printf("\n\t%s, hlen: %u, v: %u, pdu-v: %u, sys-id-len: %u (%u), max-area: %u (%u)",
             tok2str(isis_pdu_values,
                     "unknown, type %u",
             tok2str(isis_pdu_values,
                     "unknown, type %u",
-                   pdu_type));
+                   pdu_type),
+           isis_header->fixed_len,
+           isis_header->version,
+           isis_header->pdu_version,
+          id_length,
+          isis_header->id_length,
+           max_area,
+           isis_header->max_area);
  
      if (vflag > 1) {
          if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
  
      if (vflag > 1) {
          if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
@@ -1312,11 +1478,11 @@ static int isis_print (const u_int8_t *p, u_int length)
  
      switch (pdu_type) {
  
  
      switch (pdu_type) {
  
-    case L1_LAN_IIH:
-    case L2_LAN_IIH:
-       if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
+    case ISIS_PDU_L1_LAN_IIH:
+    case ISIS_PDU_L2_LAN_IIH:
+       if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
             printf(", bogus fixed header length %u should be %lu",
             printf(", bogus fixed header length %u should be %lu",
-                  header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
+                  isis_header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
             return (0);
         }
  
             return (0);
         }
  
@@ -1336,7 +1502,7 @@ static int isis_print (const u_int8_t *p, u_int length)
  
         printf("\n\t  lan-id:    %s, Priority: %u, PDU length: %u",
                 isis_print_id(header_iih_lan->lan_id, NODE_ID_LEN),
  
         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,
+               (header_iih_lan->priority) & ISIS_LAN_PRIORITY_MASK,
                 pdu_len);
  
          if (vflag > 1) {
                 pdu_len);
  
          if (vflag > 1) {
@@ -1348,10 +1514,10 @@ static int isis_print (const u_int8_t *p, u_int length)
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
         break;
  
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
         break;
  
-    case PTP_IIH:
-       if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE)) {
+    case ISIS_PDU_PTP_IIH:
+       if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE)) {
             printf(", bogus fixed header length %u should be %lu",
             printf(", bogus fixed header length %u should be %lu",
-                  header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
+                  isis_header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
             return (0);
         }
  
             return (0);
         }
  
@@ -1362,13 +1528,15 @@ static int isis_print (const u_int8_t *p, u_int length)
         }
  
         TCHECK(*header_iih_ptp);
         }
  
         TCHECK(*header_iih_ptp);
-       printf("\n\t  source-id: %s, holding time: %us, circuit-id: 0x%02x, %s, PDU length: %u",
+       printf("\n\t  source-id: %s, holding time: %us, Flags: [%s]",
                 isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN),
                 EXTRACT_16BITS(header_iih_ptp->holding_time),
                 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",
                 tok2str(isis_iih_circuit_type_values,
                         "unknown circuit type 0x%02x",
-                       header_iih_ptp->circuit_type),
+                       header_iih_ptp->circuit_type));
+
+       printf("\n\t  circuit-id: 0x%02x, PDU length: %u",
+               header_iih_ptp->circuit_id,
                 pdu_len);
  
          if (vflag > 1) {
                 pdu_len);
  
          if (vflag > 1) {
@@ -1380,11 +1548,11 @@ static int isis_print (const u_int8_t *p, u_int length)
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
         break;
  
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
         break;
  
-    case L1_LSP:
-    case L2_LSP:
-       if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE)) {
+    case ISIS_PDU_L1_LSP:
+    case ISIS_PDU_L2_LSP:
+       if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE)) {
             printf(", bogus fixed header length %u should be %lu",
             printf(", bogus fixed header length %u should be %lu",
-                  header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
+                  isis_header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
             return (0);
         }
  
             return (0);
         }
  
@@ -1395,19 +1563,25 @@ static int isis_print (const u_int8_t *p, u_int length)
         }
  
         TCHECK(*header_lsp);
         }
  
         TCHECK(*header_lsp);
-       printf("\n\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us",
+       printf("\n\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us\n\t  chksum: 0x%04x",
                 isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
                 EXTRACT_32BITS(header_lsp->sequence_number),
                 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, " : "");
+               EXTRACT_16BITS(header_lsp->remaining_lifetime),
+               EXTRACT_16BITS(header_lsp->checksum));
+
+        /* if this is a purge do not attempt to verify the checksum */
+        if ( EXTRACT_16BITS(header_lsp->remaining_lifetime) == 0 &&
+             EXTRACT_16BITS(header_lsp->checksum) == 0)
+            printf(" (purged)");
+        else
+            /* verify the checksum -
+             * checking starts at the lsp-id field at byte position [12]
+             * hence the length needs to be reduced by 12 bytes */
+            printf(" (%s)", (osi_cksum((u_int8_t *)header_lsp->lsp_id, length-12)) ? "incorrect" : "correct");
+
+       printf(", PDU length: %u, Flags: [ %s",
+               pdu_len,
+               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_ATT_DEFAULT_BIT(header_lsp->typeblock) ? "default " : "");
  
         if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
             printf("%s", ISIS_MASK_LSP_ATT_DEFAULT_BIT(header_lsp->typeblock) ? "default " : "");
@@ -1417,7 +1591,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             printf("ATT bit set, ");
         }
         printf("%s", ISIS_MASK_LSP_PARTITION_BIT(header_lsp->typeblock) ? "P bit set, " : "");
             printf("ATT bit set, ");
         }
         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 ]", 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))
  
          if (vflag > 1) {
              if(!print_unknown_data(pptr,"\n\t  ",ISIS_LSP_HEADER_SIZE))
@@ -1428,11 +1602,11 @@ static int isis_print (const u_int8_t *p, u_int length)
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
         break;
  
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
         break;
  
-    case L1_CSNP:
-    case L2_CSNP:
-       if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE)) {
+    case ISIS_PDU_L1_CSNP:
+    case ISIS_PDU_L2_CSNP:
+       if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE)) {
             printf(", bogus fixed header length %u should be %lu",
             printf(", bogus fixed header length %u should be %lu",
-                  header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
+                  isis_header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
             return (0);
         }
  
             return (0);
         }
  
@@ -1460,11 +1634,11 @@ static int isis_print (const u_int8_t *p, u_int length)
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
          break;
  
         pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
          break;
  
-    case L1_PSNP:
-    case L2_PSNP:
-       if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE)) {
+    case ISIS_PDU_L1_PSNP:
+    case ISIS_PDU_L2_PSNP:
+       if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE)) {
             printf("- bogus fixed header length %u should be %lu",
             printf("- bogus fixed header length %u should be %lu",
-                  header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
+                  isis_header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
             return (0);
         }
  
             return (0);
         }
  
@@ -1475,8 +1649,9 @@ static int isis_print (const u_int8_t *p, u_int length)
         }
  
         TCHECK(*header_psnp);
         }
  
         TCHECK(*header_psnp);
-       printf("\n\t  source-id:    %s",
-               isis_print_id(header_psnp->source_id, NODE_ID_LEN));
+       printf("\n\t  source-id:    %s, PDU length: %u",
+               isis_print_id(header_psnp->source_id, NODE_ID_LEN),
+               pdu_len);
  
          if (vflag > 1) {
              if(!print_unknown_data(pptr,"\n\t  ",ISIS_PSNP_HEADER_SIZE))
  
          if (vflag > 1) {
              if(!print_unknown_data(pptr,"\n\t  ",ISIS_PSNP_HEADER_SIZE))
@@ -1526,7 +1701,7 @@ static int isis_print (const u_int8_t *p, u_int length)
  
          /* now check if we have a decoder otherwise do a hexdump at the end*/
         switch (tlv_type) {
  
          /* now check if we have a decoder otherwise do a hexdump at the end*/
         switch (tlv_type) {
-       case TLV_AREA_ADDR:
+       case ISIS_TLV_AREA_ADDR:
             if (!TTEST2(*tptr, 1))
                 goto trunctlv;
             alen = *tptr++;
             if (!TTEST2(*tptr, 1))
                 goto trunctlv;
             alen = *tptr++;
@@ -1543,17 +1718,17 @@ static int isis_print (const u_int8_t *p, u_int length)
                 alen = *tptr++;
             }
             break;
                 alen = *tptr++;
             }
             break;
-       case TLV_ISNEIGH:
+       case ISIS_TLV_ISNEIGH:
             while (tmp >= ETHER_ADDR_LEN) {
                  if (!TTEST2(*tptr, ETHER_ADDR_LEN))
                      goto trunctlv;
             while (tmp >= ETHER_ADDR_LEN) {
                  if (!TTEST2(*tptr, ETHER_ADDR_LEN))
                      goto trunctlv;
-                printf("\n\t      IS Neighbor: %s",isis_print_id(tptr,ETHER_ADDR_LEN));
+                printf("\n\t      SNPA: %s",isis_print_id(tptr,ETHER_ADDR_LEN));
                  tmp -= ETHER_ADDR_LEN;
                  tptr += ETHER_ADDR_LEN;
             }
             break;
  
                  tmp -= ETHER_ADDR_LEN;
                  tptr += ETHER_ADDR_LEN;
             }
             break;
  
-        case TLV_ISNEIGH_VARLEN:
+        case ISIS_TLV_ISNEIGH_VARLEN:
              if (!TTEST2(*tptr, 1))
                 goto trunctlv;
             lan_alen = *tptr++; /* LAN adress length */
              if (!TTEST2(*tptr, 1))
                 goto trunctlv;
             lan_alen = *tptr++; /* LAN adress length */
@@ -1568,10 +1743,10 @@ static int isis_print (const u_int8_t *p, u_int length)
              }
              break;
  
              }
              break;
  
-       case TLV_PADDING:
+       case ISIS_TLV_PADDING:
             break;
  
             break;
  
-        case TLV_MT_IS_REACH:
+        case ISIS_TLV_MT_IS_REACH:
              while (tmp >= 2+NODE_ID_LEN+3+1) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
              while (tmp >= 2+NODE_ID_LEN+3+1) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
@@ -1588,7 +1763,7 @@ static int isis_print (const u_int8_t *p, u_int length)
              }
              break;
  
              }
              break;
  
-        case TLV_IS_ALIAS_ID:
+        case ISIS_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 ? */
             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 ? */
@@ -1598,7 +1773,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-        case TLV_EXT_IS_REACH:
+        case ISIS_TLV_EXT_IS_REACH:
              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 ? */
              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 ? */
@@ -1607,7 +1782,7 @@ static int isis_print (const u_int8_t *p, u_int length)
                  tptr+=ext_is_len;
              }
              break;
                  tptr+=ext_is_len;
              }
              break;
-        case TLV_IS_REACH:
+        case ISIS_TLV_IS_REACH:
             if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
                  goto trunctlv;
              printf("\n\t      %s",
             if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
                  goto trunctlv;
              printf("\n\t      %s",
@@ -1626,7 +1801,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
              break;
  
             }
              break;
  
-        case TLV_ESNEIGH:
+        case ISIS_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))
             tlv_es_reach = (const struct isis_tlv_es_reach *)tptr;
              while (tmp >= sizeof(struct isis_tlv_es_reach)) {
                 if (!TTEST(*tlv_es_reach))
@@ -1640,13 +1815,13 @@ static int isis_print (const u_int8_t *p, u_int length)
              break;
  
              /* those two TLVs share the same format */
              break;
  
              /* those two TLVs share the same format */
-       case TLV_IP_REACH:
-       case TLV_IP_REACH_EXT:
+       case ISIS_TLV_INT_IP_REACH:
+       case ISIS_TLV_EXT_IP_REACH:
             if (!isis_print_tlv_ip_reach(pptr, "\n\t      ", tlv_len))
                 return (1);
             break;
  
             if (!isis_print_tlv_ip_reach(pptr, "\n\t      ", tlv_len))
                 return (1);
             break;
  
-       case TLV_EXT_IP_REACH:
+       case ISIS_TLV_EXTD_IP_REACH:
             while (tmp>0) {
                  ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV4);
                  if (ext_ip_len == 0) /* did something go wrong ? */
             while (tmp>0) {
                  ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV4);
                  if (ext_ip_len == 0) /* did something go wrong ? */
@@ -1656,7 +1831,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-        case TLV_MT_IP_REACH:
+        case ISIS_TLV_MT_IP_REACH:
             while (tmp>0) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
             while (tmp>0) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
@@ -1673,7 +1848,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             break;
  
  #ifdef INET6
             break;
  
  #ifdef INET6
-       case TLV_IP6_REACH:
+       case ISIS_TLV_IP6_REACH:
             while (tmp>0) {
                  ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV6);
                  if (ext_ip_len == 0) /* did something go wrong ? */
             while (tmp>0) {
                  ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", IPV6);
                  if (ext_ip_len == 0) /* did something go wrong ? */
@@ -1683,7 +1858,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_MT_IP6_REACH:
+       case ISIS_TLV_MT_IP6_REACH:
             while (tmp>0) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
             while (tmp>0) {
                  mt_len = isis_print_mtid(tptr, "\n\t      ");
                  if (mt_len == 0) /* did something go wrong ? */
@@ -1699,7 +1874,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_IP6ADDR:
+       case ISIS_TLV_IP6ADDR:
             while (tmp>0) {
                 if (!TTEST2(*tptr, 16))
                     goto trunctlv;
             while (tmp>0) {
                 if (!TTEST2(*tptr, 16))
                     goto trunctlv;
@@ -1712,7 +1887,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  #endif
             }
             break;
  #endif
-       case TLV_AUTH:
+       case ISIS_TLV_AUTH:
             if (!TTEST2(*tptr, 1))
                 goto trunctlv;
  
             if (!TTEST2(*tptr, 1))
                 goto trunctlv;
  
@@ -1722,23 +1897,23 @@ static int isis_print (const u_int8_t *p, u_int length)
                             *tptr));
  
             switch (*tptr) {
                             *tptr));
  
             switch (*tptr) {
-           case SUBTLV_AUTH_SIMPLE:
+           case ISIS_SUBTLV_AUTH_SIMPLE:
                 for(i=1;i<tlv_len;i++) {
                     if (!TTEST2(*(tptr+i), 1))
                         goto trunctlv;
                     printf("%c",*(tptr+i));
                 }
                 break;
                 for(i=1;i<tlv_len;i++) {
                     if (!TTEST2(*(tptr+i), 1))
                         goto trunctlv;
                     printf("%c",*(tptr+i));
                 }
                 break;
-           case SUBTLV_AUTH_MD5:
+           case ISIS_SUBTLV_AUTH_MD5:
                 for(i=1;i<tlv_len;i++) {
                     if (!TTEST2(*(tptr+i), 1))
                         goto trunctlv;
                     printf("%02x",*(tptr+i));
                 }
                 for(i=1;i<tlv_len;i++) {
                     if (!TTEST2(*(tptr+i), 1))
                         goto trunctlv;
                     printf("%02x",*(tptr+i));
                 }
-               if (tlv_len != SUBTLV_AUTH_MD5_LEN+1)
+               if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)
                      printf(", (malformed subTLV) ");
                 break;
                      printf(", (malformed subTLV) ");
                 break;
-           case SUBTLV_AUTH_PRIVATE:
+           case ISIS_SUBTLV_AUTH_PRIVATE:
             default:
                 if(!print_unknown_data(tptr+1,"\n\t\t  ",tlv_len-1))
                     return(0);
             default:
                 if(!print_unknown_data(tptr+1,"\n\t\t  ",tlv_len-1))
                     return(0);
@@ -1746,27 +1921,28 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_PTP_ADJ:
+       case ISIS_TLV_PTP_ADJ:
             tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)tptr;
             if(tmp>=1) {
                 if (!TTEST2(*tptr, 1))
                     goto trunctlv;
             tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)tptr;
             if(tmp>=1) {
                 if (!TTEST2(*tptr, 1))
                     goto trunctlv;
-               printf("\n\t      Adjacency State: %s",
-                      tok2str(isis_ptp_adjancey_values, "0x%02x", *tptr));
+               printf("\n\t      Adjacency State: %s (%u)",
+                      tok2str(isis_ptp_adjancey_values, "unknown", *tptr),
+                        *tptr);
                 tmp--;
             }
             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;
                 tmp--;
             }
             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;
-               printf("\n\t      Extended Local circuit ID: 0x%08x",
+               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(tmp>=SYSTEM_ID_LEN) {
                 if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))
                     goto trunctlv;
                        EXTRACT_32BITS(tlv_ptp_adj->extd_local_circuit_id));
                 tmp-=sizeof(tlv_ptp_adj->extd_local_circuit_id);
             }
             if(tmp>=SYSTEM_ID_LEN) {
                 if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))
                     goto trunctlv;
-               printf("\n\t      Neighbor SystemID: %s",
+               printf("\n\t      Neighbor System-ID: %s",
                        isis_print_id(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
                 tmp-=SYSTEM_ID_LEN;
             }
                        isis_print_id(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
                 tmp-=SYSTEM_ID_LEN;
             }
@@ -1774,33 +1950,35 @@ static int isis_print (const u_int8_t *p, u_int length)
                 if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
                              sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))
                     goto trunctlv;
                 if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
                              sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))
                     goto trunctlv;
-               printf("\n\t      Neighbor Extended Local circuit ID: 0x%08x",
+               printf("\n\t      Neighbor Extended Local circuit-ID: 0x%08x",
                        EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));
             }
             break;
  
                        EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));
             }
             break;
  
-       case TLV_PROTOCOLS:
+       case ISIS_TLV_PROTOCOLS:
             printf("\n\t      NLPID(s): ");
             while (tmp>0) {
                 if (!TTEST2(*(tptr), 1))
                     goto trunctlv;
             printf("\n\t      NLPID(s): ");
             while (tmp>0) {
                 if (!TTEST2(*(tptr), 1))
                     goto trunctlv;
-               printf("%s",
+               printf("%s (0x%02x)",
                         tok2str(osi_nlpid_values,
                         tok2str(osi_nlpid_values,
-                               "Unknown 0x%02x",
-                               *tptr++));
+                               "unknown",
+                               *tptr),
+                       *tptr);
                 if (tmp>1) /* further NPLIDs ? - put comma */
                     printf(", ");
                 if (tmp>1) /* further NPLIDs ? - put comma */
                     printf(", ");
+                tptr++;
                  tmp--;
             }
             break;
  
                  tmp--;
             }
             break;
  
-       case TLV_TE_ROUTER_ID:
+       case ISIS_TLV_TE_ROUTER_ID:
             if (!TTEST2(*pptr, 4))
                 goto trunctlv;
             printf("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(pptr));
             break;
  
             if (!TTEST2(*pptr, 4))
                 goto trunctlv;
             printf("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(pptr));
             break;
  
-       case TLV_IPADDR:
+       case ISIS_TLV_IPADDR:
             while (tmp>0) {
                 if (!TTEST2(*tptr, 4))
                     goto trunctlv;
             while (tmp>0) {
                 if (!TTEST2(*tptr, 4))
                     goto trunctlv;
@@ -1810,7 +1988,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_HOSTNAME:
+       case ISIS_TLV_HOSTNAME:
             printf("\n\t      Hostname: ");
             while (tmp>0) {
                 if (!TTEST2(*tptr, 1))
             printf("\n\t      Hostname: ");
             while (tmp>0) {
                 if (!TTEST2(*tptr, 1))
@@ -1820,7 +1998,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_SHARED_RISK_GROUP:
+       case ISIS_TLV_SHARED_RISK_GROUP:
             if (!TTEST2(*tptr, NODE_ID_LEN))
                  goto trunctlv;
             printf("\n\t      IS Neighbor: %s", isis_print_id(tptr, NODE_ID_LEN));
             if (!TTEST2(*tptr, NODE_ID_LEN))
                  goto trunctlv;
             printf("\n\t      IS Neighbor: %s", isis_print_id(tptr, NODE_ID_LEN));
@@ -1829,7 +2007,7 @@ static int isis_print (const u_int8_t *p, u_int length)
  
             if (!TTEST2(*tptr, 1))
                  goto trunctlv;
  
             if (!TTEST2(*tptr, 1))
                  goto trunctlv;
-           printf(", %s", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");
+           printf(", Flags: [%s]", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");
             tmp--;
  
             if (!TTEST2(*tptr,4))
             tmp--;
  
             if (!TTEST2(*tptr,4))
@@ -1853,10 +2031,10 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_LSP:
+       case ISIS_TLV_LSP:
             tlv_lsp = (const struct isis_tlv_lsp *)tptr;
             while(tmp>0) {
             tlv_lsp = (const struct isis_tlv_lsp *)tptr;
             while(tmp>0) {
-               if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN]))
+               if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN-1]))
                     goto trunctlv;
                 printf("\n\t      lsp-id: %s",
                         isis_print_id(tlv_lsp->lsp_id, LSP_ID_LEN));
                     goto trunctlv;
                 printf("\n\t      lsp-id: %s",
                         isis_print_id(tlv_lsp->lsp_id, LSP_ID_LEN));
@@ -1874,15 +2052,21 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_CHECKSUM:
+       case ISIS_TLV_CHECKSUM:
             if (!TTEST2(*tptr, 2))
                 goto trunctlv;
             if (!TTEST2(*tptr, 2))
                 goto trunctlv;
-           printf("\n\t      checksum: 0x%04x (%s)",
-                  EXTRACT_16BITS(tptr),
-                   (osi_cksum(optr, length)) ? "incorrect" : "correct");
+           printf("\n\t      checksum: 0x%04x ", EXTRACT_16BITS(tptr));
+            /* do not attempt to verify the checksum if it is zero
+             * most likely a HMAC-MD5 TLV is also present and
+             * to avoid conflicts the checksum TLV is zeroed.
+             * see rfc3358 for details
+             */
+            if (EXTRACT_16BITS(tptr) == 0)
+                printf("(unverified)");
+            else printf("(%s)", osi_cksum(optr, length) ? "incorrect" : "correct");
             break;
  
             break;
  
-       case TLV_MT_SUPPORTED:
+       case ISIS_TLV_MT_SUPPORTED:
             while (tmp>1) {
                 /* length can only be a multiple of 2, otherwise there is
                    something broken -> so decode down until length is 1 */
             while (tmp>1) {
                 /* length can only be a multiple of 2, otherwise there is
                    something broken -> so decode down until length is 1 */
@@ -1899,7 +2083,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
  
             }
             break;
  
-       case TLV_RESTART_SIGNALING:
+       case ISIS_TLV_RESTART_SIGNALING:
              if (!TTEST2(*tptr, 3))
                  goto trunctlv;
              printf("\n\t      Flags [%s], Remaining holding time %us",
              if (!TTEST2(*tptr, 3))
                  goto trunctlv;
              printf("\n\t      Flags [%s], Remaining holding time %us",
@@ -1908,7 +2092,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             tptr+=3;
             break;
  
             tptr+=3;
             break;
  
-        case TLV_IDRP_INFO:
+        case ISIS_TLV_IDRP_INFO:
              if (!TTEST2(*tptr, 1))
                  goto trunctlv;
              printf("\n\t      Inter-Domain Information Type: %s",
              if (!TTEST2(*tptr, 1))
                  goto trunctlv;
              printf("\n\t      Inter-Domain Information Type: %s",
@@ -1916,13 +2100,13 @@ static int isis_print (const u_int8_t *p, u_int length)
                             "Unknown (0x%02x)",
                             *tptr));
              switch (*tptr++) {
                             "Unknown (0x%02x)",
                             *tptr));
              switch (*tptr++) {
-            case SUBTLV_IDRP_ASN:
+            case ISIS_SUBTLV_IDRP_ASN:
                  if (!TTEST2(*tptr, 2)) /* fetch AS number */
                      goto trunctlv;
                  printf("AS Number: %u",EXTRACT_16BITS(tptr));
                  break;
                  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:
+            case ISIS_SUBTLV_IDRP_LOCAL:
+            case ISIS_SUBTLV_IDRP_RES:
              default:
                  if(!print_unknown_data(tptr,"\n\t      ",tlv_len-1))
                      return(0);
              default:
                  if(!print_unknown_data(tptr,"\n\t      ",tlv_len-1))
                      return(0);
@@ -1930,13 +2114,13 @@ static int isis_print (const u_int8_t *p, u_int length)
              }
              break;
  
              }
              break;
  
-        case TLV_LSP_BUFFERSIZE:
+        case ISIS_TLV_LSP_BUFFERSIZE:
              if (!TTEST2(*tptr, 2))
                  goto trunctlv;
              printf("\n\t      LSP Buffersize: %u",EXTRACT_16BITS(tptr));
              break;
  
              if (!TTEST2(*tptr, 2))
                  goto trunctlv;
              printf("\n\t      LSP Buffersize: %u",EXTRACT_16BITS(tptr));
              break;
  
-        case TLV_PART_DIS:
+        case ISIS_TLV_PART_DIS:
              while (tmp >= SYSTEM_ID_LEN) {
                  if (!TTEST2(*tptr, SYSTEM_ID_LEN))
                      goto trunctlv;
              while (tmp >= SYSTEM_ID_LEN) {
                  if (!TTEST2(*tptr, SYSTEM_ID_LEN))
                      goto trunctlv;
@@ -1946,7 +2130,7 @@ static int isis_print (const u_int8_t *p, u_int length)
              }
              break;
  
              }
              break;
  
-        case TLV_PREFIX_NEIGH:
+        case ISIS_TLV_PREFIX_NEIGH:
              if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
                  goto trunctlv;
              printf("\n\t      Metric Block");
              if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
                  goto trunctlv;
              printf("\n\t      Metric Block");
@@ -1969,16 +2153,19 @@ static int isis_print (const u_int8_t *p, u_int length)
              }
              break;
  
              }
              break;
  
-        case TLV_IIH_SEQNR:
+        case ISIS_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;
  
              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:
+        case ISIS_TLV_VENDOR_PRIVATE:
              if (!TTEST2(*tptr, 3)) /* check if enough byte for a full oui */
                  goto trunctlv;
              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) );
+            vendor_id = EXTRACT_24BITS(tptr);
+            printf("\n\t      Vendor: %s (%u)",
+                   tok2str(oui_values,"Unknown",vendor_id),
+                   vendor_id);
              tptr+=3;
              tmp-=3;
              if (tmp > 0) /* hexdump the rest */
              tptr+=3;
              tmp-=3;
              if (tmp > 0) /* hexdump the rest */
@@ -1990,11 +2177,11 @@ static int isis_print (const u_int8_t *p, u_int length)
               * you are welcome to contribute code ;-)
               */
  
               * 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:
+        case ISIS_TLV_DECNET_PHASE4:
+        case ISIS_TLV_LUCENT_PRIVATE:
+        case ISIS_TLV_IPAUTH:
+        case ISIS_TLV_NORTEL_PRIVATE1:
+        case ISIS_TLV_NORTEL_PRIVATE2:
  
         default:
              if (vflag <= 1) {
  
         default:
              if (vflag <= 1) {