]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-isoclns.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add SunATM support, based on code from Yen Yen Lim at North Dakota State
[tcpdump] / print-isoclns.c
diff --git a/print-isoclns.c b/print-isoclns.c
index e9100911adf986c283653323c1356505297dc93e..d9b5e9d255f39fe8f240823c81d3556f0c8e873c 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -26,7 +26,7 @@
 
 #ifndef lint
 static const char rcsid[] =
 
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.43 2002-04-09 08:27:25 guy Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.52 2002-06-29 04:33:31 guy Exp $ (LBL)";
 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H
@@ -52,7 +52,7 @@ static const char rcsid[] =
 #define        NLPID_ESIS      130     /* 0x82 */
 #define        NLPID_ISIS      131     /* 0x83 */
 #define NLPID_IP6       0x8e
 #define        NLPID_ESIS      130     /* 0x82 */
 #define        NLPID_ISIS      131     /* 0x83 */
 #define NLPID_IP6       0x8e
-#define NLPID_IP        0xcc  
+#define NLPID_IP        0xcc
 #define        NLPID_NULLNS    0
 
 /*
 #define        NLPID_NULLNS    0
 
 /*
@@ -60,6 +60,9 @@ static const char rcsid[] =
  */
 
 #define SYSTEM_ID_LEN  ETHER_ADDR_LEN
  */
 
 #define SYSTEM_ID_LEN  ETHER_ADDR_LEN
+#define NODE_ID_LEN     SYSTEM_ID_LEN+1
+#define LSP_ID_LEN      SYSTEM_ID_LEN+2
+
 #define ISIS_VERSION   1
 #define PDU_TYPE_MASK  0x1F
 #define PRIORITY_MASK  0x7F
 #define ISIS_VERSION   1
 #define PDU_TYPE_MASK  0x1F
 #define PRIORITY_MASK  0x7F
@@ -76,13 +79,13 @@ static const char rcsid[] =
 
 static struct tok isis_pdu_values[] = {
     { L1_LAN_IIH,       "L1 Lan IIH"},
 
 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_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"},
     { L2_CSNP,          "L2 CSNP"},
-    { L1_PSNP,          "L1 PSNP"},   
+    { L1_PSNP,          "L1 PSNP"},
     { L2_PSNP,          "L2 PSNP"},
     { 0, NULL}
 };
     { L2_PSNP,          "L2 PSNP"},
     { 0, NULL}
 };
@@ -99,14 +102,16 @@ static struct tok isis_pdu_values[] = {
 #define TLV_IS_REACH            2
 #define TLV_ESNEIGH             3
 #define TLV_PART_DIS            4
 #define TLV_IS_REACH            2
 #define TLV_ESNEIGH             3
 #define TLV_PART_DIS            4
-#define TLV_SUMMARY             5
+#define TLV_PREFIX_NEIGH        5
 #define TLV_ISNEIGH             6
 #define TLV_ISNEIGH             6
+#define TLV_ISNEIGH_VARLEN      7
 #define TLV_PADDING             8
 #define TLV_LSP                 9
 #define TLV_AUTH                10
 #define TLV_CHECKSUM            12
 #define TLV_LSP_BUFFERSIZE      14
 #define TLV_EXT_IS_REACH        22
 #define TLV_PADDING             8
 #define TLV_LSP                 9
 #define TLV_AUTH                10
 #define TLV_CHECKSUM            12
 #define TLV_LSP_BUFFERSIZE      14
 #define TLV_EXT_IS_REACH        22
+#define TLV_IS_ALIAS_ID         24
 #define TLV_DECNET_PHASE4       42
 #define TLV_LUCENT_PRIVATE      66
 #define TLV_IP_REACH            128
 #define TLV_DECNET_PHASE4       42
 #define TLV_LUCENT_PRIVATE      66
 #define TLV_IP_REACH            128
@@ -120,7 +125,7 @@ static struct tok isis_pdu_values[] = {
 #define TLV_HOSTNAME            137
 #define TLV_SHARED_RISK_GROUP   138
 #define TLV_NORTEL_PRIVATE1     176
 #define TLV_HOSTNAME            137
 #define TLV_SHARED_RISK_GROUP   138
 #define TLV_NORTEL_PRIVATE1     176
-#define TLV_NORTEL_PRIVATE2     177   
+#define TLV_NORTEL_PRIVATE2     177
 #define TLV_RESTART_SIGNALING   211
 #define TLV_MT_IS_REACH         222
 #define TLV_MT_SUPPORTED        229
 #define TLV_RESTART_SIGNALING   211
 #define TLV_MT_IS_REACH         222
 #define TLV_MT_SUPPORTED        229
@@ -132,39 +137,41 @@ static struct tok isis_pdu_values[] = {
 
 static struct tok isis_tlv_values[] = {
     { TLV_AREA_ADDR,        "Area address(es)"},
 
 static struct tok isis_tlv_values[] = {
     { TLV_AREA_ADDR,        "Area address(es)"},
-    { TLV_IS_REACH,          "IS Reachability"},           
-    { TLV_ESNEIGH,           "IS Neighbor(s)"},           
-    { TLV_PART_DIS,          "Partition DIS"},           
-    { TLV_SUMMARY,           "Prefix Neighbors"},          
-    { TLV_ISNEIGH,           "IS Neighbor(s)"},   
-    { 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_DECNET_PHASE4,     "DECnet Phase IV"},     
-    { TLV_LUCENT_PRIVATE,    "Lucent Proprietary"},     
-    { TLV_IP_REACH,          "IP Internal reachability"}, 
-    { TLV_PROTOCOLS,         "Protocols supported"}, 
-    { TLV_IP_REACH_EXT,      "IP External reachability"}, 
-    { TLV_IDRP_INFO,         "Inter-Domain Information Type"}, 
-    { TLV_IPADDR,            "IP Interface address(es)"},            
-    { TLV_IPAUTH,            "IP authentication (depreciated)"},            
-    { TLV_TE_ROUTER_ID,      "Traffic Engineering Router ID"}, 
-    { TLV_EXT_IP_REACH,      "Extended IP reachability"}, 
-    { TLV_HOSTNAME,          "Hostname"}, 
-    { TLV_SHARED_RISK_GROUP, "Shared Risk Link Group"},  
-    { TLV_NORTEL_PRIVATE1,   "Nortel Proprietary"},   
-    { TLV_NORTEL_PRIVATE2,   "Nortel Proprietary"},   
-    { TLV_RESTART_SIGNALING, "Restart Signaling"}, 
-    { TLV_MT_IS_REACH,       "Multi Topology IS Reachability"}, 
-    { TLV_MT_SUPPORTED,      "Multi Topology"}, 
-    { TLV_IP6ADDR,           "IP6 Interface address(es)"},           
-    { TLV_MT_IP_REACH,       "Multi-Topology IP reachability"}, 
-    { TLV_IP6_REACH,         "IP6 reachability"}, 
-    { TLV_MT_IP6_REACH,      "Multi-Topology IP6 reachability"},      
-    { TLV_PTP_ADJ,           "Point-to-point Adjacency State"}, 
+    { 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_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"},
     { 0, NULL }
 };
 
     { 0, NULL }
 };
 
@@ -180,7 +187,8 @@ static struct tok isis_tlv_values[] = {
 #define SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20
 #define SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21
 
 #define SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20
 #define SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21
 
-#define SUBTLV_EXT_IP_REACH_ADMIN_TAG             1
+#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_SIMPLE        1
 #define SUBTLV_AUTH_MD5          54
@@ -194,8 +202,18 @@ static struct tok isis_subtlv_auth_values[] = {
     { 0, NULL }
 };
 
     { 0, NULL }
 };
 
+#define SUBTLV_IDRP_RES           0
+#define SUBTLV_IDRP_LOCAL         1
+#define SUBTLV_IDRP_ASN           2
+
+static struct tok isis_subtlv_idrp_values[] = {
+    { SUBTLV_IDRP_RES,         "Reserved"},
+    { SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
+    { SUBTLV_IDRP_ASN,         "AS Number Tag"},
+    { 0, NULL}
+};
 
 
-#define ISIS_8BIT_MASK(x)                  ((x)&0xff) 
+#define ISIS_8BIT_MASK(x)                  ((x)&0xff)
 
 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
 
 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
@@ -320,30 +338,36 @@ static struct tok isis_ptp_adjancey_values[] = {
 
 struct isis_tlv_ptp_adj {
     u_char adjacency_state;
 
 struct isis_tlv_ptp_adj {
     u_char adjacency_state;
-    u_char ext_local_circuit_id[4];
+    u_char extd_local_circuit_id[4];
     u_char neighbor_sysid[SYSTEM_ID_LEN];
     u_char neighbor_sysid[SYSTEM_ID_LEN];
-    u_char neighbor_ext_local_circuit_id[4]; 
+    u_char neighbor_extd_local_circuit_id[4];
 };
 
 };
 
-static int osi_cksum(const u_char *, u_int, u_char *);
+static int osi_cksum(const u_char *, u_int);
 static void esis_print(const u_char *, u_int);
 static int isis_print(const u_char *, u_int);
 
 static void esis_print(const u_char *, u_int);
 static int isis_print(const u_char *, u_int);
 
-struct isis_tlv_ip_reach {
+struct isis_metric_block {
     u_char metric_default;
     u_char metric_delay;
     u_char metric_expense;
     u_char metric_error;
     u_char metric_default;
     u_char metric_delay;
     u_char metric_expense;
     u_char metric_error;
-    u_char prefix[4];
-    u_char mask[4];
 };
 
 struct isis_tlv_is_reach {
 };
 
 struct isis_tlv_is_reach {
-    u_char metric_default;
-    u_char metric_delay;
-    u_char metric_expense;
-    u_char metric_error;
-    u_char neighbor_nodeid[SYSTEM_ID_LEN+1];
+    struct isis_metric_block isis_metric_block;
+    u_char neighbor_nodeid[NODE_ID_LEN];
+};
+
+struct isis_tlv_es_reach {
+    struct isis_metric_block isis_metric_block;
+    u_char neighbor_sysid[SYSTEM_ID_LEN];
+};
+
+struct isis_tlv_ip_reach {
+    struct isis_metric_block isis_metric_block;
+    u_char prefix[4];
+    u_char mask[4];
 };
 
 static struct tok isis_is_reach_virtual_values[] = {
 };
 
 static struct tok isis_is_reach_virtual_values[] = {
@@ -369,7 +393,7 @@ struct isis_iih_lan_header {
     u_char holding_time[2];
     u_char pdu_len[2];
     u_char priority;
     u_char holding_time[2];
     u_char pdu_len[2];
     u_char priority;
-    u_char lan_id[SYSTEM_ID_LEN+1];
+    u_char lan_id[NODE_ID_LEN];
 };
 
 struct isis_iih_ptp_header {
 };
 
 struct isis_iih_ptp_header {
@@ -383,7 +407,7 @@ struct isis_iih_ptp_header {
 struct isis_lsp_header {
     u_char pdu_len[2];
     u_char remaining_lifetime[2];
 struct isis_lsp_header {
     u_char pdu_len[2];
     u_char remaining_lifetime[2];
-    u_char lsp_id[SYSTEM_ID_LEN+2];
+    u_char lsp_id[LSP_ID_LEN];
     u_char sequence_number[4];
     u_char checksum[2];
     u_char typeblock;
     u_char sequence_number[4];
     u_char checksum[2];
     u_char typeblock;
@@ -391,23 +415,23 @@ struct isis_lsp_header {
 
 struct isis_csnp_header {
     u_char pdu_len[2];
 
 struct isis_csnp_header {
     u_char pdu_len[2];
-    u_char source_id[SYSTEM_ID_LEN+1];
-    u_char start_lsp_id[SYSTEM_ID_LEN+2];
-    u_char end_lsp_id[SYSTEM_ID_LEN+2];
+    u_char source_id[NODE_ID_LEN];
+    u_char start_lsp_id[LSP_ID_LEN];
+    u_char end_lsp_id[LSP_ID_LEN];
 };
 
 struct isis_psnp_header {
     u_char pdu_len[2];
 };
 
 struct isis_psnp_header {
     u_char pdu_len[2];
-    u_char source_id[SYSTEM_ID_LEN+1];
+    u_char source_id[NODE_ID_LEN];
 };
 
 struct isis_tlv_lsp {
     u_char remaining_lifetime[2];
 };
 
 struct isis_tlv_lsp {
     u_char remaining_lifetime[2];
-    u_char lsp_id[SYSTEM_ID_LEN+2];
+    u_char lsp_id[LSP_ID_LEN];
     u_char sequence_number[4];
     u_char checksum[2];
 };
     u_char sequence_number[4];
     u_char checksum[2];
 };
-    
+
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
@@ -420,7 +444,7 @@ void isoclns_print(const u_char *p, u_int length, u_int caplen,
 {
        u_char pdu_type;
        const struct isis_common_header *header;
 {
        u_char pdu_type;
        const struct isis_common_header *header;
-       
+
        header = (const struct isis_common_header *)p;
        pdu_type = header->pdu_type & PDU_TYPE_MASK;
 
        header = (const struct isis_common_header *)p;
        pdu_type = header->pdu_type & PDU_TYPE_MASK;
 
@@ -500,7 +524,6 @@ esis_print(const u_char *p, u_int length)
        const u_char *ep;
        u_int li;
        const struct esis_hdr *eh;
        const u_char *ep;
        u_int li;
        const struct esis_hdr *eh;
-       u_char off[2];
 
        if (length <= 2) {
                if (qflag)
 
        if (length <= 2) {
                if (qflag)
@@ -547,10 +570,8 @@ esis_print(const u_char *p, u_int length)
                printf(" type %d", eh->type & 0x1f);
                break;
        }
                printf(" type %d", eh->type & 0x1f);
                break;
        }
-       off[0] = eh->cksum[0];
-       off[1] = eh->cksum[1];
-       if (vflag && osi_cksum(p, li, off)) {
-               printf(" bad cksum (got %02x%02x)",
+       if (vflag && osi_cksum(p, li)) {
+               printf(" bad cksum (got 0x%02x%02x)",
                       eh->cksum[1], eh->cksum[0]);
                default_print(p, length);
                return;
                       eh->cksum[1], eh->cksum[0]);
                default_print(p, length);
                return;
@@ -648,69 +669,96 @@ esis_print(const u_char *p, u_int length)
                }
 }
 
                }
 }
 
-/*
- * print_nsap
- * Print out an NSAP. 
- */
-static int
+/* allocate space for the following string
+ * xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx
+ * 32 bytes plus one termination byte */
+static char *
 print_nsap(register const u_char *cp, register int length)
 {
        int i;
 print_nsap(register const u_char *cp, register int length)
 {
        int i;
+       static char nsap[33];
+        char *pos = nsap;
+
+        if (length==0) {
+               *(pos) = '0';
+                *(pos+1) = '\0';
+                return (nsap);
+        }
 
        for (i = 0; i < length; i++) {
                if (!TTEST2(*cp, 1))
                        return (0);
 
        for (i = 0; i < length; i++) {
                if (!TTEST2(*cp, 1))
                        return (0);
-               printf("%02x", *cp++);
+               pos+=sprintf(pos, "%02x", *cp++);
                if (((i & 1) == 0) && (i + 1 < length)) {
                if (((i & 1) == 0) && (i + 1 < length)) {
-                       printf(".");
+                       pos+=sprintf(pos, ".");
                }
        }
                }
        }
-       return (1);
+        *(pos) = '\0';
+       return (nsap);
 }
 
 }
 
-static int
-isis_print_sysid(const u_char *cp)
+/* allocate space for the following string
+ * xxxx.xxxx.xxxx
+ * 14 bytes plus one termination byte */
+static char *
+isis_print_sysid(const u_char *cp, int sysid_len)
 {
        int i;
 {
        int i;
+       static char sysid[15];
+        char *pos = sysid;
 
 
-       for (i = 1; i <= 6; i++) {
+       for (i = 1; i <= sysid_len; i++) {
                if (!TTEST2(*cp, 1))
                        return (0);
                if (!TTEST2(*cp, 1))
                        return (0);
-               printf("%02x", *cp++);
+               pos+=sprintf(pos, "%02x", *cp++);
                if ((i==2)^(i==4)) {
                if ((i==2)^(i==4)) {
-                       printf(".");
+                       pos+=sprintf(pos, ".");
                }
        }
                }
        }
-       return (1);
+        *(pos) = '\0';
+       return (sysid);
 }
 
 }
 
-static int
+
+/* allocate space for the following string
+ * xxxx.xxxx.xxxx.yy
+ * 17 bytes plus one termination byte */
+static char *
 isis_print_nodeid(const u_char *cp)
 {
        int i;
 isis_print_nodeid(const u_char *cp)
 {
        int i;
+       static char nodeid[18];
+        char *pos = nodeid;
 
        for (i = 1; i <= 7; i++) {
                if (!TTEST2(*cp, 1))
                        return (0);
 
        for (i = 1; i <= 7; i++) {
                if (!TTEST2(*cp, 1))
                        return (0);
-               printf("%02x", *cp++);
+               pos+=sprintf(pos, "%02x", *cp++);
                if ((i & 1) == 0) {
                if ((i & 1) == 0) {
-                       printf(".");
+                       pos+=sprintf(pos, ".");
                }
        }
                }
        }
-       return (1);
+        *(pos) = '\0';
+       return (nodeid);
 }
 
 }
 
-static void
+/* allocate space for the following string
+ * xxxx.xxxx.xxxx.yy-zz
+ * 20 bytes plus one termination byte */
+static char *
 isis_print_lspid(const u_char *cp)
 {
        int i;
 isis_print_lspid(const u_char *cp)
 {
        int i;
+       static char lspid[21];
+        char *pos = lspid;
 
        for (i = 1; i <= 7; i++) {
 
        for (i = 1; i <= 7; i++) {
-               printf("%02x", *cp++);
+               pos+=sprintf(pos, "%02x", *cp++);
                if ((i & 1) == 0)
                if ((i & 1) == 0)
-                       printf(".");
+                       pos+=sprintf(pos, ".");
        }
        }
-       printf("-%02x", *cp);
+       pos+=sprintf(pos, "-%02x", *cp);
+        return (lspid);
 }
 
 /*
 }
 
 /*
@@ -721,10 +769,10 @@ isis_print_lspid(const u_char *cp)
  */
 
 static int
  */
 
 static int
-isis_print_unknown_data(const u_char *cp,const u_char *lf,int len)
+isis_print_unknown_data(const u_char *cp,const char *lf,int len)
 {
         int i;
 {
         int i;
-       
+
        printf("%s0x0000: ",lf);
        for(i=0;i<len;i++) {
            if (!TTEST2(*(cp+i), 1))
        printf("%s0x0000: ",lf);
        for(i=0;i<len;i++) {
            if (!TTEST2(*(cp+i), 1))
@@ -745,6 +793,30 @@ trunctlv:
 
 }
 
 
 }
 
+/* print the 4-byte metric block which is common found in the old-style TLVs */
+
+static int
+isis_print_metric_block (const struct isis_metric_block *isis_metric_block)
+{
+    printf(", Default Metric: %d, %s",
+           ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_default),
+           ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_default) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_delay))
+        printf("\n\t\t\t  Delay Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_delay),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_delay) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_expense))
+        printf("\n\t\t\t  Expense Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_expense),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_expense) ? "External" : "Internal");
+    if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_error))
+        printf("\n\t\t\t  Error Metric: %d, %s",
+               ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_error),
+               ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_error) ? "External" : "Internal");
+
+    return(1); /* everything is ok */
+}
+
 static int
 isis_print_tlv_ip_reach (const u_char *cp, int length)
 {
 static int
 isis_print_tlv_ip_reach (const u_char *cp, int length)
 {
@@ -767,7 +839,7 @@ isis_print_tlv_ip_reach (const u_char *cp, int length)
 
        while (length > 0) {
                if (length < sizeof(*tlv_ip_reach)) {
 
        while (length > 0) {
                if (length < sizeof(*tlv_ip_reach)) {
-                       printf("short IP reachability (%d vs %lu)", length,
+                       printf("short IPv4 reachability (%d vs %lu)", length,
                            (unsigned long)sizeof(*tlv_ip_reach));
                        return (0);
                }
                            (unsigned long)sizeof(*tlv_ip_reach));
                        return (0);
                }
@@ -790,34 +862,34 @@ isis_print_tlv_ip_reach (const u_char *cp, int length)
                 * 34 indicates no match -> must be a discontiguous netmask
                 * lets dump the mask, otherwise print the prefix_len
                 */
                 * 34 indicates no match -> must be a discontiguous netmask
                 * lets dump the mask, otherwise print the prefix_len
                 */
-               if (prefix_len == 34) 
+               if (prefix_len == 34)
                        printf("\n\t\t\tIPv4 prefix: %s mask %s",
                               ipaddr_string((tlv_ip_reach->prefix)),
                               ipaddr_string((tlv_ip_reach->mask)));
                        printf("\n\t\t\tIPv4 prefix: %s mask %s",
                               ipaddr_string((tlv_ip_reach->prefix)),
                               ipaddr_string((tlv_ip_reach->mask)));
-               else 
+               else
                        printf("\n\t\t\tIPv4 prefix: %s/%u",
                               ipaddr_string((tlv_ip_reach->prefix)),
                               prefix_len);
 
                printf("\n\t\t\t  Default Metric: %02d, %s, Distribution: %s",
                        printf("\n\t\t\tIPv4 prefix: %s/%u",
                               ipaddr_string((tlv_ip_reach->prefix)),
                               prefix_len);
 
                printf("\n\t\t\t  Default Metric: %02d, %s, Distribution: %s",
-                   ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_default),
-                   ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_default) ? "External" : "Internal",
-                   ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->metric_default) ? "down" : "up");
+                   ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_default),
+                   ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_default) ? "External" : "Internal",
+                   ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->isis_metric_block.metric_default) ? "down" : "up");
 
 
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_delay))
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_delay))
                        printf("\n\t\t\t  Delay Metric: %02d, %s",
                        printf("\n\t\t\t  Delay Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_delay),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_delay) ? "External" : "Internal");
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_delay),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_delay) ? "External" : "Internal");
 
 
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_expense))
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_expense))
                        printf("\n\t\t\t  Expense Metric: %02d, %s",
                        printf("\n\t\t\t  Expense Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_expense),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_expense) ? "External" : "Internal");
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_expense),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_expense) ? "External" : "Internal");
 
 
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->metric_error))
+               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_error))
                        printf("\n\t\t\t  Error Metric: %02d, %s",
                        printf("\n\t\t\t  Error Metric: %02d, %s",
-                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->metric_error),
-                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->metric_error) ? "External" : "Internal");
+                           ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_error),
+                           ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_error) ? "External" : "Internal");
 
                length -= sizeof(struct isis_tlv_ip_reach);
                tlv_ip_reach++;
 
                length -= sizeof(struct isis_tlv_ip_reach);
                tlv_ip_reach++;
@@ -827,20 +899,28 @@ isis_print_tlv_ip_reach (const u_char *cp, int length)
 
 /*
  * this is the common IP-REACH subTLV decoder it is called
 
 /*
  * this is the common IP-REACH subTLV decoder it is called
- * from various EXTD-IP REACH TLVs (135,236)
+ * from various EXTD-IP REACH TLVs (135,235,236,237)
  */
 
 static int
  */
 
 static int
-isis_print_ip_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *lf) {
+isis_print_ip_reach_subtlv (const u_char *tptr,int subt,int subl,const char *lf) {
 
         switch(subt) {
 
         switch(subt) {
-        case SUBTLV_EXT_IP_REACH_ADMIN_TAG:
+        case SUBTLV_IP_REACH_ADMIN_TAG32:
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
-            printf("%sAdministrative tag: 0x%08x",
+            printf("%s32-Bit Administrative tag: 0x%08x",
                    lf,
                    EXTRACT_32BITS(tptr));
             break;
                    lf,
                    EXTRACT_32BITS(tptr));
             break;
+        case SUBTLV_IP_REACH_ADMIN_TAG64:
+            if (!TTEST2(*tptr,8))
+                goto trunctlv;
+            printf("%s64-Bit Administrative tag: 0x%08x%08x",
+                   lf,
+                   EXTRACT_32BITS(tptr),
+                   EXTRACT_32BITS(tptr+4));
+            break;
         default:
             printf("%sunknown subTLV, type %d, length %d",
                    lf,
         default:
             printf("%sunknown subTLV, type %d, length %d",
                    lf,
@@ -850,7 +930,7 @@ isis_print_ip_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
                                        subl))
                 return(0);
             break;
                                        subl))
                 return(0);
             break;
-        }      
+        }
         return(1);
 
 trunctlv:
         return(1);
 
 trunctlv:
@@ -860,11 +940,11 @@ trunctlv:
 
 /*
  * this is the common IS-REACH subTLV decoder it is called
 
 /*
  * this is the common IS-REACH subTLV decoder it is called
- * from various EXTD-IS REACH TLVs (22,222)
+ * from various EXTD-IS REACH TLVs (22,24,222)
  */
 
 static int
  */
 
 static int
-isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *lf) {
+isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const char *lf) {
 
         int i,j;
         float bw; /* copy buffer for several subTLVs */
 
         int i,j;
         float bw; /* copy buffer for several subTLVs */
@@ -895,16 +975,16 @@ isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             j = EXTRACT_32BITS(tptr);
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             j = EXTRACT_32BITS(tptr);
-            memcpy (&bw, &j, 4);            
+            memcpy (&bw, &j, 4);
             printf("%sMaximum link bandwidth : %.3f Mbps",
                    lf,
                    bw*8/1000000 );
             printf("%sMaximum link bandwidth : %.3f Mbps",
                    lf,
                    bw*8/1000000 );
-            break;                            
+            break;
         case SUBTLV_EXT_IS_REACH_RESERVABLE_BW :
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             j = EXTRACT_32BITS(tptr);
         case SUBTLV_EXT_IS_REACH_RESERVABLE_BW :
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             j = EXTRACT_32BITS(tptr);
-            memcpy (&bw, &j, 4); 
+            memcpy (&bw, &j, 4);
             printf("%sReservable link bandwidth: %.3f Mbps",
                    lf,
                    bw*8/1000000  );
             printf("%sReservable link bandwidth: %.3f Mbps",
                    lf,
                    bw*8/1000000  );
@@ -915,27 +995,27 @@ isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
                 if (!TTEST2(*(tptr+i*4),4))
                     goto trunctlv;
                 j = EXTRACT_32BITS(tptr);
                 if (!TTEST2(*(tptr+i*4),4))
                     goto trunctlv;
                 j = EXTRACT_32BITS(tptr);
-                memcpy (&bw, &j, 4);   
+                memcpy (&bw, &j, 4);
                 printf("%s  priority level %d: %.3f Mbps",
                        lf,
                        i,
                        bw*8/1000000 );
             }
                 printf("%s  priority level %d: %.3f Mbps",
                        lf,
                        i,
                        bw*8/1000000 );
             }
-            break;      
+            break;
         case SUBTLV_EXT_IS_REACH_TE_METRIC:
             if (!TTEST2(*tptr,3))
                 goto trunctlv;
             printf("%sTraffic Engineering Metric: %d",
                    lf,
                    EXTRACT_24BITS(tptr));
         case SUBTLV_EXT_IS_REACH_TE_METRIC:
             if (!TTEST2(*tptr,3))
                 goto trunctlv;
             printf("%sTraffic Engineering Metric: %d",
                    lf,
                    EXTRACT_24BITS(tptr));
-            break;                            
+            break;
         case SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             printf("%sIPv4 interface address: %s",
                    lf,
                    ipaddr_string(tptr));
         case SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
             printf("%sIPv4 interface address: %s",
                    lf,
                    ipaddr_string(tptr));
-            break;     
+            break;
         case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
         case SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
             if (!TTEST2(*tptr,4))
                 goto trunctlv;
@@ -984,7 +1064,7 @@ isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
                 if (!TTEST2(*(tptr+(i*4)+4),4))
                     goto trunctlv;
                 j = EXTRACT_32BITS(tptr);
                 if (!TTEST2(*(tptr+(i*4)+4),4))
                     goto trunctlv;
                 j = EXTRACT_32BITS(tptr);
-                memcpy (&bw, &j, 4);   
+                memcpy (&bw, &j, 4);
                 printf("%s    priority level %d: %.3f Mbps",
                        lf,
                        i,
                 printf("%s    priority level %d: %.3f Mbps",
                        lf,
                        i,
@@ -1014,7 +1094,7 @@ isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
                    lf,
                    subt,
                    subl);
                    lf,
                    subt,
                    subl);
-            break;                                 
+            break;
         default:
             printf("%sunknown subTLV, type %d, length %d",
                    lf,
         default:
             printf("%sunknown subTLV, type %d, length %d",
                    lf,
@@ -1024,7 +1104,7 @@ isis_print_is_reach_subtlv (const u_char *tptr,int subt,int subl,const u_char *l
                                        subl))
                 return(0);
             break;
                                        subl))
                 return(0);
             break;
-        }      
+        }
         return(1);
 
 trunctlv:
         return(1);
 
 trunctlv:
@@ -1051,8 +1131,9 @@ static int isis_print (const u_char *p, u_int length)
     const struct isis_tlv_lsp *tlv_lsp;
     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
     const struct isis_tlv_is_reach *tlv_is_reach;
     const struct isis_tlv_lsp *tlv_lsp;
     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
     const struct isis_tlv_is_reach *tlv_is_reach;
+    const struct isis_tlv_es_reach *tlv_es_reach;
 
 
-    u_char pdu_type, max_area, id_length, type, len, tmp, alen, subl, subt, tslen;
+    u_char pdu_type, max_area, id_length, type, len, tmp, alen, lan_alen, prefix_len, subl, subt, tslen;
     const u_char *optr, *pptr, *tptr;
     u_short packet_len,pdu_len,time_remain;
     u_int i,j,bit_length,byte_length,metric,ra,rr;
     const u_char *optr, *pptr, *tptr;
     u_short packet_len,pdu_len,time_remain;
     u_int i,j,bit_length,byte_length,metric,ra,rr;
@@ -1060,19 +1141,18 @@ static int isis_print (const u_char *p, u_int length)
 #ifdef INET6
     u_char prefix6[16]; /* copy buffer for ipv6 prefixes */
 #endif
 #ifdef INET6
     u_char prefix6[16]; /* copy buffer for ipv6 prefixes */
 #endif
-    u_char off[2];
-
     packet_len=length;
     packet_len=length;
-    optr = p; /* initialize the _o_riginal pointer - need it for parsing the checksum TLV */
-    header = (const struct isis_common_header *)p; 
+    optr = p; /* initialize the _o_riginal pointer to the packet start -
+               need it for parsing the checksum TLV */
+    header = (const struct isis_common_header *)p;
     TCHECK(*header);
     TCHECK(*header);
-    pptr = p+(ISIS_COMMON_HEADER_SIZE);    
+    pptr = p+(ISIS_COMMON_HEADER_SIZE);
     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
     header_lsp = (const struct isis_lsp_header *)pptr;
     header_csnp = (const struct isis_csnp_header *)pptr;
     header_psnp = (const struct isis_psnp_header *)pptr;
     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
     header_lsp = (const struct isis_lsp_header *)pptr;
     header_csnp = (const struct isis_csnp_header *)pptr;
     header_psnp = (const struct isis_psnp_header *)pptr;
-    
+
     /*
      * Sanity checking of the header.
      */
     /*
      * Sanity checking of the header.
      */
@@ -1091,7 +1171,7 @@ static int isis_print (const u_char *p, u_int length)
               header->id_length);
        return (0);
     }
               header->id_length);
        return (0);
     }
-    
+
     if (header->pkt_version != ISIS_VERSION) {
        printf(", version %d packet not supported", header->pkt_version);
        return (0);
     if (header->pkt_version != ISIS_VERSION) {
        printf(", version %d packet not supported", header->pkt_version);
        return (0);
@@ -1114,7 +1194,7 @@ static int isis_print (const u_char *p, u_int length)
     case 0:
         id_length = 6;  /* silly shit again */
        break;
     case 0:
         id_length = 6;  /* silly shit again */
        break;
-    case 1:              /* 1-8 are valid sys-ID lenghts */               
+    case 1:              /* 1-8 are valid sys-ID lenghts */
     case 2:
     case 3:
     case 4:
     case 2:
     case 3:
     case 4:
@@ -1127,7 +1207,7 @@ static int isis_print (const u_char *p, u_int length)
         id_length = 0;   /* entirely useless */
        break;
     default:
         id_length = 0;   /* entirely useless */
        break;
     default:
-       printf(", bad packet -- illegal sys-ID length (%u)", id_length);      
+       printf(", bad packet -- illegal sys-ID length (%u)", id_length);
        return (0);
        break;
     }
        return (0);
        break;
     }
@@ -1139,7 +1219,7 @@ static int isis_print (const u_char *p, u_int length)
           header->id_length,
            max_area,
            header->max_area);
           header->id_length,
            max_area,
            header->max_area);
-           
+
     pdu_type=header->pdu_type;
 
     /* first lets see if we know the PDU name*/
     pdu_type=header->pdu_type;
 
     /* first lets see if we know the PDU name*/
@@ -1147,10 +1227,10 @@ static int isis_print (const u_char *p, u_int length)
            tok2str(isis_pdu_values,
                    "unknown PDU, type %d",
                    pdu_type));
            tok2str(isis_pdu_values,
                    "unknown PDU, type %d",
                    pdu_type));
-     
+
     switch (pdu_type) {
 
     switch (pdu_type) {
 
-    case L1_LAN_IIH:    
+    case L1_LAN_IIH:
     case L2_LAN_IIH:
        if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
            printf(", bogus fixed header length %u should be %lu",
     case L2_LAN_IIH:
        if (header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
            printf(", bogus fixed header length %u should be %lu",
@@ -1165,17 +1245,17 @@ static int isis_print (const u_char *p, u_int length)
        }
 
        TCHECK(*header_iih_lan);
        }
 
        TCHECK(*header_iih_lan);
-       printf("\n\t\t  source-id: ");
-       isis_print_sysid(header_iih_lan->source_id);
-       printf(", holding time: %u, %s",
+       printf("\n\t\t  source-id: %s,  holding time: %u, %s",
+               isis_print_sysid(header_iih_lan->source_id,SYSTEM_ID_LEN),
                EXTRACT_16BITS(header_iih_lan->holding_time),
                tok2str(isis_iih_circuit_type_values,
                        "unknown circuit type 0x%02x",
                        header_iih_lan->circuit_type));
 
                EXTRACT_16BITS(header_iih_lan->holding_time),
                tok2str(isis_iih_circuit_type_values,
                        "unknown circuit type 0x%02x",
                        header_iih_lan->circuit_type));
 
-       printf("\n\t\t  lan-id:    ");
-       isis_print_nodeid(header_iih_lan->lan_id);
-       printf(", Priority: %u",(header_iih_lan->priority) & PRIORITY_MASK);            
+       printf("\n\t\t  lan-id:    %s, Priority: %u, PDU length: %u",
+               isis_print_nodeid(header_iih_lan->lan_id),
+               (header_iih_lan->priority) & PRIORITY_MASK,
+               pdu_len);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
@@ -1187,22 +1267,22 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
            return (0);
        }
-       
+
        pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
          length=pdu_len;
        }
        pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
          length=pdu_len;
        }
-       
+
        TCHECK(*header_iih_ptp);
        TCHECK(*header_iih_ptp);
-       printf("\n\t\t  source-id: ");
-       isis_print_sysid(header_iih_ptp->source_id);
-       printf(", holding time: %us",EXTRACT_16BITS(header_iih_ptp->holding_time));
-       printf(", circuit-id: 0x%02x, %s",
+       printf("\n\t\t  source-id: %s, holding time: %us, circuit-id: 0x%02x, %s, PDU length: %u",
+               isis_print_sysid(header_iih_ptp->source_id,SYSTEM_ID_LEN),
+               EXTRACT_16BITS(header_iih_ptp->holding_time),
                header_iih_ptp->circuit_id,
                tok2str(isis_iih_circuit_type_values,
                        "unknown circuit type 0x%02x",
                header_iih_ptp->circuit_id,
                tok2str(isis_iih_circuit_type_values,
                        "unknown circuit type 0x%02x",
-                       header_iih_ptp->circuit_type));
+                       header_iih_ptp->circuit_type),
+               pdu_len);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
@@ -1215,7 +1295,7 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
            return (0);
        }
-       
+
        pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
        pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
@@ -1223,17 +1303,18 @@ static int isis_print (const u_char *p, u_int length)
        }
 
        TCHECK(*header_lsp);
        }
 
        TCHECK(*header_lsp);
-       printf("\n\t\t  lsp-id: ");
-       isis_print_lspid(header_lsp->lsp_id);
-       printf(", seq: 0x%08x",EXTRACT_32BITS(header_lsp->sequence_number));
-       printf(", lifetime: %5us",EXTRACT_16BITS(header_lsp->remaining_lifetime));
-       printf("\n\t\t  chksum: 0x%04x",EXTRACT_16BITS(header_lsp->checksum));
-        /* verify the checksum */
-        if (osi_cksum(optr, length, off))
-            printf(" (incorrect)");
-        else
-            printf(" (correct)");
-             
+       printf("\n\t\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us",
+               isis_print_lspid(header_lsp->lsp_id),
+               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\t  chksum: 0x%04x (%s), PDU length: %u",
+               EXTRACT_16BITS(header_lsp->checksum),
+               (osi_cksum(optr+12, length-12)) ? "incorrect" : "correct",
+               pdu_len);
+
        printf(", %s", ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
 
        if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
        printf(", %s", ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
 
        if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
@@ -1257,7 +1338,7 @@ static int isis_print (const u_char *p, u_int length)
                   header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
            return (0);
        }
                   header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
            return (0);
        }
-       
+
        pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
        pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
        if (packet_len>pdu_len) {
          packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
@@ -1265,12 +1346,13 @@ static int isis_print (const u_char *p, u_int length)
        }
 
        TCHECK(*header_csnp);
        }
 
        TCHECK(*header_csnp);
-       printf("\n\t\t  source-id:    ");
-       isis_print_nodeid(header_csnp->source_id);              
-       printf("\n\t\t  start lsp-id: ");
-       isis_print_lspid(header_csnp->start_lsp_id);    
-       printf("\n\t\t  end lsp-id:   ");
-       isis_print_lspid(header_csnp->end_lsp_id);
+       printf("\n\t\t  source-id:    %s, PDU length: %u",
+               isis_print_nodeid(header_csnp->source_id),
+               pdu_len);
+       printf("\n\t\t  start lsp-id: %s",
+               isis_print_lspid(header_csnp->start_lsp_id));
+       printf("\n\t\t  end lsp-id:   %s",
+               isis_print_lspid(header_csnp->end_lsp_id));
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
 
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
@@ -1291,23 +1373,23 @@ static int isis_print (const u_char *p, u_int length)
        }
 
        TCHECK(*header_psnp);
        }
 
        TCHECK(*header_psnp);
-       printf("\n\t\t  source-id:    ");
-       isis_print_nodeid(header_psnp->source_id); 
- 
+       printf("\n\t\t  source-id:    %s",
+               isis_print_nodeid(header_psnp->source_id));
+
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        break;
 
     default:
        if(!isis_print_unknown_data(pptr,"\n\t\t  ",length))
        packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
        break;
 
     default:
        if(!isis_print_unknown_data(pptr,"\n\t\t  ",length))
-           return(0);  
+           return(0);
        return (0);
     }
 
     /*
      * Now print the TLV's.
      */
        return (0);
     }
 
     /*
      * Now print the TLV's.
      */
-    
+
     while (packet_len >= 2) {
         if (pptr == snapend) {
            return (1);
     while (packet_len >= 2) {
         if (pptr == snapend) {
            return (1);
@@ -1326,12 +1408,13 @@ static int isis_print (const u_char *p, u_int length)
        if (len > packet_len) {
            break;
        }
        if (len > packet_len) {
            break;
        }
-        
+
         /* first lets see if we know the TLVs name*/
         /* first lets see if we know the TLVs name*/
-       printf("\n\t\t    %s (%u)",
+       printf("\n\t\t    %s TLV #%u, length: %u",
                tok2str(isis_tlv_values,
                tok2str(isis_tlv_values,
-                       "unknown TLV, type %d, length",
+                       "unknown",
                        type),
                        type),
+               type,
                len);
 
         /* now check if we have a decoder otherwise do a hexdump at the end*/
                len);
 
         /* now check if we have a decoder otherwise do a hexdump at the end*/
@@ -1341,9 +1424,9 @@ static int isis_print (const u_char *p, u_int length)
                goto trunctlv;
            alen = *tptr++;
            while (tmp && alen < tmp) {
                goto trunctlv;
            alen = *tptr++;
            while (tmp && alen < tmp) {
-               printf("\n\t\t\tArea address (%u): ",alen);
-               if (!print_nsap(tptr, alen))
-                   return (1);
+               printf("\n\t\t\tArea address (%u): %s",
+                       alen,
+                       print_nsap(tptr, alen));
                tptr += alen;
                tmp -= alen + 1;
                if (tmp==0) /* if this is the last area address do not attemt a boundary check */
                tptr += alen;
                tmp -= alen + 1;
                if (tmp==0) /* if this is the last area address do not attemt a boundary check */
@@ -1355,14 +1438,29 @@ static int isis_print (const u_char *p, u_int length)
            break;
        case TLV_ISNEIGH:
            while (tmp >= ETHER_ADDR_LEN) {
            break;
        case TLV_ISNEIGH:
            while (tmp >= ETHER_ADDR_LEN) {
-               printf("\n\t\t\tIS Neighbor: ");
-               if (!isis_print_sysid(tptr))
-                   return (1);
-               tmp -= ETHER_ADDR_LEN;
-               tptr += ETHER_ADDR_LEN;
+            if (!TTEST2(*tptr, ETHER_ADDR_LEN))
+               goto trunctlv;
+            printf("\n\t\t\tIS Neighbor: %s",isis_print_sysid(tptr,ETHER_ADDR_LEN));
+            tmp -= ETHER_ADDR_LEN;
+            tptr += ETHER_ADDR_LEN;
            }
            break;
 
            }
            break;
 
+        case TLV_ISNEIGH_VARLEN:
+            if (!TTEST2(*tptr, 1))
+               goto trunctlv;
+           lan_alen = *tptr++; /* LAN adress length */
+            tmp --;
+            printf("\n\t\t\tLAN address length %u bytes ",lan_alen);
+           while (tmp >= lan_alen) {
+            if (!TTEST2(*tptr, lan_alen))
+               goto trunctlv;
+            printf("\n\t\t\tIS Neighbor: %s",isis_print_sysid(tptr,lan_alen));
+            tmp -= lan_alen;
+            tptr +=lan_alen;
+            }
+            break;
+
        case TLV_PADDING:
            break;
 
        case TLV_PADDING:
            break;
 
@@ -1378,10 +1476,10 @@ static int isis_print (const u_char *p, u_int length)
                printf(" Topology (0x%03x)",
                        ISIS_MASK_MTID(EXTRACT_16BITS(tptr)));
                 tptr+=2;
                printf(" Topology (0x%03x)",
                        ISIS_MASK_MTID(EXTRACT_16BITS(tptr)));
                 tptr+=2;
-               printf("\n\t\t\t  IS Neighbor: ");
-                if (!isis_print_nodeid(tptr))
-                    return (1);
-                tptr+=(SYSTEM_ID_LEN+1);
+                if (!TTEST2(*tptr, NODE_ID_LEN))
+                   goto trunctlv;
+               printf("\n\t\t\t  IS Neighbor: %s", isis_print_nodeid(tptr));
+                tptr+=(NODE_ID_LEN);
                 if (!TTEST2(*tptr, 3))
                     goto trunctlv;
                 printf(", Metric: %d",EXTRACT_24BITS(tptr));
                 if (!TTEST2(*tptr, 3))
                     goto trunctlv;
                 printf(", Metric: %d",EXTRACT_24BITS(tptr));
@@ -1391,31 +1489,29 @@ static int isis_print (const u_char *p, u_int length)
                 tslen=*(tptr++);
                 printf(", %ssub-TLVs present",tslen ? "" : "no ");
                 if (tslen) {
                 tslen=*(tptr++);
                 printf(", %ssub-TLVs present",tslen ? "" : "no ");
                 if (tslen) {
-                    printf(" (%u)",tslen);                    
+                    printf(" (%u)",tslen);
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
-                       subt=*(tptr++);
-                       subl=*(tptr++);
+                       subt=*(tptr++);
+                       subl=*(tptr++);
                        if(!isis_print_is_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        tslen-=(subl+2);
                         tmp-=(subl+2);
                     }
                        if(!isis_print_is_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        tslen-=(subl+2);
                         tmp-=(subl+2);
                     }
-                }      
+                }
                 tmp-=(SYSTEM_ID_LEN+7);
             }
             break;
 
         case TLV_EXT_IS_REACH:
             while (tmp>0) {
                 tmp-=(SYSTEM_ID_LEN+7);
             }
             break;
 
         case TLV_EXT_IS_REACH:
             while (tmp>0) {
-                if (!TTEST2(*tptr, SYSTEM_ID_LEN+1))
+                if (!TTEST2(*tptr, NODE_ID_LEN))
                     goto trunctlv;
                     goto trunctlv;
-               printf("\n\t\t\tIS Neighbor: ");
-                if (!isis_print_nodeid(tptr))
-                    return (1);
-                tptr+=(SYSTEM_ID_LEN+1);
+               printf("\n\t\t\tIS Neighbor: %s", isis_print_nodeid(tptr));
+                tptr+=(NODE_ID_LEN);
 
                 if (!TTEST2(*tptr, 3))
                     goto trunctlv;
 
                 if (!TTEST2(*tptr, 3))
                     goto trunctlv;
@@ -1427,64 +1523,53 @@ static int isis_print (const u_char *p, u_int length)
                 tslen=*(tptr++); /* read out subTLV length */
                 printf(", %ssub-TLVs present",tslen ? "" : "no ");
                 if (tslen) {
                 tslen=*(tptr++); /* read out subTLV length */
                 printf(", %ssub-TLVs present",tslen ? "" : "no ");
                 if (tslen) {
-                    printf(" (%u)",tslen);                    
+                    printf(" (%u)",tslen);
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
-                       subt=*(tptr++);
-                       subl=*(tptr++);
+                       subt=*(tptr++);
+                       subl=*(tptr++);
                        if(!isis_print_is_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        tslen-=(subl+2);
                         tmp-=(subl+2);
                     }
                        if(!isis_print_is_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        tslen-=(subl+2);
                         tmp-=(subl+2);
                     }
-                }      
+                }
                 tmp-=(SYSTEM_ID_LEN+5);
             }
             break;
         case TLV_IS_REACH:
            if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
                 goto trunctlv;
                 tmp-=(SYSTEM_ID_LEN+5);
             }
             break;
         case 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\t\t%s",
                    tok2str(isis_is_reach_virtual_values,
                            "bogus virtual flag 0x%02x",
                            *tptr++));
             printf("\n\t\t\t%s",
                    tok2str(isis_is_reach_virtual_values,
                            "bogus virtual flag 0x%02x",
                            *tptr++));
-
            tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;
            tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;
-
             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
                if (!TTEST(*tlv_is_reach))
                    goto trunctlv;
             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
                if (!TTEST(*tlv_is_reach))
                    goto trunctlv;
-
-               printf("\n\t\t\tIS Neighbor: ");
-               isis_print_nodeid(tlv_is_reach->neighbor_nodeid);
-
-               printf(", Default Metric: %d, %s",
-                          ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_default),
-                          ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_default) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_delay))
-                   printf("\n\t\t\t  Delay Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_delay),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_delay) ? "External" : "Internal");
-               
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_expense))
-                   printf("\n\t\t\t  Expense Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_expense),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_expense) ? "External" : "Internal");
-
-               if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_is_reach->metric_error))
-                   printf("\n\t\t\t  Error Metric: %d, %s",
-                                  ISIS_LSP_TLV_METRIC_VALUE(tlv_is_reach->metric_error),
-                                  ISIS_LSP_TLV_METRIC_IE(tlv_is_reach->metric_error) ? "External" : "Internal");
-
+               printf("\n\t\t\tIS Neighbor: %s", isis_print_nodeid(tlv_is_reach->neighbor_nodeid));
+                isis_print_metric_block(&tlv_is_reach->isis_metric_block);
                tmp -= sizeof(struct isis_tlv_is_reach);
                tlv_is_reach++;
            }
             break;
 
                tmp -= sizeof(struct isis_tlv_is_reach);
                tlv_is_reach++;
            }
             break;
 
+        case TLV_ESNEIGH:
+           tlv_es_reach = (const struct isis_tlv_es_reach *)tptr;
+            while (tmp >= sizeof(struct isis_tlv_es_reach)) {
+               if (!TTEST(*tlv_es_reach))
+                   goto trunctlv;
+               printf("\n\t\t\tES Neighbor: %s",
+                       isis_print_sysid(tlv_es_reach->neighbor_sysid,SYSTEM_ID_LEN));
+                isis_print_metric_block(&tlv_es_reach->isis_metric_block);
+               tmp -= sizeof(struct isis_tlv_es_reach);
+               tlv_es_reach++;
+           }
+            break;
+
             /* those two TLVs share the same format */
        case TLV_IP_REACH:
        case TLV_IP_REACH_EXT:
             /* those two TLVs share the same format */
        case TLV_IP_REACH:
        case TLV_IP_REACH_EXT:
@@ -1522,7 +1607,7 @@ static int isis_print (const u_char *p, u_int length)
                    return (1);
                memcpy(prefix,tptr,byte_length);
                 tptr+=byte_length;
                    return (1);
                memcpy(prefix,tptr,byte_length);
                 tptr+=byte_length;
-               printf("\n\t\t\tIPv4 prefix: %s/%d", 
+               printf("\n\t\t\tIPv4 prefix: %s/%d",
                       ipaddr_string(prefix),
                       bit_length);
 
                       ipaddr_string(prefix),
                       bit_length);
 
@@ -1542,13 +1627,13 @@ static int isis_print (const u_char *p, u_int length)
                      return (1);
                     tslen=*(tptr++);
                     tmp--;
                      return (1);
                     tslen=*(tptr++);
                     tmp--;
-                   printf(" (%u)",tslen);   /* print out subTLV length */          
+                   printf(" (%u)",tslen);   /* print out subTLV length */
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
-                       subt=*(tptr++);
-                       subl=*(tptr++);
+                       subt=*(tptr++);
+                       subl=*(tptr++);
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
@@ -1578,7 +1663,7 @@ static int isis_print (const u_char *p, u_int length)
                    return (1);
                memcpy(prefix,tptr,byte_length);
                 tptr+=byte_length;
                    return (1);
                memcpy(prefix,tptr,byte_length);
                 tptr+=byte_length;
-               printf("\n\t\t\tIPv4 prefix: %s/%d", 
+               printf("\n\t\t\tIPv4 prefix: %s/%d",
                       ipaddr_string(prefix),
                       bit_length);
 
                       ipaddr_string(prefix),
                       bit_length);
 
@@ -1598,13 +1683,13 @@ static int isis_print (const u_char *p, u_int length)
                      return (1);
                     tslen=*(tptr++);
                     tmp--;
                      return (1);
                     tslen=*(tptr++);
                     tmp--;
-                   printf(" (%u)",tslen);   /* print out subTLV length */          
+                   printf(" (%u)",tslen);   /* print out subTLV length */
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
-                       subt=*(tptr++);
-                       subl=*(tptr++);
+                       subt=*(tptr++);
+                       subl=*(tptr++);
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
@@ -1652,16 +1737,16 @@ static int isis_print (const u_char *p, u_int length)
                        the aggregate bytecount of the subTLVs for this prefix
                      */
                    if (!TTEST2(*tptr, 1))
                        the aggregate bytecount of the subTLVs for this prefix
                      */
                    if (!TTEST2(*tptr, 1))
-                     return (1);                     
+                     return (1);
                     tslen=*(tptr++);
                     tmp--;
                     tslen=*(tptr++);
                     tmp--;
-                   printf(" (%u)",tslen);   /* print out subTLV length */          
+                   printf(" (%u)",tslen);   /* print out subTLV length */
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
 
                     while (tslen>0) {
                         if (!TTEST2(*tptr,2))
                             goto trunctlv;
-                       subt=*(tptr++);
-                       subl=*(tptr++);
+                       subt=*(tptr++);
+                       subl=*(tptr++);
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
                        if(!isis_print_ip_reach_subtlv(tptr,subt,subl,"\n\t\t\t  "))
                            return(0);
                        tptr+=subl;
@@ -1718,7 +1803,7 @@ static int isis_print (const u_char *p, u_int length)
            case SUBTLV_AUTH_PRIVATE:
            default:
                if(!isis_print_unknown_data(tptr+1,"\n\t\t\t    ",len-1))
            case SUBTLV_AUTH_PRIVATE:
            default:
                if(!isis_print_unknown_data(tptr+1,"\n\t\t\t    ",len-1))
-                   return(0);  
+                   return(0);
                break;
            }
            break;
                break;
            }
            break;
@@ -1732,25 +1817,27 @@ static int isis_print (const u_char *p, u_int length)
                       tok2str(isis_ptp_adjancey_values, "0x%02x", *tptr));
                tmp--;
            }
                       tok2str(isis_ptp_adjancey_values, "0x%02x", *tptr));
                tmp--;
            }
-           if(tmp>=4) {
-               if (!TTEST2(tlv_ptp_adj->ext_local_circuit_id, 4))
+           if(tmp>sizeof(tlv_ptp_adj->extd_local_circuit_id)) {
+               if (!TTEST2(tlv_ptp_adj->extd_local_circuit_id,
+                            sizeof(tlv_ptp_adj->extd_local_circuit_id)))
                    goto trunctlv;
                printf("\n\t\t\tExtended Local circuit ID: 0x%08x",
                    goto trunctlv;
                printf("\n\t\t\tExtended Local circuit ID: 0x%08x",
-                      EXTRACT_32BITS(tlv_ptp_adj->ext_local_circuit_id));
-               tmp-=4;
+                      EXTRACT_32BITS(tlv_ptp_adj->extd_local_circuit_id));
+               tmp-=sizeof(tlv_ptp_adj->extd_local_circuit_id);
            }
            }
-           if(tmp>=6) {
-               if (!TTEST2(tlv_ptp_adj->neighbor_sysid, 6))
+           if(tmp>=SYSTEM_ID_LEN) {
+               if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))
                    goto trunctlv;
                    goto trunctlv;
-               printf("\n\t\t\tNeighbor SystemID: ");
-                      isis_print_sysid(tlv_ptp_adj->neighbor_sysid);
-               tmp-=6;
+               printf("\n\t\t\tNeighbor SystemID: %s",
+                      isis_print_sysid(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
+               tmp-=SYSTEM_ID_LEN;
            }
            }
-           if(tmp>=4) {
-               if (!TTEST2(tlv_ptp_adj->neighbor_ext_local_circuit_id, 4))
+           if(tmp>=sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)) {
+               if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
+                            sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))
                    goto trunctlv;
                printf("\n\t\t\tNeighbor Extended Local circuit ID: 0x%08x",
                    goto trunctlv;
                printf("\n\t\t\tNeighbor Extended Local circuit ID: 0x%08x",
-                      EXTRACT_32BITS(tlv_ptp_adj->neighbor_ext_local_circuit_id));
+                      EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));
            }
            break;
 
            }
            break;
 
@@ -1796,13 +1883,11 @@ static int isis_print (const u_char *p, u_int length)
            break;
 
        case TLV_SHARED_RISK_GROUP:
            break;
 
        case TLV_SHARED_RISK_GROUP:
-           if (!TTEST2(*tptr, 7))
+           if (!TTEST2(*tptr, NODE_ID_LEN))
              goto trunctlv;
              goto trunctlv;
-           printf("\n\t\t\tIS Neighbor: ");
-           if (!isis_print_nodeid(tptr))
-             return (1);
-           tptr+=(SYSTEM_ID_LEN+1);
-           len-=(SYSTEM_ID_LEN+1);
+           printf("\n\t\t\tIS Neighbor: %s", isis_print_nodeid(tptr));
+           tptr+=(NODE_ID_LEN);
+           len-=(NODE_ID_LEN);
 
            if (!TTEST2(*tptr, 1))
              goto trunctlv;
 
            if (!TTEST2(*tptr, 1))
              goto trunctlv;
@@ -1819,26 +1904,25 @@ static int isis_print (const u_char *p, u_int length)
              goto trunctlv;
            printf("\n\t\t\tIPv4 neighbor address: %s", ipaddr_string(tptr));
            tptr+=4;
              goto trunctlv;
            printf("\n\t\t\tIPv4 neighbor address: %s", ipaddr_string(tptr));
            tptr+=4;
-           len-=4;         
+           len-=4;
 
            while (tmp>0) {
              if (!TTEST2(*tptr, 4))
 
            while (tmp>0) {
              if (!TTEST2(*tptr, 4))
-               goto trunctlv;      
+               goto trunctlv;
              printf("\n\t\t\tLink-ID: 0x%08x", EXTRACT_32BITS(tptr));
              tptr+=4;
              printf("\n\t\t\tLink-ID: 0x%08x", EXTRACT_32BITS(tptr));
              tptr+=4;
-             len-=4;   
+             len-=4;
            }
            break;
 
            }
            break;
 
-       case TLV_LSP:    
-           tlv_lsp = (const struct isis_tlv_lsp *)tptr; 
+       case TLV_LSP:
+           tlv_lsp = (const struct isis_tlv_lsp *)tptr;
            while(tmp>0) {
            while(tmp>0) {
-               printf("\n\t\t\tlsp-id: ");
-               if (!isis_print_nodeid(tlv_lsp->lsp_id))
-                   return (1);
-               if (!TTEST((tlv_lsp->lsp_id)[SYSTEM_ID_LEN+1]))
+               printf("\n\t\t\tlsp-id: %s",
+                       isis_print_nodeid(tlv_lsp->lsp_id));
+               if (!TTEST((tlv_lsp->lsp_id)[NODE_ID_LEN]))
                    goto trunctlv;
                    goto trunctlv;
-               printf("-%02x",(tlv_lsp->lsp_id)[SYSTEM_ID_LEN+1]);
+               printf("-%02x",(tlv_lsp->lsp_id)[NODE_ID_LEN]);
                if (!TTEST2(tlv_lsp->sequence_number, 4))
                    goto trunctlv;
                printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));
                if (!TTEST2(tlv_lsp->sequence_number, 4))
                    goto trunctlv;
                printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));
@@ -1856,17 +1940,14 @@ static int isis_print (const u_char *p, u_int length)
        case TLV_CHECKSUM:
            if (!TTEST2(*tptr, 2))
                goto trunctlv;
        case TLV_CHECKSUM:
            if (!TTEST2(*tptr, 2))
                goto trunctlv;
-           printf("\n\t\t\tchecksum: 0x%04x", 
-                  EXTRACT_16BITS(tptr));
-           if (osi_cksum(optr, length, off))
-               printf(" (incorrect)");
-           else
-               printf(" (correct)");
+           printf("\n\t\t\tchecksum: 0x%04x (%s)",
+                  EXTRACT_16BITS(tptr),
+                   (osi_cksum(optr, length)) ? "incorrect" : "correct");
            break;
 
        case TLV_MT_SUPPORTED:
            while (tmp>1) {
            break;
 
        case TLV_MT_SUPPORTED:
            while (tmp>1) {
-               /* length can only be a multiple of 2, otherwise there is 
+               /* length can only be a multiple of 2, otherwise there is
                   something broken -> so decode down until length is 1 */
                if (tmp!=1) {
                    if (!TTEST2(*tptr, 2))
                   something broken -> so decode down until length is 1 */
                if (tmp!=1) {
                    if (!TTEST2(*tptr, 2))
@@ -1891,7 +1972,7 @@ static int isis_print (const u_char *p, u_int length)
 
        case TLV_RESTART_SIGNALING:
             if (!TTEST2(*tptr, 3))
 
        case TLV_RESTART_SIGNALING:
             if (!TTEST2(*tptr, 3))
-                goto trunctlv;    
+                goto trunctlv;
            rr = ISIS_MASK_TLV_RESTART_RR(*tptr);
            ra = ISIS_MASK_TLV_RESTART_RA(*tptr);
            tptr++;
            rr = ISIS_MASK_TLV_RESTART_RR(*tptr);
            ra = ISIS_MASK_TLV_RESTART_RA(*tptr);
            tptr++;
@@ -1900,18 +1981,75 @@ static int isis_print (const u_char *p, u_int length)
                   rr ? "set" : "clear", ra ? "set" : "clear", time_remain);
            break;
 
                   rr ? "set" : "clear", ra ? "set" : "clear", time_remain);
            break;
 
+        case TLV_IDRP_INFO:
+            if (!TTEST2(*tptr, 1))
+                goto trunctlv;
+            printf("\n\t\t\tInter-Domain Information Type: %s",
+                   tok2str(isis_subtlv_idrp_values,
+                           "Unknown (0x%02x)",
+                           *tptr));
+            switch (*tptr++) {
+            case SUBTLV_IDRP_ASN:
+                if (!TTEST2(*tptr, 2)) /* fetch AS number */
+                    goto trunctlv;
+                printf("AS Number: %u",EXTRACT_16BITS(tptr));
+                break;
+            case SUBTLV_IDRP_LOCAL:
+            case SUBTLV_IDRP_RES:
+            default:
+                if(!isis_print_unknown_data(tptr,"\n\t\t\t",len-1))
+                    return(0);
+                break;
+            }
+            break;
+
+        case TLV_LSP_BUFFERSIZE:
+            if (!TTEST2(*tptr, 2))
+                goto trunctlv;
+                printf("LSP Buffersize: %u",EXTRACT_16BITS(tptr));
+            break;
+
+        case TLV_PART_DIS:
+            while (tmp >= SYSTEM_ID_LEN) {
+            if (!TTEST2(*tptr, SYSTEM_ID_LEN))
+                goto trunctlv;
+            printf("%s",isis_print_sysid(tptr,SYSTEM_ID_LEN));
+            tptr+=SYSTEM_ID_LEN;
+            tmp-=SYSTEM_ID_LEN;
+            }
+            break;
+
+        case TLV_PREFIX_NEIGH:
+            if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
+                goto trunctlv;
+            printf("Metric Block");
+            isis_print_metric_block((const struct isis_metric_block *)tptr);
+            tptr+=sizeof(struct isis_metric_block);
+            tmp-=sizeof(struct isis_metric_block);
+
+            while(tmp>0) {
+                if (!TTEST2(*tptr, 1))
+                    goto trunctlv;
+                prefix_len=*tptr++; /* read out prefix length in semioctets*/
+                tmp--;
+                if (!TTEST2(*tptr, prefix_len/2))
+                    goto trunctlv;
+                printf("\n\t\t\tAddress: %s/%u",
+                       print_nsap(tptr,prefix_len/2),
+                       prefix_len*4);
+                tptr+=prefix_len/2;
+                tmp-=prefix_len/2;
+            }
+            break;
+
             /*
              * FIXME those are the defined TLVs that lack a decoder
              * you are welcome to contribute code ;-)
              */
 
             /*
              * FIXME those are the defined TLVs that lack a decoder
              * you are welcome to contribute code ;-)
              */
 
-        case TLV_ESNEIGH:
-        case TLV_PART_DIS:
-        case TLV_SUMMARY:
-        case TLV_LSP_BUFFERSIZE:
+        case TLV_IS_ALIAS_ID:
         case TLV_DECNET_PHASE4:
         case TLV_LUCENT_PRIVATE:
         case TLV_DECNET_PHASE4:
         case TLV_LUCENT_PRIVATE:
-        case TLV_IDRP_INFO:
         case TLV_IPAUTH:
         case TLV_NORTEL_PRIVATE1:
         case TLV_NORTEL_PRIVATE2:
         case TLV_IPAUTH:
         case TLV_NORTEL_PRIVATE1:
         case TLV_NORTEL_PRIVATE2:
@@ -1946,16 +2084,12 @@ trunctlv:
  */
 
 static int
  */
 
 static int
-osi_cksum(register const u_char *p, register u_int len, u_char *off)
+osi_cksum(const u_char *tptr, u_int len)
 {
        int32_t c0 = 0, c1 = 0;
 
 {
        int32_t c0 = 0, c1 = 0;
 
-       if ((off[0] == 0) && (off[1] == 0))
-               return 0;
-
-       off[0] = off[1] = 0;
        while ((int)--len >= 0) {
        while ((int)--len >= 0) {
-               c0 += *p++;
+               c0 += *tptr++;
                c0 %= 255;
                c1 += c0;
                c1 %= 255;
                c0 %= 255;
                c1 += c0;
                c1 %= 255;
[mirror] the TCPdump network dissector