X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/abad30540b26443dc1036670bb114b2184e9b4ae..a9a7c86c7875a38358a9ff1f2a35e93febf6f41e:/print-nfs.c

diff --git a/print-nfs.c b/print-nfs.c
index 4a2d1f3e..4d17757f 100644
--- a/print-nfs.c
+++ b/print-nfs.c
@@ -21,7 +21,7 @@
 
 #ifndef lint
 static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.103 2004-09-24 18:21:25 guy Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.111 2007-12-22 03:08:04 guy Exp $ (LBL)";
 #endif
 
 #ifdef HAVE_CONFIG_H
@@ -30,8 +30,6 @@ static const char rcsid[] _U_ =
 
 #include <tcpdump-stdinc.h>
 
-#include <rpc/rpc.h>
-
 #include <pcap.h>
 #include <stdio.h>
 #include <string.h>
@@ -47,15 +45,16 @@ static const char rcsid[] _U_ =
 #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 void xid_map_enter(const struct rpc_msg *, const u_char *);
-static int32_t xid_map_find(const struct rpc_msg *, const u_char *,
+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 rpc_msg *, u_int32_t, u_int32_t, int);
+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 *);
 
 /*
@@ -157,40 +156,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)
 {
@@ -321,13 +286,18 @@ void
 nfsreply_print(register const u_char *bp, u_int length,
 	       register const u_char *bp2)
 {
-	register const struct rpc_msg *rp;
-	u_int32_t proc, vers;
+	register const struct sunrpc_msg *rp;
+	u_int32_t proc, vers, reply_stat;
 	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 */
-	rp = (const struct rpc_msg *)bp;
+	rp = (const struct sunrpc_msg *)bp;
 
+	TCHECK(rp->rm_xid);
 	if (!nflag) {
 		strlcpy(srcid, "nfs", sizeof(srcid));
 		snprintf(dstid, sizeof(dstid), "%u",
@@ -338,13 +308,92 @@ 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) == MSG_ACCEPTED?
-			     "ok":"ERR",
-			     length);
+	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;
 
-	if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
-		interp_reply(rp, proc, vers, length);
+			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)
+		fputs(" [|nfs]", stdout);
 }
 
 /*
@@ -352,7 +401,7 @@ nfsreply_print(register const u_char *bp, u_int length,
  * If the packet was truncated, return 0.
  */
 static const u_int32_t *
-parsereq(register const struct rpc_msg *rp, register u_int length)
+parsereq(register const struct sunrpc_msg *rp, register u_int length)
 {
 	register const u_int32_t *dp;
 	register u_int len;
@@ -423,9 +472,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);
@@ -452,16 +503,19 @@ void
 nfsreq_print(register const u_char *bp, u_int length,
     register const u_char *bp2)
 {
-	register const struct rpc_msg *rp;
+	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;
 	char srcid[20], dstid[20];	/*fits 32bit*/
 
 	nfserr = 0;		/* assume no error */
-	rp = (const struct rpc_msg *)bp;
+	rp = (const struct sunrpc_msg *)bp;
+
+	TCHECK(rp->rm_xid);
 	if (!nflag) {
 		snprintf(srcid, sizeof(srcid), "%u",
 		    EXTRACT_32BITS(&rp->rm_xid));
@@ -474,7 +528,8 @@ nfsreq_print(register const u_char *bp, u_int length,
 	print_nfsaddr(bp2, srcid, dstid);
 	(void)printf("%d", length);
 
-	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 +571,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 +619,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 +637,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 +756,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 +785,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 +822,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;
@@ -839,8 +930,8 @@ struct xid_map_entry xid_map[XIDMAPSIZE];
 int	xid_map_next = 0;
 int	xid_map_hint = 0;
 
-static void
-xid_map_enter(const struct rpc_msg *rp, const u_char *bp)
+static int
+xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
 {
 	struct ip *ip = NULL;
 #ifdef INET6
@@ -848,6 +939,8 @@ xid_map_enter(const struct rpc_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 +951,7 @@ xid_map_enter(const struct rpc_msg *rp, const u_char *bp)
 		break;
 #endif
 	default:
-		return;
+		return (1);
 	}
 
 	xmep = &xid_map[xid_map_next];
@@ -881,6 +974,7 @@ xid_map_enter(const struct rpc_msg *rp, const u_char *bp)
 #endif
 	xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
 	xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
+	return (1);
 }
 
 /*
@@ -888,7 +982,7 @@ xid_map_enter(const struct rpc_msg *rp, const u_char *bp)
  * version in vers return, or returns -1 on failure
  */
 static int
-xid_map_find(const struct rpc_msg *rp, const u_char *bp, u_int32_t *proc,
+xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc,
 	     u_int32_t *vers)
 {
 	int i;
@@ -955,11 +1049,11 @@ xid_map_find(const struct rpc_msg *rp, const u_char *bp, u_int32_t *proc,
  * If the packet was truncated, return 0.
  */
 static const u_int32_t *
-parserep(register const struct rpc_msg *rp, register u_int length)
+parserep(register const struct sunrpc_msg *rp, register u_int length)
 {
 	register const u_int32_t *dp;
 	u_int len;
-	enum accept_stat astat;
+	enum sunrpc_accept_stat astat;
 
 	/*
 	 * Portability note:
@@ -990,33 +1084,33 @@ parserep(register const struct rpc_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 SUCCESS:
+	case SUNRPC_SUCCESS:
 		break;
 
-	case PROG_UNAVAIL:
+	case SUNRPC_PROG_UNAVAIL:
 		printf(" PROG_UNAVAIL");
 		nfserr = 1;		/* suppress trunc string */
 		return (NULL);
 
-	case PROG_MISMATCH:
+	case SUNRPC_PROG_MISMATCH:
 		printf(" PROG_MISMATCH");
 		nfserr = 1;		/* suppress trunc string */
 		return (NULL);
 
-	case PROC_UNAVAIL:
+	case SUNRPC_PROC_UNAVAIL:
 		printf(" PROC_UNAVAIL");
 		nfserr = 1;		/* suppress trunc string */
 		return (NULL);
 
-	case GARBAGE_ARGS:
+	case SUNRPC_GARBAGE_ARGS:
 		printf(" GARBAGE_ARGS");
 		nfserr = 1;		/* suppress trunc string */
 		return (NULL);
 
-	case SYSTEM_ERR:
+	case SUNRPC_SYSTEM_ERR:
 		printf(" SYSTEM_ERR");
 		nfserr = 1;		/* suppress trunc string */
 		return (NULL);
@@ -1070,8 +1164,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 +1179,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 +1290,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 +1342,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 +1488,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));
@@ -1444,7 +1532,7 @@ trunc:
 }
 
 static void
-interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
+interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
 {
 	register const u_int32_t *dp;
 	register int v3;