Another UN*Xism we need - isascii().

[tcpdump] / print-icmp.c

diff --git a/print-icmp.c b/print-icmp.c
index fd3c2e33ddf50446b08f9128e7a37bafc4dd62e6..7e7db14a7fef6e2f8caa2e5c7bd4506e0ad29cdf 100644 (file)
--- a/print-icmp.c
+++ b/print-icmp.c
@@ -22,10 +22,10 @@
 /* \summary: Internet Control Message Protocol (ICMP) printer */
 
 #ifdef HAVE_CONFIG_H
 /* \summary: Internet Control Message Protocol (ICMP) printer */
 
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

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

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


@@ -48,17 +48,17 @@
  * Structure of an icmp header.
  */
 struct icmp {
  * Structure of an icmp header.
  */
 struct icmp {

-       uint8_t  icmp_type;             /* type of message, see below */
-       uint8_t  icmp_code;             /* type sub code */
-       uint16_t icmp_cksum;            /* ones complement cksum of struct */
+       nd_uint8_t  icmp_type;          /* type of message, see below */
+       nd_uint8_t  icmp_code;          /* type sub code */
+       nd_uint16_t icmp_cksum;         /* ones complement cksum of struct */

        union {
        union {

-               uint8_t ih_pptr;                        /* ICMP_PARAMPROB */
+               nd_uint8_t ih_pptr;             /* ICMP_PARAMPROB */

                struct in_addr ih_gwaddr;       /* ICMP_REDIRECT */
                struct ih_idseq {
                struct in_addr ih_gwaddr;       /* ICMP_REDIRECT */
                struct ih_idseq {

-                       uint16_t icd_id;
-                       uint16_t icd_seq;
+                       nd_uint16_t icd_id;
+                       nd_uint16_t icd_seq;

                } ih_idseq;
                } ih_idseq;

-               uint32_t ih_void;
+               nd_uint32_t ih_void;

        } icmp_hun;
 #define        icmp_pptr       icmp_hun.ih_pptr
 #define        icmp_gwaddr     icmp_hun.ih_gwaddr
        } icmp_hun;
 #define        icmp_pptr       icmp_hun.ih_pptr
 #define        icmp_gwaddr     icmp_hun.ih_gwaddr


@@ -67,16 +67,16 @@ struct icmp {
 #define        icmp_void       icmp_hun.ih_void
        union {
                struct id_ts {
 #define        icmp_void       icmp_hun.ih_void
        union {
                struct id_ts {

-                       uint32_t its_otime;
-                       uint32_t its_rtime;
-                       uint32_t its_ttime;
+                       nd_uint32_t its_otime;
+                       nd_uint32_t its_rtime;
+                       nd_uint32_t its_ttime;

                } id_ts;
                struct id_ip  {
                        struct ip idi_ip;
                        /* options and then 64 bits of data */
                } id_ip;
                } id_ts;
                struct id_ip  {
                        struct ip idi_ip;
                        /* options and then 64 bits of data */
                } id_ip;

-               uint32_t id_mask;
-               uint8_t id_data[1];
+               nd_uint32_t id_mask;
+               nd_byte id_data[1];

        } icmp_dun;
 #define        icmp_otime      icmp_dun.id_ts.its_otime
 #define        icmp_rtime      icmp_dun.id_ts.its_rtime
        } icmp_dun;
 #define        icmp_otime      icmp_dun.id_ts.its_otime
 #define        icmp_rtime      icmp_dun.id_ts.its_rtime


@@ -240,20 +240,20 @@ static const struct tok type2str[] = {
 
 /* rfc1191 */
 struct mtu_discovery {
 
 /* rfc1191 */
 struct mtu_discovery {

-       uint16_t unused;
-       uint16_t nexthopmtu;
+       nd_uint16_t unused;
+       nd_uint16_t nexthopmtu;

 };
 
 /* rfc1256 */
 struct ih_rdiscovery {
 };
 
 /* rfc1256 */
 struct ih_rdiscovery {

-       uint8_t ird_addrnum;
-       uint8_t ird_addrsiz;
-       uint16_t ird_lifetime;
+       nd_uint8_t ird_addrnum;
+       nd_uint8_t ird_addrsiz;
+       nd_uint16_t ird_lifetime;

 };
 
 struct id_rdiscovery {
 };
 
 struct id_rdiscovery {

-       uint32_t ird_addr;
-       uint32_t ird_pref;
+       nd_uint32_t ird_addr;
+       nd_uint32_t ird_pref;

 };
 
 /*
 };
 
 /*


@@ -283,22 +283,22 @@ struct id_rdiscovery {
  */
 
 struct icmp_ext_t {
  */
 
 struct icmp_ext_t {

-    uint8_t icmp_type;
-    uint8_t icmp_code;
-    uint8_t icmp_checksum[2];
-    uint8_t icmp_reserved;
-    uint8_t icmp_length;
-    uint8_t icmp_reserved2[2];
-    uint8_t icmp_ext_legacy_header[128]; /* extension header starts 128 bytes after ICMP header */
-    uint8_t icmp_ext_version_res[2];
-    uint8_t icmp_ext_checksum[2];
-    uint8_t icmp_ext_data[1];
+    nd_uint8_t  icmp_type;
+    nd_uint8_t  icmp_code;
+    nd_uint16_t icmp_checksum;
+    nd_byte     icmp_reserved;
+    nd_uint8_t  icmp_length;
+    nd_byte     icmp_reserved2[2];
+    nd_byte     icmp_ext_legacy_header[128]; /* extension header starts 128 bytes after ICMP header */
+    nd_byte     icmp_ext_version_res[2];
+    nd_uint16_t icmp_ext_checksum;
+    nd_byte     icmp_ext_data[1];

 };
 
 struct icmp_mpls_ext_object_header_t {
 };
 
 struct icmp_mpls_ext_object_header_t {

-    uint8_t length[2];
-    uint8_t class_num;
-    uint8_t ctype;
+    nd_uint16_t length;
+    nd_uint8_t  class_num;
+    nd_uint8_t  ctype;

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


@@ -332,10 +332,12 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
 {
        char *cp;
        const struct icmp *dp;
 {
        char *cp;
        const struct icmp *dp;

+       uint8_t icmp_type, icmp_code;

         const struct icmp_ext_t *ext_dp;
        const struct ip *ip;
        const char *str, *fmt;
        const struct ip *oip;
         const struct icmp_ext_t *ext_dp;
        const struct ip *ip;
        const char *str, *fmt;
        const struct ip *oip;

+       uint8_t ip_proto;

        const struct udphdr *ouh;
         const uint8_t *obj_tptr;
         uint32_t raw_label;
        const struct udphdr *ouh;
         const uint8_t *obj_tptr;
         uint32_t raw_label;


@@ -350,39 +352,42 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
        ip = (const struct ip *)bp2;
        str = buf;
 
        ip = (const struct ip *)bp2;
        str = buf;
 

-       ND_TCHECK(dp->icmp_code);
-       switch (dp->icmp_type) {
+       ND_TCHECK_1(dp->icmp_code);
+       icmp_type = EXTRACT_U_1(dp->icmp_type);
+       icmp_code = EXTRACT_U_1(dp->icmp_code);
+       switch (icmp_type) {

 
        case ICMP_ECHO:
        case ICMP_ECHOREPLY:
 
        case ICMP_ECHO:
        case ICMP_ECHOREPLY:

-               ND_TCHECK(dp->icmp_seq);
+               ND_TCHECK_2(dp->icmp_seq);

                (void)snprintf(buf, sizeof(buf), "echo %s, id %u, seq %u",
                (void)snprintf(buf, sizeof(buf), "echo %s, id %u, seq %u",

-                               dp->icmp_type == ICMP_ECHO ?
+                               icmp_type == ICMP_ECHO ?

                                "request" : "reply",
                                "request" : "reply",

-                               EXTRACT_BE_16BITS(&dp->icmp_id),
-                               EXTRACT_BE_16BITS(&dp->icmp_seq));
+                               EXTRACT_BE_U_2(dp->icmp_id),
+                               EXTRACT_BE_U_2(dp->icmp_seq));

                break;
 
        case ICMP_UNREACH:
                break;
 
        case ICMP_UNREACH:

-               ND_TCHECK(dp->icmp_ip.ip_dst);
-               switch (dp->icmp_code) {
+               ND_TCHECK_4(dp->icmp_ip.ip_dst);
+               switch (icmp_code) {

 
                case ICMP_UNREACH_PROTOCOL:
 
                case ICMP_UNREACH_PROTOCOL:

-                       ND_TCHECK(dp->icmp_ip.ip_p);
+                       ND_TCHECK_1(dp->icmp_ip.ip_p);

                        (void)snprintf(buf, sizeof(buf),
                        (void)snprintf(buf, sizeof(buf),

-                           "%s protocol %d unreachable",
+                           "%s protocol %u unreachable",

                            ipaddr_string(ndo, &dp->icmp_ip.ip_dst),
                            ipaddr_string(ndo, &dp->icmp_ip.ip_dst),

-                           dp->icmp_ip.ip_p);
+                           EXTRACT_U_1(dp->icmp_ip.ip_p));

                        break;
 
                case ICMP_UNREACH_PORT:
                        break;
 
                case ICMP_UNREACH_PORT:

-                       ND_TCHECK(dp->icmp_ip.ip_p);
+                       ND_TCHECK_1(dp->icmp_ip.ip_p);

                        oip = &dp->icmp_ip;
                        hlen = IP_HL(oip) * 4;
                        ouh = (const struct udphdr *)(((const u_char *)oip) + hlen);
                        oip = &dp->icmp_ip;
                        hlen = IP_HL(oip) * 4;
                        ouh = (const struct udphdr *)(((const u_char *)oip) + hlen);

-                       ND_TCHECK(ouh->uh_dport);
-                       dport = EXTRACT_BE_16BITS(&ouh->uh_dport);
-                       switch (oip->ip_p) {
+                       ND_TCHECK_2(ouh->uh_dport);
+                       dport = EXTRACT_BE_U_2(ouh->uh_dport);
+                       ip_proto = EXTRACT_U_1(oip->ip_p);
+                       switch (ip_proto) {

 
                        case IPPROTO_TCP:
                                (void)snprintf(buf, sizeof(buf),
 
                        case IPPROTO_TCP:
                                (void)snprintf(buf, sizeof(buf),


@@ -402,19 +407,19 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                                (void)snprintf(buf, sizeof(buf),
                                        "%s protocol %u port %u unreachable",
                                        ipaddr_string(ndo, &oip->ip_dst),
                                (void)snprintf(buf, sizeof(buf),
                                        "%s protocol %u port %u unreachable",
                                        ipaddr_string(ndo, &oip->ip_dst),

-                                       oip->ip_p, dport);
+                                       ip_proto, dport);

                                break;
                        }
                        break;
 
                case ICMP_UNREACH_NEEDFRAG:
                    {
                                break;
                        }
                        break;
 
                case ICMP_UNREACH_NEEDFRAG:
                    {

-                       register const struct mtu_discovery *mp;
+                       const struct mtu_discovery *mp;

                        mp = (const struct mtu_discovery *)(const u_char *)&dp->icmp_void;
                        mp = (const struct mtu_discovery *)(const u_char *)&dp->icmp_void;

-                       mtu = EXTRACT_BE_16BITS(&mp->nexthopmtu);
+                       mtu = EXTRACT_BE_U_2(mp->nexthopmtu);

                        if (mtu) {
                                (void)snprintf(buf, sizeof(buf),
                        if (mtu) {
                                (void)snprintf(buf, sizeof(buf),

-                                   "%s unreachable - need to frag (mtu %d)",
+                                   "%s unreachable - need to frag (mtu %u)",

                                    ipaddr_string(ndo, &dp->icmp_ip.ip_dst), mtu);
                        } else {
                                (void)snprintf(buf, sizeof(buf),
                                    ipaddr_string(ndo, &dp->icmp_ip.ip_dst), mtu);
                        } else {
                                (void)snprintf(buf, sizeof(buf),


@@ -425,8 +430,8 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                        break;
 
                default:
                        break;
 
                default:

-                       fmt = tok2str(unreach2str, "#%d %%s unreachable",
-                           dp->icmp_code);
+                       fmt = tok2str(unreach2str, "#%u %%s unreachable",
+                           icmp_code);

                        (void)snprintf(buf, sizeof(buf), fmt,
                            ipaddr_string(ndo, &dp->icmp_ip.ip_dst));
                        break;
                        (void)snprintf(buf, sizeof(buf), fmt,
                            ipaddr_string(ndo, &dp->icmp_ip.ip_dst));
                        break;


@@ -434,9 +439,9 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                break;
 
        case ICMP_REDIRECT:
                break;
 
        case ICMP_REDIRECT:

-               ND_TCHECK(dp->icmp_ip.ip_dst);
-               fmt = tok2str(type2str, "redirect-#%d %%s to net %%s",
-                   dp->icmp_code);
+               ND_TCHECK_4(dp->icmp_ip.ip_dst);
+               fmt = tok2str(type2str, "redirect-#%u %%s to net %%s",
+                   icmp_code);

                (void)snprintf(buf, sizeof(buf), fmt,
                    ipaddr_string(ndo, &dp->icmp_ip.ip_dst),
                    ipaddr_string(ndo, &dp->icmp_gwaddr));
                (void)snprintf(buf, sizeof(buf), fmt,
                    ipaddr_string(ndo, &dp->icmp_ip.ip_dst),
                    ipaddr_string(ndo, &dp->icmp_gwaddr));


@@ -444,18 +449,18 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
 
        case ICMP_ROUTERADVERT:
            {
 
        case ICMP_ROUTERADVERT:
            {

-               register const struct ih_rdiscovery *ihp;
-               register const struct id_rdiscovery *idp;
+               const struct ih_rdiscovery *ihp;
+               const struct id_rdiscovery *idp;

                u_int lifetime, num, size;
 
                (void)snprintf(buf, sizeof(buf), "router advertisement");
                cp = buf + strlen(buf);
 
                ihp = (const struct ih_rdiscovery *)&dp->icmp_void;
                u_int lifetime, num, size;
 
                (void)snprintf(buf, sizeof(buf), "router advertisement");
                cp = buf + strlen(buf);
 
                ihp = (const struct ih_rdiscovery *)&dp->icmp_void;

-               ND_TCHECK(*ihp);
+               ND_TCHECK_SIZE(ihp);

                (void)strncpy(cp, " lifetime ", sizeof(buf) - (cp - buf));
                cp = buf + strlen(buf);
                (void)strncpy(cp, " lifetime ", sizeof(buf) - (cp - buf));
                cp = buf + strlen(buf);

-               lifetime = EXTRACT_BE_16BITS(&ihp->ird_lifetime);
+               lifetime = EXTRACT_BE_U_2(ihp->ird_lifetime);

                if (lifetime < 60) {
                        (void)snprintf(cp, sizeof(buf) - (cp - buf), "%u",
                            lifetime);
                if (lifetime < 60) {
                        (void)snprintf(cp, sizeof(buf) - (cp - buf), "%u",
                            lifetime);


@@ -471,22 +476,22 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                }
                cp = buf + strlen(buf);
 
                }
                cp = buf + strlen(buf);
 

-               num = ihp->ird_addrnum;
-               (void)snprintf(cp, sizeof(buf) - (cp - buf), " %d:", num);
+               num = EXTRACT_U_1(ihp->ird_addrnum);
+               (void)snprintf(cp, sizeof(buf) - (cp - buf), " %u:", num);

                cp = buf + strlen(buf);
 
                cp = buf + strlen(buf);
 

-               size = ihp->ird_addrsiz;
+               size = EXTRACT_U_1(ihp->ird_addrsiz);

                if (size != 2) {
                        (void)snprintf(cp, sizeof(buf) - (cp - buf),
                if (size != 2) {
                        (void)snprintf(cp, sizeof(buf) - (cp - buf),

-                           " [size %d]", size);
+                           " [size %u]", size);

                        break;
                }
                idp = (const struct id_rdiscovery *)&dp->icmp_data;
                while (num-- > 0) {
                        break;
                }
                idp = (const struct id_rdiscovery *)&dp->icmp_data;
                while (num-- > 0) {

-                       ND_TCHECK(*idp);
+                       ND_TCHECK_SIZE(idp);

                        (void)snprintf(cp, sizeof(buf) - (cp - buf), " {%s %u}",
                            ipaddr_string(ndo, &idp->ird_addr),
                        (void)snprintf(cp, sizeof(buf) - (cp - buf), " {%s %u}",
                            ipaddr_string(ndo, &idp->ird_addr),

-                           EXTRACT_BE_32BITS(&idp->ird_pref));
+                           EXTRACT_BE_U_4(idp->ird_pref));

                        cp = buf + strlen(buf);
                        ++idp;
                }
                        cp = buf + strlen(buf);
                        ++idp;
                }


@@ -494,8 +499,8 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                break;
 
        case ICMP_TIMXCEED:
                break;
 
        case ICMP_TIMXCEED:

-               ND_TCHECK(dp->icmp_ip.ip_dst);
-               switch (dp->icmp_code) {
+               ND_TCHECK_4(dp->icmp_ip.ip_dst);
+               switch (icmp_code) {

 
                case ICMP_TIMXCEED_INTRANS:
                        str = "time exceeded in-transit";
 
                case ICMP_TIMXCEED_INTRANS:
                        str = "time exceeded in-transit";


@@ -507,67 +512,67 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
 
                default:
                        (void)snprintf(buf, sizeof(buf), "time exceeded-#%u",
 
                default:
                        (void)snprintf(buf, sizeof(buf), "time exceeded-#%u",

-                           dp->icmp_code);
+                           icmp_code);

                        break;
                }
                break;
 
        case ICMP_PARAMPROB:
                        break;
                }
                break;
 
        case ICMP_PARAMPROB:

-               if (dp->icmp_code)
+               if (icmp_code)

                        (void)snprintf(buf, sizeof(buf),
                        (void)snprintf(buf, sizeof(buf),

-                           "parameter problem - code %u", dp->icmp_code);
+                           "parameter problem - code %u", icmp_code);

                else {
                else {

-                       ND_TCHECK(dp->icmp_pptr);
+                       ND_TCHECK_1(dp->icmp_pptr);

                        (void)snprintf(buf, sizeof(buf),
                        (void)snprintf(buf, sizeof(buf),

-                           "parameter problem - octet %u", dp->icmp_pptr);
+                           "parameter problem - octet %u", EXTRACT_U_1(dp->icmp_pptr));

                }
                break;
 
        case ICMP_MASKREPLY:
                }
                break;
 
        case ICMP_MASKREPLY:

-               ND_TCHECK(dp->icmp_mask);
+               ND_TCHECK_4(dp->icmp_mask);

                (void)snprintf(buf, sizeof(buf), "address mask is 0x%08x",
                (void)snprintf(buf, sizeof(buf), "address mask is 0x%08x",

-                   EXTRACT_BE_32BITS(&dp->icmp_mask));
+                   EXTRACT_BE_U_4(dp->icmp_mask));

                break;
 
        case ICMP_TSTAMP:
                break;
 
        case ICMP_TSTAMP:

-               ND_TCHECK(dp->icmp_seq);
+               ND_TCHECK_2(dp->icmp_seq);

                (void)snprintf(buf, sizeof(buf),
                    "time stamp query id %u seq %u",
                (void)snprintf(buf, sizeof(buf),
                    "time stamp query id %u seq %u",

-                   EXTRACT_BE_16BITS(&dp->icmp_id),
-                   EXTRACT_BE_16BITS(&dp->icmp_seq));
+                   EXTRACT_BE_U_2(dp->icmp_id),
+                   EXTRACT_BE_U_2(dp->icmp_seq));

                break;
 
        case ICMP_TSTAMPREPLY:
                break;
 
        case ICMP_TSTAMPREPLY:

-               ND_TCHECK(dp->icmp_ttime);
+               ND_TCHECK_4(dp->icmp_ttime);

                (void)snprintf(buf, sizeof(buf),
                    "time stamp reply id %u seq %u: org %s",
                (void)snprintf(buf, sizeof(buf),
                    "time stamp reply id %u seq %u: org %s",

-                               EXTRACT_BE_16BITS(&dp->icmp_id),
-                               EXTRACT_BE_16BITS(&dp->icmp_seq),
-                               icmp_tstamp_print(EXTRACT_BE_32BITS(&dp->icmp_otime)));
+                               EXTRACT_BE_U_2(dp->icmp_id),
+                               EXTRACT_BE_U_2(dp->icmp_seq),
+                               icmp_tstamp_print(EXTRACT_BE_U_4(dp->icmp_otime)));

 
                 (void)snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),", recv %s",
 
                 (void)snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),", recv %s",

-                         icmp_tstamp_print(EXTRACT_BE_32BITS(&dp->icmp_rtime)));
+                         icmp_tstamp_print(EXTRACT_BE_U_4(dp->icmp_rtime)));

                 (void)snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),", xmit %s",
                 (void)snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),", xmit %s",

-                         icmp_tstamp_print(EXTRACT_BE_32BITS(&dp->icmp_ttime)));
+                         icmp_tstamp_print(EXTRACT_BE_U_4(dp->icmp_ttime)));

                 break;
 
        default:
                 break;
 
        default:

-               str = tok2str(icmp2str, "type-#%d", dp->icmp_type);
+               str = tok2str(icmp2str, "type-#%u", icmp_type);

                break;
        }
                break;
        }

-       ND_PRINT((ndo, "ICMP %s, length %u", str, plen));
+       ND_PRINT("ICMP %s, length %u", str, plen);

        if (ndo->ndo_vflag && !fragmented) { /* don't attempt checksumming if this is a frag */
        if (ndo->ndo_vflag && !fragmented) { /* don't attempt checksumming if this is a frag */

-               if (ND_TTEST2(*bp, plen)) {
+               if (ND_TTEST_LEN(bp, plen)) {

                        uint16_t sum;
 
                        vec[0].ptr = (const uint8_t *)(const void *)dp;
                        vec[0].len = plen;
                        sum = in_cksum(vec, 1);
                        if (sum != 0) {
                        uint16_t sum;
 
                        vec[0].ptr = (const uint8_t *)(const void *)dp;
                        vec[0].len = plen;
                        sum = in_cksum(vec, 1);
                        if (sum != 0) {

-                               uint16_t icmp_sum = EXTRACT_BE_16BITS(&dp->icmp_cksum);
-                               ND_PRINT((ndo, " (wrong icmp cksum %x (->%x)!)",
+                               uint16_t icmp_sum = EXTRACT_BE_U_2(dp->icmp_cksum);
+                               ND_PRINT(" (wrong icmp cksum %x (->%x)!)",

                                             icmp_sum,
                                             icmp_sum,

-                                            in_cksum_shouldbe(icmp_sum, sum)));
+                                            in_cksum_shouldbe(icmp_sum, sum));

                        }
                }
        }
                        }
                }
        }


@@ -576,22 +581,22 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
          * print the remnants of the IP packet.
          * save the snaplength as this may get overidden in the IP printer.
          */
          * print the remnants of the IP packet.
          * save the snaplength as this may get overidden in the IP printer.
          */

-       if (ndo->ndo_vflag >= 1 && ICMP_ERRTYPE(dp->icmp_type)) {
+       if (ndo->ndo_vflag >= 1 && ICMP_ERRTYPE(icmp_type)) {

                bp += 8;
                bp += 8;

-               ND_PRINT((ndo, "\n\t"));
+               ND_PRINT("\n\t");

                ip = (const struct ip *)bp;
                 snapend_save = ndo->ndo_snapend;
                ip = (const struct ip *)bp;
                 snapend_save = ndo->ndo_snapend;

-               ND_TCHECK_16BITS(&ip->ip_len);
-               ip_print(ndo, bp, EXTRACT_BE_16BITS(&ip->ip_len));
+               ND_TCHECK_2(ip->ip_len);
+               ip_print(ndo, bp, EXTRACT_BE_U_2(ip->ip_len));

                 ndo->ndo_snapend = snapend_save;
        }
 
         /*
          * Attempt to decode the MPLS extensions only for some ICMP types.
          */
                 ndo->ndo_snapend = snapend_save;
        }
 
         /*
          * Attempt to decode the MPLS extensions only for some ICMP types.
          */

-        if (ndo->ndo_vflag >= 1 && plen > ICMP_EXTD_MINLEN && ICMP_MPLS_EXT_TYPE(dp->icmp_type)) {
+        if (ndo->ndo_vflag >= 1 && plen > ICMP_EXTD_MINLEN && ICMP_MPLS_EXT_TYPE(icmp_type)) {

 
 

-            ND_TCHECK(*ext_dp);
+            ND_TCHECK_SIZE(ext_dp);

 
             /*
              * Check first if the mpls extension header shows a non-zero length.
 
             /*
              * Check first if the mpls extension header shows a non-zero length.


@@ -599,8 +604,8 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
              * to check if an extension header is present. This is expedient,
              * however not all implementations set the length field proper.
              */
              * to check if an extension header is present. This is expedient,
              * however not all implementations set the length field proper.
              */

-            if (!ext_dp->icmp_length &&
-                ND_TTEST2(ext_dp->icmp_ext_version_res, plen - ICMP_EXTD_MINLEN)) {
+            if (EXTRACT_U_1(ext_dp->icmp_length) == 0 &&
+                ND_TTEST_LEN(ext_dp->icmp_ext_version_res, plen - ICMP_EXTD_MINLEN)) {

                 vec[0].ptr = (const uint8_t *)(const void *)&ext_dp->icmp_ext_version_res;
                 vec[0].len = plen - ICMP_EXTD_MINLEN;
                 if (in_cksum(vec, 1)) {
                 vec[0].ptr = (const uint8_t *)(const void *)&ext_dp->icmp_ext_version_res;
                 vec[0].len = plen - ICMP_EXTD_MINLEN;
                 if (in_cksum(vec, 1)) {


@@ -608,26 +613,26 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                 }
             }
 
                 }
             }
 

-            ND_PRINT((ndo, "\n\tMPLS extension v%u",
-                   ICMP_MPLS_EXT_EXTRACT_VERSION(*(ext_dp->icmp_ext_version_res))));
+            ND_PRINT("\n\tMPLS extension v%u",
+                   ICMP_MPLS_EXT_EXTRACT_VERSION(*(ext_dp->icmp_ext_version_res)));

 
             /*
              * Sanity checking of the header.
              */
             if (ICMP_MPLS_EXT_EXTRACT_VERSION(*(ext_dp->icmp_ext_version_res)) !=
                 ICMP_MPLS_EXT_VERSION) {
 
             /*
              * Sanity checking of the header.
              */
             if (ICMP_MPLS_EXT_EXTRACT_VERSION(*(ext_dp->icmp_ext_version_res)) !=
                 ICMP_MPLS_EXT_VERSION) {

-                ND_PRINT((ndo, " packet not supported"));
+                ND_PRINT(" packet not supported");

                 return;
             }
 
             hlen = plen - ICMP_EXTD_MINLEN;
                 return;
             }
 
             hlen = plen - ICMP_EXTD_MINLEN;

-            if (ND_TTEST2(ext_dp->icmp_ext_version_res, hlen)) {
+            if (ND_TTEST_LEN(ext_dp->icmp_ext_version_res, hlen)) {

                 vec[0].ptr = (const uint8_t *)(const void *)&ext_dp->icmp_ext_version_res;
                 vec[0].len = hlen;
                 vec[0].ptr = (const uint8_t *)(const void *)&ext_dp->icmp_ext_version_res;
                 vec[0].len = hlen;

-                ND_PRINT((ndo, ", checksum 0x%04x (%scorrect), length %u",
-                       EXTRACT_BE_16BITS(ext_dp->icmp_ext_checksum),
+                ND_PRINT(", checksum 0x%04x (%scorrect), length %u",
+                       EXTRACT_BE_U_2(ext_dp->icmp_ext_checksum),

                        in_cksum(vec, 1) ? "in" : "",
                        in_cksum(vec, 1) ? "in" : "",

-                       hlen));
+                       hlen);

             }
 
             hlen -= 4; /* subtract common header size */
             }
 
             hlen -= 4; /* subtract common header size */


@@ -636,17 +641,17 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
             while (hlen > sizeof(struct icmp_mpls_ext_object_header_t)) {
 
                 icmp_mpls_ext_object_header = (const struct icmp_mpls_ext_object_header_t *)obj_tptr;
             while (hlen > sizeof(struct icmp_mpls_ext_object_header_t)) {
 
                 icmp_mpls_ext_object_header = (const struct icmp_mpls_ext_object_header_t *)obj_tptr;

-                ND_TCHECK(*icmp_mpls_ext_object_header);
-                obj_tlen = EXTRACT_BE_16BITS(icmp_mpls_ext_object_header->length);
-                obj_class_num = icmp_mpls_ext_object_header->class_num;
-                obj_ctype = icmp_mpls_ext_object_header->ctype;
+                ND_TCHECK_SIZE(icmp_mpls_ext_object_header);
+                obj_tlen = EXTRACT_BE_U_2(icmp_mpls_ext_object_header->length);
+                obj_class_num = EXTRACT_U_1(icmp_mpls_ext_object_header->class_num);
+                obj_ctype = EXTRACT_U_1(icmp_mpls_ext_object_header->ctype);

                 obj_tptr += sizeof(struct icmp_mpls_ext_object_header_t);
 
                 obj_tptr += sizeof(struct icmp_mpls_ext_object_header_t);
 

-                ND_PRINT((ndo, "\n\t  %s Object (%u), Class-Type: %u, length %u",
+                ND_PRINT("\n\t  %s Object (%u), Class-Type: %u, length %u",

                        tok2str(icmp_mpls_ext_obj_values,"unknown",obj_class_num),
                        obj_class_num,
                        obj_ctype,
                        tok2str(icmp_mpls_ext_obj_values,"unknown",obj_class_num),
                        obj_class_num,
                        obj_ctype,

-                       obj_tlen));
+                       obj_tlen);

 
                 hlen-=sizeof(struct icmp_mpls_ext_object_header_t); /* length field includes tlv header */
 
 
                 hlen-=sizeof(struct icmp_mpls_ext_object_header_t); /* length field includes tlv header */
 


@@ -661,12 +666,12 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
                 case 1:
                     switch(obj_ctype) {
                     case 1:
                 case 1:
                     switch(obj_ctype) {
                     case 1:

-                        ND_TCHECK2(*obj_tptr, 4);
-                        raw_label = EXTRACT_BE_32BITS(obj_tptr);
-                        ND_PRINT((ndo, "\n\t    label %u, exp %u", MPLS_LABEL(raw_label), MPLS_EXP(raw_label)));
+                        ND_TCHECK_4(obj_tptr);
+                        raw_label = EXTRACT_BE_U_4(obj_tptr);
+                        ND_PRINT("\n\t    label %u, exp %u", MPLS_LABEL(raw_label), MPLS_EXP(raw_label));

                         if (MPLS_STACK(raw_label))
                         if (MPLS_STACK(raw_label))

-                            ND_PRINT((ndo, ", [S]"));
-                        ND_PRINT((ndo, ", ttl %u", MPLS_TTL(raw_label)));
+                            ND_PRINT(", [S]");
+                        ND_PRINT(", ttl %u", MPLS_TTL(raw_label));

                         break;
                     default:
                         print_unknown_data(ndo, obj_tptr, "\n\t    ", obj_tlen);
                         break;
                     default:
                         print_unknown_data(ndo, obj_tptr, "\n\t    ", obj_tlen);


@@ -691,7 +696,7 @@ icmp_print(netdissect_options *ndo, const u_char *bp, u_int plen, const u_char *
 
        return;
 trunc:
 
        return;
 trunc:

-       ND_PRINT((ndo, "[|icmp]"));
+       ND_PRINT("[|icmp]");

 }
 /*
  * Local Variables:
 }
 /*
  * Local Variables: