Default to first interface from pcap_findalldevs()

[tcpdump] / print-isoclns.c

diff --git a/print-isoclns.c b/print-isoclns.c
index 50e268c8439b0f905434ed31db37430c2e2a1dc0..2d5ac4591e0c619f2e9e1efb49e7bd58cf6a3f2b 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -24,16 +24,15 @@
  * complete IS-IS & CLNP support.
  */
 
  * complete IS-IS & CLNP support.
  */
 

-#define NETDISSECT_REWORKED

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

-#include <tcpdump-stdinc.h>
+#include <netdissect-stdinc.h>

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

-#include "interface.h"
+#include "netdissect.h"

 #include "addrtoname.h"
 #include "ether.h"
 #include "nlpid.h"
 #include "addrtoname.h"
 #include "ether.h"
 #include "nlpid.h"


@@ -103,6 +102,7 @@ static const struct tok isis_pdu_values[] = {
 #define ISIS_TLV_AUTH                10  /* iso10589, rfc3567 */
 #define ISIS_TLV_CHECKSUM            12  /* rfc3358 */
 #define ISIS_TLV_CHECKSUM_MINLEN 2
 #define ISIS_TLV_AUTH                10  /* iso10589, rfc3567 */
 #define ISIS_TLV_CHECKSUM            12  /* rfc3358 */
 #define ISIS_TLV_CHECKSUM_MINLEN 2

+#define ISIS_TLV_POI                 13  /* rfc6232 */

 #define ISIS_TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
 #define ISIS_TLV_LSP_BUFFERSIZE_MINLEN 2
 #define ISIS_TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */
 #define ISIS_TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
 #define ISIS_TLV_LSP_BUFFERSIZE_MINLEN 2
 #define ISIS_TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */


@@ -152,6 +152,7 @@ static const struct tok isis_tlv_values[] = {
     { ISIS_TLV_LSP,                "LSP entries"},
     { ISIS_TLV_AUTH,               "Authentication"},
     { ISIS_TLV_CHECKSUM,           "Checksum"},
     { ISIS_TLV_LSP,                "LSP entries"},
     { ISIS_TLV_AUTH,               "Authentication"},
     { ISIS_TLV_CHECKSUM,           "Checksum"},

+    { ISIS_TLV_POI,                "Purge Originator Identifier"},

     { ISIS_TLV_LSP_BUFFERSIZE,     "LSP Buffersize"},
     { ISIS_TLV_EXT_IS_REACH,       "Extended IS Reachability"},
     { ISIS_TLV_IS_ALIAS_ID,        "IS Alias ID"},
     { ISIS_TLV_LSP_BUFFERSIZE,     "LSP Buffersize"},
     { ISIS_TLV_EXT_IS_REACH,       "Extended IS Reachability"},
     { ISIS_TLV_IS_ALIAS_ID,        "IS Alias ID"},


@@ -446,10 +447,10 @@ static const struct tok isis_mt_capability_subtlv_values[] = {
 };
 
 struct isis_spb_mcid {
 };
 
 struct isis_spb_mcid {

-  u_int8_t  format_id;
-  u_int8_t  name[32];
-  u_int8_t  revision_lvl[2];
-  u_int8_t  digest[16];
+  uint8_t  format_id;
+  uint8_t  name[32];
+  uint8_t  revision_lvl[2];
+  uint8_t  digest[16];

 };
 
 struct isis_subtlv_spb_mcid {
 };
 
 struct isis_subtlv_spb_mcid {


@@ -458,11 +459,11 @@ struct isis_subtlv_spb_mcid {
 };
 
 struct isis_subtlv_spb_instance {
 };
 
 struct isis_subtlv_spb_instance {

-  u_int8_t cist_root_id[8];
-  u_int8_t cist_external_root_path_cost[4];
-  u_int8_t bridge_priority[2];
-  u_int8_t spsourceid[4];
-  u_int8_t no_of_trees;
+  uint8_t cist_root_id[8];
+  uint8_t cist_external_root_path_cost[4];
+  uint8_t bridge_priority[2];
+  uint8_t spsourceid[4];
+  uint8_t no_of_trees;

 };
 
 #define CLNP_SEGMENT_PART  0x80
 };
 
 #define CLNP_SEGMENT_PART  0x80


@@ -553,39 +554,39 @@ static const struct tok isis_ptp_adjancey_values[] = {
 };
 
 struct isis_tlv_ptp_adj {
 };
 
 struct isis_tlv_ptp_adj {

-    u_int8_t adjacency_state;
-    u_int8_t extd_local_circuit_id[4];
-    u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
-    u_int8_t neighbor_extd_local_circuit_id[4];
+    uint8_t adjacency_state;
+    uint8_t extd_local_circuit_id[4];
+    uint8_t neighbor_sysid[SYSTEM_ID_LEN];
+    uint8_t neighbor_extd_local_circuit_id[4];

 };
 
 };
 

-static void osi_print_cksum(netdissect_options *, const u_int8_t *pptr, u_int16_t checksum,
-                            u_int checksum_offset, u_int length);
-static int clnp_print(netdissect_options *, const u_int8_t *, u_int);
-static void esis_print(netdissect_options *, const u_int8_t *, u_int);
-static int isis_print(netdissect_options *, const u_int8_t *, u_int);
+static void osi_print_cksum(netdissect_options *, const uint8_t *pptr,
+                           uint16_t checksum, int checksum_offset, int length);
+static int clnp_print(netdissect_options *, const uint8_t *, u_int);
+static void esis_print(netdissect_options *, const uint8_t *, u_int);
+static int isis_print(netdissect_options *, const uint8_t *, u_int);

 
 struct isis_metric_block {
 
 struct isis_metric_block {

-    u_int8_t metric_default;
-    u_int8_t metric_delay;
-    u_int8_t metric_expense;
-    u_int8_t metric_error;
+    uint8_t metric_default;
+    uint8_t metric_delay;
+    uint8_t metric_expense;
+    uint8_t metric_error;

 };
 
 struct isis_tlv_is_reach {
     struct isis_metric_block isis_metric_block;
 };
 
 struct isis_tlv_is_reach {
     struct isis_metric_block isis_metric_block;

-    u_int8_t neighbor_nodeid[NODE_ID_LEN];
+    uint8_t neighbor_nodeid[NODE_ID_LEN];

 };
 
 struct isis_tlv_es_reach {
     struct isis_metric_block isis_metric_block;
 };
 
 struct isis_tlv_es_reach {
     struct isis_metric_block isis_metric_block;

-    u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
+    uint8_t neighbor_sysid[SYSTEM_ID_LEN];

 };
 
 struct isis_tlv_ip_reach {
     struct isis_metric_block isis_metric_block;
 };
 
 struct isis_tlv_ip_reach {
     struct isis_metric_block isis_metric_block;

-    u_int8_t prefix[4];
-    u_int8_t mask[4];
+    uint8_t prefix[4];
+    uint8_t mask[4];

 };
 
 static const struct tok isis_is_reach_virtual_values[] = {
 };
 
 static const struct tok isis_is_reach_virtual_values[] = {


@@ -602,59 +603,59 @@ static const struct tok isis_restart_flag_values[] = {
 };
 
 struct isis_common_header {
 };
 
 struct isis_common_header {

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

 };
 
 struct isis_iih_lan_header {
 };
 
 struct isis_iih_lan_header {

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

 };
 
 struct isis_iih_ptp_header {
 };
 
 struct isis_iih_ptp_header {

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

 };
 
 struct isis_lsp_header {
 };
 
 struct isis_lsp_header {

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

 };
 
 struct isis_csnp_header {
 };
 
 struct isis_csnp_header {

-    u_int8_t pdu_len[2];
-    u_int8_t source_id[NODE_ID_LEN];
-    u_int8_t start_lsp_id[LSP_ID_LEN];
-    u_int8_t end_lsp_id[LSP_ID_LEN];
+    uint8_t pdu_len[2];
+    uint8_t source_id[NODE_ID_LEN];
+    uint8_t start_lsp_id[LSP_ID_LEN];
+    uint8_t end_lsp_id[LSP_ID_LEN];

 };
 
 struct isis_psnp_header {
 };
 
 struct isis_psnp_header {

-    u_int8_t pdu_len[2];
-    u_int8_t source_id[NODE_ID_LEN];
+    uint8_t pdu_len[2];
+    uint8_t source_id[NODE_ID_LEN];

 };
 
 struct isis_tlv_lsp {
 };
 
 struct isis_tlv_lsp {

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

 };
 
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
 };
 
 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))


@@ -665,7 +666,7 @@ struct isis_tlv_lsp {
 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
 
 void isoclns_print(netdissect_options *ndo,
 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
 
 void isoclns_print(netdissect_options *ndo,

-                   const u_int8_t *p, u_int length, u_int caplen)
+                   const uint8_t *p, u_int length, u_int caplen)

 {
        if (caplen <= 1) { /* enough bytes on the wire ? */
                ND_PRINT((ndo, "|OSI"));
 {
        if (caplen <= 1) { /* enough bytes on the wire ? */
                ND_PRINT((ndo, "|OSI"));


@@ -703,11 +704,9 @@ void isoclns_print(netdissect_options *ndo,
                ip_print(ndo, p + 1, length - 1);
                break;
 
                ip_print(ndo, p + 1, length - 1);
                break;
 

-#ifdef INET6

        case NLPID_IP6:
                ip6_print(ndo, p + 1, length - 1);
                break;
        case NLPID_IP6:
                ip6_print(ndo, p + 1, length - 1);
                break;

-#endif

 
        case NLPID_PPP:
                ppp_print(ndo, p + 1, length - 1);
 
        case NLPID_PPP:
                ppp_print(ndo, p + 1, length - 1);


@@ -739,19 +738,19 @@ static const struct tok clnp_pdu_values[] = {
 };
 
 struct clnp_header_t {
 };
 
 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];
+    uint8_t nlpid;
+    uint8_t length_indicator;
+    uint8_t version;
+    uint8_t lifetime; /* units of 500ms */
+    uint8_t type;
+    uint8_t segment_length[2];
+    uint8_t cksum[2];

 };
 
 struct clnp_segment_header_t {
 };
 
 struct clnp_segment_header_t {

-    u_int8_t data_unit_id[2];
-    u_int8_t segment_offset[2];
-    u_int8_t total_length[2];
+    uint8_t data_unit_id[2];
+    uint8_t segment_offset[2];
+    uint8_t total_length[2];

 };
 
 /*
 };
 
 /*


@@ -761,13 +760,13 @@ struct clnp_segment_header_t {
 
 static int
 clnp_print(netdissect_options *ndo,
 
 static int
 clnp_print(netdissect_options *ndo,

-           const u_int8_t *pptr, u_int length)
+           const uint8_t *pptr, u_int length)

 {
 {

-       const u_int8_t *optr,*source_address,*dest_address;
+       const uint8_t *optr,*source_address,*dest_address;

         u_int li,tlen,nsap_offset,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_int li,tlen,nsap_offset,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;
+        uint8_t rfd_error_major,rfd_error_minor;

 
        clnp_header = (const struct clnp_header_t *) pptr;
         ND_TCHECK(*clnp_header);
 
        clnp_header = (const struct clnp_header_t *) pptr;
         ND_TCHECK(*clnp_header);


@@ -808,8 +807,8 @@ clnp_print(netdissect_options *ndo,
         if (ndo->ndo_vflag < 1) {
             ND_PRINT((ndo, "%s%s > %s, %s, length %u",
                    ndo->ndo_eflag ? "" : ", ",
         if (ndo->ndo_vflag < 1) {
             ND_PRINT((ndo, "%s%s > %s, %s, length %u",
                    ndo->ndo_eflag ? "" : ", ",

-                   isonsap_string(source_address, source_address_length),
-                   isonsap_string(dest_address, dest_address_length),
+                   isonsap_string(ndo, source_address, source_address_length),
+                   isonsap_string(ndo, dest_address, dest_address_length),

                    tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
                    length));
             return (1);
                    tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
                    length));
             return (1);


@@ -833,9 +832,9 @@ clnp_print(netdissect_options *ndo,
 
         ND_PRINT((ndo, "\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
                source_address_length,
 
         ND_PRINT((ndo, "\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
                source_address_length,

-               isonsap_string(source_address, source_address_length),
+               isonsap_string(ndo, source_address, source_address_length),

                dest_address_length,
                dest_address_length,

-               isonsap_string(dest_address, dest_address_length)));
+               isonsap_string(ndo, dest_address, dest_address_length)));

 
         if (clnp_flags & CLNP_SEGMENT_PART) {
                clnp_segment_header = (const struct clnp_segment_header_t *) pptr;
 
         if (clnp_flags & CLNP_SEGMENT_PART) {
                clnp_segment_header = (const struct clnp_segment_header_t *) pptr;


@@ -851,7 +850,7 @@ clnp_print(netdissect_options *ndo,
         /* now walk the options */
         while (li >= 2) {
             u_int op, opli;
         /* now walk the options */
         while (li >= 2) {
             u_int op, opli;

-            const u_int8_t *tptr;
+            const uint8_t *tptr;

 
             ND_TCHECK2(*pptr, 2);
             if (li < 2) {
 
             ND_TCHECK2(*pptr, 2);
             if (li < 2) {


@@ -906,7 +905,7 @@ clnp_print(netdissect_options *ndo,
                                     ND_TCHECK2(*source_address, source_address_length);
                                     ND_PRINT((ndo, "\n\t    NSAP address (length %u): %s",
                                            source_address_length,
                                     ND_TCHECK2(*source_address, source_address_length);
                                     ND_PRINT((ndo, "\n\t    NSAP address (length %u): %s",
                                            source_address_length,

-                                           isonsap_string(source_address, source_address_length)));
+                                           isonsap_string(ndo, source_address, source_address_length)));

                             }
                             tlen-=source_address_length+1;
                     }
                             }
                             tlen-=source_address_length+1;
                     }


@@ -1006,20 +1005,20 @@ static const struct tok esis_pdu_values[] = {
 };
 
 struct esis_header_t {
 };
 
 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 holdtime[2];
-       u_int8_t cksum[2];
+       uint8_t nlpid;
+       uint8_t length_indicator;
+       uint8_t version;
+       uint8_t reserved;
+       uint8_t type;
+       uint8_t holdtime[2];
+       uint8_t cksum[2];

 };
 
 static void
 esis_print(netdissect_options *ndo,
 };
 
 static void
 esis_print(netdissect_options *ndo,

-           const u_int8_t *pptr, u_int length)
+           const uint8_t *pptr, u_int length)

 {
 {

-       const u_int8_t *optr;
+       const uint8_t *optr;

        u_int li,esis_pdu_type,source_address_length, source_address_number;
        const struct esis_header_t *esis_header;
 
        u_int li,esis_pdu_type,source_address_length, source_address_number;
        const struct esis_header_t *esis_header;
 


@@ -1057,7 +1056,7 @@ esis_print(netdissect_options *ndo,
 
        if (li < sizeof(struct esis_header_t) + 2) {
             ND_PRINT((ndo, " length indicator < min PDU size %d:", li));
 
        if (li < sizeof(struct esis_header_t) + 2) {
             ND_PRINT((ndo, " length indicator < min PDU size %d:", li));

-            while (--length != 0)
+            while (pptr < ndo->ndo_snapend)

                 ND_PRINT((ndo, "%02X", *pptr++));
             return;
        }
                 ND_PRINT((ndo, "%02X", *pptr++));
             return;
        }


@@ -1093,7 +1092,7 @@ esis_print(netdissect_options *ndo,
 
        switch (esis_pdu_type) {
        case ESIS_PDU_REDIRECT: {
 
        switch (esis_pdu_type) {
        case ESIS_PDU_REDIRECT: {

-               const u_int8_t *dst, *snpa, *neta;
+               const uint8_t *dst, *snpa, *neta;

                u_int dstl, snpal, netal;
 
                ND_TCHECK(*pptr);
                u_int dstl, snpal, netal;
 
                ND_TCHECK(*pptr);


@@ -1112,7 +1111,7 @@ esis_print(netdissect_options *ndo,
                dst = pptr;
                pptr += dstl;
                 li -= dstl;
                dst = pptr;
                pptr += dstl;
                 li -= dstl;

-               ND_PRINT((ndo, "\n\t  %s", isonsap_string(dst, dstl)));
+               ND_PRINT((ndo, "\n\t  %s", isonsap_string(ndo, dst, dstl)));

 
                ND_TCHECK(*pptr);
                if (li < 1) {
 
                ND_TCHECK(*pptr);
                if (li < 1) {


@@ -1147,9 +1146,9 @@ esis_print(netdissect_options *ndo,
                 li -= netal;
 
                if (netal == 0)
                 li -= netal;
 
                if (netal == 0)

-                       ND_PRINT((ndo, "\n\t  %s", etheraddr_string(snpa)));
+                       ND_PRINT((ndo, "\n\t  %s", etheraddr_string(ndo, snpa)));

                else
                else

-                       ND_PRINT((ndo, "\n\t  %s", isonsap_string(neta, netal)));
+                       ND_PRINT((ndo, "\n\t  %s", isonsap_string(ndo, neta, netal)));

                break;
        }
 
                break;
        }
 


@@ -1182,7 +1181,7 @@ esis_print(netdissect_options *ndo,
                }
                 ND_PRINT((ndo, "\n\t  NET (length: %u): %s",
                        source_address_length,
                }
                 ND_PRINT((ndo, "\n\t  NET (length: %u): %s",
                        source_address_length,

-                       isonsap_string(pptr, source_address_length)));
+                       isonsap_string(ndo, pptr, source_address_length)));

                 pptr += source_address_length;
                 li -= source_address_length;
                 source_address_number--;
                 pptr += source_address_length;
                 li -= source_address_length;
                 source_address_number--;


@@ -1204,7 +1203,7 @@ esis_print(netdissect_options *ndo,
                 ND_PRINT((ndo, ", bad ish/li"));
                 return;
             }
                 ND_PRINT((ndo, ", bad ish/li"));
                 return;
             }

-            ND_PRINT((ndo, "\n\t  NET (length: %u): %s", source_address_length, isonsap_string(pptr, source_address_length)));
+            ND_PRINT((ndo, "\n\t  NET (length: %u): %s", source_address_length, isonsap_string(ndo, pptr, source_address_length)));

             pptr += source_address_length;
             li -= source_address_length;
             break;
             pptr += source_address_length;
             li -= source_address_length;
             break;


@@ -1221,7 +1220,7 @@ esis_print(netdissect_options *ndo,
         /* now walk the options */
         while (li != 0) {
             u_int op, opli;
         /* now walk the options */
         while (li != 0) {
             u_int op, opli;

-            const u_int8_t *tptr;
+            const uint8_t *tptr;

 
             if (li < 2) {
                 ND_PRINT((ndo, ", bad opts/li"));
 
             if (li < 2) {
                 ND_PRINT((ndo, ", bad opts/li"));


@@ -1316,7 +1315,7 @@ isis_print_mcid(netdissect_options *ndo,
 
 static int
 isis_print_mt_port_cap_subtlv(netdissect_options *ndo,
 
 static int
 isis_print_mt_port_cap_subtlv(netdissect_options *ndo,

-                              const u_int8_t *tptr, int len)
+                              const uint8_t *tptr, int len)

 {
   int stlv_type, stlv_len;
   const struct isis_subtlv_spb_mcid *subtlv_spb_mcid;
 {
   int stlv_type, stlv_len;
   const struct isis_subtlv_spb_mcid *subtlv_spb_mcid;


@@ -1343,7 +1342,7 @@ isis_print_mt_port_cap_subtlv(netdissect_options *ndo,
         if (!ND_TTEST2(*(tptr), ISIS_SUBTLV_SPB_MCID_MIN_LEN))
           goto trunctlv;
 
         if (!ND_TTEST2(*(tptr), ISIS_SUBTLV_SPB_MCID_MIN_LEN))
           goto trunctlv;
 

-        subtlv_spb_mcid = (struct isis_subtlv_spb_mcid *)tptr;
+        subtlv_spb_mcid = (const struct isis_subtlv_spb_mcid *)tptr;

 
         ND_PRINT((ndo,  "\n\t         MCID: "));
         isis_print_mcid(ndo, &(subtlv_spb_mcid->mcid));
 
         ND_PRINT((ndo,  "\n\t         MCID: "));
         isis_print_mcid(ndo, &(subtlv_spb_mcid->mcid));


@@ -1429,7 +1428,7 @@ isis_print_mt_port_cap_subtlv(netdissect_options *ndo,
 
 static int
 isis_print_mt_capability_subtlv(netdissect_options *ndo,
 
 static int
 isis_print_mt_capability_subtlv(netdissect_options *ndo,

-                                const u_int8_t *tptr, int len)
+                                const uint8_t *tptr, int len)

 {
   int stlv_type, stlv_len, tmp;
 
 {
   int stlv_type, stlv_len, tmp;
 


@@ -1545,7 +1544,7 @@ isis_print_mt_capability_subtlv(netdissect_options *ndo,
 
 /* shared routine for printing system, node and lsp-ids */
 static char *
 
 /* shared routine for printing system, node and lsp-ids */
 static char *

-isis_print_id(const u_int8_t *cp, int id_len)
+isis_print_id(const uint8_t *cp, int id_len)

 {
     int i;
     static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];
 {
     int i;
     static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];


@@ -1592,7 +1591,7 @@ isis_print_metric_block(netdissect_options *ndo,
 
 static int
 isis_print_tlv_ip_reach(netdissect_options *ndo,
 
 static int
 isis_print_tlv_ip_reach(netdissect_options *ndo,

-                        const u_int8_t *cp, const char *ident, int length)
+                        const uint8_t *cp, const char *ident, int length)

 {
        int prefix_len;
        const struct isis_tlv_ip_reach *tlv_ip_reach;
 {
        int prefix_len;
        const struct isis_tlv_ip_reach *tlv_ip_reach;


@@ -1615,12 +1614,12 @@ isis_print_tlv_ip_reach(netdissect_options *ndo,
                if (prefix_len == -1)
                        ND_PRINT((ndo, "%sIPv4 prefix: %s mask %s",
                                ident,
                if (prefix_len == -1)
                        ND_PRINT((ndo, "%sIPv4 prefix: %s mask %s",
                                ident,

-                              ipaddr_string((tlv_ip_reach->prefix)),
-                              ipaddr_string((tlv_ip_reach->mask))));
+                              ipaddr_string(ndo, (tlv_ip_reach->prefix)),
+                              ipaddr_string(ndo, (tlv_ip_reach->mask))));

                else
                        ND_PRINT((ndo, "%sIPv4 prefix: %15s/%u",
                                ident,
                else
                        ND_PRINT((ndo, "%sIPv4 prefix: %15s/%u",
                                ident,

-                              ipaddr_string((tlv_ip_reach->prefix)),
+                              ipaddr_string(ndo, (tlv_ip_reach->prefix)),

                               prefix_len));
 
                ND_PRINT((ndo, ", Distribution: %s, Metric: %u, %s",
                               prefix_len));
 
                ND_PRINT((ndo, ", Distribution: %s, Metric: %u, %s",


@@ -1659,9 +1658,9 @@ isis_print_tlv_ip_reach(netdissect_options *ndo,
 
 static int
 isis_print_ip_reach_subtlv(netdissect_options *ndo,
 
 static int
 isis_print_ip_reach_subtlv(netdissect_options *ndo,

-                           const u_int8_t *tptr, int subt, int subl,
-                           const char *ident) {
-
+                           const uint8_t *tptr, int subt, int subl,
+                           const char *ident)
+{

         /* first lets see if we know the subTLVs name*/
        ND_PRINT((ndo, "%s%s subTLV #%u, length: %u",
                  ident, tok2str(isis_ext_ip_reach_subtlv_values, "unknown", subt),
         /* first lets see if we know the subTLVs name*/
        ND_PRINT((ndo, "%s%s subTLV #%u, length: %u",
                  ident, tok2str(isis_ext_ip_reach_subtlv_values, "unknown", subt),


@@ -1709,13 +1708,13 @@ trunctlv:
 
 static int
 isis_print_is_reach_subtlv(netdissect_options *ndo,
 
 static int
 isis_print_is_reach_subtlv(netdissect_options *ndo,

-                           const u_int8_t *tptr, u_int subt, u_int subl,
-                           const char *ident) {
-
+                           const uint8_t *tptr, u_int subt, u_int subl,
+                           const char *ident)
+{

         u_int te_class,priority_level,gmpls_switch_cap;
         union { /* int to float conversion buffer for several subTLVs */
             float f;
         u_int te_class,priority_level,gmpls_switch_cap;
         union { /* int to float conversion buffer for several subTLVs */
             float f;

-            u_int32_t i;
+            uint32_t i;

         } bw;
 
         /* first lets see if we know the subTLVs name*/
         } bw;
 
         /* first lets see if we know the subTLVs name*/


@@ -1739,7 +1738,7 @@ isis_print_is_reach_subtlv(netdissect_options *ndo,
         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
             if (subl >= sizeof(struct in_addr))
         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
             if (subl >= sizeof(struct in_addr))

-              ND_PRINT((ndo, ", %s", ipaddr_string(tptr)));
+              ND_PRINT((ndo, ", %s", ipaddr_string(ndo, tptr)));

             break;
         case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
        case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:
             break;
         case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
        case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:


@@ -1870,8 +1869,8 @@ trunctlv:
 
 static int
 isis_print_ext_is_reach(netdissect_options *ndo,
 
 static int
 isis_print_ext_is_reach(netdissect_options *ndo,

-                        const u_int8_t *tptr, const char *ident, int tlv_type) {
-
+                        const uint8_t *tptr, const char *ident, int tlv_type)
+{

     char ident_buffer[20];
     int subtlv_type,subtlv_len,subtlv_sum_len;
     int proc_bytes = 0; /* how many bytes did we process ? */
     char ident_buffer[20];
     int subtlv_type,subtlv_len,subtlv_sum_len;
     int proc_bytes = 0; /* how many bytes did we process ? */


@@ -1920,8 +1919,8 @@ isis_print_ext_is_reach(netdissect_options *ndo,
 
 static int
 isis_print_mtid(netdissect_options *ndo,
 
 static int
 isis_print_mtid(netdissect_options *ndo,

-                const u_int8_t *tptr, const char *ident) {
-
+                const uint8_t *tptr, const char *ident)
+{

     if (!ND_TTEST2(*tptr, 2))
         return(0);
 
     if (!ND_TTEST2(*tptr, 2))
         return(0);
 


@@ -1947,14 +1946,10 @@ isis_print_mtid(netdissect_options *ndo,
 
 static int
 isis_print_extd_ip_reach(netdissect_options *ndo,
 
 static int
 isis_print_extd_ip_reach(netdissect_options *ndo,

-                         const u_int8_t *tptr, const char *ident, u_int16_t afi) {
-
+                         const uint8_t *tptr, const char *ident, uint16_t afi)
+{

     char ident_buffer[20];
     char ident_buffer[20];

-#ifdef INET6
-    u_int8_t prefix[sizeof(struct in6_addr)]; /* shared copy buffer for IPv4 and IPv6 prefixes */
-#else
-    u_int8_t prefix[sizeof(struct in_addr)]; /* shared copy buffer for IPv4 prefixes */
-#endif
+    uint8_t prefix[sizeof(struct in6_addr)]; /* shared copy buffer for IPv4 and IPv6 prefixes */

     u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;
 
     if (!ND_TTEST2(*tptr, 4))
     u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;
 
     if (!ND_TTEST2(*tptr, 4))


@@ -1975,7 +1970,6 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
             return (0);
         }
         processed++;
             return (0);
         }
         processed++;

-#ifdef INET6

     } else if (afi == AF_INET6) {
         if (!ND_TTEST2(*tptr, 1)) /* fetch status & prefix_len byte */
             return (0);
     } else if (afi == AF_INET6) {
         if (!ND_TTEST2(*tptr, 1)) /* fetch status & prefix_len byte */
             return (0);


@@ -1988,7 +1982,6 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
             return (0);
         }
         processed+=2;
             return (0);
         }
         processed+=2;

-#endif

     } else
         return (0); /* somebody is fooling us */
 
     } else
         return (0); /* somebody is fooling us */
 


@@ -2004,15 +1997,13 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
     if (afi == AF_INET)
         ND_PRINT((ndo, "%sIPv4 prefix: %15s/%u",
                ident,
     if (afi == AF_INET)
         ND_PRINT((ndo, "%sIPv4 prefix: %15s/%u",
                ident,

-               ipaddr_string(prefix),
+               ipaddr_string(ndo, prefix),

                bit_length));
                bit_length));

-#ifdef INET6
-    if (afi == AF_INET6)
+    else if (afi == AF_INET6)

         ND_PRINT((ndo, "%sIPv6 prefix: %s/%u",
                ident,
         ND_PRINT((ndo, "%sIPv6 prefix: %s/%u",
                ident,

-               ip6addr_string(prefix),
+               ip6addr_string(ndo, prefix),

                bit_length));
                bit_length));

-#endif

 
     ND_PRINT((ndo, ", Distribution: %s, Metric: %u",
            ISIS_MASK_TLV_EXTD_IP_UPDOWN(status_byte) ? "down" : "up",
 
     ND_PRINT((ndo, ", Distribution: %s, Metric: %u",
            ISIS_MASK_TLV_EXTD_IP_UPDOWN(status_byte) ? "down" : "up",


@@ -2020,17 +2011,13 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
 
     if (afi == AF_INET && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
         ND_PRINT((ndo, ", sub-TLVs present"));
 
     if (afi == AF_INET && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
         ND_PRINT((ndo, ", sub-TLVs present"));

-#ifdef INET6
-    if (afi == AF_INET6)
+    else if (afi == AF_INET6)

         ND_PRINT((ndo, ", %s%s",
                ISIS_MASK_TLV_EXTD_IP6_IE(status_byte) ? "External" : "Internal",
                ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : ""));
         ND_PRINT((ndo, ", %s%s",
                ISIS_MASK_TLV_EXTD_IP6_IE(status_byte) ? "External" : "Internal",
                ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : ""));

-#endif

 
     if ((afi == AF_INET  && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
 
     if ((afi == AF_INET  && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))

-#ifdef INET6

      || (afi == AF_INET6 && ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte))
      || (afi == AF_INET6 && ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte))

-#endif

        ) {
         /* assume that one prefix can hold more
            than one subTLV - therefore the first byte must reflect
        ) {
         /* assume that one prefix can hold more
            than one subTLV - therefore the first byte must reflect


@@ -2065,7 +2052,7 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
 
 static int
 isis_print(netdissect_options *ndo,
 
 static int
 isis_print(netdissect_options *ndo,

-           const u_int8_t *p, u_int length)
+           const uint8_t *p, u_int length)

 {
     const struct isis_common_header *isis_header;
 
 {
     const struct isis_common_header *isis_header;
 


@@ -2080,9 +2067,9 @@ isis_print(netdissect_options *ndo,
     const struct isis_tlv_is_reach *tlv_is_reach;
     const struct isis_tlv_es_reach *tlv_es_reach;
 
     const struct isis_tlv_is_reach *tlv_is_reach;
     const struct isis_tlv_es_reach *tlv_es_reach;
 

-    u_int8_t pdu_type, max_area, id_length, tlv_type, tlv_len, tmp, alen, lan_alen, prefix_len;
-    u_int8_t ext_is_len, ext_ip_len, mt_len;
-    const u_int8_t *optr, *pptr, *tptr;
+    uint8_t pdu_type, max_area, id_length, tlv_type, tlv_len, tmp, alen, lan_alen, prefix_len;
+    uint8_t ext_is_len, ext_ip_len, mt_len;
+    const uint8_t *optr, *pptr, *tptr;

     u_short packet_len,pdu_len, key_id;
     u_int i,vendor_id;
     int sigcheck;
     u_short packet_len,pdu_len, key_id;
     u_int i,vendor_id;
     int sigcheck;


@@ -2319,7 +2306,7 @@ isis_print(netdissect_options *ndo,
                EXTRACT_16BITS(header_lsp->checksum)));
 
 
                EXTRACT_16BITS(header_lsp->checksum)));
 
 

-        osi_print_cksum(ndo, (u_int8_t *)header_lsp->lsp_id,
+        osi_print_cksum(ndo, (uint8_t *)header_lsp->lsp_id,

                         EXTRACT_16BITS(header_lsp->checksum), 12, length-12);
 
         /*
                         EXTRACT_16BITS(header_lsp->checksum), 12, length-12);
 
         /*


@@ -2416,8 +2403,7 @@ isis_print(netdissect_options *ndo,
        break;
 
     default:
        break;
 
     default:

-       if (!print_unknown_data(ndo, pptr, "\n\t  ", length))
-           return(0);
+       (void)print_unknown_data(ndo, pptr, "\n\t  ", length);

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


@@ -2452,7 +2438,7 @@ isis_print(netdissect_options *ndo,
                tlv_type,
                tlv_len));
 
                tlv_type,
                tlv_len));
 

-        if (tlv_len == 0) /* something is malformed */
+        if (tlv_len == 0) /* something is invalid */

            continue;
 
         /* now check if we have a decoder otherwise do a hexdump at the end*/
            continue;
 
         /* now check if we have a decoder otherwise do a hexdump at the end*/


@@ -2464,7 +2450,7 @@ isis_print(netdissect_options *ndo,
            while (tmp && alen < tmp) {
                ND_PRINT((ndo, "\n\t      Area address (length: %u): %s",
                        alen,
            while (tmp && alen < tmp) {
                ND_PRINT((ndo, "\n\t      Area address (length: %u): %s",
                        alen,

-                       isonsap_string(tptr, alen)));
+                       isonsap_string(ndo, 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 */


@@ -2607,7 +2593,6 @@ isis_print(netdissect_options *ndo,
            }
            break;
 
            }
            break;
 

-#ifdef INET6

        case ISIS_TLV_IP6_REACH:
            while (tmp>0) {
                 ext_ip_len = isis_print_extd_ip_reach(ndo, tptr, "\n\t      ", AF_INET6);
        case ISIS_TLV_IP6_REACH:
            while (tmp>0) {
                 ext_ip_len = isis_print_extd_ip_reach(ndo, tptr, "\n\t      ", AF_INET6);


@@ -2641,13 +2626,12 @@ isis_print(netdissect_options *ndo,
                    goto trunctlv;
 
                 ND_PRINT((ndo, "\n\t      IPv6 interface address: %s",
                    goto trunctlv;
 
                 ND_PRINT((ndo, "\n\t      IPv6 interface address: %s",

-                      ip6addr_string(tptr)));
+                      ip6addr_string(ndo, tptr)));

 
                tptr += sizeof(struct in6_addr);
                tmp -= sizeof(struct in6_addr);
            }
            break;
 
                tptr += sizeof(struct in6_addr);
                tmp -= sizeof(struct in6_addr);
            }
            break;

-#endif

        case ISIS_TLV_AUTH:
            if (!ND_TTEST2(*tptr, 1))
                goto trunctlv;
        case ISIS_TLV_AUTH:
            if (!ND_TTEST2(*tptr, 1))
                goto trunctlv;


@@ -2672,10 +2656,10 @@ isis_print(netdissect_options *ndo,
                    ND_PRINT((ndo, "%02x", *(tptr + i)));
                }
                if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)
                    ND_PRINT((ndo, "%02x", *(tptr + i)));
                }
                if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)

-                    ND_PRINT((ndo, ", (malformed subTLV) "));
+                    ND_PRINT((ndo, ", (invalid subTLV) "));

 
 #ifdef HAVE_LIBCRYPTO
 
 #ifdef HAVE_LIBCRYPTO

-                sigcheck = signature_verify(optr, length,
+                sigcheck = signature_verify(ndo, optr, length,

                                             (unsigned char *)tptr + 1);
 #else
                 sigcheck = CANT_CHECK_SIGNATURE;
                                             (unsigned char *)tptr + 1);
 #else
                 sigcheck = CANT_CHECK_SIGNATURE;


@@ -2686,7 +2670,7 @@ isis_print(netdissect_options *ndo,
             case ISIS_SUBTLV_AUTH_GENERIC:
                 key_id = EXTRACT_16BITS((tptr+1));
                 ND_PRINT((ndo, "%u, password: ", key_id));
             case ISIS_SUBTLV_AUTH_GENERIC:
                 key_id = EXTRACT_16BITS((tptr+1));
                 ND_PRINT((ndo, "%u, password: ", key_id));

-                for(i=1 + sizeof(u_int16_t);i<tlv_len;i++) {
+                for(i=1 + sizeof(uint16_t);i<tlv_len;i++) {

                     if (!ND_TTEST2(*(tptr + i), 1))
                         goto trunctlv;
                     ND_PRINT((ndo, "%02x", *(tptr + i)));
                     if (!ND_TTEST2(*(tptr + i), 1))
                         goto trunctlv;
                     ND_PRINT((ndo, "%02x", *(tptr + i)));


@@ -2790,14 +2774,14 @@ isis_print(netdissect_options *ndo,
        case ISIS_TLV_TE_ROUTER_ID:
            if (!ND_TTEST2(*pptr, sizeof(struct in_addr)))
                goto trunctlv;
        case ISIS_TLV_TE_ROUTER_ID:
            if (!ND_TTEST2(*pptr, sizeof(struct in_addr)))
                goto trunctlv;

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

            break;
 
        case ISIS_TLV_IPADDR:
            while (tmp>=sizeof(struct in_addr)) {
                if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                    goto trunctlv;
            break;
 
        case ISIS_TLV_IPADDR:
            while (tmp>=sizeof(struct in_addr)) {
                if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                    goto trunctlv;

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

                tptr += sizeof(struct in_addr);
                tmp -= sizeof(struct in_addr);
            }
                tptr += sizeof(struct in_addr);
                tmp -= sizeof(struct in_addr);
            }


@@ -2833,7 +2817,7 @@ isis_print(netdissect_options *ndo,
                break;
            if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                 goto trunctlv;
                break;
            if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                 goto trunctlv;

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

            tptr+=sizeof(struct in_addr);
            tmp-=sizeof(struct in_addr);
 
            tptr+=sizeof(struct in_addr);
            tmp-=sizeof(struct in_addr);
 


@@ -2841,7 +2825,7 @@ isis_print(netdissect_options *ndo,
                break;
            if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                 goto trunctlv;
                break;
            if (!ND_TTEST2(*tptr, sizeof(struct in_addr)))
                 goto trunctlv;

-           ND_PRINT((ndo, "\n\t      IPv4 neighbor address: %s", ipaddr_string(tptr)));
+           ND_PRINT((ndo, "\n\t      IPv4 neighbor address: %s", ipaddr_string(ndo, tptr)));

            tptr+=sizeof(struct in_addr);
            tmp-=sizeof(struct in_addr);
 
            tptr+=sizeof(struct in_addr);
            tmp-=sizeof(struct in_addr);
 


@@ -2889,6 +2873,22 @@ isis_print(netdissect_options *ndo,
             osi_print_cksum(ndo, optr, EXTRACT_16BITS(tptr), tptr-optr, length);
            break;
 
             osi_print_cksum(ndo, optr, EXTRACT_16BITS(tptr), tptr-optr, length);
            break;
 

+       case ISIS_TLV_POI:
+           if (tlv_len >= SYSTEM_ID_LEN + 1) {
+               if (!ND_TTEST2(*tptr, SYSTEM_ID_LEN + 1))
+                   goto trunctlv;
+               ND_PRINT((ndo, "\n\t      Purge Originator System-ID: %s",
+                      isis_print_id(tptr + 1, SYSTEM_ID_LEN)));
+           }
+
+           if (tlv_len == 2 * SYSTEM_ID_LEN + 1) {
+               if (!ND_TTEST2(*tptr, 2 * SYSTEM_ID_LEN + 1))
+                   goto trunctlv;
+               ND_PRINT((ndo, "\n\t      Received from System-ID: %s",
+                      isis_print_id(tptr + SYSTEM_ID_LEN + 1, SYSTEM_ID_LEN)));
+           }
+           break;
+

        case ISIS_TLV_MT_SUPPORTED:
             if (tmp < ISIS_TLV_MT_SUPPORTED_MINLEN)
                 break;
        case ISIS_TLV_MT_SUPPORTED:
             if (tmp < ISIS_TLV_MT_SUPPORTED_MINLEN)
                 break;


@@ -2902,7 +2902,7 @@ isis_print(netdissect_options *ndo,
                     tptr+=mt_len;
                     tmp-=mt_len;
                } else {
                     tptr+=mt_len;
                     tmp-=mt_len;
                } else {

-                   ND_PRINT((ndo, "\n\t      malformed MT-ID"));
+                   ND_PRINT((ndo, "\n\t      invalid MT-ID"));

                    break;
                }
            }
                    break;
                }
            }


@@ -3006,7 +3006,7 @@ isis_print(netdissect_options *ndo,
                 if (!ND_TTEST2(*tptr, prefix_len / 2))
                     goto trunctlv;
                 ND_PRINT((ndo, "\n\t\tAddress: %s/%u",
                 if (!ND_TTEST2(*tptr, prefix_len / 2))
                     goto trunctlv;
                 ND_PRINT((ndo, "\n\t\tAddress: %s/%u",

-                       isonsap_string(tptr, prefix_len / 2), prefix_len * 4));
+                       isonsap_string(ndo, tptr, prefix_len / 2), prefix_len * 4));

                 tptr+=prefix_len/2;
                 tmp-=prefix_len/2;
             }
                 tptr+=prefix_len/2;
                 tmp-=prefix_len/2;
             }


@@ -3078,21 +3078,38 @@ isis_print(netdissect_options *ndo,
 }
 
 static void
 }
 
 static void

-osi_print_cksum(netdissect_options *ndo,
-                const u_int8_t *pptr, u_int16_t checksum,
-                    u_int checksum_offset, u_int length)
+osi_print_cksum(netdissect_options *ndo, const uint8_t *pptr,
+               uint16_t checksum, int checksum_offset, int length)

 {
 {

-        u_int16_t calculated_checksum;
+        uint16_t calculated_checksum;

 
 

-        /* do not attempt to verify the checksum if it is zero */
-        if (!checksum) {
-                ND_PRINT((ndo, "(unverified)"));
+        /* do not attempt to verify the checksum if it is zero,
+         * if the total length is nonsense,
+         * if the offset is nonsense,
+         * or the base pointer is not sane
+         */
+        if (!checksum
+            || length < 0
+            || checksum_offset < 0
+            || length > ndo->ndo_snaplen
+            || checksum_offset > ndo->ndo_snaplen
+            || checksum_offset > length) {
+                ND_PRINT((ndo, " (unverified)"));

         } else {
         } else {

+                const char *truncated = "trunc";
+#if 0
+                printf("\nosi_print_cksum: %p %u %u %u\n", pptr, checksum_offset, length, ndo->ndo_snaplen);
+                ND_TCHECK2(pptr, checksum_offset+length);
+#endif

                 calculated_checksum = create_osi_cksum(pptr, checksum_offset, length);
                 if (checksum == calculated_checksum) {
                         ND_PRINT((ndo, " (correct)"));
                 } else {
                 calculated_checksum = create_osi_cksum(pptr, checksum_offset, length);
                 if (checksum == calculated_checksum) {
                         ND_PRINT((ndo, " (correct)"));
                 } else {

-                        ND_PRINT((ndo, " (incorrect should be 0x%04x)", calculated_checksum));
+                        truncated = "incorrect";
+#if 0
+                        trunc:
+#endif
+                        ND_PRINT((ndo, " (%s should be 0x%04x)", truncated, calculated_checksum));

                 }
         }
 }
                 }
         }
 }