]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-nfs.c
NDOize more small decoders
[tcpdump] / print-nfs.c
index 6c528b7c3ed26f34654c8a9bd48c3b9839dbb70c..0a8bcf25e7e7ce6e704bcabf3812f9243c2bce6d 100644 (file)
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.104 2004-12-27 00:41:31 guy Exp $ (LBL)";
-#endif
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
-#include <pcap.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -48,14 +42,15 @@ static const char rcsid[] _U_ =
 #include "rpc_auth.h"
 #include "rpc_msg.h"
 
+static const char tstr[] = " [|nfs]";
+
 static void nfs_printfh(const u_int32_t *, const u_int);
-static void xid_map_enter(const struct sunrpc_msg *, const u_char *);
-static int32_t xid_map_find(const struct sunrpc_msg *, const u_char *,
+static int xid_map_enter(const struct sunrpc_msg *, const u_char *);
+static int xid_map_find(const struct sunrpc_msg *, const u_char *,
                            u_int32_t *, u_int32_t *);
 static void interp_reply(const struct sunrpc_msg *, u_int32_t, u_int32_t, int);
 static const u_int32_t *parse_post_op_attr(const u_int32_t *, int);
 static void print_sattr3(const struct nfsv3_sattr *sa3, int verbose);
-static int print_int64(const u_int32_t *dp, int how);
 static void print_nfsaddr(const u_char *, const char *, const char *);
 
 /*
@@ -101,7 +96,7 @@ u_int32_t nfsv3_procid[NFS_NPROCS] = {
  * the first NFS server was the SunOS 2.0 one, and until 5.0 SunOS
  * was primarily BSD-derived.
  */
-static struct tok status2str[] = {
+static const struct tok status2str[] = {
        { 1,     "Operation not permitted" },   /* EPERM */
        { 2,     "No such file or directory" }, /* ENOENT */
        { 5,     "Input/output error" },        /* EIO */
@@ -139,14 +134,14 @@ static struct tok status2str[] = {
        { 0,     NULL }
 };
 
-static struct tok nfsv3_writemodes[] = {
+static const struct tok nfsv3_writemodes[] = {
        { 0,            "unstable" },
        { 1,            "datasync" },
        { 2,            "filesync" },
        { 0,            NULL }
 };
 
-static struct tok type2str[] = {
+static const struct tok type2str[] = {
        { NFNON,        "NON" },
        { NFREG,        "REG" },
        { NFDIR,        "DIR" },
@@ -157,40 +152,6 @@ static struct tok type2str[] = {
        { 0,            NULL }
 };
 
-/*
- * Print out a 64-bit integer. This appears to be different on each system,
- * try to make the best of it. The integer stored as 2 consecutive XDR
- * encoded 32-bit integers, to which a pointer is passed.
- *
- * We assume that PRId64, PRIu64, and PRIx64 are defined, and that
- * u_int64_t is defined.
- */
-
-#define UNSIGNED 0
-#define SIGNED   1
-#define HEX      2
-
-static int print_int64(const u_int32_t *dp, int how)
-{
-       u_int64_t res;
-
-       res = EXTRACT_64BITS((u_int8_t *)dp);
-       switch (how) {
-       case SIGNED:
-               printf("%" PRId64, res);
-               break;
-       case UNSIGNED:
-               printf("%" PRIu64, res);
-               break;
-       case HEX:
-               printf("%" PRIx64, res);
-               break;
-       default:
-               return (0);
-       }
-       return (1);
-}
-
 static void
 print_nfsaddr(const u_char *bp, const char *s, const char *d)
 {
@@ -322,12 +283,12 @@ nfsreply_print(register const u_char *bp, u_int length,
               register const u_char *bp2)
 {
        register const struct sunrpc_msg *rp;
-       u_int32_t proc, vers;
        char srcid[20], dstid[20];      /*fits 32bit*/
 
        nfserr = 0;             /* assume no error */
        rp = (const struct sunrpc_msg *)bp;
 
+       TCHECK(rp->rm_xid);
        if (!nflag) {
                strlcpy(srcid, "nfs", sizeof(srcid));
                snprintf(dstid, sizeof(dstid), "%u",
@@ -338,13 +299,115 @@ nfsreply_print(register const u_char *bp, u_int length,
                    EXTRACT_32BITS(&rp->rm_xid));
        }
        print_nfsaddr(bp2, srcid, dstid);
-       (void)printf("reply %s %d",
-            EXTRACT_32BITS(&rp->rm_reply.rp_stat) == SUNRPC_MSG_ACCEPTED?
-                    "ok":"ERR",
-            length);
 
-       if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
-               interp_reply(rp, proc, vers, length);
+       nfsreply_print_noaddr(bp, length, bp2);
+       return;
+
+trunc:
+       if (!nfserr)
+               printf("%s", tstr);
+}
+
+void
+nfsreply_print_noaddr(register const u_char *bp, u_int length,
+              register const u_char *bp2)
+{
+       register const struct sunrpc_msg *rp;
+       u_int32_t proc, vers, reply_stat;
+       enum sunrpc_reject_stat rstat;
+       u_int32_t rlow;
+       u_int32_t rhigh;
+       enum sunrpc_auth_stat rwhy;
+
+       nfserr = 0;             /* assume no error */
+       rp = (const struct sunrpc_msg *)bp;
+
+       TCHECK(rp->rm_reply.rp_stat);
+       reply_stat = EXTRACT_32BITS(&rp->rm_reply.rp_stat);
+       switch (reply_stat) {
+
+       case SUNRPC_MSG_ACCEPTED:
+               (void)printf("reply ok %u", length);
+               if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
+                       interp_reply(rp, proc, vers, length);
+               break;
+
+       case SUNRPC_MSG_DENIED:
+               (void)printf("reply ERR %u: ", length);
+               TCHECK(rp->rm_reply.rp_reject.rj_stat);
+               rstat = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_stat);
+               switch (rstat) {
+
+               case SUNRPC_RPC_MISMATCH:
+                       TCHECK(rp->rm_reply.rp_reject.rj_vers.high);
+                       rlow = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.low);
+                       rhigh = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.high);
+                       (void)printf("RPC Version mismatch (%u-%u)",
+                           rlow, rhigh);
+                       break;
+
+               case SUNRPC_AUTH_ERROR:
+                       TCHECK(rp->rm_reply.rp_reject.rj_why);
+                       rwhy = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_why);
+                       (void)printf("Auth ");
+                       switch (rwhy) {
+
+                       case SUNRPC_AUTH_OK:
+                               (void)printf("OK");
+                               break;
+
+                       case SUNRPC_AUTH_BADCRED:
+                               (void)printf("Bogus Credentials (seal broken)");
+                               break;
+
+                       case SUNRPC_AUTH_REJECTEDCRED:
+                               (void)printf("Rejected Credentials (client should begin new session)");
+                               break;
+
+                       case SUNRPC_AUTH_BADVERF:
+                               (void)printf("Bogus Verifier (seal broken)");
+                               break;
+
+                       case SUNRPC_AUTH_REJECTEDVERF:
+                               (void)printf("Verifier expired or was replayed");
+                               break;
+
+                       case SUNRPC_AUTH_TOOWEAK:
+                               (void)printf("Credentials are too weak");
+                               break;
+
+                       case SUNRPC_AUTH_INVALIDRESP:
+                               (void)printf("Bogus response verifier");
+                               break;
+
+                       case SUNRPC_AUTH_FAILED:
+                               (void)printf("Unknown failure");
+                               break;
+
+                       default:
+                               (void)printf("Invalid failure code %u",
+                                   (unsigned int)rwhy);
+                               break;
+                       }
+                       break;
+
+               default:
+                       (void)printf("Unknown reason for rejecting rpc message %u",
+                           (unsigned int)rstat);
+                       break;
+               }
+               break;
+
+       default:
+               (void)printf("reply Unknown rpc response code=%u %u",
+                   reply_stat, length);
+               break;
+       }
+       return;
+
+trunc:
+       if (!nfserr)
+               printf("%s", tstr);
 }
 
 /*
@@ -423,9 +486,11 @@ parsefn(register const u_int32_t *dp)
        cp = (u_char *)dp;
        /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
        dp += ((len + 3) & ~3) / sizeof(*dp);
-       /* XXX seems like we should be checking the length */
        putchar('"');
-       (void) fn_printn(cp, len, NULL);
+       if (fn_printn(cp, len, snapend)) {
+               putchar('"');
+               goto trunc;
+       }
        putchar('"');
 
        return (dp);
@@ -453,15 +518,12 @@ nfsreq_print(register const u_char *bp, u_int length,
     register const u_char *bp2)
 {
        register const struct sunrpc_msg *rp;
-       register const u_int32_t *dp;
-       nfs_type type;
-       int v3;
-       u_int32_t proc;
-       struct nfsv3_sattr sa3;
        char srcid[20], dstid[20];      /*fits 32bit*/
 
        nfserr = 0;             /* assume no error */
        rp = (const struct sunrpc_msg *)bp;
+
+       TCHECK(rp->rm_xid);
        if (!nflag) {
                snprintf(srcid, sizeof(srcid), "%u",
                    EXTRACT_32BITS(&rp->rm_xid));
@@ -472,9 +534,33 @@ nfsreq_print(register const u_char *bp, u_int length,
                snprintf(dstid, sizeof(dstid), "%u", NFS_PORT);
        }
        print_nfsaddr(bp2, srcid, dstid);
+
+       nfsreq_print_noaddr(bp, length, bp2);
+       return;
+
+trunc:
+       if (!nfserr)
+               printf("%s", tstr);
+}
+
+void
+nfsreq_print_noaddr(register const u_char *bp, u_int length,
+    register const u_char *bp2)
+{
+       register const struct sunrpc_msg *rp;
+       register const u_int32_t *dp;
+       nfs_type type;
+       int v3;
+       u_int32_t proc;
+       u_int32_t access_flags;
+       struct nfsv3_sattr sa3;
+
        (void)printf("%d", length);
+       nfserr = 0;             /* assume no error */
+       rp = (const struct sunrpc_msg *)bp;
 
-       xid_map_enter(rp, bp2); /* record proc number for later on */
+       if (!xid_map_enter(rp, bp2))    /* record proc number for later on */
+               goto trunc;
 
        v3 = (EXTRACT_32BITS(&rp->rm_call.cb_vers) == NFS_VER3);
        proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
@@ -516,7 +602,37 @@ nfsreq_print(register const u_char *bp, u_int length,
                if ((dp = parsereq(rp, length)) != NULL &&
                    (dp = parsefh(dp, v3)) != NULL) {
                        TCHECK(dp[0]);
-                       printf(" %04x", EXTRACT_32BITS(&dp[0]));
+                       access_flags = EXTRACT_32BITS(&dp[0]);
+                       if (access_flags & ~NFSV3ACCESS_FULL) {
+                               /* NFSV3ACCESS definitions aren't up to date */
+                               printf(" %04x", access_flags);
+                       } else if ((access_flags & NFSV3ACCESS_FULL) == NFSV3ACCESS_FULL) {
+                               printf(" NFS_ACCESS_FULL");
+                       } else {
+                               char separator = ' ';
+                               if (access_flags & NFSV3ACCESS_READ) {
+                                       printf(" NFS_ACCESS_READ");
+                                       separator = '|';
+                               }
+                               if (access_flags & NFSV3ACCESS_LOOKUP) {
+                                       printf("%cNFS_ACCESS_LOOKUP", separator);
+                                       separator = '|';
+                               }
+                               if (access_flags & NFSV3ACCESS_MODIFY) {
+                                       printf("%cNFS_ACCESS_MODIFY", separator);
+                                       separator = '|';
+                               }
+                               if (access_flags & NFSV3ACCESS_EXTEND) {
+                                       printf("%cNFS_ACCESS_EXTEND", separator);
+                                       separator = '|';
+                               }
+                               if (access_flags & NFSV3ACCESS_DELETE) {
+                                       printf("%cNFS_ACCESS_DELETE", separator);
+                                       separator = '|';
+                               }
+                               if (access_flags & NFSV3ACCESS_EXECUTE)
+                                       printf("%cNFS_ACCESS_EXECUTE", separator);
+                       }
                        return;
                }
                break;
@@ -534,9 +650,9 @@ nfsreq_print(register const u_char *bp, u_int length,
                    (dp = parsefh(dp, v3)) != NULL) {
                        if (v3) {
                                TCHECK(dp[2]);
-                               printf(" %u bytes @ ",
-                                      EXTRACT_32BITS(&dp[2]));
-                               print_int64(dp, UNSIGNED);
+                               printf(" %u bytes @ %" PRIu64,
+                                      EXTRACT_32BITS(&dp[2]),
+                                      EXTRACT_64BITS(&dp[0]));
                        } else {
                                TCHECK(dp[1]);
                                printf(" %u bytes @ %u",
@@ -552,10 +668,11 @@ nfsreq_print(register const u_char *bp, u_int length,
                if ((dp = parsereq(rp, length)) != NULL &&
                    (dp = parsefh(dp, v3)) != NULL) {
                        if (v3) {
-                               TCHECK(dp[4]);
-                               printf(" %u bytes @ ",
-                                               EXTRACT_32BITS(&dp[4]));
-                               print_int64(dp, UNSIGNED);
+                               TCHECK(dp[2]);
+                               printf(" %u (%u) bytes @ %" PRIu64,
+                                               EXTRACT_32BITS(&dp[4]),
+                                               EXTRACT_32BITS(&dp[2]),
+                                               EXTRACT_64BITS(&dp[0]));
                                if (vflag) {
                                        dp += 3;
                                        TCHECK(dp[0]);
@@ -670,9 +787,9 @@ nfsreq_print(register const u_char *bp, u_int length,
                                 * We shouldn't really try to interpret the
                                 * offset cookie here.
                                 */
-                               printf(" %u bytes @ ",
-                                   EXTRACT_32BITS(&dp[4]));
-                               print_int64(dp, SIGNED);
+                               printf(" %u bytes @ %" PRId64,
+                                   EXTRACT_32BITS(&dp[4]),
+                                   EXTRACT_64BITS(&dp[0]));
                                if (vflag)
                                        printf(" verf %08x%08x", dp[2],
                                               dp[3]);
@@ -699,11 +816,14 @@ nfsreq_print(register const u_char *bp, u_int length,
                         * We don't try to interpret the offset
                         * cookie here.
                         */
-                       printf(" %u bytes @ ", EXTRACT_32BITS(&dp[4]));
-                       print_int64(dp, SIGNED);
-                       if (vflag)
+                       printf(" %u bytes @ %" PRId64,
+                               EXTRACT_32BITS(&dp[4]),
+                               EXTRACT_64BITS(&dp[0]));
+                       if (vflag) {
+                               TCHECK(dp[5]);
                                printf(" max %u verf %08x%08x",
                                       EXTRACT_32BITS(&dp[5]), dp[2], dp[3]);
+                       }
                        return;
                }
                break;
@@ -733,8 +853,10 @@ nfsreq_print(register const u_char *bp, u_int length,
                printf(" commit");
                if ((dp = parsereq(rp, length)) != NULL &&
                    (dp = parsefh(dp, v3)) != NULL) {
-                       printf(" %u bytes @ ", EXTRACT_32BITS(&dp[2]));
-                       print_int64(dp, UNSIGNED);
+                       TCHECK(dp[2]);
+                       printf(" %u bytes @ %" PRIu64,
+                               EXTRACT_32BITS(&dp[2]),
+                               EXTRACT_64BITS(&dp[0]));
                        return;
                }
                break;
@@ -746,7 +868,7 @@ nfsreq_print(register const u_char *bp, u_int length,
 
 trunc:
        if (!nfserr)
-               fputs(" [|nfs]", stdout);
+               printf("%s", tstr);
 }
 
 /*
@@ -762,7 +884,7 @@ static void
 nfs_printfh(register const u_int32_t *dp, const u_int len)
 {
        my_fsid fsid;
-       ino_t ino;
+       u_int32_t ino;
        const char *sfsname = NULL;
        char *spacep;
 
@@ -839,7 +961,7 @@ struct xid_map_entry xid_map[XIDMAPSIZE];
 int    xid_map_next = 0;
 int    xid_map_hint = 0;
 
-static void
+static int
 xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
 {
        struct ip *ip = NULL;
@@ -848,6 +970,8 @@ xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
 #endif
        struct xid_map_entry *xmep;
 
+       if (!TTEST(rp->rm_call.cb_vers))
+               return (0);
        switch (IP_V((struct ip *)bp)) {
        case 4:
                ip = (struct ip *)bp;
@@ -858,7 +982,7 @@ xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
                break;
 #endif
        default:
-               return;
+               return (1);
        }
 
        xmep = &xid_map[xid_map_next];
@@ -869,18 +993,19 @@ xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
        xmep->xid = rp->rm_xid;
        if (ip) {
                xmep->ipver = 4;
-               memcpy(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
-               memcpy(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
+               UNALIGNED_MEMCPY(&xmep->client, &ip->ip_src, sizeof(ip->ip_src));
+               UNALIGNED_MEMCPY(&xmep->server, &ip->ip_dst, sizeof(ip->ip_dst));
        }
 #ifdef INET6
        else if (ip6) {
                xmep->ipver = 6;
-               memcpy(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
-               memcpy(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
+               UNALIGNED_MEMCPY(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
+               UNALIGNED_MEMCPY(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
        }
 #endif
        xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
        xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
+       return (1);
 }
 
 /*
@@ -909,18 +1034,18 @@ xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc,
                        goto nextitem;
                switch (xmep->ipver) {
                case 4:
-                       if (memcmp(&ip->ip_src, &xmep->server,
+                       if (UNALIGNED_MEMCMP(&ip->ip_src, &xmep->server,
                                   sizeof(ip->ip_src)) != 0 ||
-                           memcmp(&ip->ip_dst, &xmep->client,
+                           UNALIGNED_MEMCMP(&ip->ip_dst, &xmep->client,
                                   sizeof(ip->ip_dst)) != 0) {
                                cmp = 0;
                        }
                        break;
 #ifdef INET6
                case 6:
-                       if (memcmp(&ip6->ip6_src, &xmep->server,
+                       if (UNALIGNED_MEMCMP(&ip6->ip6_src, &xmep->server,
                                   sizeof(ip6->ip6_src)) != 0 ||
-                           memcmp(&ip6->ip6_dst, &xmep->client,
+                           UNALIGNED_MEMCMP(&ip6->ip6_dst, &xmep->client,
                                   sizeof(ip6->ip6_dst)) != 0) {
                                cmp = 0;
                        }
@@ -990,7 +1115,7 @@ parserep(register const struct sunrpc_msg *rp, register u_int length)
        /*
         * now we can check the ar_stat field
         */
-       astat = EXTRACT_32BITS(dp);
+       astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp);
        switch (astat) {
 
        case SUNRPC_SUCCESS:
@@ -1070,8 +1195,8 @@ parsefattr(const u_int32_t *dp, int verbose, int v3)
                    EXTRACT_32BITS(&fap->fa_gid));
                if (v3) {
                        TCHECK(fap->fa3_size);
-                       printf(" sz ");
-                       print_int64((u_int32_t *)&fap->fa3_size, UNSIGNED);
+                       printf(" sz %" PRIu64,
+                               EXTRACT_64BITS((u_int32_t *)&fap->fa3_size));
                } else {
                        TCHECK(fap->fa2_size);
                        printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size));
@@ -1085,10 +1210,10 @@ parsefattr(const u_int32_t *dp, int verbose, int v3)
                               EXTRACT_32BITS(&fap->fa_nlink),
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
                               EXTRACT_32BITS(&fap->fa3_rdev.specdata2));
-                       printf(" fsid ");
-                       print_int64((u_int32_t *)&fap->fa3_fsid, HEX);
-                       printf(" fileid ");
-                       print_int64((u_int32_t *)&fap->fa3_fileid, HEX);
+                       printf(" fsid %" PRIx64,
+                               EXTRACT_64BITS((u_int32_t *)&fap->fa3_fsid));
+                       printf(" fileid %" PRIx64,
+                               EXTRACT_64BITS((u_int32_t *)&fap->fa3_fileid));
                        printf(" a/m/ctime %u.%06u",
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
                               EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec));
@@ -1196,20 +1321,15 @@ parsestatfs(const u_int32_t *dp, int v3)
        sfsp = (const struct nfs_statfs *)dp;
 
        if (v3) {
-               printf(" tbytes ");
-               print_int64((u_int32_t *)&sfsp->sf_tbytes, UNSIGNED);
-               printf(" fbytes ");
-               print_int64((u_int32_t *)&sfsp->sf_fbytes, UNSIGNED);
-               printf(" abytes ");
-               print_int64((u_int32_t *)&sfsp->sf_abytes, UNSIGNED);
+               printf(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64,
+                       EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tbytes),
+                       EXTRACT_64BITS((u_int32_t *)&sfsp->sf_fbytes),
+                       EXTRACT_64BITS((u_int32_t *)&sfsp->sf_abytes));
                if (vflag) {
-                       printf(" tfiles ");
-                       print_int64((u_int32_t *)&sfsp->sf_tfiles, UNSIGNED);
-                       printf(" ffiles ");
-                       print_int64((u_int32_t *)&sfsp->sf_ffiles, UNSIGNED);
-                       printf(" afiles ");
-                       print_int64((u_int32_t *)&sfsp->sf_afiles, UNSIGNED);
-                       printf(" invar %u",
+                       printf(" tfiles %" PRIu64 " ffiles %" PRIu64 " afiles %" PRIu64 " invar %u",
+                              EXTRACT_64BITS((u_int32_t *)&sfsp->sf_tfiles),
+                              EXTRACT_64BITS((u_int32_t *)&sfsp->sf_ffiles),
+                              EXTRACT_64BITS((u_int32_t *)&sfsp->sf_afiles),
                               EXTRACT_32BITS(&sfsp->sf_invarsec));
                }
        } else {
@@ -1253,8 +1373,7 @@ trunc:
 static const u_int32_t *
 parse_wcc_attr(const u_int32_t *dp)
 {
-       printf(" sz ");
-       print_int64(dp, UNSIGNED);
+       printf(" sz %" PRIu64, EXTRACT_64BITS(&dp[0]));
        printf(" mtime %u.%06u ctime %u.%06u",
               EXTRACT_32BITS(&dp[2]), EXTRACT_32BITS(&dp[3]),
               EXTRACT_32BITS(&dp[4]), EXTRACT_32BITS(&dp[5]));
@@ -1400,10 +1519,10 @@ parsefsinfo(const u_int32_t *dp)
               EXTRACT_32BITS(&sfp->fs_wtpref),
               EXTRACT_32BITS(&sfp->fs_dtpref));
        if (vflag) {
-               printf(" rtmult %u wtmult %u maxfsz ",
+               printf(" rtmult %u wtmult %u maxfsz %" PRIu64,
                       EXTRACT_32BITS(&sfp->fs_rtmult),
-                      EXTRACT_32BITS(&sfp->fs_wtmult));
-               print_int64((u_int32_t *)&sfp->fs_maxfilesize, UNSIGNED);
+                      EXTRACT_32BITS(&sfp->fs_wtmult),
+                      EXTRACT_64BITS((u_int32_t *)&sfp->fs_maxfilesize));
                printf(" delta %u.%06u ",
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
                       EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec));
@@ -1759,5 +1878,5 @@ interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int le
        }
 trunc:
        if (!nfserr)
-               fputs(" [|nfs]", stdout);
+               printf("%s", tstr);
 }