X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/ec799d60f6cd3f41041b57efe3963c28dda94d4a..296d466cd6bbf2f7e75e15bb6a01268e88c76ed0:/print-nfs.c diff --git a/print-nfs.c b/print-nfs.c index 4d17757f..b67ec370 100644 --- a/print-nfs.c +++ b/print-nfs.c @@ -19,22 +19,17 @@ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ -#ifndef lint -static const char rcsid[] _U_ = - "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.111 2007-12-22 03:08:04 guy Exp $ (LBL)"; -#endif +/* \summary: Network File System (NFS) printer */ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif +#include -#include +#include "netdissect-stdinc.h" -#include #include #include +#include -#include "interface.h" +#include "netdissect.h" #include "addrtoname.h" #include "extract.h" @@ -42,25 +37,21 @@ static const char rcsid[] _U_ = #include "nfsfh.h" #include "ip.h" -#ifdef INET6 #include "ip6.h" -#endif #include "rpc_auth.h" #include "rpc_msg.h" -static void nfs_printfh(const u_int32_t *, const u_int); -static int xid_map_enter(const struct sunrpc_msg *, const u_char *); -static int32_t 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 void print_nfsaddr(const u_char *, const char *, const 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(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); /* * Mapping of old NFS Version 2 RPC numbers to generic numbers. */ -u_int32_t nfsv3_procid[NFS_NPROCS] = { +static uint32_t nfsv3_procid[NFS_NPROCS] = { NFSPROC_NULL, NFSPROC_GETATTR, NFSPROC_SETATTR, @@ -89,6 +80,33 @@ u_int32_t nfsv3_procid[NFS_NPROCS] = { NFSPROC_NOOP }; +static const struct tok nfsproc_str[] = { + { NFSPROC_NOOP, "nop" }, + { NFSPROC_NULL, "null" }, + { NFSPROC_GETATTR, "getattr" }, + { NFSPROC_SETATTR, "setattr" }, + { NFSPROC_LOOKUP, "lookup" }, + { NFSPROC_ACCESS, "access" }, + { NFSPROC_READLINK, "readlink" }, + { NFSPROC_READ, "read" }, + { NFSPROC_WRITE, "write" }, + { NFSPROC_CREATE, "create" }, + { NFSPROC_MKDIR, "mkdir" }, + { NFSPROC_SYMLINK, "symlink" }, + { NFSPROC_MKNOD, "mknod" }, + { NFSPROC_REMOVE, "remove" }, + { NFSPROC_RMDIR, "rmdir" }, + { NFSPROC_RENAME, "rename" }, + { NFSPROC_LINK, "link" }, + { NFSPROC_READDIR, "readdir" }, + { NFSPROC_READDIRPLUS, "readdirplus" }, + { NFSPROC_FSSTAT, "fsstat" }, + { NFSPROC_FSINFO, "fsinfo" }, + { NFSPROC_PATHCONF, "pathconf" }, + { NFSPROC_COMMIT, "commit" }, + { 0, NULL } +}; + /* * NFS V2 and V3 status values. * @@ -100,7 +118,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 */ @@ -138,14 +156,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" }, @@ -156,269 +174,303 @@ static struct tok type2str[] = { { 0, NULL } }; +static const struct tok sunrpc_auth_str[] = { + { SUNRPC_AUTH_OK, "OK" }, + { SUNRPC_AUTH_BADCRED, "Bogus Credentials (seal broken)" }, + { SUNRPC_AUTH_REJECTEDCRED, "Rejected Credentials (client should begin new session)" }, + { SUNRPC_AUTH_BADVERF, "Bogus Verifier (seal broken)" }, + { SUNRPC_AUTH_REJECTEDVERF, "Verifier expired or was replayed" }, + { SUNRPC_AUTH_TOOWEAK, "Credentials are too weak" }, + { SUNRPC_AUTH_INVALIDRESP, "Bogus response verifier" }, + { SUNRPC_AUTH_FAILED, "Unknown failure" }, + { 0, NULL } +}; + +static const struct tok sunrpc_str[] = { + { SUNRPC_PROG_UNAVAIL, "PROG_UNAVAIL" }, + { SUNRPC_PROG_MISMATCH, "PROG_MISMATCH" }, + { SUNRPC_PROC_UNAVAIL, "PROC_UNAVAIL" }, + { SUNRPC_GARBAGE_ARGS, "GARBAGE_ARGS" }, + { SUNRPC_SYSTEM_ERR, "SYSTEM_ERR" }, + { 0, NULL } +}; + static void -print_nfsaddr(const u_char *bp, const char *s, const char *d) +nfsaddr_print(netdissect_options *ndo, + const u_char *bp, const char *s, const char *d) { - struct ip *ip; -#ifdef INET6 - struct ip6_hdr *ip6; + const struct ip *ip; + const struct ip6_hdr *ip6; char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN]; -#else -#ifndef INET_ADDRSTRLEN -#define INET_ADDRSTRLEN 16 -#endif - char srcaddr[INET_ADDRSTRLEN], dstaddr[INET_ADDRSTRLEN]; -#endif srcaddr[0] = dstaddr[0] = '\0'; - switch (IP_V((struct ip *)bp)) { + switch (IP_V((const struct ip *)bp)) { case 4: - ip = (struct ip *)bp; - strlcpy(srcaddr, ipaddr_string(&ip->ip_src), sizeof(srcaddr)); - strlcpy(dstaddr, ipaddr_string(&ip->ip_dst), sizeof(dstaddr)); + ip = (const struct ip *)bp; + strlcpy(srcaddr, GET_IPADDR_STRING(ip->ip_src), sizeof(srcaddr)); + strlcpy(dstaddr, GET_IPADDR_STRING(ip->ip_dst), sizeof(dstaddr)); break; -#ifdef INET6 case 6: - ip6 = (struct ip6_hdr *)bp; - strlcpy(srcaddr, ip6addr_string(&ip6->ip6_src), + ip6 = (const struct ip6_hdr *)bp; + strlcpy(srcaddr, GET_IP6ADDR_STRING(ip6->ip6_src), sizeof(srcaddr)); - strlcpy(dstaddr, ip6addr_string(&ip6->ip6_dst), + strlcpy(dstaddr, GET_IP6ADDR_STRING(ip6->ip6_dst), sizeof(dstaddr)); break; -#endif default: strlcpy(srcaddr, "?", sizeof(srcaddr)); strlcpy(dstaddr, "?", sizeof(dstaddr)); break; } - (void)printf("%s.%s > %s.%s: ", srcaddr, s, dstaddr, d); + ND_PRINT("%s.%s > %s.%s: ", srcaddr, s, dstaddr, d); } -static const u_int32_t * -parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3) +/* + * NFS Version 3 sattr3 structure for the new node creation case. + * This does not have a fixed layout on the network, so this + * structure does not correspond to the layout of the data on + * the network; it's used to store the data when the sattr3 + * is parsed for use when it's later printed. + */ +struct nfsv3_sattr { + uint32_t sa_modeset; + uint32_t sa_mode; + uint32_t sa_uidset; + uint32_t sa_uid; + uint32_t sa_gidset; + uint32_t sa_gid; + uint32_t sa_sizeset; + uint32_t sa_size; + uint32_t sa_atimetype; + struct { + uint32_t nfsv3_sec; + uint32_t nfsv3_nsec; + } sa_atime; + uint32_t sa_mtimetype; + struct { + uint32_t nfsv3_sec; + uint32_t nfsv3_nsec; + } sa_mtime; +}; + +static const uint32_t * +parse_sattr3(netdissect_options *ndo, + const uint32_t *dp, struct nfsv3_sattr *sa3) { - TCHECK(dp[0]); - sa3->sa_modeset = EXTRACT_32BITS(dp); + sa3->sa_modeset = GET_BE_U_4(dp); dp++; if (sa3->sa_modeset) { - TCHECK(dp[0]); - sa3->sa_mode = EXTRACT_32BITS(dp); + sa3->sa_mode = GET_BE_U_4(dp); dp++; } - TCHECK(dp[0]); - sa3->sa_uidset = EXTRACT_32BITS(dp); + sa3->sa_uidset = GET_BE_U_4(dp); dp++; if (sa3->sa_uidset) { - TCHECK(dp[0]); - sa3->sa_uid = EXTRACT_32BITS(dp); + sa3->sa_uid = GET_BE_U_4(dp); dp++; } - TCHECK(dp[0]); - sa3->sa_gidset = EXTRACT_32BITS(dp); + sa3->sa_gidset = GET_BE_U_4(dp); dp++; if (sa3->sa_gidset) { - TCHECK(dp[0]); - sa3->sa_gid = EXTRACT_32BITS(dp); + sa3->sa_gid = GET_BE_U_4(dp); dp++; } - TCHECK(dp[0]); - sa3->sa_sizeset = EXTRACT_32BITS(dp); + sa3->sa_sizeset = GET_BE_U_4(dp); dp++; if (sa3->sa_sizeset) { - TCHECK(dp[0]); - sa3->sa_size = EXTRACT_32BITS(dp); + sa3->sa_size = GET_BE_U_4(dp); dp++; } - TCHECK(dp[0]); - sa3->sa_atimetype = EXTRACT_32BITS(dp); + sa3->sa_atimetype = GET_BE_U_4(dp); dp++; if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) { - TCHECK(dp[1]); - sa3->sa_atime.nfsv3_sec = EXTRACT_32BITS(dp); + sa3->sa_atime.nfsv3_sec = GET_BE_U_4(dp); dp++; - sa3->sa_atime.nfsv3_nsec = EXTRACT_32BITS(dp); + sa3->sa_atime.nfsv3_nsec = GET_BE_U_4(dp); dp++; } - TCHECK(dp[0]); - sa3->sa_mtimetype = EXTRACT_32BITS(dp); + sa3->sa_mtimetype = GET_BE_U_4(dp); dp++; if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) { - TCHECK(dp[1]); - sa3->sa_mtime.nfsv3_sec = EXTRACT_32BITS(dp); + sa3->sa_mtime.nfsv3_sec = GET_BE_U_4(dp); dp++; - sa3->sa_mtime.nfsv3_nsec = EXTRACT_32BITS(dp); + sa3->sa_mtime.nfsv3_nsec = GET_BE_U_4(dp); dp++; } return dp; -trunc: - return NULL; } -static int nfserr; /* true if we error rather than trunc */ - static void -print_sattr3(const struct nfsv3_sattr *sa3, int verbose) +print_sattr3(netdissect_options *ndo, + const struct nfsv3_sattr *sa3, int verbose) { if (sa3->sa_modeset) - printf(" mode %o", sa3->sa_mode); + ND_PRINT(" mode %o", sa3->sa_mode); if (sa3->sa_uidset) - printf(" uid %u", sa3->sa_uid); + ND_PRINT(" uid %u", sa3->sa_uid); if (sa3->sa_gidset) - printf(" gid %u", sa3->sa_gid); + ND_PRINT(" gid %u", sa3->sa_gid); if (verbose > 1) { if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) - printf(" atime %u.%06u", sa3->sa_atime.nfsv3_sec, + ND_PRINT(" atime %u.%06u", sa3->sa_atime.nfsv3_sec, sa3->sa_atime.nfsv3_nsec); if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) - printf(" mtime %u.%06u", sa3->sa_mtime.nfsv3_sec, + ND_PRINT(" mtime %u.%06u", sa3->sa_mtime.nfsv3_sec, sa3->sa_mtime.nfsv3_nsec); } } void -nfsreply_print(register const u_char *bp, u_int length, - register const u_char *bp2) +nfsreply_print(netdissect_options *ndo, + const u_char *bp, u_int length, + const u_char *bp2) { - register const struct sunrpc_msg *rp; - u_int32_t proc, vers, reply_stat; + const struct sunrpc_msg *rp; char srcid[20], dstid[20]; /*fits 32bit*/ - enum sunrpc_reject_stat rstat; - u_int32_t rlow; - u_int32_t rhigh; - enum sunrpc_auth_stat rwhy; - nfserr = 0; /* assume no error */ + ndo->ndo_protocol = "nfs"; rp = (const struct sunrpc_msg *)bp; - TCHECK(rp->rm_xid); - if (!nflag) { + if (!ndo->ndo_nflag) { strlcpy(srcid, "nfs", sizeof(srcid)); snprintf(dstid, sizeof(dstid), "%u", - EXTRACT_32BITS(&rp->rm_xid)); + GET_BE_U_4(rp->rm_xid)); } else { snprintf(srcid, sizeof(srcid), "%u", NFS_PORT); snprintf(dstid, sizeof(dstid), "%u", - EXTRACT_32BITS(&rp->rm_xid)); + GET_BE_U_4(rp->rm_xid)); } - print_nfsaddr(bp2, srcid, dstid); - TCHECK(rp->rm_reply.rp_stat); - reply_stat = EXTRACT_32BITS(&rp->rm_reply.rp_stat); + nfsaddr_print(ndo, bp2, srcid, dstid); + + nfsreply_noaddr_print(ndo, bp, length, bp2); +} + +void +nfsreply_noaddr_print(netdissect_options *ndo, + const u_char *bp, u_int length, + const u_char *bp2) +{ + const struct sunrpc_msg *rp; + uint32_t proc, vers, reply_stat; + enum sunrpc_reject_stat rstat; + uint32_t rlow; + uint32_t rhigh; + enum sunrpc_auth_stat rwhy; + + ndo->ndo_protocol = "nfs"; + rp = (const struct sunrpc_msg *)bp; + + ND_TCHECK_4(rp->rm_reply.rp_stat); + reply_stat = GET_BE_U_4(&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); + ND_PRINT("reply ok %u", length); + if (xid_map_find(ndo, rp, bp2, &proc, &vers) >= 0) + interp_reply(ndo, 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); + ND_PRINT("reply ERR %u: ", length); + ND_TCHECK_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: - 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); + ND_TCHECK_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: - 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; - } + ND_TCHECK_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; default: - (void)printf("Unknown reason for rejecting rpc message %u", - (unsigned int)rstat); + ND_PRINT("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); + ND_PRINT("reply Unknown rpc response code=%u %u", reply_stat, length); break; } return; trunc: - if (!nfserr) - fputs(" [|nfs]", stdout); + nd_print_trunc(ndo); } /* * Return a pointer to the first file handle in the packet. * If the packet was truncated, return 0. */ -static const u_int32_t * -parsereq(register const struct sunrpc_msg *rp, register u_int length) +static const uint32_t * +parsereq(netdissect_options *ndo, + const struct sunrpc_msg *rp, u_int length) { - register const u_int32_t *dp; - register u_int len; + const uint32_t *dp; + u_int len, rounded_len; /* - * find the start of the req data (if we captured it) + * Find the start of the req data (if we captured it). + * First, get the length of the credentials, and make sure + * we have all of the opaque part of the credentials. */ - dp = (u_int32_t *)&rp->rm_call.cb_cred; - TCHECK(dp[1]); - len = EXTRACT_32BITS(&dp[1]); - if (len < length) { + dp = (const uint32_t *)&rp->rm_call.cb_cred; + if (length < 2 * sizeof(*dp)) + goto trunc; + len = GET_BE_U_4(dp + 1); + if (len > length) { + ND_PRINT(" [credentials length %u > %u]", len, length); + nd_print_invalid(ndo); + return NULL; + } + rounded_len = roundup2(len, 4); + ND_TCHECK_LEN(dp + 2, rounded_len); + if (2 * sizeof(*dp) + rounded_len <= length) { + /* + * We have all of the credentials. Skip past them; they + * consist of 4 bytes of flavor, 4 bytes of length, + * and len-rounded-up-to-a-multiple-of-4 bytes of + * data. + */ dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp); - TCHECK(dp[1]); - len = EXTRACT_32BITS(&dp[1]); - if (len < length) { + length -= 2 * sizeof(*dp) + rounded_len; + + /* + * Now get the length of the verifier, and make sure + * we have all of the opaque part of the verifier. + */ + if (length < 2 * sizeof(*dp)) + goto trunc; + len = GET_BE_U_4(dp + 1); + if (len > length) { + ND_PRINT(" [verifier length %u > %u]", len, length); + nd_print_invalid(ndo); + return NULL; + } + rounded_len = roundup2(len, 4); + ND_TCHECK_LEN(dp + 2, rounded_len); + if (2 * sizeof(*dp) + rounded_len < length) { + /* + * We have all of the verifier. Skip past it; + * it consists of 4 bytes of flavor, 4 bytes of + * length, and len-rounded-up-to-a-multiple-of-4 + * bytes of data. + */ dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp); - TCHECK2(dp[0], 0); return (dp); } } @@ -430,54 +482,58 @@ trunc: * Print out an NFS file handle and return a pointer to following word. * If packet was truncated, return 0. */ -static const u_int32_t * -parsefh(register const u_int32_t *dp, int v3) +static const uint32_t * +parsefh(netdissect_options *ndo, + const uint32_t *dp, int v3) { u_int len; if (v3) { - TCHECK(dp[0]); - len = EXTRACT_32BITS(dp) / 4; + len = GET_BE_U_4(dp) / 4; dp++; } else len = NFSX_V2FH / 4; - if (TTEST2(*dp, len * sizeof(*dp))) { - nfs_printfh(dp, len); + if (ND_TTEST_LEN(dp, len * sizeof(*dp))) { + nfs_printfh(ndo, dp, len); return (dp + len); - } -trunc: - return (NULL); + } else + return NULL; } /* * Print out a file name and return pointer to 32-bit word past it. * If packet was truncated, return 0. */ -static const u_int32_t * -parsefn(register const u_int32_t *dp) +static const uint32_t * +parsefn(netdissect_options *ndo, + const uint32_t *dp) { - register u_int32_t len; - register const u_char *cp; + uint32_t len, rounded_len; + const u_char *cp; - /* Bail if we don't have the string length */ - TCHECK(*dp); + /* Fetch big-endian string length */ + len = GET_BE_U_4(dp); + dp++; - /* Fetch string length; convert to host order */ - len = *dp++; - NTOHL(len); + if (UINT_MAX - len < 3) { + ND_PRINT("[cannot pad to 32-bit boundaries]"); + nd_print_invalid(ndo); + return NULL; + } - TCHECK2(*dp, ((len + 3) & ~3)); + rounded_len = roundup2(len, 4); + ND_TCHECK_LEN(dp, rounded_len); - cp = (u_char *)dp; + cp = (const u_char *)dp; /* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */ - dp += ((len + 3) & ~3) / sizeof(*dp); - putchar('"'); - if (fn_printn(cp, len, snapend)) { - putchar('"'); + dp += rounded_len / sizeof(*dp); + ND_PRINT("\""); + if (nd_printn(ndo, cp, len, ndo->ndo_snapend)) { + ND_PRINT("\""); goto trunc; } - putchar('"'); + ND_PRINT("\""); return (dp); trunc: @@ -489,355 +545,302 @@ trunc: * Return pointer to 32-bit word past file name. * If packet was truncated (or there was some other error), return 0. */ -static const u_int32_t * -parsefhn(register const u_int32_t *dp, int v3) +static const uint32_t * +parsefhn(netdissect_options *ndo, + const uint32_t *dp, int v3) { - dp = parsefh(dp, v3); + dp = parsefh(ndo, dp, v3); if (dp == NULL) return (NULL); - putchar(' '); - return (parsefn(dp)); + ND_PRINT(" "); + return (parsefn(ndo, dp)); } void -nfsreq_print(register const u_char *bp, u_int length, - register const u_char *bp2) +nfsreq_noaddr_print(netdissect_options *ndo, + const u_char *bp, u_int length, + const u_char *bp2) { - register const struct sunrpc_msg *rp; - register const u_int32_t *dp; + const struct sunrpc_msg *rp; + const uint32_t *dp; nfs_type type; int v3; - u_int32_t proc; - u_int32_t access_flags; + uint32_t proc; + uint32_t access_flags; struct nfsv3_sattr sa3; - char srcid[20], dstid[20]; /*fits 32bit*/ - nfserr = 0; /* assume no error */ + ndo->ndo_protocol = "nfs"; + ND_PRINT("%u", length); rp = (const struct sunrpc_msg *)bp; - TCHECK(rp->rm_xid); - if (!nflag) { - snprintf(srcid, sizeof(srcid), "%u", - EXTRACT_32BITS(&rp->rm_xid)); - strlcpy(dstid, "nfs", sizeof(dstid)); - } else { - snprintf(srcid, sizeof(srcid), "%u", - EXTRACT_32BITS(&rp->rm_xid)); - snprintf(dstid, sizeof(dstid), "%u", NFS_PORT); - } - print_nfsaddr(bp2, srcid, dstid); - (void)printf("%d", length); - - if (!xid_map_enter(rp, bp2)) /* record proc number for later on */ + if (!xid_map_enter(ndo, 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); + 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]; + ND_PRINT(" %s", tok2str(nfsproc_str, "proc-%u", proc)); switch (proc) { - case NFSPROC_NOOP: - printf(" nop"); - return; - case NFSPROC_NULL: - printf(" null"); - return; case NFSPROC_GETATTR: - printf(" getattr"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; - break; - case NFSPROC_SETATTR: - printf(" setattr"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; + case NFSPROC_READLINK: + case NFSPROC_FSSTAT: + case NFSPROC_FSINFO: + case NFSPROC_PATHCONF: + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + if (parsefh(ndo, dp, v3) == NULL) + goto trunc; break; case NFSPROC_LOOKUP: - printf(" lookup"); - if ((dp = parsereq(rp, length)) != NULL && - parsefhn(dp, v3) != NULL) - return; + case NFSPROC_CREATE: + case NFSPROC_MKDIR: + case NFSPROC_REMOVE: + case NFSPROC_RMDIR: + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + if (parsefhn(ndo, dp, v3) == NULL) + goto trunc; break; case NFSPROC_ACCESS: - printf(" access"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - TCHECK(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); + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + access_flags = GET_BE_U_4(dp); + if (access_flags & ~NFSV3ACCESS_FULL) { + /* NFSV3ACCESS definitions aren't up to date */ + ND_PRINT(" %04x", access_flags); + } else if ((access_flags & NFSV3ACCESS_FULL) == NFSV3ACCESS_FULL) { + ND_PRINT(" NFS_ACCESS_FULL"); + } else { + char separator = ' '; + if (access_flags & NFSV3ACCESS_READ) { + ND_PRINT(" NFS_ACCESS_READ"); + separator = '|'; } - return; + if (access_flags & NFSV3ACCESS_LOOKUP) { + ND_PRINT("%cNFS_ACCESS_LOOKUP", separator); + separator = '|'; + } + if (access_flags & NFSV3ACCESS_MODIFY) { + ND_PRINT("%cNFS_ACCESS_MODIFY", separator); + separator = '|'; + } + if (access_flags & NFSV3ACCESS_EXTEND) { + ND_PRINT("%cNFS_ACCESS_EXTEND", separator); + separator = '|'; + } + if (access_flags & NFSV3ACCESS_DELETE) { + ND_PRINT("%cNFS_ACCESS_DELETE", separator); + separator = '|'; + } + if (access_flags & NFSV3ACCESS_EXECUTE) + ND_PRINT("%cNFS_ACCESS_EXECUTE", separator); } break; - case NFSPROC_READLINK: - printf(" readlink"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; - break; - case NFSPROC_READ: - printf(" read"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - if (v3) { - TCHECK(dp[2]); - printf(" %u bytes @ %" PRIu64, - EXTRACT_32BITS(&dp[2]), - EXTRACT_64BITS(&dp[0])); - } else { - TCHECK(dp[1]); - printf(" %u bytes @ %u", - EXTRACT_32BITS(&dp[1]), - EXTRACT_32BITS(&dp[0])); - } - return; + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + if (v3) { + ND_PRINT(" %u bytes @ %" PRIu64, + GET_BE_U_4(dp + 2), + GET_BE_U_8(dp)); + } else { + ND_PRINT(" %u bytes @ %u", + GET_BE_U_4(dp + 1), + GET_BE_U_4(dp)); } break; case NFSPROC_WRITE: - printf(" write"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - if (v3) { - 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]); - printf(" <%s>", - tok2str(nfsv3_writemodes, - NULL, EXTRACT_32BITS(dp))); - } - } else { - TCHECK(dp[3]); - printf(" %u (%u) bytes @ %u (%u)", - EXTRACT_32BITS(&dp[3]), - EXTRACT_32BITS(&dp[2]), - EXTRACT_32BITS(&dp[1]), - EXTRACT_32BITS(&dp[0])); + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + if (v3) { + ND_PRINT(" %u (%u) bytes @ %" PRIu64, + 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, + NULL, GET_BE_U_4(dp + 3))); } - return; + } else { + ND_PRINT(" %u (%u) bytes @ %u (%u)", + GET_BE_U_4(dp + 3), + GET_BE_U_4(dp + 2), + GET_BE_U_4(dp + 1), + GET_BE_U_4(dp)); } break; - case NFSPROC_CREATE: - printf(" create"); - if ((dp = parsereq(rp, length)) != NULL && - parsefhn(dp, v3) != NULL) - return; - break; - - case NFSPROC_MKDIR: - printf(" mkdir"); - if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0) - return; - break; - case NFSPROC_SYMLINK: - printf(" symlink"); - if ((dp = parsereq(rp, length)) != 0 && - (dp = parsefhn(dp, v3)) != 0) { - fputs(" ->", stdout); - if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0) - break; - if (parsefn(dp) == 0) - break; - if (v3 && vflag) - print_sattr3(&sa3, vflag); - return; - } + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefhn(ndo, dp, v3); + if (dp == NULL) + goto trunc; + ND_PRINT(" ->"); + if (v3 && (dp = parse_sattr3(ndo, dp, &sa3)) == NULL) + goto trunc; + if (parsefn(ndo, dp) == NULL) + goto trunc; + if (v3 && ndo->ndo_vflag) + print_sattr3(ndo, &sa3, ndo->ndo_vflag); break; case NFSPROC_MKNOD: - printf(" mknod"); - if ((dp = parsereq(rp, length)) != 0 && - (dp = parsefhn(dp, v3)) != 0) { - TCHECK(*dp); - type = (nfs_type)EXTRACT_32BITS(dp); - dp++; - if ((dp = parse_sattr3(dp, &sa3)) == 0) - break; - printf(" %s", tok2str(type2str, "unk-ft %d", type)); - if (vflag && (type == NFCHR || type == NFBLK)) { - TCHECK(dp[1]); - printf(" %u/%u", - EXTRACT_32BITS(&dp[0]), - EXTRACT_32BITS(&dp[1])); - dp += 2; - } - if (vflag) - print_sattr3(&sa3, vflag); - return; + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefhn(ndo, dp, v3); + if (dp == NULL) + goto trunc; + 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)) { + ND_PRINT(" %u/%u", + GET_BE_U_4(dp), + GET_BE_U_4(dp + 1)); + dp += 2; } - break; - - case NFSPROC_REMOVE: - printf(" remove"); - if ((dp = parsereq(rp, length)) != NULL && - parsefhn(dp, v3) != NULL) - return; - break; - - case NFSPROC_RMDIR: - printf(" rmdir"); - if ((dp = parsereq(rp, length)) != NULL && - parsefhn(dp, v3) != NULL) - return; + if (ndo->ndo_vflag) + print_sattr3(ndo, &sa3, ndo->ndo_vflag); break; case NFSPROC_RENAME: - printf(" rename"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefhn(dp, v3)) != NULL) { - fputs(" ->", stdout); - if (parsefhn(dp, v3) != NULL) - return; - } + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefhn(ndo, dp, v3); + if (dp == NULL) + goto trunc; + ND_PRINT(" ->"); + if (parsefhn(ndo, dp, v3) == NULL) + goto trunc; break; case NFSPROC_LINK: - printf(" link"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - fputs(" ->", stdout); - if (parsefhn(dp, v3) != NULL) - return; - } + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + ND_PRINT(" ->"); + if (parsefhn(ndo, dp, v3) == NULL) + goto trunc; break; case NFSPROC_READDIR: - printf(" readdir"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - if (v3) { - TCHECK(dp[4]); - /* - * We shouldn't really try to interpret the - * offset cookie here. - */ - printf(" %u bytes @ %" PRId64, - EXTRACT_32BITS(&dp[4]), - EXTRACT_64BITS(&dp[0])); - if (vflag) - printf(" verf %08x%08x", dp[2], - dp[3]); - } else { - TCHECK(dp[1]); + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + if (v3) { + /* + * We shouldn't really try to interpret the + * offset cookie here. + */ + ND_PRINT(" %u bytes @ %" PRId64, + GET_BE_U_4(dp + 4), + GET_BE_U_8(dp)); + if (ndo->ndo_vflag) { /* - * Print the offset as signed, since -1 is - * common, but offsets > 2^31 aren't. + * This displays the 8 bytes + * of the verifier in order, + * from the low-order byte + * to the high-order byte. */ - printf(" %u bytes @ %d", - EXTRACT_32BITS(&dp[1]), - EXTRACT_32BITS(&dp[0])); + ND_PRINT(" verf %08x%08x", + GET_BE_U_4(dp + 2), + GET_BE_U_4(dp + 3)); } - return; + } else { + /* + * Print the offset as signed, since -1 is + * common, but offsets > 2^31 aren't. + */ + ND_PRINT(" %u bytes @ %u", + GET_BE_U_4(dp + 1), + GET_BE_U_4(dp)); } break; case NFSPROC_READDIRPLUS: - printf(" readdirplus"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - TCHECK(dp[4]); + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + /* + * We don't try to interpret the offset + * cookie here. + */ + ND_PRINT(" %u bytes @ %" PRId64, + GET_BE_U_4(dp + 4), + GET_BE_U_8(dp)); + if (ndo->ndo_vflag) { /* - * We don't try to interpret the offset - * cookie here. + * This displays the 8 bytes + * of the verifier in order, + * from the low-order byte + * to the high-order byte. */ - 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; + ND_PRINT(" max %u verf %08x%08x", + GET_BE_U_4(dp + 5), + GET_BE_U_4(dp + 2), + GET_BE_U_4(dp + 3)); } break; - case NFSPROC_FSSTAT: - printf(" fsstat"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; - break; - - case NFSPROC_FSINFO: - printf(" fsinfo"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; - break; - - case NFSPROC_PATHCONF: - printf(" pathconf"); - if ((dp = parsereq(rp, length)) != NULL && - parsefh(dp, v3) != NULL) - return; - break; - case NFSPROC_COMMIT: - printf(" commit"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp, v3)) != NULL) { - TCHECK(dp[2]); - printf(" %u bytes @ %" PRIu64, - EXTRACT_32BITS(&dp[2]), - EXTRACT_64BITS(&dp[0])); - return; - } + dp = parsereq(ndo, rp, length); + if (dp == NULL) + goto trunc; + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + ND_PRINT(" %u bytes @ %" PRIu64, + GET_BE_U_4(dp + 2), + GET_BE_U_8(dp)); break; default: - printf(" proc-%u", EXTRACT_32BITS(&rp->rm_call.cb_proc)); - return; + break; } + return; trunc: - if (!nfserr) - fputs(" [|nfs]", stdout); + nd_print_trunc(ndo); } /* @@ -850,51 +853,70 @@ trunc: * additional hacking on the parser code. */ static void -nfs_printfh(register const u_int32_t *dp, const u_int len) +nfs_printfh(netdissect_options *ndo, + const uint32_t *dp, const u_int len) { my_fsid fsid; - ino_t ino; + uint32_t ino; const char *sfsname = NULL; char *spacep; - if (uflag) { + if (ndo->ndo_uflag) { u_int i; char const *sep = ""; - printf(" fh["); + ND_PRINT(" fh["); for (i=0; i NFSX_V3FHMAX) + stringlen = NFSX_V3FHMAX; + strncpy(temp, sfsname, stringlen); + temp[stringlen] = '\0'; /* Remove trailing spaces */ spacep = strchr(temp, ' '); if (spacep) *spacep = '\0'; - (void)printf(" fh %s/", temp); + ND_PRINT(" fh "); + fn_print_str(ndo, (const u_char *)temp); + ND_PRINT("/"); } else { - (void)printf(" fh %d,%d/", + ND_PRINT(" fh %u,%u/", fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor); } - if(fsid.Fsid_dev.Minor == 257) + if(fsid.Fsid_dev.Minor == UINT_MAX && fsid.Fsid_dev.Major == UINT_MAX) /* Print the undecoded handle */ - (void)printf("%s", fsid.Opaque_Handle); + fn_print_str(ndo, (const u_char *)fsid.Opaque_Handle); else - (void)printf("%ld", (long) ino); + ND_PRINT("%u", ino); } /* @@ -904,17 +926,12 @@ nfs_printfh(register const u_int32_t *dp, const u_int len) */ struct xid_map_entry { - u_int32_t xid; /* transaction ID (net order) */ + uint32_t xid; /* transaction ID (net order) */ int ipver; /* IP version (4 or 6) */ -#ifdef INET6 - struct in6_addr client; /* client IP address (net order) */ - struct in6_addr server; /* server IP address (net order) */ -#else - struct in_addr client; /* client IP address (net order) */ - struct in_addr server; /* server IP address (net order) */ -#endif - u_int32_t proc; /* call proc number (host order) */ - u_int32_t vers; /* program version (host 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) */ }; /* @@ -925,31 +942,28 @@ struct xid_map_entry { #define XIDMAPSIZE 64 -struct xid_map_entry xid_map[XIDMAPSIZE]; +static struct xid_map_entry xid_map[XIDMAPSIZE]; -int xid_map_next = 0; -int xid_map_hint = 0; +static int xid_map_next = 0; +static int xid_map_hint = 0; static int -xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp) +xid_map_enter(netdissect_options *ndo, + const struct sunrpc_msg *rp, const u_char *bp) { - struct ip *ip = NULL; -#ifdef INET6 - struct ip6_hdr *ip6 = NULL; -#endif + const struct ip *ip = NULL; + const struct ip6_hdr *ip6 = NULL; struct xid_map_entry *xmep; - if (!TTEST(rp->rm_call.cb_vers)) + if (!ND_TTEST_4(rp->rm_call.cb_proc)) return (0); - switch (IP_V((struct ip *)bp)) { + switch (IP_V((const struct ip *)bp)) { case 4: - ip = (struct ip *)bp; + ip = (const struct ip *)bp; break; -#ifdef INET6 case 6: - ip6 = (struct ip6_hdr *)bp; + ip6 = (const struct ip6_hdr *)bp; break; -#endif default: return (1); } @@ -959,21 +973,22 @@ xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp) if (++xid_map_next >= XIDMAPSIZE) xid_map_next = 0; - xmep->xid = rp->rm_xid; + UNALIGNED_MEMCPY(&xmep->xid, &rp->rm_xid, sizeof(xmep->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)); - } -#ifdef INET6 - else if (ip6) { + UNALIGNED_MEMCPY(&xmep->client, ip->ip_src, + sizeof(ip->ip_src)); + UNALIGNED_MEMCPY(&xmep->server, ip->ip_dst, + sizeof(ip->ip_dst)); + } 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); + xmep->proc = GET_BE_U_4(&rp->rm_call.cb_proc); + xmep->vers = GET_BE_U_4(&rp->rm_call.cb_vers); return (1); } @@ -982,18 +997,17 @@ xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp) * version in vers return, or returns -1 on failure */ static int -xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc, - u_int32_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; - u_int32_t xid = rp->rm_xid; - struct ip *ip = (struct ip *)bp; -#ifdef INET6 - struct ip6_hdr *ip6 = (struct ip6_hdr *)bp; -#endif + uint32_t xid; + const struct ip *ip = (const struct ip *)bp; + const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp; int cmp; + UNALIGNED_MEMCPY(&xid, &rp->rm_xid, sizeof(xmep->xid)); /* Start searching from where we last left off */ i = xid_map_hint; do { @@ -1003,23 +1017,21 @@ 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, - sizeof(ip->ip_src)) != 0 || - memcmp(&ip->ip_dst, &xmep->client, - sizeof(ip->ip_dst)) != 0) { + if (UNALIGNED_MEMCMP(ip->ip_src, &xmep->server, + sizeof(ip->ip_src)) != 0 || + 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, - sizeof(ip6->ip6_src)) != 0 || - memcmp(&ip6->ip6_dst, &xmep->client, - sizeof(ip6->ip6_dst)) != 0) { + if (UNALIGNED_MEMCMP(ip6->ip6_src, &xmep->server, + sizeof(ip6->ip6_src)) != 0 || + UNALIGNED_MEMCMP(ip6->ip6_dst, &xmep->client, + sizeof(ip6->ip6_dst)) != 0) { cmp = 0; } break; -#endif default: cmp = 0; break; @@ -1048,10 +1060,11 @@ xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc, * Return a pointer to the beginning of the actual results. * If the packet was truncated, return 0. */ -static const u_int32_t * -parserep(register const struct sunrpc_msg *rp, register u_int length) +static const uint32_t * +parserep(netdissect_options *ndo, + const struct sunrpc_msg *rp, u_int length, int *nfserrp) { - register const u_int32_t *dp; + const uint32_t *dp; u_int len; enum sunrpc_accept_stat astat; @@ -1059,7 +1072,7 @@ parserep(register const struct sunrpc_msg *rp, register u_int length) * Portability note: * Here we find the address of the ar_verf credentials. * Originally, this calculation was - * dp = (u_int32_t *)&rp->rm_reply.rp_acpt.ar_verf + * dp = (uint32_t *)&rp->rm_reply.rp_acpt.ar_verf * On the wire, the rp_acpt field starts immediately after * the (32 bit) rp_stat field. However, rp_acpt (which is a * "struct accepted_reply") contains a "struct opaque_auth", @@ -1070,244 +1083,223 @@ parserep(register const struct sunrpc_msg *rp, register u_int length) * representation. Instead, we skip past the rp_stat field, * which is an "enum" and so occupies one 32-bit word. */ - dp = ((const u_int32_t *)&rp->rm_reply) + 1; - TCHECK(dp[1]); - len = EXTRACT_32BITS(&dp[1]); + dp = ((const uint32_t *)&rp->rm_reply) + 1; + len = GET_BE_U_4(dp + 1); if (len >= length) return (NULL); /* * skip past the ar_verf credentials. */ - dp += (len + (2*sizeof(u_int32_t) + 3)) / sizeof(u_int32_t); - TCHECK2(dp[0], 0); + dp += (len + (2*sizeof(uint32_t) + 3)) / sizeof(uint32_t); /* * now we can check the ar_stat field */ - astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp); - switch (astat) { - - case SUNRPC_SUCCESS: - break; - - case SUNRPC_PROG_UNAVAIL: - printf(" PROG_UNAVAIL"); - nfserr = 1; /* suppress trunc string */ - return (NULL); - - case SUNRPC_PROG_MISMATCH: - printf(" PROG_MISMATCH"); - nfserr = 1; /* suppress trunc string */ - return (NULL); - - case SUNRPC_PROC_UNAVAIL: - printf(" PROC_UNAVAIL"); - nfserr = 1; /* suppress trunc string */ - return (NULL); - - case SUNRPC_GARBAGE_ARGS: - printf(" GARBAGE_ARGS"); - nfserr = 1; /* suppress trunc string */ - return (NULL); - - case SUNRPC_SYSTEM_ERR: - printf(" SYSTEM_ERR"); - nfserr = 1; /* suppress trunc string */ - return (NULL); - - default: - printf(" ar_stat %d", astat); - nfserr = 1; /* suppress trunc string */ + 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 */ return (NULL); } /* successful return */ - TCHECK2(*dp, sizeof(astat)); - return ((u_int32_t *) (sizeof(astat) + ((char *)dp))); + ND_TCHECK_LEN(dp, sizeof(astat)); + return ((const uint32_t *) (sizeof(astat) + ((const char *)dp))); trunc: return (0); } -static const u_int32_t * -parsestatus(const u_int32_t *dp, int *er) +static const uint32_t * +parsestatus(netdissect_options *ndo, + const uint32_t *dp, u_int *er, int *nfserrp) { - int errnum; + u_int errnum; - TCHECK(dp[0]); - - errnum = EXTRACT_32BITS(&dp[0]); + errnum = GET_BE_U_4(dp); if (er) *er = errnum; if (errnum != 0) { - if (!qflag) - printf(" ERROR: %s", - tok2str(status2str, "unk %d", errnum)); - nfserr = 1; + if (!ndo->ndo_qflag) + ND_PRINT(" ERROR: %s", + tok2str(status2str, "unk %u", errnum)); + *nfserrp = 1; } return (dp + 1); -trunc: - return NULL; } -static const u_int32_t * -parsefattr(const u_int32_t *dp, int verbose, int v3) +static const uint32_t * +parsefattr(netdissect_options *ndo, + const uint32_t *dp, int verbose, int v3) { const struct nfs_fattr *fap; fap = (const struct nfs_fattr *)dp; - TCHECK(fap->fa_gid); + ND_TCHECK_4(fap->fa_gid); if (verbose) { - printf(" %s %o ids %d/%d", - tok2str(type2str, "unk-ft %d ", - EXTRACT_32BITS(&fap->fa_type)), - EXTRACT_32BITS(&fap->fa_mode), - EXTRACT_32BITS(&fap->fa_uid), - EXTRACT_32BITS(&fap->fa_gid)); + /* + * XXX - UIDs and GIDs are unsigned in NFS and in + * at least some UN*Xes, but we'll show them as + * signed because -2 has traditionally been the + * UID for "nobody", rather than 4294967294. + */ + ND_PRINT(" %s %o ids %d/%d", + tok2str(type2str, "unk-ft %u ", + 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) { - TCHECK(fap->fa3_size); - printf(" sz %" PRIu64, - EXTRACT_64BITS((u_int32_t *)&fap->fa3_size)); + ND_PRINT(" sz %" PRIu64, + GET_BE_U_8(fap->fa3_size)); } else { - TCHECK(fap->fa2_size); - printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size)); + ND_PRINT(" sz %u", GET_BE_U_4(fap->fa2_size)); } } /* print lots more stuff */ if (verbose > 1) { if (v3) { - TCHECK(fap->fa3_ctime); - printf(" nlink %d rdev %d/%d", - EXTRACT_32BITS(&fap->fa_nlink), - EXTRACT_32BITS(&fap->fa3_rdev.specdata1), - EXTRACT_32BITS(&fap->fa3_rdev.specdata2)); - 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)); - printf(" %u.%06u", - EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_sec), - EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_nsec)); - printf(" %u.%06u", - EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_sec), - EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_nsec)); + ND_TCHECK_8(&fap->fa3_ctime); + ND_PRINT(" nlink %u rdev %u/%u", + 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, + GET_BE_U_8(fap->fa3_fsid)); + ND_PRINT(" fileid %" PRIx64, + GET_BE_U_8(fap->fa3_fileid)); + ND_PRINT(" a/m/ctime %u.%06u", + GET_BE_U_4(fap->fa3_atime.nfsv3_sec), + GET_BE_U_4(fap->fa3_atime.nfsv3_nsec)); + ND_PRINT(" %u.%06u", + GET_BE_U_4(fap->fa3_mtime.nfsv3_sec), + GET_BE_U_4(fap->fa3_mtime.nfsv3_nsec)); + ND_PRINT(" %u.%06u", + GET_BE_U_4(fap->fa3_ctime.nfsv3_sec), + GET_BE_U_4(fap->fa3_ctime.nfsv3_nsec)); } else { - TCHECK(fap->fa2_ctime); - printf(" nlink %d rdev %x fsid %x nodeid %x a/m/ctime", - EXTRACT_32BITS(&fap->fa_nlink), - EXTRACT_32BITS(&fap->fa2_rdev), - EXTRACT_32BITS(&fap->fa2_fsid), - EXTRACT_32BITS(&fap->fa2_fileid)); - printf(" %u.%06u", - EXTRACT_32BITS(&fap->fa2_atime.nfsv2_sec), - EXTRACT_32BITS(&fap->fa2_atime.nfsv2_usec)); - printf(" %u.%06u", - EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_sec), - EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_usec)); - printf(" %u.%06u", - EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_sec), - EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec)); + ND_TCHECK_8(&fap->fa2_ctime); + ND_PRINT(" nlink %u rdev 0x%x fsid 0x%x nodeid 0x%x a/m/ctime", + 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", + GET_BE_U_4(fap->fa2_atime.nfsv2_sec), + GET_BE_U_4(fap->fa2_atime.nfsv2_usec)); + ND_PRINT(" %u.%06u", + GET_BE_U_4(fap->fa2_mtime.nfsv2_sec), + GET_BE_U_4(fap->fa2_mtime.nfsv2_usec)); + ND_PRINT(" %u.%06u", + GET_BE_U_4(fap->fa2_ctime.nfsv2_sec), + GET_BE_U_4(fap->fa2_ctime.nfsv2_usec)); } } - return ((const u_int32_t *)((unsigned char *)dp + + return ((const uint32_t *)((const unsigned char *)dp + (v3 ? NFSX_V3FATTR : NFSX_V2FATTR))); trunc: return (NULL); } static int -parseattrstat(const u_int32_t *dp, int verbose, int v3) +parseattrstat(netdissect_options *ndo, + const uint32_t *dp, int verbose, int v3, int *nfserrp) { - int er; + u_int er; - dp = parsestatus(dp, &er); + dp = parsestatus(ndo, dp, &er, nfserrp); if (dp == NULL) return (0); if (er) return (1); - return (parsefattr(dp, verbose, v3) != NULL); + return (parsefattr(ndo, dp, verbose, v3) != NULL); } static int -parsediropres(const u_int32_t *dp) +parsediropres(netdissect_options *ndo, + const uint32_t *dp, int *nfserrp) { - int er; + u_int er; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); if (er) return (1); - dp = parsefh(dp, 0); + dp = parsefh(ndo, dp, 0); if (dp == NULL) return (0); - return (parsefattr(dp, vflag, 0) != NULL); + return (parsefattr(ndo, dp, ndo->ndo_vflag, 0) != NULL); } static int -parselinkres(const u_int32_t *dp, int v3) +parselinkres(netdissect_options *ndo, + const uint32_t *dp, int v3, int *nfserrp) { - int er; + u_int er; - dp = parsestatus(dp, &er); + dp = parsestatus(ndo, dp, &er, nfserrp); if (dp == NULL) return(0); if (er) return(1); - if (v3 && !(dp = parse_post_op_attr(dp, vflag))) - return (0); - putchar(' '); - return (parsefn(dp) != NULL); + if (v3) { + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + return (0); + } + ND_PRINT(" "); + return (parsefn(ndo, dp) != NULL); } static int -parsestatfs(const u_int32_t *dp, int v3) +parsestatfs(netdissect_options *ndo, + const uint32_t *dp, int v3, int *nfserrp) { const struct nfs_statfs *sfsp; - int er; + u_int er; - dp = parsestatus(dp, &er); + dp = parsestatus(ndo, dp, &er, nfserrp); if (dp == NULL) return (0); if (!v3 && er) return (1); - if (qflag) + if (ndo->ndo_qflag) return(1); if (v3) { - if (vflag) - printf(" POST:"); - if (!(dp = parse_post_op_attr(dp, vflag))) + if (ndo->ndo_vflag) + ND_PRINT(" POST:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) return (0); } - TCHECK2(*dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS)); + ND_TCHECK_LEN(dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS)); sfsp = (const struct nfs_statfs *)dp; if (v3) { - 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 %" 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)); + ND_PRINT(" tbytes %" PRIu64 " fbytes %" PRIu64 " abytes %" PRIu64, + 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", + 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 { - printf(" tsize %d bsize %d blocks %d bfree %d bavail %d", - EXTRACT_32BITS(&sfsp->sf_tsize), - EXTRACT_32BITS(&sfsp->sf_bsize), - EXTRACT_32BITS(&sfsp->sf_blocks), - EXTRACT_32BITS(&sfsp->sf_bfree), - EXTRACT_32BITS(&sfsp->sf_bavail)); + ND_PRINT(" tsize %u bsize %u blocks %u bfree %u bavail %u", + 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); @@ -1316,52 +1308,52 @@ trunc: } static int -parserddires(const u_int32_t *dp) +parserddires(netdissect_options *ndo, + const uint32_t *dp, int *nfserrp) { - int er; + u_int er; - dp = parsestatus(dp, &er); + dp = parsestatus(ndo, dp, &er, nfserrp); if (dp == NULL) return (0); if (er) return (1); - if (qflag) + if (ndo->ndo_qflag) return (1); - TCHECK(dp[2]); - printf(" offset %x size %d ", - EXTRACT_32BITS(&dp[0]), EXTRACT_32BITS(&dp[1])); - if (dp[2] != 0) - printf(" eof"); + ND_PRINT(" offset 0x%x size %u ", + GET_BE_U_4(dp), GET_BE_U_4(dp + 1)); + if (GET_BE_U_4(dp + 2) != 0) + ND_PRINT(" eof"); return (1); -trunc: - return (0); } -static const u_int32_t * -parse_wcc_attr(const u_int32_t *dp) +static const uint32_t * +parse_wcc_attr(netdissect_options *ndo, + const uint32_t *dp) { - 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])); + /* Our caller has already checked this */ + ND_PRINT(" sz %" PRIu64, GET_BE_U_8(dp)); + ND_PRINT(" mtime %u.%06u ctime %u.%06u", + 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); } /* * Pre operation attributes. Print only if vflag > 1. */ -static const u_int32_t * -parse_pre_op_attr(const u_int32_t *dp, int verbose) +static const uint32_t * +parse_pre_op_attr(netdissect_options *ndo, + const uint32_t *dp, int verbose) { - TCHECK(dp[0]); - if (!EXTRACT_32BITS(&dp[0])) + if (!GET_BE_U_4(dp)) return (dp + 1); dp++; - TCHECK2(*dp, 24); + ND_TCHECK_LEN(dp, 24); if (verbose > 1) { - return parse_wcc_attr(dp); + return parse_wcc_attr(ndo, dp); } else { /* If not verbose enough, just skip over wcc_attr */ return (dp + 6); @@ -1373,128 +1365,139 @@ trunc: /* * Post operation attributes are printed if vflag >= 1 */ -static const u_int32_t * -parse_post_op_attr(const u_int32_t *dp, int verbose) +static const uint32_t * +parse_post_op_attr(netdissect_options *ndo, + const uint32_t *dp, int verbose) { - TCHECK(dp[0]); - if (!EXTRACT_32BITS(&dp[0])) + if (!GET_BE_U_4(dp)) return (dp + 1); dp++; if (verbose) { - return parsefattr(dp, verbose, 1); + return parsefattr(ndo, dp, verbose, 1); } else - return (dp + (NFSX_V3FATTR / sizeof (u_int32_t))); -trunc: - return (NULL); + return (dp + (NFSX_V3FATTR / sizeof (uint32_t))); } -static const u_int32_t * -parse_wcc_data(const u_int32_t *dp, int verbose) +static const uint32_t * +parse_wcc_data(netdissect_options *ndo, + const uint32_t *dp, int verbose) { if (verbose > 1) - printf(" PRE:"); - if (!(dp = parse_pre_op_attr(dp, verbose))) + ND_PRINT(" PRE:"); + dp = parse_pre_op_attr(ndo, dp, verbose); + if (dp == NULL) return (0); if (verbose) - printf(" POST:"); - return parse_post_op_attr(dp, verbose); + ND_PRINT(" POST:"); + return parse_post_op_attr(ndo, dp, verbose); } -static const u_int32_t * -parsecreateopres(const u_int32_t *dp, int verbose) +static const uint32_t * +parsecreateopres(netdissect_options *ndo, + const uint32_t *dp, int verbose, int *nfserrp) { - int er; + u_int er; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); if (er) - dp = parse_wcc_data(dp, verbose); + dp = parse_wcc_data(ndo, dp, verbose); else { - TCHECK(dp[0]); - if (!EXTRACT_32BITS(&dp[0])) + if (!GET_BE_U_4(dp)) return (dp + 1); dp++; - if (!(dp = parsefh(dp, 1))) + dp = parsefh(ndo, dp, 1); + if (dp == NULL) return (0); if (verbose) { - if (!(dp = parse_post_op_attr(dp, verbose))) + dp = parse_post_op_attr(ndo, dp, verbose); + if (dp == NULL) return (0); - if (vflag > 1) { - printf(" dir attr:"); - dp = parse_wcc_data(dp, verbose); + if (ndo->ndo_vflag > 1) { + ND_PRINT(" dir attr:"); + dp = parse_wcc_data(ndo, dp, verbose); } } } return (dp); -trunc: - return (NULL); } -static int -parsewccres(const u_int32_t *dp, int verbose) +static const uint32_t * +parsewccres(netdissect_options *ndo, + const uint32_t *dp, int verbose, int *nfserrp) { - int er; + u_int er; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); - return parse_wcc_data(dp, verbose) != 0; + return parse_wcc_data(ndo, dp, verbose); } -static const u_int32_t * -parsev3rddirres(const u_int32_t *dp, int verbose) +static const uint32_t * +parsev3rddirres(netdissect_options *ndo, + const uint32_t *dp, int verbose, int *nfserrp) { - int er; + u_int er; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); - if (vflag) - printf(" POST:"); - if (!(dp = parse_post_op_attr(dp, verbose))) + if (ndo->ndo_vflag) + ND_PRINT(" POST:"); + dp = parse_post_op_attr(ndo, dp, verbose); + if (dp == NULL) return (0); if (er) return dp; - if (vflag) { - TCHECK(dp[1]); - printf(" verf %08x%08x", dp[0], dp[1]); + if (ndo->ndo_vflag) { + /* + * 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", + GET_BE_U_4(dp), GET_BE_U_4(dp + 1)); dp += 2; } return dp; -trunc: - return (NULL); } static int -parsefsinfo(const u_int32_t *dp) +parsefsinfo(netdissect_options *ndo, + const uint32_t *dp, int *nfserrp) { - struct nfsv3_fsinfo *sfp; - int er; + const struct nfsv3_fsinfo *sfp; + u_int er; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); - if (vflag) - printf(" POST:"); - if (!(dp = parse_post_op_attr(dp, vflag))) + if (ndo->ndo_vflag) + ND_PRINT(" POST:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) return (0); if (er) return (1); - sfp = (struct nfsv3_fsinfo *)dp; - TCHECK(*sfp); - printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u", - EXTRACT_32BITS(&sfp->fs_rtmax), - EXTRACT_32BITS(&sfp->fs_rtpref), - EXTRACT_32BITS(&sfp->fs_wtmax), - EXTRACT_32BITS(&sfp->fs_wtpref), - EXTRACT_32BITS(&sfp->fs_dtpref)); - if (vflag) { - printf(" rtmult %u wtmult %u maxfsz %" PRIu64, - EXTRACT_32BITS(&sfp->fs_rtmult), - 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)); + sfp = (const struct nfsv3_fsinfo *)dp; + ND_TCHECK_SIZE(sfp); + ND_PRINT(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u", + 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, + 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 ", + GET_BE_U_4(sfp->fs_timedelta.nfsv3_sec), + GET_BE_U_4(sfp->fs_timedelta.nfsv3_nsec)); } return (1); trunc: @@ -1502,350 +1505,355 @@ trunc: } static int -parsepathconf(const u_int32_t *dp) +parsepathconf(netdissect_options *ndo, + const uint32_t *dp, int *nfserrp) { - int er; - struct nfsv3_pathconf *spp; + u_int er; + const struct nfsv3_pathconf *spp; - if (!(dp = parsestatus(dp, &er))) + dp = parsestatus(ndo, dp, &er, nfserrp); + if (dp == NULL) return (0); - if (vflag) - printf(" POST:"); - if (!(dp = parse_post_op_attr(dp, vflag))) + if (ndo->ndo_vflag) + ND_PRINT(" POST:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) return (0); if (er) return (1); - spp = (struct nfsv3_pathconf *)dp; - TCHECK(*spp); + spp = (const struct nfsv3_pathconf *)dp; + ND_TCHECK_SIZE(spp); - printf(" linkmax %u namemax %u %s %s %s %s", - EXTRACT_32BITS(&spp->pc_linkmax), - EXTRACT_32BITS(&spp->pc_namemax), - EXTRACT_32BITS(&spp->pc_notrunc) ? "notrunc" : "", - EXTRACT_32BITS(&spp->pc_chownrestricted) ? "chownres" : "", - EXTRACT_32BITS(&spp->pc_caseinsensitive) ? "igncase" : "", - EXTRACT_32BITS(&spp->pc_casepreserving) ? "keepcase" : ""); + ND_PRINT(" linkmax %u namemax %u %s %s %s %s", + 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); } static void -interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length) +interp_reply(netdissect_options *ndo, + const struct sunrpc_msg *rp, uint32_t proc, uint32_t vers, + int length) { - register const u_int32_t *dp; - register int v3; - int er; + const uint32_t *dp; + int v3; + u_int er; + int nfserr = 0; v3 = (vers == NFS_VER3); if (!v3 && proc < NFS_NPROCS) proc = nfsv3_procid[proc]; + ND_PRINT(" %s", tok2str(nfsproc_str, "proc-%u", proc)); switch (proc) { - case NFSPROC_NOOP: - printf(" nop"); - return; - - case NFSPROC_NULL: - printf(" null"); - return; - case NFSPROC_GETATTR: - printf(" getattr"); - dp = parserep(rp, length); - if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parseattrstat(ndo, dp, !ndo->ndo_qflag, v3, &nfserr) == 0) + goto trunc; break; case NFSPROC_SETATTR: - printf(" setattr"); - if (!(dp = parserep(rp, length))) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (parsewccres(dp, vflag)) - return; + if (parsewccres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; } else { - if (parseattrstat(dp, !qflag, 0) != 0) - return; + if (parseattrstat(ndo, dp, !ndo->ndo_qflag, 0, &nfserr) == 0) + goto trunc; } break; case NFSPROC_LOOKUP: - printf(" lookup"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (!(dp = parsestatus(dp, &er))) - break; + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; if (er) { - if (vflag > 1) { - printf(" post dattr:"); - dp = parse_post_op_attr(dp, vflag); + if (ndo->ndo_vflag > 1) { + ND_PRINT(" post dattr:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; } } else { - if (!(dp = parsefh(dp, v3))) - break; - if ((dp = parse_post_op_attr(dp, vflag)) && - vflag > 1) { - printf(" post dattr:"); - dp = parse_post_op_attr(dp, vflag); + dp = parsefh(ndo, dp, v3); + if (dp == NULL) + goto trunc; + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + if (ndo->ndo_vflag > 1) { + ND_PRINT(" post dattr:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; } } - if (dp) - return; } else { - if (parsediropres(dp) != 0) - return; + if (parsediropres(ndo, dp, &nfserr) == 0) + goto trunc; } break; case NFSPROC_ACCESS: - printf(" access"); - if (!(dp = parserep(rp, length))) - break; - if (!(dp = parsestatus(dp, &er))) - break; - if (vflag) - printf(" attr:"); - if (!(dp = parse_post_op_attr(dp, vflag))) - break; - if (!er) - printf(" c %04x", EXTRACT_32BITS(&dp[0])); - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; + if (ndo->ndo_vflag) + ND_PRINT(" attr:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + if (!er) { + ND_PRINT(" c %04x", GET_BE_U_4(dp)); + } + break; case NFSPROC_READLINK: - printf(" readlink"); - dp = parserep(rp, length); - if (dp != NULL && parselinkres(dp, v3) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parselinkres(ndo, dp, v3, &nfserr) == 0) + goto trunc; break; case NFSPROC_READ: - printf(" read"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (!(dp = parsestatus(dp, &er))) - break; - if (!(dp = parse_post_op_attr(dp, vflag))) - break; - if (er) - return; - if (vflag) { - TCHECK(dp[1]); - printf(" %u bytes", EXTRACT_32BITS(&dp[0])); - if (EXTRACT_32BITS(&dp[1])) - printf(" EOF"); + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + if (!er) { + if (ndo->ndo_vflag) { + ND_PRINT(" %u bytes", GET_BE_U_4(dp)); + if (GET_BE_U_4(dp + 1)) + ND_PRINT(" EOF"); + } } - return; } else { - if (parseattrstat(dp, vflag, 0) != 0) - return; + if (parseattrstat(ndo, dp, ndo->ndo_vflag, 0, &nfserr) == 0) + goto trunc; } break; case NFSPROC_WRITE: - printf(" write"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (!(dp = parsestatus(dp, &er))) - break; - if (!(dp = parse_wcc_data(dp, vflag))) - break; - if (er) - return; - if (vflag) { - TCHECK(dp[0]); - printf(" %u bytes", EXTRACT_32BITS(&dp[0])); - if (vflag > 1) { - TCHECK(dp[1]); - printf(" <%s>", - tok2str(nfsv3_writemodes, - NULL, EXTRACT_32BITS(&dp[1]))); + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; + dp = parse_wcc_data(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + if (!er) { + if (ndo->ndo_vflag) { + ND_PRINT(" %u bytes", GET_BE_U_4(dp)); + if (ndo->ndo_vflag > 1) { + ND_PRINT(" <%s>", + tok2str(nfsv3_writemodes, + NULL, GET_BE_U_4(dp + 1))); + + /* write-verf-cookie */ + ND_PRINT(" verf %" PRIx64, + GET_BE_U_8(dp + 2)); + } } - return; } + return; } else { - if (parseattrstat(dp, vflag, v3) != 0) - return; + if (parseattrstat(ndo, dp, ndo->ndo_vflag, v3, &nfserr) == 0) + goto trunc; } break; case NFSPROC_CREATE: - printf(" create"); - if (!(dp = parserep(rp, length))) - break; - if (v3) { - if (parsecreateopres(dp, vflag) != 0) - return; - } else { - if (parsediropres(dp) != 0) - return; - } - break; - case NFSPROC_MKDIR: - printf(" mkdir"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (parsecreateopres(dp, vflag) != 0) - return; + if (parsecreateopres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; } else { - if (parsediropres(dp) != 0) - return; + if (parsediropres(ndo, dp, &nfserr) == 0) + goto trunc; } break; case NFSPROC_SYMLINK: - printf(" symlink"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (parsecreateopres(dp, vflag) != 0) - return; + if (parsecreateopres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; } else { - if (parsestatus(dp, &er) != 0) - return; + if (parsestatus(ndo, dp, &er, &nfserr) == NULL) + goto trunc; } break; case NFSPROC_MKNOD: - printf(" mknod"); - if (!(dp = parserep(rp, length))) - break; - if (parsecreateopres(dp, vflag) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parsecreateopres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; break; case NFSPROC_REMOVE: - printf(" remove"); - if (!(dp = parserep(rp, length))) - break; - if (v3) { - if (parsewccres(dp, vflag)) - return; - } else { - if (parsestatus(dp, &er) != 0) - return; - } - break; - case NFSPROC_RMDIR: - printf(" rmdir"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (parsewccres(dp, vflag)) - return; + if (parsewccres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; } else { - if (parsestatus(dp, &er) != 0) - return; + if (parsestatus(ndo, dp, &er, &nfserr) == NULL) + goto trunc; } break; case NFSPROC_RENAME: - printf(" rename"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (!(dp = parsestatus(dp, &er))) - break; - if (vflag) { - printf(" from:"); - if (!(dp = parse_wcc_data(dp, vflag))) - break; - printf(" to:"); - if (!(dp = parse_wcc_data(dp, vflag))) - break; + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; + if (ndo->ndo_vflag) { + ND_PRINT(" from:"); + dp = parse_wcc_data(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + ND_PRINT(" to:"); + dp = parse_wcc_data(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; } - return; } else { - if (parsestatus(dp, &er) != 0) - return; + if (parsestatus(ndo, dp, &er, &nfserr) == NULL) + goto trunc; } break; case NFSPROC_LINK: - printf(" link"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (!(dp = parsestatus(dp, &er))) - break; - if (vflag) { - printf(" file POST:"); - if (!(dp = parse_post_op_attr(dp, vflag))) - break; - printf(" dir:"); - if (!(dp = parse_wcc_data(dp, vflag))) - break; - return; + dp = parsestatus(ndo, dp, &er, &nfserr); + if (dp == NULL) + goto trunc; + if (ndo->ndo_vflag) { + ND_PRINT(" file POST:"); + dp = parse_post_op_attr(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; + ND_PRINT(" dir:"); + dp = parse_wcc_data(ndo, dp, ndo->ndo_vflag); + if (dp == NULL) + goto trunc; } + return; } else { - if (parsestatus(dp, &er) != 0) - return; + if (parsestatus(ndo, dp, &er, &nfserr) == NULL) + goto trunc; } break; case NFSPROC_READDIR: - printf(" readdir"); - if (!(dp = parserep(rp, length))) - break; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; if (v3) { - if (parsev3rddirres(dp, vflag)) - return; + if (parsev3rddirres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; } else { - if (parserddires(dp) != 0) - return; + if (parserddires(ndo, dp, &nfserr) == 0) + goto trunc; } break; case NFSPROC_READDIRPLUS: - printf(" readdirplus"); - if (!(dp = parserep(rp, length))) - break; - if (parsev3rddirres(dp, vflag)) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parsev3rddirres(ndo, dp, ndo->ndo_vflag, &nfserr) == NULL) + goto trunc; break; case NFSPROC_FSSTAT: - printf(" fsstat"); - dp = parserep(rp, length); - if (dp != NULL && parsestatfs(dp, v3) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parsestatfs(ndo, dp, v3, &nfserr) == 0) + goto trunc; break; case NFSPROC_FSINFO: - printf(" fsinfo"); - dp = parserep(rp, length); - if (dp != NULL && parsefsinfo(dp) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parsefsinfo(ndo, dp, &nfserr) == 0) + goto trunc; break; case NFSPROC_PATHCONF: - printf(" pathconf"); - dp = parserep(rp, length); - if (dp != NULL && parsepathconf(dp) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + if (parsepathconf(ndo, dp, &nfserr) == 0) + goto trunc; break; case NFSPROC_COMMIT: - printf(" commit"); - dp = parserep(rp, length); - if (dp != NULL && parsewccres(dp, vflag) != 0) - return; + dp = parserep(ndo, rp, length, &nfserr); + if (dp == NULL) + goto trunc; + dp = parsewccres(ndo, dp, ndo->ndo_vflag, &nfserr); + if (dp == NULL) + goto trunc; + if (ndo->ndo_vflag > 1) { + /* write-verf-cookie */ + ND_PRINT(" verf %" PRIx64, GET_BE_U_8(dp)); + } break; default: - printf(" proc-%u", proc); - return; + break; } + return; + trunc: if (!nfserr) - fputs(" [|nfs]", stdout); + nd_print_trunc(ndo); }