resolve merge conflicts and update for proper build; including:

o print-fr.c returned to code on vendor branch
o remove pmap_prot.h include from print-sunrprc.c
o remove gcc/i386-specific ntoh* write-arounds from tcpdump-stdinc.h

Reviewed by:	bms

1 files changed, 855 insertions, 445 deletions

diff --git a/contrib/tcpdump/print-isoclns.c b/contrib/tcpdump/print-isoclns.c
index 5dc660f..9f2e8c3 100644
--- a/contrib/tcpdump/print-isoclns.c
+++ b/contrib/tcpdump/print-isoclns.c
@@ -21,14 +21,14 @@
  * Original code by Matt Thomas, Digital Equipment Corporation
  *
  * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
- * complete IS-IS support.
+ * complete IS-IS & CLNP support.
  *
  * $FreeBSD$
  */
 
 #ifndef lint
 static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.106.2.5 2004/03/24 01:45:26 guy Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.133 2005/04/06 21:32:40 mcr Exp $ (LBL)";
 #endif
 
 #ifdef HAVE_CONFIG_H
@@ -44,15 +44,10 @@ static const char rcsid[] _U_ =
 #include "addrtoname.h"
 #include "ethertype.h"
 #include "ether.h"
+#include "nlpid.h"
 #include "extract.h"
 #include "gmpls.h"
-
-#define	NLPID_CLNS	129	/* 0x81 */
-#define	NLPID_ESIS	130	/* 0x82 */
-#define	NLPID_ISIS	131	/* 0x83 */
-#define NLPID_IP6       0x8e
-#define NLPID_IP        0xcc
-#define	NLPID_NULLNS	0
+#include "oui.h"
 
 #define IPV4            1       /* AFI value */
 #define IPV6            2       /* AFI value */
@@ -66,29 +61,35 @@ static const char rcsid[] _U_ =
 #define LSP_ID_LEN      SYSTEM_ID_LEN+2
 
 #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 CLNP_VERSION	1
+
+#define ISIS_PDU_TYPE_MASK      0x1F
+#define ESIS_PDU_TYPE_MASK      0x1F
+#define CLNP_PDU_TYPE_MASK      0x1F
+#define CLNP_FLAG_MASK          0xE0
+#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[] = {
-    { 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}
 };
 
@@ -100,155 +101,273 @@ static struct tok isis_pdu_values[] = {
  * 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, rfc3567 */
-#define TLV_CHECKSUM            12  /* rfc3358 */
-#define TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
-#define TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */
-#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_INT_IP_REACH        128 /* rfc1195, rfc2966 */
-#define TLV_PROTOCOLS           129 /* rfc1195 */
-#define TLV_EXT_IP_REACH        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-05 */
-#define TLV_EXTD_IP_REACH       135 /* draft-ietf-isis-traffic-05 */
-#define TLV_HOSTNAME            137 /* rfc2763 */
-#define TLV_SHARED_RISK_GROUP   138 /* draft-ietf-isis-gmpls-extensions */
-#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[] = {
-    { 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_INT_IP_REACH,      "IPv4 Internal Reachability"},
-    { TLV_PROTOCOLS,         "Protocols supported"},
-    { TLV_EXT_IP_REACH,      "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_EXTD_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 SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID  4 /* draft-ietf-isis-gmpls-extensions */
-#define SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID        5 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR        6 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR    8 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_MAX_LINK_BW           9 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_RESERVABLE_BW        10 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_UNRESERVED_BW        11 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_TE_METRIC            18 /* draft-ietf-isis-traffic-05 */
-#define SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20 /* draft-ietf-isis-gmpls-extensions */
-#define SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21 /* draft-ietf-isis-gmpls-extensions */
+#define CLNP_OPTION_DISCARD_REASON   193
+#define CLNP_OPTION_QOS_MAINTENANCE  195 /* iso8473 */
+#define CLNP_OPTION_PRIORITY         205 /* iso8473 */
+
+static struct tok clnp_option_values[] = {
+    { CLNP_OPTION_DISCARD_REASON,  "Discard Reason"},
+    { CLNP_OPTION_PRIORITY,        "Priority"},
+    { CLNP_OPTION_QOS_MAINTENANCE, "QoS Maintenance"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_class_values[] = {
+    { 0x0, "General"},
+    { 0x8, "Address"},
+    { 0x9, "Source Routeing"},
+    { 0xa, "Lifetime"},
+    { 0xb, "PDU Discarded"},
+    { 0xc, "Reassembly"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_general_values[] = {
+    { 0x0, "Reason not specified"},
+    { 0x1, "Protocol procedure error"},
+    { 0x2, "Incorrect checksum"},
+    { 0x3, "PDU discarded due to congestion"},
+    { 0x4, "Header syntax error (cannot be parsed)"},
+    { 0x5, "Segmentation needed but not permitted"},
+    { 0x6, "Incomplete PDU received"},
+    { 0x7, "Duplicate option"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_address_values[] = {
+    { 0x0, "Destination address unreachable"},
+    { 0x1, "Destination address unknown"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_source_routeing_values[] = {
+    { 0x0, "Unspecified source routeing error"},
+    { 0x1, "Syntax error in source routeing field"},
+    { 0x2, "Unknown address in source routeing field"},
+    { 0x3, "Path not acceptable"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_lifetime_values[] = {
+    { 0x0, "Lifetime expired while data unit in transit"},
+    { 0x1, "Lifetime expired during reassembly"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_pdu_discard_values[] = {
+    { 0x0, "Unsupported option not specified"},
+    { 0x1, "Unsupported protocol version"},
+    { 0x2, "Unsupported security option"},
+    { 0x3, "Unsupported source routeing option"},
+    { 0x4, "Unsupported recording of route option"},
+    { 0, NULL }
+};
+
+static struct tok clnp_option_rfd_reassembly_values[] = {
+    { 0x0, "Reassembly interference"},
+    { 0, NULL }
+};
+
+/* array of 16 error-classes */
+static struct tok *clnp_option_rfd_error_class[] = {
+    clnp_option_rfd_general_values,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    clnp_option_rfd_address_values,
+    clnp_option_rfd_source_routeing_values,
+    clnp_option_rfd_lifetime_values,
+    clnp_option_rfd_pdu_discard_values,
+    clnp_option_rfd_reassembly_values,
+    NULL,
+    NULL,
+    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[] = {
-    { SUBTLV_EXT_IS_REACH_ADMIN_GROUP,            "Administrative groups" },
-    { SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID,   "Link Local/Remote Identifier" },
-    { SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID,         "Link Remote Identifier" },
-    { SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR,         "IPv4 interface address" },
-    { SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR,     "IPv4 neighbor address" },
-    { SUBTLV_EXT_IS_REACH_MAX_LINK_BW,            "Maximum link bandwidth" },
-    { SUBTLV_EXT_IS_REACH_RESERVABLE_BW,          "Reservable link bandwidth" },
-    { SUBTLV_EXT_IS_REACH_UNRESERVED_BW,          "Unreserved bandwidth" },
-    { SUBTLV_EXT_IS_REACH_TE_METRIC,              "Traffic Engineering Metric" },
-    { SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE,   "Link Protection Type" },
-    { 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" },
+    { 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 }
 };
 
-#define SUBTLV_EXTD_IP_REACH_ADMIN_TAG32          1
-#define SUBTLV_EXTD_IP_REACH_ADMIN_TAG64          2
+#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[] = {
-    { SUBTLV_EXTD_IP_REACH_ADMIN_TAG32,           "32-Bit Administrative tag" },
-    { SUBTLV_EXTD_IP_REACH_ADMIN_TAG64,           "64-Bit Administrative tag" },
+    { 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 SUBTLV_AUTH_SIMPLE        1
-#define SUBTLV_AUTH_MD5          54
-#define SUBTLV_AUTH_MD5_LEN      16
-#define SUBTLV_AUTH_PRIVATE     255
+#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[] = {
-    { 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 }
 };
 
-#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[] = {
-    { 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}
 };
 
-#define ISIS_8BIT_MASK(x)                  ((x)&0xff)
+#define CLNP_SEGMENT_PART  0x80
+#define CLNP_MORE_SEGMENTS 0x40
+#define CLNP_REQUEST_ER    0x20
+
+static struct tok clnp_flag_values[] = {
+    { CLNP_SEGMENT_PART, "Segmentation permitted"},
+    { CLNP_MORE_SEGMENTS, "more Segments"},
+    { CLNP_REQUEST_ER, "request Error Report"},
+    { 0, NULL}
+};
 
 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
@@ -310,13 +429,6 @@ static struct tok isis_lsp_istype_values[] = {
     { 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.
@@ -326,7 +438,6 @@ static struct tok osi_nlpid_values[] = {
 #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" },
@@ -342,6 +453,7 @@ struct isis_tlv_ptp_adj {
 };
 
 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);
 
@@ -436,35 +548,6 @@ struct isis_tlv_lsp {
     u_int8_t checksum[2];
 };
 
-static char *
-print_nsap(register const u_int8_t *pptr, register int nsap_length)
-{
-	int nsap_idx;
-	static char nsap_ascii_output[sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx")];
-        char *junk_buf = nsap_ascii_output;
-
-        if (nsap_length < 1 || nsap_length > 20) {
-                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);
-		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++ = '.';
-		}
-	}
-        *(junk_buf) = '\0';
-	return (nsap_ascii_output);
-}
-
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
@@ -478,15 +561,21 @@ void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
 
 	header = (const struct isis_common_header *)p;
 
-        printf("%sOSI", caplen < 1 ? "|" : "");
-
-        if (caplen < 1) /* enough bytes on the wire ? */
-                return;
+        if (caplen <= 1) { /* enough bytes on the wire ? */
+            printf("|OSI");
+            return;
+        }
 
+        if (eflag)
+            printf("OSI NLPID %s (0x%02x): ",
+                   tok2str(nlpid_values,"Unknown",*p),
+                   *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:
@@ -499,188 +588,477 @@ void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
 		break;
 
 	case NLPID_NULLNS:
-		(void)printf(", ISO NULLNS, length: %u", length);
+		(void)printf(", length: %u", length);
 		break;
 
+        case NLPID_Q933:
+                q933_print(p+1, length-1);
+                break;
+
+        case NLPID_IP:
+		ip_print(gndo, p+1, length-1);
+                break;
+
+#ifdef INET6
+        case NLPID_IP6:
+                ip6_print(p+1, length-1);
+                break;
+#endif
+
+        case NLPID_PPP:
+                ppp_print(p+1, length-1);
+                break;
+
 	default:
-		(void)printf(", Unknown NLPID 0x%02x, length: %u", p[0], length);
+                if (!eflag)
+                    printf("OSI NLPID 0x%02x unknown",*p);
+		(void)printf(", length: %u", length);
 		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];
+};
+
+struct clnp_segment_header_t {
+    u_int8_t data_unit_id[2];
+    u_int8_t segment_offset[2];
+    u_int8_t total_length[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, clnp_flags;
+	const struct clnp_header_t *clnp_header;
+	const struct clnp_segment_header_t *clnp_segment_header;
+        u_int8_t rfd_error_major,rfd_error_minor;
+
+	clnp_header = (const struct clnp_header_t *) pptr;
+        TCHECK(*clnp_header);
+
+        li = clnp_header->length_indicator;
+        optr = pptr;
+
+        if (!eflag)
+            printf("CLNP");
+
+        /*
+         * Sanity checking of the header.
+         */
+
+        if (clnp_header->version != CLNP_VERSION) {
+            printf("version %d packet not supported", clnp_header->version);
+            return (0);
+        }
+
+        /* FIXME further header sanity checking */
+
+        clnp_pdu_type = clnp_header->type & CLNP_PDU_TYPE_MASK;
+        clnp_flags = clnp_header->type & CLNP_FLAG_MASK;
+
+        pptr += sizeof(struct clnp_header_t);
+        li -= sizeof(struct clnp_header_t);
+        dest_address_length = *pptr;
+        dest_address = pptr + 1;
+
+        pptr += (1 + dest_address_length);
+        li -= (1 + dest_address_length);
+        source_address_length = *pptr;
+        source_address = pptr +1;
+
+        pptr += (1 + source_address_length);
+        li -= (1 + source_address_length);
+
+        if (vflag < 1) {
+            printf("%s%s > %s, %s, length %u",
+                   eflag ? "" : ", ",
+                   isonsap_string(source_address, source_address_length),
+                   isonsap_string(dest_address, dest_address_length),
+                   tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
+                   length);
+            return (1);
+        }
+        printf("%slength %u",eflag ? "" : ", ",length);
+
+        printf("\n\t%s PDU, hlen: %u, v: %u, lifetime: %u.%us, Segment 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, clnp_header->length_indicator) ? "incorrect" : "correct");
+
+        printf("\n\tFlags [%s]",
+               bittok2str(clnp_flag_values,"none",clnp_flags));
+
+        printf("\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
+               source_address_length,
+               isonsap_string(source_address, source_address_length),
+               dest_address_length,
+               isonsap_string(dest_address,dest_address_length));
+
+        if (clnp_flags & CLNP_SEGMENT_PART) {
+            	clnp_segment_header = (const struct clnp_segment_header_t *) pptr;
+                printf("\n\tData Unit ID: 0x%04x, Segment Offset: %u, Total PDU Length: %u",
+                       EXTRACT_16BITS(clnp_segment_header->data_unit_id),
+                       EXTRACT_16BITS(clnp_segment_header->segment_offset),
+                       EXTRACT_16BITS(clnp_segment_header->total_length));
+                pptr+=sizeof(const struct clnp_segment_header_t);
+                li-=sizeof(const struct clnp_segment_header_t);
+        }
+
+        /* now walk the options */
+        while (li >= 2) {
+            u_int op, opli;
+            const u_int8_t *tptr;
+            
+            if (snapend - pptr < 2)
+                return (0);
+            if (li < 2) {
+                printf(", bad opts/li");
+                return (0);
+            }
+            op = *pptr++;
+            opli = *pptr++;
+            li -= 2;
+            if (opli > li) {
+                printf(", opt (%d) too long", op);
+                return (0);
+            }
+            li -= opli;
+            tptr = pptr;
+            
+            if (snapend < pptr)
+                return(0);
+            
+            printf("\n\t  %s Option #%u, length %u, value: ",
+                   tok2str(clnp_option_values,"Unknown",op),
+                   op,
+                   opli);
+
+            switch (op) {
+
+            case CLNP_OPTION_PRIORITY:
+                printf("%u", *tptr);
+                break;
+
+            case CLNP_OPTION_DISCARD_REASON:
+                rfd_error_major = (*tptr&0xf0) >> 4;
+                rfd_error_minor = *tptr&0x0f;
+                printf("\n\t    Class: %s Error (0x%01x), %s (0x%01x)",
+                       tok2str(clnp_option_rfd_class_values,"Unknown",rfd_error_major),
+                       rfd_error_major,
+                       tok2str(clnp_option_rfd_error_class[rfd_error_major],"Unknown",rfd_error_minor),
+                       rfd_error_minor);
+                break;
+
+                /*
+                 * FIXME those are the defined Options that lack a decoder
+                 * you are welcome to contribute code ;-)
+                 */
+
+            default:
+                print_unknown_data(tptr,"\n\t  ",opli);
+                break;
+            }
+            if (vflag > 1)
+                print_unknown_data(pptr,"\n\t  ",opli);
+            pptr += opli;
+        }
+
+        switch (clnp_pdu_type) {
+
+        case    CLNP_PDU_ER: /* fall through */
+        case 	CLNP_PDU_ERP:
+            if (*(pptr) == NLPID_CLNP) {
+                printf("\n\t-----original packet-----\n\t");
+                /* FIXME recursion protection */
+                clnp_print(pptr, length-clnp_header->length_indicator);
+                break;
+            } 
+
+        case 	CLNP_PDU_DT:
+        case 	CLNP_PDU_MD:
+        case 	CLNP_PDU_ERQ:
+            
+        default:
+            /* dump the PDU specific data */
+            if (length-(pptr-optr) > 0) {
+                printf("\n\t  undecoded non-header data, length %u",length-clnp_header->length_indicator);
+                print_unknown_data(pptr,"\n\t  ",length-(pptr-optr));
+            }
+        }
+
+        return (1);
+
+ trunc:
+    fputs("[|clnp]", stdout);
+    return (1);
+
+}
+
+
+#define	ESIS_PDU_REDIRECT	6
+#define	ESIS_PDU_ESH	        2
+#define	ESIS_PDU_ISH	        4
 
-static struct tok esis_values[] = {
-    { ESIS_REDIRECT, "redirect"},
-    { ESIS_ESH,      "ESH"},
-    { ESIS_ISH,      "ISH"},
+static struct tok esis_pdu_values[] = {
+    { ESIS_PDU_REDIRECT, "redirect"},
+    { ESIS_PDU_ESH,      "ESH"},
+    { ESIS_PDU_ISH,      "ISH"},
     { 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 tmo[2];
+	u_int8_t holdtime[2];
 	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 (!eflag)
+            printf("ES-IS");
 
 	if (length <= 2) {
 		if (qflag)
-			printf(" bad pkt!");
+			printf("bad pkt!");
 		else
-			printf(" no header at all!");
+			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 (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%s, length %u",
+                   eflag ? "" : ", ",
+                   tok2str(esis_pdu_values,"unknown type (%u)",esis_pdu_type),
+                   length);
+            return;
+        } else
+            printf("%slength %u\n\t%s (%u)",
+                   eflag ? "" : ", ",
+                   length,
+                   tok2str(esis_pdu_values,"unknown type: %u", esis_pdu_type),
+                   esis_pdu_type);
+
+        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");
 
-	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(", holding time: %us, length indicator: %u",EXTRACT_16BITS(esis_header->holdtime),li);
 
-	switch (eh->type & 0x1f) {
-	case ESIS_REDIRECT: {
-		const u_int8_t *dst, *snpa, *is;
+        if (vflag > 1)
+            print_unknown_data(optr,"\n\t",sizeof(struct esis_header_t));
 
-		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)
+	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;
-		if (p > ep) {
-			printf(" [bad li]");
+		printf("\n\t  %s", isonsap_string(dst+1,*dst));
+		snpa = pptr; pptr += *pptr + 1;
+		tptr = pptr;   pptr += *pptr + 1;
+		if (pptr > snapend)
 			return;
-		}
-		if (is[0] == 0)
-			printf(" > %s", etheraddr_string(&snpa[1]));
+
+		if (tptr[0] == 0)
+			printf("\n\t  %s", etheraddr_string(&snpa[1]));
 		else
-			printf(" > %s", isonsap_string(is));
-		li = ep - p;
+			printf("\n\t  %s", isonsap_string(tptr+1,*tptr));
 		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,
+                       isonsap_string(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, isonsap_string(pptr+1, source_address_length));
+            pptr += source_address_length+1;
+            li -= source_address_length +1;
+            break;
 	}
 
 	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;
 	}
 
-        /* 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(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 */
 static char *
@@ -810,7 +1188,8 @@ isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *i
 	    goto trunctlv;
 
     switch(subt) {
-    case SUBTLV_EXTD_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) {
 	    printf(", 0x%08x (=%u)",
 		   EXTRACT_32BITS(tptr),
@@ -819,7 +1198,7 @@ isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *i
 	    subl-=4;
 	}
 	break;
-    case SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:
+    case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:
         while (subl >= 8) {
 	    printf(", 0x%08x%08x",
 		   EXTRACT_32BITS(tptr),
@@ -849,7 +1228,7 @@ trunctlv:
 static int
 isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
 
-        int priority_level;
+        int priority_level,bandwidth_constraint;
         union { /* int to float conversion buffer for several subTLVs */
             float f; 
             u_int32_t i;
@@ -868,28 +1247,28 @@ isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *i
 	    goto trunctlv;
 
         switch(subt) {
-        case SUBTLV_EXT_IS_REACH_ADMIN_GROUP:      
-        case SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:
-        case SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
+        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:
 	    if (subl >= 4) {
 	      printf(", 0x%08x", EXTRACT_32BITS(tptr));
 	      if (subl == 8) /* draft-ietf-isis-gmpls-extensions */
 	        printf(", 0x%08x", EXTRACT_32BITS(tptr+4));
 	    }
 	    break;
-        case SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
-        case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
+        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
+        case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
             if (subl >= 4)
               printf(", %s", ipaddr_string(tptr));
             break;
-        case SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
-	case SUBTLV_EXT_IS_REACH_RESERVABLE_BW:  
+        case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
+	case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:  
             if (subl >= 4) {
               bw.i = EXTRACT_32BITS(tptr);
               printf(", %.3f Mbps", bw.f*8/1000000 );
             }
             break;
-        case SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
+        case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
             if (subl >= 32) {
               for (priority_level = 0; priority_level < 8; priority_level++) {
                 bw.i = EXTRACT_32BITS(tptr);
@@ -901,18 +1280,34 @@ isis_print_is_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *i
 	      }
             }
             break;
-        case SUBTLV_EXT_IS_REACH_TE_METRIC:
+        case ISIS_SUBTLV_EXT_IS_REACH_DIFFSERV_TE:
+            printf("%sBandwidth Constraints Model ID: %s (%u)",
+                   ident,
+                   tok2str(diffserv_te_bc_values, "unknown", *tptr),
+                   *tptr);
+            tptr++;
+            /* decode BCs until the subTLV ends */
+            for (bandwidth_constraint = 0; bandwidth_constraint < (subl-1)/4; bandwidth_constraint++) {
+                bw.i = EXTRACT_32BITS(tptr);
+                printf("%s  Bandwidth constraint %d: %.3f Mbps",
+                       ident,
+                       bandwidth_constraint,
+                       bw.f*8/1000000 );
+		tptr+=4;
+            }
+            break;
+        case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:
             if (subl >= 3)
               printf(", %u", EXTRACT_24BITS(tptr));
             break;
-        case SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
+        case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
             if (subl >= 2) {
               printf(", %s, Priority %u",
 		   bittok2str(gmpls_link_prot_values, "none", *tptr),
                    *(tptr+1));
             }
             break;
-        case SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
+        case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
             if (subl >= 36) {
               printf("%s  Interface Switching Capability:%s",
                    ident,
@@ -971,7 +1366,7 @@ isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv_type) {
     printf("%sIS Neighbor: %s", ident, isis_print_id(tptr, NODE_ID_LEN));
     tptr+=(NODE_ID_LEN);
 
-    if (tlv_type != TLV_IS_ALIAS_ID) { /* the Alias TLV Metric field is implicit 0 */
+    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));
@@ -1133,7 +1528,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)
 {
-    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;
@@ -1150,13 +1545,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_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 */
-    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;
@@ -1164,39 +1559,42 @@ static int isis_print (const u_int8_t *p, u_int length)
     header_csnp = (const struct isis_csnp_header *)pptr;
     header_psnp = (const struct isis_psnp_header *)pptr;
 
+    if (!eflag)
+        printf("IS-IS");
+
     /*
      * 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);
     }
 
-    if ((header->id_length != SYSTEM_ID_LEN) && (header->id_length != 0)) {
-	printf(", system ID length of %d is not supported",
-	       header->id_length);
+    if ((isis_header->id_length != SYSTEM_ID_LEN) && (isis_header->id_length != 0)) {
+	printf("system ID length of %d is not supported",
+	       isis_header->id_length);
 	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);
     }
 
-    max_area = header->max_area;
+    max_area = isis_header->max_area;
     switch(max_area) {
     case 0:
 	max_area = 3;	 /* silly shit */
 	break;
     case 255:
-	printf(", bad packet -- 255 areas");
+	printf("bad packet -- 255 areas");
 	return (0);
     default:
 	break;
     }
 
-    id_length = header->id_length;
+    id_length = isis_header->id_length;
     switch(id_length) {
     case 0:
         id_length = 6;	 /* silly shit again */
@@ -1219,44 +1617,45 @@ static int isis_print (const u_int8_t *p, u_int length)
 
     /* toss any non 6-byte sys-ID len PDUs */
     if (id_length != 6 ) { 
-	printf(", bad packet -- illegal sys-ID length (%u)", id_length);
+	printf("bad packet -- illegal sys-ID length (%u)", id_length);
 	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) {
-        printf(", IS-IS, %s",
+        printf("%s%s",
+               eflag ? "" : ", ",
                tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type));
 
 	switch (pdu_type) {
 
-	case L1_LAN_IIH:
-	case L2_LAN_IIH:
+	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;
-	case PTP_IIH:
+	case ISIS_PDU_PTP_IIH:
 	    printf(", src-id %s", isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN));
 	    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;
-	case L1_CSNP:
-	case L2_CSNP:
-	    printf(", src-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,NODE_ID_LEN));
 	    break;
-	case L1_PSNP:
-	case L2_PSNP:
-	    printf(", src-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,NODE_ID_LEN));
 	    break;
 
 	}
@@ -1266,19 +1665,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 */
-    printf(", IS-IS, length: %u",length);
+    printf("%slength %u", eflag ? "" : ", ",length);
 
     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",
                    pdu_type),
-           header->fixed_len,
-           header->version,
-           header->pdu_version,
+           isis_header->fixed_len,
+           isis_header->version,
+           isis_header->pdu_version,
 	   id_length,
-	   header->id_length,
+	   isis_header->id_length,
            max_area,
-           header->max_area);
+           isis_header->max_area);
 
     if (vflag > 1) {
         if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
@@ -1287,11 +1686,11 @@ static int isis_print (const u_int8_t *p, u_int length)
 
     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",
-		   header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
+		   isis_header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
 	    return (0);
 	}
 
@@ -1311,7 +1710,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),
-               (header_iih_lan->priority) & PRIORITY_MASK,
+               (header_iih_lan->priority) & ISIS_LAN_PRIORITY_MASK,
                pdu_len);
 
         if (vflag > 1) {
@@ -1323,10 +1722,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;
 
-    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",
-		   header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
+		   isis_header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
 	    return (0);
 	}
 
@@ -1357,11 +1756,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;
 
-    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",
-		   header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
+		   isis_header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
 	    return (0);
 	}
 
@@ -1411,11 +1810,11 @@ static int isis_print (const u_int8_t *p, u_int length)
 	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",
-		   header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
+		   isis_header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
 	    return (0);
 	}
 
@@ -1443,11 +1842,11 @@ static int isis_print (const u_int8_t *p, u_int length)
 	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",
-		   header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
+		   isis_header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
 	    return (0);
 	}
 
@@ -1510,14 +1909,14 @@ 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) {
-	case TLV_AREA_ADDR:
+	case ISIS_TLV_AREA_ADDR:
 	    if (!TTEST2(*tptr, 1))
 		goto trunctlv;
 	    alen = *tptr++;
 	    while (tmp && alen < tmp) {
 		printf("\n\t      Area address (length: %u): %s",
                        alen,
-                       print_nsap(tptr, alen));
+                       isonsap_string(tptr,alen));
 		tptr += alen;
 		tmp -= alen + 1;
 		if (tmp==0) /* if this is the last area address do not attemt a boundary check */
@@ -1527,7 +1926,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 		alen = *tptr++;
 	    }
 	    break;
-	case TLV_ISNEIGH:
+	case ISIS_TLV_ISNEIGH:
 	    while (tmp >= ETHER_ADDR_LEN) {
                 if (!TTEST2(*tptr, ETHER_ADDR_LEN))
                     goto trunctlv;
@@ -1537,7 +1936,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-        case TLV_ISNEIGH_VARLEN:
+        case ISIS_TLV_ISNEIGH_VARLEN:
             if (!TTEST2(*tptr, 1))
 		goto trunctlv;
 	    lan_alen = *tptr++; /* LAN adress length */
@@ -1552,10 +1951,10 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             break;
 
-	case TLV_PADDING:
+	case ISIS_TLV_PADDING:
 	    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 ? */
@@ -1572,7 +1971,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             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 ? */
@@ -1582,7 +1981,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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 ? */
@@ -1591,7 +1990,7 @@ static int isis_print (const u_int8_t *p, u_int length)
                 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",
@@ -1610,7 +2009,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
             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))
@@ -1624,13 +2023,13 @@ static int isis_print (const u_int8_t *p, u_int length)
             break;
 
             /* those two TLVs share the same format */
-	case TLV_INT_IP_REACH:
-	case TLV_EXT_IP_REACH:
+	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;
 
-	case TLV_EXTD_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 ? */
@@ -1640,7 +2039,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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 ? */
@@ -1657,7 +2056,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    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 ? */
@@ -1667,7 +2066,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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 ? */
@@ -1683,7 +2082,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-	case TLV_IP6ADDR:
+	case ISIS_TLV_IP6ADDR:
 	    while (tmp>0) {
 		if (!TTEST2(*tptr, 16))
 		    goto trunctlv;
@@ -1696,7 +2095,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 #endif
-	case TLV_AUTH:
+	case ISIS_TLV_AUTH:
 	    if (!TTEST2(*tptr, 1))
 		goto trunctlv;
 
@@ -1706,23 +2105,23 @@ static int isis_print (const u_int8_t *p, u_int length)
                            *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;
-	    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));
 		}
-		if (tlv_len != SUBTLV_AUTH_MD5_LEN+1)
+		if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)
                     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);
@@ -1730,7 +2129,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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))
@@ -1764,13 +2163,13 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-	case TLV_PROTOCOLS:
+	case ISIS_TLV_PROTOCOLS:
 	    printf("\n\t      NLPID(s): ");
 	    while (tmp>0) {
 		if (!TTEST2(*(tptr), 1))
 		    goto trunctlv;
 		printf("%s (0x%02x)",
-                       tok2str(osi_nlpid_values,
+                       tok2str(nlpid_values,
                                "unknown",
                                *tptr),
                        *tptr);
@@ -1781,13 +2180,13 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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;
 
-	case TLV_IPADDR:
+	case ISIS_TLV_IPADDR:
 	    while (tmp>0) {
 		if (!TTEST2(*tptr, 4))
 		    goto trunctlv;
@@ -1797,7 +2196,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-	case TLV_HOSTNAME:
+	case ISIS_TLV_HOSTNAME:
 	    printf("\n\t      Hostname: ");
 	    while (tmp>0) {
 		if (!TTEST2(*tptr, 1))
@@ -1807,7 +2206,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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));
@@ -1840,7 +2239,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-	case TLV_LSP:
+	case ISIS_TLV_LSP:
 	    tlv_lsp = (const struct isis_tlv_lsp *)tptr;
 	    while(tmp>0) {
 		if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN-1]))
@@ -1861,7 +2260,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    break;
 
-	case TLV_CHECKSUM:
+	case ISIS_TLV_CHECKSUM:
 	    if (!TTEST2(*tptr, 2))
 		goto trunctlv;
 	    printf("\n\t      checksum: 0x%04x ", EXTRACT_16BITS(tptr));
@@ -1875,7 +2274,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             else printf("(%s)", osi_cksum(optr, length) ? "incorrect" : "correct");
 	    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 */
@@ -1892,7 +2291,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    }
 	    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",
@@ -1901,7 +2300,7 @@ static int isis_print (const u_int8_t *p, u_int length)
 	    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",
@@ -1909,13 +2308,13 @@ static int isis_print (const u_int8_t *p, u_int length)
                            "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;
-            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);
@@ -1923,13 +2322,13 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             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;
 
-        case TLV_PART_DIS:
+        case ISIS_TLV_PART_DIS:
             while (tmp >= SYSTEM_ID_LEN) {
                 if (!TTEST2(*tptr, SYSTEM_ID_LEN))
                     goto trunctlv;
@@ -1939,7 +2338,7 @@ static int isis_print (const u_int8_t *p, u_int length)
             }
             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");
@@ -1955,23 +2354,26 @@ static int isis_print (const u_int8_t *p, u_int length)
                 if (!TTEST2(*tptr, prefix_len/2))
                     goto trunctlv;
                 printf("\n\t\tAddress: %s/%u",
-                       print_nsap(tptr,prefix_len/2),
+                       isonsap_string(tptr,prefix_len/2),
                        prefix_len*4);
                 tptr+=prefix_len/2;
                 tmp-=prefix_len/2;
             }
             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;
 
-        case TLV_VENDOR_PRIVATE:
+        case ISIS_TLV_VENDOR_PRIVATE:
             if (!TTEST2(*tptr, 3)) /* check if enough byte for a full oui */
                 goto trunctlv;
-            printf("\n\t      Vendor OUI Code: 0x%06x", EXTRACT_24BITS(tptr) );
+            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 */
@@ -1983,11 +2385,11 @@ static int isis_print (const u_int8_t *p, u_int length)
              * 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) {
@@ -2037,3 +2439,11 @@ osi_cksum(const u_int8_t *tptr, u_int len)
 	}
 	return (c0 | c1);
 }
+
+
+/*
+ * Local Variables:
+ * c-style: whitesmith
+ * c-basic-offset: 8
+ * End:
+ */