]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-nfs.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
remove redundant ND_TCHECK, let GET_ routines handle checks
[tcpdump] / print-nfs.c
diff --git a/print-nfs.c b/print-nfs.c
index 5772b314214883616fc526835c432c87c3dffc8c..20b0cfcef4d8260537b2a3aa690c7cd88b9dab87 100644 (file)
--- a/print-nfs.c
+++ b/print-nfs.c
@@ -29,6 +29,7 @@
 
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>
+#include <limits.h>
 
 #include "netdissect.h"
 #include "addrtoname.h"
 
 #include "netdissect.h"
 #include "addrtoname.h"
@@ -45,8 +46,7 @@
 
 static void nfs_printfh(netdissect_options *, const uint32_t *, const u_int);
 static int xid_map_enter(netdissect_options *, const struct sunrpc_msg *, const u_char *);
 
 static void nfs_printfh(netdissect_options *, const uint32_t *, const u_int);
 static int xid_map_enter(netdissect_options *, const struct sunrpc_msg *, const u_char *);
-static int xid_map_find(const struct sunrpc_msg *, const u_char *,
-                           uint32_t *, uint32_t *);
+static int xid_map_find(netdissect_options *, const struct sunrpc_msg *, const u_char *, uint32_t *, uint32_t *);
 static void interp_reply(netdissect_options *, const struct sunrpc_msg *, uint32_t, uint32_t, int);
 static const uint32_t *parse_post_op_attr(netdissect_options *, const uint32_t *, int);
 
 static void interp_reply(netdissect_options *, const struct sunrpc_msg *, uint32_t, uint32_t, int);
 static const uint32_t *parse_post_op_attr(netdissect_options *, const uint32_t *, int);
 
@@ -209,14 +209,14 @@ print_nfsaddr(netdissect_options *ndo,
        switch (IP_V((const struct ip *)bp)) {
        case 4:
                ip = (const struct ip *)bp;
        switch (IP_V((const struct ip *)bp)) {
        case 4:
                ip = (const struct ip *)bp;
-               strlcpy(srcaddr, ipaddr_string(ndo, ip->ip_src), sizeof(srcaddr));
-               strlcpy(dstaddr, ipaddr_string(ndo, ip->ip_dst), sizeof(dstaddr));
+               strlcpy(srcaddr, GET_IPADDR_STRING(ip->ip_src), sizeof(srcaddr));
+               strlcpy(dstaddr, GET_IPADDR_STRING(ip->ip_dst), sizeof(dstaddr));
                break;
        case 6:
                ip6 = (const struct ip6_hdr *)bp;
                break;
        case 6:
                ip6 = (const struct ip6_hdr *)bp;
-               strlcpy(srcaddr, ip6addr_string(ndo, ip6->ip6_src),
+               strlcpy(srcaddr, GET_IP6ADDR_STRING(ip6->ip6_src),
                    sizeof(srcaddr));
                    sizeof(srcaddr));
-               strlcpy(dstaddr, ip6addr_string(ndo, ip6->ip6_dst),
+               strlcpy(dstaddr, GET_IP6ADDR_STRING(ip6->ip6_dst),
                    sizeof(dstaddr));
                break;
        default:
                    sizeof(dstaddr));
                break;
        default:
@@ -260,67 +260,53 @@ static const uint32_t *
 parse_sattr3(netdissect_options *ndo,
              const uint32_t *dp, struct nfsv3_sattr *sa3)
 {
 parse_sattr3(netdissect_options *ndo,
              const uint32_t *dp, struct nfsv3_sattr *sa3)
 {
-       ND_TCHECK_4(dp);
-       sa3->sa_modeset = EXTRACT_BE_U_4(dp);
+       sa3->sa_modeset = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_modeset) {
        dp++;
        if (sa3->sa_modeset) {
-               ND_TCHECK_4(dp);
-               sa3->sa_mode = EXTRACT_BE_U_4(dp);
+               sa3->sa_mode = GET_BE_U_4(dp);
                dp++;
        }
 
                dp++;
        }
 
-       ND_TCHECK_4(dp);
-       sa3->sa_uidset = EXTRACT_BE_U_4(dp);
+       sa3->sa_uidset = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_uidset) {
        dp++;
        if (sa3->sa_uidset) {
-               ND_TCHECK_4(dp);
-               sa3->sa_uid = EXTRACT_BE_U_4(dp);
+               sa3->sa_uid = GET_BE_U_4(dp);
                dp++;
        }
 
                dp++;
        }
 
-       ND_TCHECK_4(dp);
-       sa3->sa_gidset = EXTRACT_BE_U_4(dp);
+       sa3->sa_gidset = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_gidset) {
        dp++;
        if (sa3->sa_gidset) {
-               ND_TCHECK_4(dp);
-               sa3->sa_gid = EXTRACT_BE_U_4(dp);
+               sa3->sa_gid = GET_BE_U_4(dp);
                dp++;
        }
 
                dp++;
        }
 
-       ND_TCHECK_4(dp);
-       sa3->sa_sizeset = EXTRACT_BE_U_4(dp);
+       sa3->sa_sizeset = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_sizeset) {
        dp++;
        if (sa3->sa_sizeset) {
-               ND_TCHECK_4(dp);
-               sa3->sa_size = EXTRACT_BE_U_4(dp);
+               sa3->sa_size = GET_BE_U_4(dp);
                dp++;
        }
 
                dp++;
        }
 
-       ND_TCHECK_4(dp);
-       sa3->sa_atimetype = EXTRACT_BE_U_4(dp);
+       sa3->sa_atimetype = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) {
        dp++;
        if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) {
-               ND_TCHECK_4(dp + 1);
-               sa3->sa_atime.nfsv3_sec = EXTRACT_BE_U_4(dp);
+               sa3->sa_atime.nfsv3_sec = GET_BE_U_4(dp);
                dp++;
                dp++;
-               sa3->sa_atime.nfsv3_nsec = EXTRACT_BE_U_4(dp);
+               sa3->sa_atime.nfsv3_nsec = GET_BE_U_4(dp);
                dp++;
        }
 
                dp++;
        }
 
-       ND_TCHECK_4(dp);
-       sa3->sa_mtimetype = EXTRACT_BE_U_4(dp);
+       sa3->sa_mtimetype = GET_BE_U_4(dp);
        dp++;
        if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) {
        dp++;
        if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) {
-               ND_TCHECK_4(dp + 1);
-               sa3->sa_mtime.nfsv3_sec = EXTRACT_BE_U_4(dp);
+               sa3->sa_mtime.nfsv3_sec = GET_BE_U_4(dp);
                dp++;
                dp++;
-               sa3->sa_mtime.nfsv3_nsec = EXTRACT_BE_U_4(dp);
+               sa3->sa_mtime.nfsv3_nsec = GET_BE_U_4(dp);
                dp++;
        }
 
        return dp;
                dp++;
        }
 
        return dp;
-trunc:
-       return NULL;
 }
 
 static void
 }
 
 static void
@@ -354,23 +340,18 @@ nfsreply_print(netdissect_options *ndo,
        ndo->ndo_protocol = "nfs";
        rp = (const struct sunrpc_msg *)bp;
 
        ndo->ndo_protocol = "nfs";
        rp = (const struct sunrpc_msg *)bp;
 
-       ND_TCHECK_4(rp->rm_xid);
        if (!ndo->ndo_nflag) {
                strlcpy(srcid, "nfs", sizeof(srcid));
        if (!ndo->ndo_nflag) {
                strlcpy(srcid, "nfs", sizeof(srcid));
-               nd_snprintf(dstid, sizeof(dstid), "%u",
-                   EXTRACT_BE_U_4(rp->rm_xid));
+               snprintf(dstid, sizeof(dstid), "%u",
+                   GET_BE_U_4(rp->rm_xid));
        } else {
        } else {
-               nd_snprintf(srcid, sizeof(srcid), "%u", NFS_PORT);
-               nd_snprintf(dstid, sizeof(dstid), "%u",
-                   EXTRACT_BE_U_4(rp->rm_xid));
+               snprintf(srcid, sizeof(srcid), "%u", NFS_PORT);
+               snprintf(dstid, sizeof(dstid), "%u",
+                   GET_BE_U_4(rp->rm_xid));
        }
        print_nfsaddr(ndo, bp2, srcid, dstid);
 
        nfsreply_noaddr_print(ndo, bp, length, bp2);
        }
        print_nfsaddr(ndo, bp2, srcid, dstid);
 
        nfsreply_noaddr_print(ndo, bp, length, bp2);
-       return;
-
-trunc:
-       nd_print_trunc(ndo);
 }
 
 void
 }
 
 void
@@ -389,31 +370,31 @@ nfsreply_noaddr_print(netdissect_options *ndo,
        rp = (const struct sunrpc_msg *)bp;
 
        ND_TCHECK_4(rp->rm_reply.rp_stat);
        rp = (const struct sunrpc_msg *)bp;
 
        ND_TCHECK_4(rp->rm_reply.rp_stat);
-       reply_stat = EXTRACT_BE_U_4(&rp->rm_reply.rp_stat);
+       reply_stat = GET_BE_U_4(&rp->rm_reply.rp_stat);
        switch (reply_stat) {
 
        case SUNRPC_MSG_ACCEPTED:
                ND_PRINT("reply ok %u", length);
        switch (reply_stat) {
 
        case SUNRPC_MSG_ACCEPTED:
                ND_PRINT("reply ok %u", length);
-               if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
+               if (xid_map_find(ndo, rp, bp2, &proc, &vers) >= 0)
                        interp_reply(ndo, rp, proc, vers, length);
                break;
 
        case SUNRPC_MSG_DENIED:
                ND_PRINT("reply ERR %u: ", length);
                ND_TCHECK_4(rp->rm_reply.rp_reject.rj_stat);
                        interp_reply(ndo, rp, proc, vers, length);
                break;
 
        case SUNRPC_MSG_DENIED:
                ND_PRINT("reply ERR %u: ", length);
                ND_TCHECK_4(rp->rm_reply.rp_reject.rj_stat);
-               rstat = EXTRACT_BE_U_4(&rp->rm_reply.rp_reject.rj_stat);
+               rstat = GET_BE_U_4(&rp->rm_reply.rp_reject.rj_stat);
                switch (rstat) {
 
                case SUNRPC_RPC_MISMATCH:
                        ND_TCHECK_4(rp->rm_reply.rp_reject.rj_vers.high);
                switch (rstat) {
 
                case SUNRPC_RPC_MISMATCH:
                        ND_TCHECK_4(rp->rm_reply.rp_reject.rj_vers.high);
-                       rlow = EXTRACT_BE_U_4(&rp->rm_reply.rp_reject.rj_vers.low);
-                       rhigh = EXTRACT_BE_U_4(&rp->rm_reply.rp_reject.rj_vers.high);
+                       rlow = GET_BE_U_4(&rp->rm_reply.rp_reject.rj_vers.low);
+                       rhigh = GET_BE_U_4(&rp->rm_reply.rp_reject.rj_vers.high);
                        ND_PRINT("RPC Version mismatch (%u-%u)", rlow, rhigh);
                        break;
 
                case SUNRPC_AUTH_ERROR:
                        ND_TCHECK_4(rp->rm_reply.rp_reject.rj_why);
                        ND_PRINT("RPC Version mismatch (%u-%u)", rlow, rhigh);
                        break;
 
                case SUNRPC_AUTH_ERROR:
                        ND_TCHECK_4(rp->rm_reply.rp_reject.rj_why);
-                       rwhy = EXTRACT_BE_U_4(&rp->rm_reply.rp_reject.rj_why);
+                       rwhy = GET_BE_U_4(&rp->rm_reply.rp_reject.rj_why);
                        ND_PRINT("Auth %s", tok2str(sunrpc_auth_str, "Invalid failure code %u", rwhy));
                        break;
 
                        ND_PRINT("Auth %s", tok2str(sunrpc_auth_str, "Invalid failure code %u", rwhy));
                        break;
 
@@ -452,8 +433,7 @@ parsereq(netdissect_options *ndo,
        dp = (const uint32_t *)&rp->rm_call.cb_cred;
        if (length < 2 * sizeof(*dp))
                goto trunc;
        dp = (const uint32_t *)&rp->rm_call.cb_cred;
        if (length < 2 * sizeof(*dp))
                goto trunc;
-       ND_TCHECK_4(dp + 1);
-       len = EXTRACT_BE_U_4(dp + 1);
+       len = GET_BE_U_4(dp + 1);
        rounded_len = roundup2(len, 4);
        ND_TCHECK_LEN(dp + 2, rounded_len);
        if (2 * sizeof(*dp) + rounded_len <= length) {
        rounded_len = roundup2(len, 4);
        ND_TCHECK_LEN(dp + 2, rounded_len);
        if (2 * sizeof(*dp) + rounded_len <= length) {
@@ -472,8 +452,7 @@ parsereq(netdissect_options *ndo,
                 */
                if (length < 2 * sizeof(*dp))
                        goto trunc;
                 */
                if (length < 2 * sizeof(*dp))
                        goto trunc;
-               ND_TCHECK_4(dp + 1);
-               len = EXTRACT_BE_U_4(dp + 1);
+               len = GET_BE_U_4(dp + 1);
                rounded_len = roundup2(len, 4);
                ND_TCHECK_LEN(dp + 2, rounded_len);
                if (2 * sizeof(*dp) + rounded_len < length) {
                rounded_len = roundup2(len, 4);
                ND_TCHECK_LEN(dp + 2, rounded_len);
                if (2 * sizeof(*dp) + rounded_len < length) {
@@ -502,8 +481,7 @@ parsefh(netdissect_options *ndo,
        u_int len;
 
        if (v3) {
        u_int len;
 
        if (v3) {
-               ND_TCHECK_4(dp);
-               len = EXTRACT_BE_U_4(dp) / 4;
+               len = GET_BE_U_4(dp) / 4;
                dp++;
        } else
                len = NFSX_V2FH / 4;
                dp++;
        } else
                len = NFSX_V2FH / 4;
@@ -511,9 +489,8 @@ parsefh(netdissect_options *ndo,
        if (ND_TTEST_LEN(dp, len * sizeof(*dp))) {
                nfs_printfh(ndo, dp, len);
                return (dp + len);
        if (ND_TTEST_LEN(dp, len * sizeof(*dp))) {
                nfs_printfh(ndo, dp, len);
                return (dp + len);
-       }
-trunc:
-       return (NULL);
+       } else
+               return NULL;
 }
 
 /*
 }
 
 /*
@@ -524,21 +501,25 @@ static const uint32_t *
 parsefn(netdissect_options *ndo,
         const uint32_t *dp)
 {
 parsefn(netdissect_options *ndo,
         const uint32_t *dp)
 {
-       uint32_t len;
+       uint32_t len, rounded_len;
        const u_char *cp;
 
        const u_char *cp;
 
-       /* Bail if we don't have the string length */
-       ND_TCHECK_4(dp);
-
        /* Fetch big-endian string length */
        /* Fetch big-endian string length */
-       len = EXTRACT_BE_U_4(dp);
+       len = GET_BE_U_4(dp);
        dp++;
 
        dp++;
 
-       ND_TCHECK_LEN(dp, ((len + 3) & ~3));
+       if (UINT_MAX - len < 3) {
+               ND_PRINT("[cannot pad to 32-bit boundaries]");
+               nd_print_invalid(ndo);
+               return NULL;
+       }
+
+       rounded_len = roundup2(len, 4);
+       ND_TCHECK_LEN(dp, rounded_len);
 
        cp = (const u_char *)dp;
        /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
 
        cp = (const u_char *)dp;
        /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
-       dp += ((len + 3) & ~3) / sizeof(*dp);
+       dp += rounded_len / sizeof(*dp);
        ND_PRINT("\"");
        if (nd_printn(ndo, cp, len, ndo->ndo_snapend)) {
                ND_PRINT("\"");
        ND_PRINT("\"");
        if (nd_printn(ndo, cp, len, ndo->ndo_snapend)) {
                ND_PRINT("\"");
@@ -587,8 +568,8 @@ nfsreq_noaddr_print(netdissect_options *ndo,
        if (!xid_map_enter(ndo, rp, bp2))       /* record proc number for later on */
                goto trunc;
 
        if (!xid_map_enter(ndo, rp, bp2))       /* record proc number for later on */
                goto trunc;
 
-       v3 = (EXTRACT_BE_U_4(&rp->rm_call.cb_vers) == NFS_VER3);
-       proc = EXTRACT_BE_U_4(&rp->rm_call.cb_proc);
+       v3 = (GET_BE_U_4(&rp->rm_call.cb_vers) == NFS_VER3);
+       proc = GET_BE_U_4(&rp->rm_call.cb_proc);
 
        if (!v3 && proc < NFS_NPROCS)
                proc =  nfsv3_procid[proc];
 
        if (!v3 && proc < NFS_NPROCS)
                proc =  nfsv3_procid[proc];
@@ -628,8 +609,7 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
-               ND_TCHECK_4(dp);
-               access_flags = EXTRACT_BE_U_4(dp);
+               access_flags = GET_BE_U_4(dp);
                if (access_flags & ~NFSV3ACCESS_FULL) {
                        /* NFSV3ACCESS definitions aren't up to date */
                        ND_PRINT(" %04x", access_flags);
                if (access_flags & ~NFSV3ACCESS_FULL) {
                        /* NFSV3ACCESS definitions aren't up to date */
                        ND_PRINT(" %04x", access_flags);
@@ -670,15 +650,13 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                if (dp == NULL)
                        goto trunc;
                if (v3) {
                if (dp == NULL)
                        goto trunc;
                if (v3) {
-                       ND_TCHECK_4(dp + 2);
                        ND_PRINT(" %u bytes @ %" PRIu64,
                        ND_PRINT(" %u bytes @ %" PRIu64,
-                              EXTRACT_BE_U_4(dp + 2),
-                              EXTRACT_BE_U_8(dp));
+                              GET_BE_U_4(dp + 2),
+                              GET_BE_U_8(dp));
                } else {
                } else {
-                       ND_TCHECK_4(dp + 1);
                        ND_PRINT(" %u bytes @ %u",
                        ND_PRINT(" %u bytes @ %u",
-                           EXTRACT_BE_U_4(dp + 1),
-                           EXTRACT_BE_U_4(dp));
+                           GET_BE_U_4(dp + 1),
+                           GET_BE_U_4(dp));
                }
                break;
 
                }
                break;
 
@@ -690,23 +668,21 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                if (dp == NULL)
                        goto trunc;
                if (v3) {
                if (dp == NULL)
                        goto trunc;
                if (v3) {
-                       ND_TCHECK_4(dp + 4);
                        ND_PRINT(" %u (%u) bytes @ %" PRIu64,
                        ND_PRINT(" %u (%u) bytes @ %" PRIu64,
-                                       EXTRACT_BE_U_4(dp + 4),
-                                       EXTRACT_BE_U_4(dp + 2),
-                                       EXTRACT_BE_U_8(dp));
+                                       GET_BE_U_4(dp + 4),
+                                       GET_BE_U_4(dp + 2),
+                                       GET_BE_U_8(dp));
                        if (ndo->ndo_vflag) {
                                ND_PRINT(" <%s>",
                                        tok2str(nfsv3_writemodes,
                        if (ndo->ndo_vflag) {
                                ND_PRINT(" <%s>",
                                        tok2str(nfsv3_writemodes,
-                                               NULL, EXTRACT_BE_U_4(dp + 3)));
+                                               NULL, GET_BE_U_4(dp + 3)));
                        }
                } else {
                        }
                } else {
-                       ND_TCHECK_4(dp + 3);
                        ND_PRINT(" %u (%u) bytes @ %u (%u)",
                        ND_PRINT(" %u (%u) bytes @ %u (%u)",
-                                       EXTRACT_BE_U_4(dp + 3),
-                                       EXTRACT_BE_U_4(dp + 2),
-                                       EXTRACT_BE_U_4(dp + 1),
-                                       EXTRACT_BE_U_4(dp));
+                                       GET_BE_U_4(dp + 3),
+                                       GET_BE_U_4(dp + 2),
+                                       GET_BE_U_4(dp + 1),
+                                       GET_BE_U_4(dp));
                }
                break;
 
                }
                break;
 
@@ -733,18 +709,16 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                dp = parsefhn(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
                dp = parsefhn(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
-               ND_TCHECK_4(dp);
-               type = (nfs_type) EXTRACT_BE_U_4(dp);
+               type = (nfs_type) GET_BE_U_4(dp);
                dp++;
                dp = parse_sattr3(ndo, dp, &sa3);
                if (dp == NULL)
                        goto trunc;
                ND_PRINT(" %s", tok2str(type2str, "unk-ft %u", type));
                if (ndo->ndo_vflag && (type == NFCHR || type == NFBLK)) {
                dp++;
                dp = parse_sattr3(ndo, dp, &sa3);
                if (dp == NULL)
                        goto trunc;
                ND_PRINT(" %s", tok2str(type2str, "unk-ft %u", type));
                if (ndo->ndo_vflag && (type == NFCHR || type == NFBLK)) {
-                       ND_TCHECK_4(dp + 1);
                        ND_PRINT(" %u/%u",
                        ND_PRINT(" %u/%u",
-                              EXTRACT_BE_U_4(dp),
-                              EXTRACT_BE_U_4(dp + 1));
+                              GET_BE_U_4(dp),
+                              GET_BE_U_4(dp + 1));
                        dp += 2;
                }
                if (ndo->ndo_vflag)
                        dp += 2;
                }
                if (ndo->ndo_vflag)
@@ -783,14 +757,13 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                if (dp == NULL)
                        goto trunc;
                if (v3) {
                if (dp == NULL)
                        goto trunc;
                if (v3) {
-                       ND_TCHECK_4(dp + 4);
                        /*
                         * We shouldn't really try to interpret the
                         * offset cookie here.
                         */
                        ND_PRINT(" %u bytes @ %" PRId64,
                        /*
                         * We shouldn't really try to interpret the
                         * offset cookie here.
                         */
                        ND_PRINT(" %u bytes @ %" PRId64,
-                           EXTRACT_BE_U_4(dp + 4),
-                           EXTRACT_BE_U_8(dp));
+                           GET_BE_U_4(dp + 4),
+                           GET_BE_U_8(dp));
                        if (ndo->ndo_vflag) {
                                /*
                                 * This displays the 8 bytes
                        if (ndo->ndo_vflag) {
                                /*
                                 * This displays the 8 bytes
@@ -799,18 +772,17 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                                 * to the high-order byte.
                                 */
                                ND_PRINT(" verf %08x%08x",
                                 * to the high-order byte.
                                 */
                                ND_PRINT(" verf %08x%08x",
-                                         EXTRACT_BE_U_4(dp + 2),
-                                         EXTRACT_BE_U_4(dp + 3));
+                                         GET_BE_U_4(dp + 2),
+                                         GET_BE_U_4(dp + 3));
                        }
                } else {
                        }
                } else {
-                       ND_TCHECK_4(dp + 1);
                        /*
                         * Print the offset as signed, since -1 is
                         * common, but offsets > 2^31 aren't.
                         */
                        ND_PRINT(" %u bytes @ %u",
                        /*
                         * Print the offset as signed, since -1 is
                         * common, but offsets > 2^31 aren't.
                         */
                        ND_PRINT(" %u bytes @ %u",
-                           EXTRACT_BE_U_4(dp + 1),
-                           EXTRACT_BE_U_4(dp));
+                           GET_BE_U_4(dp + 1),
+                           GET_BE_U_4(dp));
                }
                break;
 
                }
                break;
 
@@ -821,16 +793,14 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
-               ND_TCHECK_4(dp + 4);
                /*
                 * We don't try to interpret the offset
                 * cookie here.
                 */
                ND_PRINT(" %u bytes @ %" PRId64,
                /*
                 * We don't try to interpret the offset
                 * cookie here.
                 */
                ND_PRINT(" %u bytes @ %" PRId64,
-                       EXTRACT_BE_U_4(dp + 4),
-                       EXTRACT_BE_U_8(dp));
+                       GET_BE_U_4(dp + 4),
+                       GET_BE_U_8(dp));
                if (ndo->ndo_vflag) {
                if (ndo->ndo_vflag) {
-                       ND_TCHECK_4(dp + 5);
                        /*
                         * This displays the 8 bytes
                         * of the verifier in order,
                        /*
                         * This displays the 8 bytes
                         * of the verifier in order,
@@ -838,9 +808,9 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                         * to the high-order byte.
                         */
                        ND_PRINT(" max %u verf %08x%08x",
                         * to the high-order byte.
                         */
                        ND_PRINT(" max %u verf %08x%08x",
-                                 EXTRACT_BE_U_4(dp + 5),
-                                 EXTRACT_BE_U_4(dp + 2),
-                                 EXTRACT_BE_U_4(dp + 3));
+                                 GET_BE_U_4(dp + 5),
+                                 GET_BE_U_4(dp + 2),
+                                 GET_BE_U_4(dp + 3));
                }
                break;
 
                }
                break;
 
@@ -851,10 +821,9 @@ nfsreq_noaddr_print(netdissect_options *ndo,
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
                dp = parsefh(ndo, dp, v3);
                if (dp == NULL)
                        goto trunc;
-               ND_TCHECK_4(dp + 2);
                ND_PRINT(" %u bytes @ %" PRIu64,
                ND_PRINT(" %u bytes @ %" PRIu64,
-                       EXTRACT_BE_U_4(dp + 2),
-                       EXTRACT_BE_U_8(dp));
+                       GET_BE_U_4(dp + 2),
+                       GET_BE_U_8(dp));
                break;
 
        default:
                break;
 
        default:
@@ -902,14 +871,14 @@ nfs_printfh(netdissect_options *ndo,
                         * running tcpdump may show the same file
                         * handle in different ways.
                         */
                         * running tcpdump may show the same file
                         * handle in different ways.
                         */
-                       ND_PRINT("%s%x", sep, EXTRACT_BE_U_4(dp + i));
+                       ND_PRINT("%s%x", sep, GET_BE_U_4(dp + i));
                        sep = ":";
                }
                ND_PRINT("]");
                return;
        }
 
                        sep = ":";
                }
                ND_PRINT("]");
                return;
        }
 
-       Parse_fh((const u_char *)dp, len, &fsid, &ino, NULL, &sfsname, 0);
+       Parse_fh(ndo, (const u_char *)dp, len, &fsid, &ino, NULL, &sfsname, 0);
 
        if (sfsname) {
                /* file system ID is ASCII, not numeric, for this server OS */
 
        if (sfsname) {
                /* file system ID is ASCII, not numeric, for this server OS */
@@ -949,8 +918,8 @@ nfs_printfh(netdissect_options *ndo,
 struct xid_map_entry {
        uint32_t        xid;            /* transaction ID (net order) */
        int ipver;                      /* IP version (4 or 6) */
 struct xid_map_entry {
        uint32_t        xid;            /* transaction ID (net order) */
        int ipver;                      /* IP version (4 or 6) */
-       struct in6_addr client;         /* client IP address (net order) */
-       struct in6_addr server;         /* server IP address (net order) */
+       nd_ipv6 client;                 /* client IP address (net order) */
+       nd_ipv6 server;                 /* server IP address (net order) */
        uint32_t        proc;           /* call proc number (host order) */
        uint32_t        vers;           /* program version (host order) */
 };
        uint32_t        proc;           /* call proc number (host order) */
        uint32_t        vers;           /* program version (host order) */
 };
@@ -1009,8 +978,8 @@ xid_map_enter(netdissect_options *ndo,
                UNALIGNED_MEMCPY(&xmep->server, ip6->ip6_dst,
                                 sizeof(ip6->ip6_dst));
        }
                UNALIGNED_MEMCPY(&xmep->server, ip6->ip6_dst,
                                 sizeof(ip6->ip6_dst));
        }
-       xmep->proc = EXTRACT_BE_U_4(&rp->rm_call.cb_proc);
-       xmep->vers = EXTRACT_BE_U_4(&rp->rm_call.cb_vers);
+       xmep->proc = GET_BE_U_4(&rp->rm_call.cb_proc);
+       xmep->vers = GET_BE_U_4(&rp->rm_call.cb_vers);
        return (1);
 }
 
        return (1);
 }
 
@@ -1019,8 +988,8 @@ xid_map_enter(netdissect_options *ndo,
  * version in vers return, or returns -1 on failure
  */
 static int
  * version in vers return, or returns -1 on failure
  */
 static int
-xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, uint32_t *proc,
-            uint32_t *vers)
+xid_map_find(netdissect_options *ndo, const struct sunrpc_msg *rp,
+            const u_char *bp, uint32_t *proc, uint32_t *vers)
 {
        int i;
        struct xid_map_entry *xmep;
 {
        int i;
        struct xid_map_entry *xmep;
@@ -1106,8 +1075,7 @@ parserep(netdissect_options *ndo,
         * which is an "enum" and so occupies one 32-bit word.
         */
        dp = ((const uint32_t *)&rp->rm_reply) + 1;
         * which is an "enum" and so occupies one 32-bit word.
         */
        dp = ((const uint32_t *)&rp->rm_reply) + 1;
-       ND_TCHECK_4(dp + 1);
-       len = EXTRACT_BE_U_4(dp + 1);
+       len = GET_BE_U_4(dp + 1);
        if (len >= length)
                return (NULL);
        /*
        if (len >= length)
                return (NULL);
        /*
@@ -1118,8 +1086,7 @@ parserep(netdissect_options *ndo,
        /*
         * now we can check the ar_stat field
         */
        /*
         * now we can check the ar_stat field
         */
-       ND_TCHECK_4(dp);
-       astat = (enum sunrpc_accept_stat) EXTRACT_BE_U_4(dp);
+       astat = (enum sunrpc_accept_stat) GET_BE_U_4(dp);
        if (astat != SUNRPC_SUCCESS) {
                ND_PRINT(" %s", tok2str(sunrpc_str, "ar_stat %u", astat));
                *nfserrp = 1;           /* suppress trunc string */
        if (astat != SUNRPC_SUCCESS) {
                ND_PRINT(" %s", tok2str(sunrpc_str, "ar_stat %u", astat));
                *nfserrp = 1;           /* suppress trunc string */
@@ -1138,9 +1105,7 @@ parsestatus(netdissect_options *ndo,
 {
        u_int errnum;
 
 {
        u_int errnum;
 
-       ND_TCHECK_4(dp);
-
-       errnum = EXTRACT_BE_U_4(dp);
+       errnum = GET_BE_U_4(dp);
        if (er)
                *er = errnum;
        if (errnum != 0) {
        if (er)
                *er = errnum;
        if (errnum != 0) {
@@ -1150,8 +1115,6 @@ parsestatus(netdissect_options *ndo,
                *nfserrp = 1;
        }
        return (dp + 1);
                *nfserrp = 1;
        }
        return (dp + 1);
-trunc:
-       return NULL;
 }
 
 static const uint32_t *
 }
 
 static const uint32_t *
@@ -1171,17 +1134,15 @@ parsefattr(netdissect_options *ndo,
                 */
                ND_PRINT(" %s %o ids %d/%d",
                    tok2str(type2str, "unk-ft %u ",
                 */
                ND_PRINT(" %s %o ids %d/%d",
                    tok2str(type2str, "unk-ft %u ",
-                   EXTRACT_BE_U_4(fap->fa_type)),
-                   EXTRACT_BE_U_4(fap->fa_mode),
-                   EXTRACT_BE_S_4(fap->fa_uid),
-                   EXTRACT_BE_S_4(fap->fa_gid));
+                   GET_BE_U_4(fap->fa_type)),
+                   GET_BE_U_4(fap->fa_mode),
+                   GET_BE_S_4(fap->fa_uid),
+                   GET_BE_S_4(fap->fa_gid));
                if (v3) {
                if (v3) {
-                       ND_TCHECK_8(fap->fa3_size);
                        ND_PRINT(" sz %" PRIu64,
                        ND_PRINT(" sz %" PRIu64,
-                               EXTRACT_BE_U_8(fap->fa3_size));
+                               GET_BE_U_8(fap->fa3_size));
                } else {
                } else {
-                       ND_TCHECK_4(fap->fa2_size);
-                       ND_PRINT(" sz %u", EXTRACT_BE_U_4(fap->fa2_size));
+                       ND_PRINT(" sz %u", GET_BE_U_4(fap->fa2_size));
                }
        }
        /* print lots more stuff */
                }
        }
        /* print lots more stuff */
@@ -1189,38 +1150,38 @@ parsefattr(netdissect_options *ndo,
                if (v3) {
                        ND_TCHECK_8(&fap->fa3_ctime);
                        ND_PRINT(" nlink %u rdev %u/%u",
                if (v3) {
                        ND_TCHECK_8(&fap->fa3_ctime);
                        ND_PRINT(" nlink %u rdev %u/%u",
-                              EXTRACT_BE_U_4(fap->fa_nlink),
-                              EXTRACT_BE_U_4(fap->fa3_rdev.specdata1),
-                              EXTRACT_BE_U_4(fap->fa3_rdev.specdata2));
+                              GET_BE_U_4(fap->fa_nlink),
+                              GET_BE_U_4(fap->fa3_rdev.specdata1),
+                              GET_BE_U_4(fap->fa3_rdev.specdata2));
                        ND_PRINT(" fsid %" PRIx64,
                        ND_PRINT(" fsid %" PRIx64,
-                               EXTRACT_BE_U_8(fap->fa3_fsid));
+                               GET_BE_U_8(fap->fa3_fsid));
                        ND_PRINT(" fileid %" PRIx64,
                        ND_PRINT(" fileid %" PRIx64,
-                               EXTRACT_BE_U_8(fap->fa3_fileid));
+                               GET_BE_U_8(fap->fa3_fileid));
                        ND_PRINT(" a/m/ctime %u.%06u",
                        ND_PRINT(" a/m/ctime %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa3_atime.nfsv3_sec),
-                              EXTRACT_BE_U_4(fap->fa3_atime.nfsv3_nsec));
+                              GET_BE_U_4(fap->fa3_atime.nfsv3_sec),
+                              GET_BE_U_4(fap->fa3_atime.nfsv3_nsec));
                        ND_PRINT(" %u.%06u",
                        ND_PRINT(" %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa3_mtime.nfsv3_sec),
-                              EXTRACT_BE_U_4(fap->fa3_mtime.nfsv3_nsec));
+                              GET_BE_U_4(fap->fa3_mtime.nfsv3_sec),
+                              GET_BE_U_4(fap->fa3_mtime.nfsv3_nsec));
                        ND_PRINT(" %u.%06u",
                        ND_PRINT(" %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa3_ctime.nfsv3_sec),
-                              EXTRACT_BE_U_4(fap->fa3_ctime.nfsv3_nsec));
+                              GET_BE_U_4(fap->fa3_ctime.nfsv3_sec),
+                              GET_BE_U_4(fap->fa3_ctime.nfsv3_nsec));
                } else {
                        ND_TCHECK_8(&fap->fa2_ctime);
                        ND_PRINT(" nlink %u rdev 0x%x fsid 0x%x nodeid 0x%x a/m/ctime",
                } else {
                        ND_TCHECK_8(&fap->fa2_ctime);
                        ND_PRINT(" nlink %u rdev 0x%x fsid 0x%x nodeid 0x%x a/m/ctime",
-                              EXTRACT_BE_U_4(fap->fa_nlink),
-                              EXTRACT_BE_U_4(fap->fa2_rdev),
-                              EXTRACT_BE_U_4(fap->fa2_fsid),
-                              EXTRACT_BE_U_4(fap->fa2_fileid));
+                              GET_BE_U_4(fap->fa_nlink),
+                              GET_BE_U_4(fap->fa2_rdev),
+                              GET_BE_U_4(fap->fa2_fsid),
+                              GET_BE_U_4(fap->fa2_fileid));
                        ND_PRINT(" %u.%06u",
                        ND_PRINT(" %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa2_atime.nfsv2_sec),
-                              EXTRACT_BE_U_4(fap->fa2_atime.nfsv2_usec));
+                              GET_BE_U_4(fap->fa2_atime.nfsv2_sec),
+                              GET_BE_U_4(fap->fa2_atime.nfsv2_usec));
                        ND_PRINT(" %u.%06u",
                        ND_PRINT(" %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa2_mtime.nfsv2_sec),
-                              EXTRACT_BE_U_4(fap->fa2_mtime.nfsv2_usec));
+                              GET_BE_U_4(fap->fa2_mtime.nfsv2_sec),
+                              GET_BE_U_4(fap->fa2_mtime.nfsv2_usec));
                        ND_PRINT(" %u.%06u",
                        ND_PRINT(" %u.%06u",
-                              EXTRACT_BE_U_4(fap->fa2_ctime.nfsv2_sec),
-                              EXTRACT_BE_U_4(fap->fa2_ctime.nfsv2_usec));
+                              GET_BE_U_4(fap->fa2_ctime.nfsv2_sec),
+                              GET_BE_U_4(fap->fa2_ctime.nfsv2_usec));
                }
        }
        return ((const uint32_t *)((const unsigned char *)dp +
                }
        }
        return ((const uint32_t *)((const unsigned char *)dp +
@@ -1313,23 +1274,23 @@ parsestatfs(netdissect_options *ndo,
 
        if (v3) {
                ND_PRINT(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
 
        if (v3) {
                ND_PRINT(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
-                       EXTRACT_BE_U_8(sfsp->sf_tbytes),
-                       EXTRACT_BE_U_8(sfsp->sf_fbytes),
-                       EXTRACT_BE_U_8(sfsp->sf_abytes));
+                       GET_BE_U_8(sfsp->sf_tbytes),
+                       GET_BE_U_8(sfsp->sf_fbytes),
+                       GET_BE_U_8(sfsp->sf_abytes));
                if (ndo->ndo_vflag) {
                        ND_PRINT(" tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
                if (ndo->ndo_vflag) {
                        ND_PRINT(" tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
-                              EXTRACT_BE_U_8(sfsp->sf_tfiles),
-                              EXTRACT_BE_U_8(sfsp->sf_ffiles),
-                              EXTRACT_BE_U_8(sfsp->sf_afiles),
-                              EXTRACT_BE_U_4(sfsp->sf_invarsec));
+                              GET_BE_U_8(sfsp->sf_tfiles),
+                              GET_BE_U_8(sfsp->sf_ffiles),
+                              GET_BE_U_8(sfsp->sf_afiles),
+                              GET_BE_U_4(sfsp->sf_invarsec));
                }
        } else {
                ND_PRINT(" tsize %u bsize %u blocks %u bfree %u bavail %u",
                }
        } else {
                ND_PRINT(" tsize %u bsize %u blocks %u bfree %u bavail %u",
-                       EXTRACT_BE_U_4(sfsp->sf_tsize),
-                       EXTRACT_BE_U_4(sfsp->sf_bsize),
-                       EXTRACT_BE_U_4(sfsp->sf_blocks),
-                       EXTRACT_BE_U_4(sfsp->sf_bfree),
-                       EXTRACT_BE_U_4(sfsp->sf_bavail));
+                       GET_BE_U_4(sfsp->sf_tsize),
+                       GET_BE_U_4(sfsp->sf_bsize),
+                       GET_BE_U_4(sfsp->sf_blocks),
+                       GET_BE_U_4(sfsp->sf_bfree),
+                       GET_BE_U_4(sfsp->sf_bavail));
        }
 
        return (1);
        }
 
        return (1);
@@ -1351,15 +1312,12 @@ parserddires(netdissect_options *ndo,
        if (ndo->ndo_qflag)
                return (1);
 
        if (ndo->ndo_qflag)
                return (1);
 
-       ND_TCHECK_4(dp + 2);
        ND_PRINT(" offset 0x%x size %u ",
        ND_PRINT(" offset 0x%x size %u ",
-              EXTRACT_BE_U_4(dp), EXTRACT_BE_U_4(dp + 1));
-       if (EXTRACT_BE_U_4(dp + 2) != 0)
+              GET_BE_U_4(dp), GET_BE_U_4(dp + 1));
+       if (GET_BE_U_4(dp + 2) != 0)
                ND_PRINT(" eof");
 
        return (1);
                ND_PRINT(" eof");
 
        return (1);
-trunc:
-       return (0);
 }
 
 static const uint32_t *
 }
 
 static const uint32_t *
@@ -1367,10 +1325,10 @@ parse_wcc_attr(netdissect_options *ndo,
                const uint32_t *dp)
 {
        /* Our caller has already checked this */
                const uint32_t *dp)
 {
        /* Our caller has already checked this */
-       ND_PRINT(" sz %" PRIu64, EXTRACT_BE_U_8(dp));
+       ND_PRINT(" sz %" PRIu64, GET_BE_U_8(dp));
        ND_PRINT(" mtime %u.%06u ctime %u.%06u",
        ND_PRINT(" mtime %u.%06u ctime %u.%06u",
-              EXTRACT_BE_U_4(dp + 2), EXTRACT_BE_U_4(dp + 3),
-              EXTRACT_BE_U_4(dp + 4), EXTRACT_BE_U_4(dp + 5));
+              GET_BE_U_4(dp + 2), GET_BE_U_4(dp + 3),
+              GET_BE_U_4(dp + 4), GET_BE_U_4(dp + 5));
        return (dp + 6);
 }
 
        return (dp + 6);
 }
 
@@ -1381,8 +1339,7 @@ static const uint32_t *
 parse_pre_op_attr(netdissect_options *ndo,
                   const uint32_t *dp, int verbose)
 {
 parse_pre_op_attr(netdissect_options *ndo,
                   const uint32_t *dp, int verbose)
 {
-       ND_TCHECK_4(dp);
-       if (!EXTRACT_BE_U_4(dp))
+       if (!GET_BE_U_4(dp))
                return (dp + 1);
        dp++;
        ND_TCHECK_LEN(dp, 24);
                return (dp + 1);
        dp++;
        ND_TCHECK_LEN(dp, 24);
@@ -1403,16 +1360,13 @@ static const uint32_t *
 parse_post_op_attr(netdissect_options *ndo,
                    const uint32_t *dp, int verbose)
 {
 parse_post_op_attr(netdissect_options *ndo,
                    const uint32_t *dp, int verbose)
 {
-       ND_TCHECK_4(dp);
-       if (!EXTRACT_BE_U_4(dp))
+       if (!GET_BE_U_4(dp))
                return (dp + 1);
        dp++;
        if (verbose) {
                return parsefattr(ndo, dp, verbose, 1);
        } else
                return (dp + (NFSX_V3FATTR / sizeof (uint32_t)));
                return (dp + 1);
        dp++;
        if (verbose) {
                return parsefattr(ndo, dp, verbose, 1);
        } else
                return (dp + (NFSX_V3FATTR / sizeof (uint32_t)));
-trunc:
-       return (NULL);
 }
 
 static const uint32_t *
 }
 
 static const uint32_t *
@@ -1442,8 +1396,7 @@ parsecreateopres(netdissect_options *ndo,
        if (er)
                dp = parse_wcc_data(ndo, dp, verbose);
        else {
        if (er)
                dp = parse_wcc_data(ndo, dp, verbose);
        else {
-               ND_TCHECK_4(dp);
-               if (!EXTRACT_BE_U_4(dp))
+               if (!GET_BE_U_4(dp))
                        return (dp + 1);
                dp++;
                dp = parsefh(ndo, dp, 1);
                        return (dp + 1);
                dp++;
                dp = parsefh(ndo, dp, 1);
@@ -1460,8 +1413,6 @@ parsecreateopres(netdissect_options *ndo,
                }
        }
        return (dp);
                }
        }
        return (dp);
-trunc:
-       return (NULL);
 }
 
 static const uint32_t *
 }
 
 static const uint32_t *
@@ -1493,18 +1444,15 @@ parsev3rddirres(netdissect_options *ndo,
        if (er)
                return dp;
        if (ndo->ndo_vflag) {
        if (er)
                return dp;
        if (ndo->ndo_vflag) {
-               ND_TCHECK_4(dp + 1);
                /*
                 * This displays the 8 bytes of the verifier in order,
                 * from the low-order byte to the high-order byte.
                 */
                ND_PRINT(" verf %08x%08x",
                /*
                 * This displays the 8 bytes of the verifier in order,
                 * from the low-order byte to the high-order byte.
                 */
                ND_PRINT(" verf %08x%08x",
-                         EXTRACT_BE_U_4(dp), EXTRACT_BE_U_4(dp + 1));
+                         GET_BE_U_4(dp), GET_BE_U_4(dp + 1));
                dp += 2;
        }
        return dp;
                dp += 2;
        }
        return dp;
-trunc:
-       return (NULL);
 }
 
 static int
 }
 
 static int
@@ -1528,19 +1476,19 @@ parsefsinfo(netdissect_options *ndo,
        sfp = (const struct nfsv3_fsinfo *)dp;
        ND_TCHECK_SIZE(sfp);
        ND_PRINT(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
        sfp = (const struct nfsv3_fsinfo *)dp;
        ND_TCHECK_SIZE(sfp);
        ND_PRINT(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
-              EXTRACT_BE_U_4(sfp->fs_rtmax),
-              EXTRACT_BE_U_4(sfp->fs_rtpref),
-              EXTRACT_BE_U_4(sfp->fs_wtmax),
-              EXTRACT_BE_U_4(sfp->fs_wtpref),
-              EXTRACT_BE_U_4(sfp->fs_dtpref));
+              GET_BE_U_4(sfp->fs_rtmax),
+              GET_BE_U_4(sfp->fs_rtpref),
+              GET_BE_U_4(sfp->fs_wtmax),
+              GET_BE_U_4(sfp->fs_wtpref),
+              GET_BE_U_4(sfp->fs_dtpref));
        if (ndo->ndo_vflag) {
                ND_PRINT(" rtmult %u wtmult %u maxfsz %" PRIu64,
        if (ndo->ndo_vflag) {
                ND_PRINT(" rtmult %u wtmult %u maxfsz %" PRIu64,
-                      EXTRACT_BE_U_4(sfp->fs_rtmult),
-                      EXTRACT_BE_U_4(sfp->fs_wtmult),
-                      EXTRACT_BE_U_8(sfp->fs_maxfilesize));
+                      GET_BE_U_4(sfp->fs_rtmult),
+                      GET_BE_U_4(sfp->fs_wtmult),
+                      GET_BE_U_8(sfp->fs_maxfilesize));
                ND_PRINT(" delta %u.%06u ",
                ND_PRINT(" delta %u.%06u ",
-                      EXTRACT_BE_U_4(sfp->fs_timedelta.nfsv3_sec),
-                      EXTRACT_BE_U_4(sfp->fs_timedelta.nfsv3_nsec));
+                      GET_BE_U_4(sfp->fs_timedelta.nfsv3_sec),
+                      GET_BE_U_4(sfp->fs_timedelta.nfsv3_nsec));
        }
        return (1);
 trunc:
        }
        return (1);
 trunc:
@@ -1569,12 +1517,12 @@ parsepathconf(netdissect_options *ndo,
        ND_TCHECK_SIZE(spp);
 
        ND_PRINT(" linkmax %u namemax %u %s %s %s %s",
        ND_TCHECK_SIZE(spp);
 
        ND_PRINT(" linkmax %u namemax %u %s %s %s %s",
-              EXTRACT_BE_U_4(spp->pc_linkmax),
-              EXTRACT_BE_U_4(spp->pc_namemax),
-              EXTRACT_BE_U_4(spp->pc_notrunc) ? "notrunc" : "",
-              EXTRACT_BE_U_4(spp->pc_chownrestricted) ? "chownres" : "",
-              EXTRACT_BE_U_4(spp->pc_caseinsensitive) ? "igncase" : "",
-              EXTRACT_BE_U_4(spp->pc_casepreserving) ? "keepcase" : "");
+              GET_BE_U_4(spp->pc_linkmax),
+              GET_BE_U_4(spp->pc_namemax),
+              GET_BE_U_4(spp->pc_notrunc) ? "notrunc" : "",
+              GET_BE_U_4(spp->pc_chownrestricted) ? "chownres" : "",
+              GET_BE_U_4(spp->pc_caseinsensitive) ? "igncase" : "",
+              GET_BE_U_4(spp->pc_casepreserving) ? "keepcase" : "");
        return (1);
 trunc:
        return (0);
        return (1);
 trunc:
        return (0);
@@ -1667,8 +1615,7 @@ interp_reply(netdissect_options *ndo,
                if (dp == NULL)
                        goto trunc;
                if (!er) {
                if (dp == NULL)
                        goto trunc;
                if (!er) {
-                       ND_TCHECK_4(dp);
-                       ND_PRINT(" c %04x", EXTRACT_BE_U_4(dp));
+                       ND_PRINT(" c %04x", GET_BE_U_4(dp));
                }
                break;
 
                }
                break;
 
@@ -1693,9 +1640,8 @@ interp_reply(netdissect_options *ndo,
                                goto trunc;
                        if (!er) {
                                if (ndo->ndo_vflag) {
                                goto trunc;
                        if (!er) {
                                if (ndo->ndo_vflag) {
-                                       ND_TCHECK_4(dp + 1);
-                                       ND_PRINT(" %u bytes", EXTRACT_BE_U_4(dp));
-                                       if (EXTRACT_BE_U_4(dp + 1))
+                                       ND_PRINT(" %u bytes", GET_BE_U_4(dp));
+                                       if (GET_BE_U_4(dp + 1))
                                                ND_PRINT(" EOF");
                                }
                        }
                                                ND_PRINT(" EOF");
                                }
                        }
@@ -1718,17 +1664,15 @@ interp_reply(netdissect_options *ndo,
                                goto trunc;
                        if (!er) {
                                if (ndo->ndo_vflag) {
                                goto trunc;
                        if (!er) {
                                if (ndo->ndo_vflag) {
-                                       ND_TCHECK_4(dp);
-                                       ND_PRINT(" %u bytes", EXTRACT_BE_U_4(dp));
+                                       ND_PRINT(" %u bytes", GET_BE_U_4(dp));
                                        if (ndo->ndo_vflag > 1) {
                                        if (ndo->ndo_vflag > 1) {
-                                               ND_TCHECK_4(dp + 1);
                                                ND_PRINT(" <%s>",
                                                        tok2str(nfsv3_writemodes,
                                                ND_PRINT(" <%s>",
                                                        tok2str(nfsv3_writemodes,
-                                                               NULL, EXTRACT_BE_U_4(dp + 1)));
+                                                               NULL, GET_BE_U_4(dp + 1)));
 
                                                /* write-verf-cookie */
 
                                                /* write-verf-cookie */
-                                               ND_TCHECK_8(dp + 2);
-                                               ND_PRINT(" verf %" PRIx64, EXTRACT_BE_U_8(dp + 2));
+                                               ND_PRINT(" verf %" PRIx64,
+                                                        GET_BE_U_8(dp + 2));
                                        }
                                }
                        }
                                        }
                                }
                        }
@@ -1891,8 +1835,7 @@ interp_reply(netdissect_options *ndo,
                        goto trunc;
                if (ndo->ndo_vflag > 1) {
                        /* write-verf-cookie */
                        goto trunc;
                if (ndo->ndo_vflag > 1) {
                        /* write-verf-cookie */
-                       ND_TCHECK_8(dp);
-                       ND_PRINT(" verf %" PRIx64, EXTRACT_BE_U_8(dp));
+                       ND_PRINT(" verf %" PRIx64, GET_BE_U_8(dp));
                }
                break;
 
                }
                break;
 
[mirror] the TCPdump network dissector