diff options
| -rw-r--r-- | nfsfh.h | 6 | ||||
| -rw-r--r-- | nfsv2.h | 262 | ||||
| -rw-r--r-- | parsenfsfh.c | 5 | ||||
| -rw-r--r-- | print-nfs.c | 1148 |
4 files changed, 935 insertions, 486 deletions
@@ -1,12 +1,12 @@ /* - * $Header: /tcpdump/master/tcpdump/nfsfh.h,v 1.6 1999-10-07 23:47:10 mcr Exp $ + * $Header: /tcpdump/master/tcpdump/nfsfh.h,v 1.7 1999-11-21 05:43:49 assar Exp $ * * nfsfh.h - NFS file handle definitions (for portable use) * * Jeffrey C. Mogul * Digital Equipment Corporation * Western Research Laboratory - */ +/* $NetBSD: nfsfh.h,v 1.1.1.2 1997/10/03 17:25:13 christos Exp $ */ /* * Internal representation of dev_t, because different NFS servers @@ -31,4 +31,4 @@ typedef struct { #define fsid_eq(a,b) ((a.fsid_code == b.fsid_code) &&\ dev_eq(a.Fsid_dev, b.Fsid_dev)) -extern void Parse_fh(caddr_t *, my_fsid *, ino_t *, char **, char **, int); +extern void Parse_fh(caddr_t *, int, my_fsid *, ino_t *, char **, char **, int); diff --git a/nfsv2.h b/nfsv2.h deleted file mode 100644 index b2c0ff99..00000000 --- a/nfsv2.h +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Copyright (c) 1994, 1995, 1996 - * The Regents of the University of California. All rights reserved. - * - * This code is derived from software contributed to Berkeley by - * Rick Macklem at The University of Guelph. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * @(#)nfsv2.h 7.11 (Berkeley) 9/30/92 - */ - -/* - * nfs definitions as per the version 2 specs - */ - -/* - * Constants as defined in the Sun NFS Version 2 spec. - * "NFS: Network File System Protocol Specification" RFC1094 - */ - -#define NFS_PORT 2049 -#define NFS_PROG 100003 -#define NFS_VER2 2 -#define NFS_MAXDGRAMDATA 8192 -#define NFS_MAXDATA 32768 -#define NFS_MAXPATHLEN 1024 -#define NFS_MAXNAMLEN 255 -#define NFS_FHSIZE 32 -#define NFS_MAXPKTHDR 404 -#define NFS_MAXPACKET (NFS_MAXPKTHDR+NFS_MAXDATA) -#define NFS_MINPACKET 20 -#define NFS_FABLKSIZE 512 /* Size in bytes of a block wrt fa_blocks */ - -/* Stat numbers for rpc returns */ -#define NFS_OK 0 -#define NFSERR_PERM 1 -#define NFSERR_NOENT 2 -#define NFSERR_IO 5 -#define NFSERR_NXIO 6 -#define NFSERR_ACCES 13 -#define NFSERR_EXIST 17 -#define NFSERR_NODEV 19 -#define NFSERR_NOTDIR 20 -#define NFSERR_ISDIR 21 -#define NFSERR_FBIG 27 -#define NFSERR_NOSPC 28 -#define NFSERR_ROFS 30 -#define NFSERR_NAMETOL 63 -#define NFSERR_NOTEMPTY 66 -#define NFSERR_DQUOT 69 -#define NFSERR_STALE 70 -#define NFSERR_WFLUSH 99 - -/* Sizes in bytes of various nfs rpc components */ -#define NFSX_FH 32 -#define NFSX_UNSIGNED 4 -#define NFSX_NFSFATTR 68 -#define NFSX_NQFATTR 92 -#define NFSX_NFSSATTR 32 -#define NFSX_NQSATTR 44 -#define NFSX_COOKIE 4 -#define NFSX_NFSSTATFS 20 -#define NFSX_NQSTATFS 28 -#define NFSX_FATTR(isnq) ((isnq) ? NFSX_NQFATTR : NFSX_NFSFATTR) -#define NFSX_SATTR(isnq) ((isnq) ? NFSX_NQSATTR : NFSX_NFSSATTR) -#define NFSX_STATFS(isnq) ((isnq) ? NFSX_NQSTATFS : NFSX_NFSSTATFS) - -/* nfs rpc procedure numbers */ -#define NFSPROC_NULL 0 -#define NFSPROC_GETATTR 1 -#define NFSPROC_SETATTR 2 -#define NFSPROC_NOOP 3 -#define NFSPROC_ROOT NFSPROC_NOOP /* Obsolete */ -#define NFSPROC_LOOKUP 4 -#define NFSPROC_READLINK 5 -#define NFSPROC_READ 6 -#define NFSPROC_WRITECACHE NFSPROC_NOOP /* Obsolete */ -#define NFSPROC_WRITE 8 -#define NFSPROC_CREATE 9 -#define NFSPROC_REMOVE 10 -#define NFSPROC_RENAME 11 -#define NFSPROC_LINK 12 -#define NFSPROC_SYMLINK 13 -#define NFSPROC_MKDIR 14 -#define NFSPROC_RMDIR 15 -#define NFSPROC_READDIR 16 -#define NFSPROC_STATFS 17 - -/* NQ nfs numbers */ -#define NQNFSPROC_READDIRLOOK 18 -#define NQNFSPROC_GETLEASE 19 -#define NQNFSPROC_VACATED 20 -#define NQNFSPROC_EVICTED 21 -#define NQNFSPROC_ACCESS 22 - -#define NFS_NPROCS 23 -/* Conversion macros */ -extern int vttoif_tab[]; -#define vtonfs_mode(t,m) \ - txdr_unsigned(((t) == VFIFO) ? MAKEIMODE(VCHR, (m)) : \ - MAKEIMODE((t), (m))) -#define nfstov_mode(a) (fxdr_unsigned(u_short, (a))&07777) -#define vtonfs_type(a) txdr_unsigned(nfs_type[((int32_t)(a))]) -#define nfstov_type(a) ntov_type[fxdr_unsigned(u_int32_t,(a))&0x7] - -/* File types */ -typedef enum { - NFNON=0, NFREG=1, NFDIR=2, NFBLK=3, NFCHR=4, NFLNK=5 -} tcpdump_nfstype; - -/* Structs for common parts of the rpc's */ -struct nfsv2_time { - u_int32_t nfs_sec; - u_int32_t nfs_usec; -}; - -struct nqnfs_time { - u_int32_t nq_sec; - u_int32_t nq_nsec; -}; - -/* - * File attributes and setable attributes. These structures cover both - * NFS version 2 and the NQNFS protocol. Note that the union is only - * used to that one pointer can refer to both variants. These structures - * go out on the wire and must be densely packed, so no quad data types - * are used. (all fields are int32_t or u_int32_t's or structures of same) - * NB: You can't do sizeof(struct nfsv2_fattr), you must use the - * NFSX_FATTR(isnq) macro. - */ -struct nfsv2_fattr { - u_int32_t fa_type; - u_int32_t fa_mode; - u_int32_t fa_nlink; - u_int32_t fa_uid; - u_int32_t fa_gid; - union { - struct { - u_int32_t nfsfa_size; - u_int32_t nfsfa_blocksize; - u_int32_t nfsfa_rdev; - u_int32_t nfsfa_blocks; - u_int32_t nfsfa_fsid; - u_int32_t nfsfa_fileid; - struct nfsv2_time nfsfa_atime; - struct nfsv2_time nfsfa_mtime; - struct nfsv2_time nfsfa_ctime; - } fa_nfsv2; - struct { - struct { - u_int32_t nqfa_qsize[2]; - } nqfa_size; - u_int32_t nqfa_blocksize; - u_int32_t nqfa_rdev; - struct { - u_int32_t nqfa_qbytes[2]; - } nqfa_bytes; - u_int32_t nqfa_fsid; - u_int32_t nqfa_fileid; - struct nqnfs_time nqfa_atime; - struct nqnfs_time nqfa_mtime; - struct nqnfs_time nqfa_ctime; - u_int32_t nqfa_flags; - u_int32_t nqfa_gen; - struct { - u_int32_t nqfa_qfilerev[2]; - } nqfa_filerev; - } fa_nqnfs; - } fa_un; -}; - -/* and some ugly defines for accessing union components */ -#define fa_nfssize fa_un.fa_nfsv2.nfsfa_size -#define fa_nfsblocksize fa_un.fa_nfsv2.nfsfa_blocksize -#define fa_nfsrdev fa_un.fa_nfsv2.nfsfa_rdev -#define fa_nfsblocks fa_un.fa_nfsv2.nfsfa_blocks -#define fa_nfsfsid fa_un.fa_nfsv2.nfsfa_fsid -#define fa_nfsfileid fa_un.fa_nfsv2.nfsfa_fileid -#define fa_nfsatime fa_un.fa_nfsv2.nfsfa_atime -#define fa_nfsmtime fa_un.fa_nfsv2.nfsfa_mtime -#define fa_nfsctime fa_un.fa_nfsv2.nfsfa_ctime -#define fa_nqsize fa_un.fa_nqnfs.nqfa_size -#define fa_nqblocksize fa_un.fa_nqnfs.nqfa_blocksize -#define fa_nqrdev fa_un.fa_nqnfs.nqfa_rdev -#define fa_nqbytes fa_un.fa_nqnfs.nqfa_bytes -#define fa_nqfsid fa_un.fa_nqnfs.nqfa_fsid -#define fa_nqfileid fa_un.fa_nqnfs.nqfa_fileid -#define fa_nqatime fa_un.fa_nqnfs.nqfa_atime -#define fa_nqmtime fa_un.fa_nqnfs.nqfa_mtime -#define fa_nqctime fa_un.fa_nqnfs.nqfa_ctime -#define fa_nqflags fa_un.fa_nqnfs.nqfa_flags -#define fa_nqgen fa_un.fa_nqnfs.nqfa_gen -#define fa_nqfilerev fa_un.fa_nqnfs.nqfa_filerev - -struct nfsv2_sattr { - u_int32_t sa_mode; - u_int32_t sa_uid; - u_int32_t sa_gid; - union { - struct { - u_int32_t nfssa_size; - struct nfsv2_time nfssa_atime; - struct nfsv2_time nfssa_mtime; - } sa_nfsv2; - struct { - struct { - u_int32_t nqsa_qsize[2]; - } nqsa_size; - struct nqnfs_time nqsa_atime; - struct nqnfs_time nqsa_mtime; - u_int32_t nqsa_flags; - u_int32_t nqsa_rdev; - } sa_nqnfs; - } sa_un; -}; - -/* and some ugly defines for accessing the unions */ -#define sa_nfssize sa_un.sa_nfsv2.nfssa_size -#define sa_nfsatime sa_un.sa_nfsv2.nfssa_atime -#define sa_nfsmtime sa_un.sa_nfsv2.nfssa_mtime -#define sa_nqsize sa_un.sa_nqnfs.nqsa_size -#define sa_nqatime sa_un.sa_nqnfs.nqsa_atime -#define sa_nqmtime sa_un.sa_nqnfs.nqsa_mtime -#define sa_nqflags sa_un.sa_nqnfs.nqsa_flags -#define sa_nqrdev sa_un.sa_nqnfs.nqsa_rdev - -struct nfsv2_statfs { - u_int32_t sf_tsize; - u_int32_t sf_bsize; - u_int32_t sf_blocks; - u_int32_t sf_bfree; - u_int32_t sf_bavail; - u_int32_t sf_files; /* Nqnfs only */ - u_int32_t sf_ffree; /* ditto */ -}; diff --git a/parsenfsfh.c b/parsenfsfh.c index 59f26548..d709e8fe 100644 --- a/parsenfsfh.c +++ b/parsenfsfh.c @@ -9,7 +9,7 @@ #ifndef lint static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/parsenfsfh.c,v 1.14 1999-10-07 23:47:11 mcr Exp $ (LBL)"; + "@(#) $Header: /tcpdump/master/tcpdump/parsenfsfh.c,v 1.15 1999-11-21 05:43:50 assar Exp $ (LBL)"; #endif #include <sys/types.h> @@ -77,8 +77,9 @@ static const char rcsid[] = static int is_UCX(unsigned char *); void -Parse_fh(fh, fsidp, inop, osnamep, fsnamep, ourself) +Parse_fh(fh, len, fsidp, inop, osnamep, fsnamep, ourself) register caddr_t *fh; +int len; my_fsid *fsidp; ino_t *inop; char **osnamep; /* if non-NULL, return OS name here */ diff --git a/print-nfs.c b/print-nfs.c index 21703ba9..41c177eb 100644 --- a/print-nfs.c +++ b/print-nfs.c @@ -21,7 +21,7 @@ #ifndef lint static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.66 1999-10-17 21:37:14 mcr Exp $ (LBL)"; + "@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.67 1999-11-21 05:43:50 assar Exp $ (LBL)"; #endif #include <sys/param.h> @@ -49,24 +49,199 @@ struct rtentry; #include "interface.h" #include "addrtoname.h" -#include "nfsv2.h" +#include "nfs.h" #include "nfsfh.h" -static void nfs_printfh(const u_int32_t *); +static void nfs_printfh(const u_int32_t *, const u_int); static void xid_map_enter(const struct rpc_msg *, const struct ip *); -static u_int32_t xid_map_find(const struct rpc_msg *, const struct ip *, - u_int32_t *); -static void interp_reply(const struct rpc_msg *, u_int32_t, u_int); +static int32_t xid_map_find(const struct rpc_msg *, const struct ip *, + u_int32_t *, u_int32_t *); +static void interp_reply(const struct rpc_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); + +/* + * Mapping of old NFS Version 2 RPC numbers to generic numbers. + */ +u_int32_t nfsv3_procid[NFS_NPROCS] = { + NFSPROC_NULL, + NFSPROC_GETATTR, + NFSPROC_SETATTR, + NFSPROC_NOOP, + NFSPROC_LOOKUP, + NFSPROC_READLINK, + NFSPROC_READ, + NFSPROC_NOOP, + NFSPROC_WRITE, + NFSPROC_CREATE, + NFSPROC_REMOVE, + NFSPROC_RENAME, + NFSPROC_LINK, + NFSPROC_SYMLINK, + NFSPROC_MKDIR, + NFSPROC_RMDIR, + NFSPROC_READDIR, + NFSPROC_FSSTAT, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP, + NFSPROC_NOOP +}; + +const char *nfsv3_writemodes[NFSV3WRITE_NMODES] = { + "unstable", + "datasync", + "filesync" +}; + +static struct tok type2str[] = { + { NFNON, "NON" }, + { NFREG, "REG" }, + { NFDIR, "DIR" }, + { NFBLK, "BLK" }, + { NFCHR, "CHR" }, + { NFLNK, "LNK" }, + { NFFIFO, "FIFO" }, + { 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. + * + * Assume that a system that has INT64_FORMAT defined, has a 64-bit + * integer datatype and can print it. + */ + +#define UNSIGNED 0 +#define SIGNED 1 +#define HEX 2 + +static int print_int64(const u_int32_t *dp, int how) +{ +#ifdef INT64_FORMAT + u_int64_t res; + + res = ((u_int64_t)ntohl(dp[0]) << 32) | (u_int64_t)ntohl(dp[1]); + switch (how) { + case SIGNED: + printf(INT64_FORMAT, res); + break; + case UNSIGNED: + printf(U_INT64_FORMAT, res); + break; + case HEX: + printf(HEX_INT64_FORMAT, res); + break; + default: + return (0); + } +#else + switch (how) { + case SIGNED : + case UNSIGNED : + case HEX : + printf ("0x%x%x", dp[0], dp[1]); + break; + default : + return (0); + } +#endif + return 1; +} + +static const u_int32_t * +parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3) +{ + register const u_int32_t *ep = (u_int32_t *)snapend; + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_modeset = ntohl(*dp++))) { + if (dp + 1 > ep) + return (0); + sa3->sa_mode = ntohl(*dp++); + } + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_uidset = ntohl(*dp++))) { + if (dp + 1 > ep) + return (0); + sa3->sa_uid = ntohl(*dp++); + } + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_gidset = ntohl(*dp++))) { + if (dp + 1 > ep) + return (0); + sa3->sa_gid = ntohl(*dp++); + } + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_sizeset = ntohl(*dp++))) { + if (dp + 1 > ep) + return (0); + sa3->sa_size = ntohl(*dp++); + } + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_atimetype = ntohl(*dp++)) == NFSV3SATTRTIME_TOCLIENT) { + if (dp + 2 > ep) + return (0); + sa3->sa_atime.nfsv3_sec = ntohl(*dp++); + sa3->sa_atime.nfsv3_nsec = ntohl(*dp++); + } + + if (dp + 1 > ep) + return (0); + if ((sa3->sa_mtimetype = ntohl(*dp++)) == NFSV3SATTRTIME_TOCLIENT) { + if (dp + 2 > ep) + return (0); + sa3->sa_mtime.nfsv3_sec = ntohl(*dp++); + sa3->sa_mtime.nfsv3_nsec = ntohl(*dp++); + } + + return dp; +} static int nfserr; /* true if we error rather than trunc */ +static void +print_sattr3(const struct nfsv3_sattr *sa3, int verbose) +{ + if (sa3->sa_modeset) + printf(" mode %o", sa3->sa_mode); + if (sa3->sa_uidset) + printf(" uid %u", sa3->sa_uid); + if (sa3->sa_gidset) + printf(" gid %u", sa3->sa_gid); + if (verbose > 1) { + if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) + printf(" 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, + sa3->sa_mtime.nfsv3_nsec); + } +} + void nfsreply_print(register const u_char *bp, u_int length, register const u_char *bp2) { register const struct rpc_msg *rp; register const struct ip *ip; - u_int32_t proc; + u_int32_t proc, vers; nfserr = 0; /* assume no error */ rp = (const struct rpc_msg *)bp; @@ -90,8 +265,8 @@ nfsreply_print(register const u_char *bp, u_int length, "ok":"ERR", length); - if (xid_map_find(rp, ip, &proc)) - interp_reply(rp, proc, length); + if (xid_map_find(rp, ip, &proc, &vers) >= 0) + interp_reply(rp, proc, vers, length); } /* @@ -129,11 +304,21 @@ trunc: * If packet was truncated, return 0. */ static const u_int32_t * -parsefh(register const u_int32_t *dp) +parsefh(register const u_int32_t *dp, int v3) { - if (dp + 8 <= (u_int32_t *)snapend) { - nfs_printfh(dp); - return (dp + 8); + int len; + + if (v3) { + if (dp + 1 > (u_int32_t *)snapend) + return (0); + len = (int)ntohl(*dp) / 4; + dp++; + } else + len = NFSX_V2FH / 4; + + if (dp + len <= (u_int32_t *)snapend) { + nfs_printfh(dp, len); + return (dp + len); } return (NULL); } @@ -175,9 +360,9 @@ parsefn(register const u_int32_t *dp) * If packet was truncated (or there was some other error), return 0. */ static const u_int32_t * -parsefhn(register const u_int32_t *dp) +parsefhn(register const u_int32_t *dp, int v3) { - dp = parsefh(dp); + dp = parsefh(dp, v3); if (dp == NULL) return (NULL); putchar(' '); @@ -191,6 +376,10 @@ nfsreq_print(register const u_char *bp, u_int length, register const struct rpc_msg *rp; register const struct ip *ip; register const u_int32_t *dp; + nfstype type; + int v3; + u_int32_t proc; + struct nfsv3_sattr sa3; nfserr = 0; /* assume no error */ rp = (const struct rpc_msg *)bp; @@ -211,162 +400,259 @@ nfsreq_print(register const u_char *bp, u_int length, xid_map_enter(rp, ip); /* record proc number for later on */ - switch (ntohl(rp->rm_call.cb_proc)) { -#ifdef NFSPROC_NOOP + v3 = (ntohl(rp->rm_call.cb_vers) == NFS_VER3); + proc = ntohl(rp->rm_call.cb_proc); + + if (!v3 && proc < NFS_NPROCS) + proc = nfsv3_procid[proc]; + + switch (proc) { case NFSPROC_NOOP: printf(" nop"); return; -#else -#define NFSPROC_NOOP -1 -#endif case NFSPROC_NULL: printf(" null"); return; case NFSPROC_GETATTR: printf(" getattr"); - if ((dp = parsereq(rp, length)) != NULL && parsefh(dp) != NULL) + 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) != NULL) + if ((dp = parsereq(rp, length)) != NULL && + parsefh(dp, v3) != NULL) return; break; -#if NFSPROC_ROOT != NFSPROC_NOOP - case NFSPROC_ROOT: - printf(" root"); - break; -#endif case NFSPROC_LOOKUP: printf(" lookup"); - if ((dp = parsereq(rp, length)) != NULL && parsefhn(dp) != NULL) + if ((dp = parsereq(rp, length)) != NULL && + parsefhn(dp, v3) != NULL) return; break; + case NFSPROC_ACCESS: + printf(" access"); + if ((dp = parsereq(rp, length)) != NULL && + (dp = parsefh(dp, v3)) != NULL) { + TCHECK2(dp[0], 4); + printf(" %04x", ntohl(dp[0])); + return; + } + break; + case NFSPROC_READLINK: printf(" readlink"); - if ((dp = parsereq(rp, length)) != NULL && parsefh(dp) != NULL) + 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)) != NULL) { + (dp = parsefh(dp, v3)) != NULL) { + if (v3) { TCHECK2(dp[0], 3 * sizeof(*dp)); + printf(" %u bytes @ ", + (u_int32_t) ntohl(dp[2])); + print_int64(dp, UNSIGNED); + } else { + TCHECK2(dp[0], 2 * sizeof(*dp)); printf(" %u bytes @ %u", (u_int32_t)ntohl(dp[1]), (u_int32_t)ntohl(dp[0])); - return; } - break; - -#if NFSPROC_WRITECACHE != NFSPROC_NOOP - case NFSPROC_WRITECACHE: - printf(" writecache"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp)) != NULL) { - TCHECK2(dp[0], 4 * sizeof(*dp)); - printf(" %u (%u) bytes @ %u (%u)", - (u_int32_t)ntohl(dp[3]), - (u_int32_t)ntohl(dp[2]), - (u_int32_t)ntohl(dp[1]), - (u_int32_t)ntohl(dp[0])); return; } break; -#endif + case NFSPROC_WRITE: printf(" write"); if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp)) != NULL) { + (dp = parsefh(dp, v3)) != NULL) { + if (v3) { + TCHECK2(dp[0], 3 * sizeof(*dp)); + printf(" %u bytes @ ", + (u_int32_t) ntohl(dp[4])); + print_int64(dp, UNSIGNED); + if (vflag) { + dp += 3; + TCHECK2(dp[0], sizeof(*dp)); + printf(" <%s>", + nfsv3_writemodes[ntohl(*dp)]); + } + } else { TCHECK2(dp[0], 4 * sizeof(*dp)); printf(" %u (%u) bytes @ %u (%u)", (u_int32_t)ntohl(dp[3]), (u_int32_t)ntohl(dp[2]), (u_int32_t)ntohl(dp[1]), (u_int32_t)ntohl(dp[0])); + } return; } break; case NFSPROC_CREATE: printf(" create"); - if ((dp = parsereq(rp, length)) != NULL && parsefhn(dp) != NULL) + if ((dp = parsereq(rp, length)) != NULL && + parsefhn(dp, v3) != NULL) return; break; - case NFSPROC_REMOVE: - printf(" remove"); - if ((dp = parsereq(rp, length)) != NULL && parsefhn(dp) != NULL) + case NFSPROC_MKDIR: + printf(" mkdir"); + if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0) return; break; - case NFSPROC_RENAME: - printf(" rename"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefhn(dp)) != NULL) { + case NFSPROC_SYMLINK: + printf(" symlink"); + if ((dp = parsereq(rp, length)) != 0 && + (dp = parsefhn(dp, v3)) != 0) { fputs(" ->", stdout); - if (parsefhn(dp) != NULL) + if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0) + break; + if (parsefn(dp) == 0) + break; + if (v3 && vflag) + print_sattr3(&sa3, vflag); return; } break; - case NFSPROC_LINK: - printf(" link"); - if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp)) != NULL) { - fputs(" ->", stdout); - if (parsefhn(dp) != NULL) + case NFSPROC_MKNOD: + printf(" mknod"); + if ((dp = parsereq(rp, length)) != 0 && + (dp = parsefhn(dp, v3)) != 0) { + if (dp + 1 > (u_int32_t *)snapend) + break; + type = (nfstype)ntohl(*dp++); + if ((dp = parse_sattr3(dp, &sa3)) == 0) + break; + printf(" %s", tok2str(type2str, "unk-ft %d", type)); + if (vflag && (type == NFCHR || type == NFBLK)) { + if (dp + 2 > (u_int32_t *)snapend) + break; + printf(" %u/%u", ntohl(dp[0]), ntohl(dp[1])); + dp += 2; + } + if (vflag) + print_sattr3(&sa3, vflag); return; } break; - case NFSPROC_SYMLINK: - printf(" symlink"); + case NFSPROC_REMOVE: + printf(" remove"); if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefhn(dp)) != NULL) { - fputs(" -> ", stdout); - if (parsefn(dp) != NULL) + parsefhn(dp, v3) != NULL) return; - } break; - case NFSPROC_MKDIR: - printf(" mkdir"); - if ((dp = parsereq(rp, length)) != NULL && parsefhn(dp) != NULL) + case NFSPROC_RMDIR: + printf(" rmdir"); + 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) != NULL) + case NFSPROC_RENAME: + printf(" rename"); + if ((dp = parsereq(rp, length)) != NULL && + (dp = parsefhn(dp, v3)) != NULL) { + fputs(" ->", stdout); + if (parsefhn(dp, v3) != NULL) + return; + } + 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; + } break; case NFSPROC_READDIR: printf(" readdir"); if ((dp = parsereq(rp, length)) != NULL && - (dp = parsefh(dp)) != NULL) { + (dp = parsefh(dp, v3)) != NULL) { + if (v3) { + TCHECK2(dp[0], 20); + /* + * We shouldn't really try to interpret the + * offset cookie here. + */ + printf(" %u bytes @ ", + (u_int32_t) ntohl(dp[4])); + print_int64(dp, SIGNED); + if (vflag) + printf(" verf %08x%08x", dp[2], + dp[3]); + } else { TCHECK2(dp[0], 2 * sizeof(*dp)); /* - * Print the offset as signed, since -1 is common, - * but offsets > 2^31 aren't. + * Print the offset as signed, since -1 is + * common, but offsets > 2^31 aren't. */ printf(" %u bytes @ %d", (u_int32_t)ntohl(dp[1]), (u_int32_t)ntohl(dp[0])); + } return; } break; - case NFSPROC_STATFS: - printf(" statfs"); - if ((dp = parsereq(rp, length)) != NULL && parsefh(dp) != NULL) + case NFSPROC_READDIRPLUS: + printf(" readdirplus"); + if ((dp = parsereq(rp, length)) != NULL && + (dp = parsefh(dp, v3)) != NULL) { + TCHECK2(dp[0], 20); + /* + * We don't try to interpret the offset + * cookie here. + */ + printf(" %u bytes @ ", (u_int32_t) ntohl(dp[4])); + print_int64(dp, SIGNED); + if (vflag) + printf(" max %u verf %08x%08x", + (u_int32_t) ntohl(dp[5]), dp[2], dp[3]); + return; + } + break; + + case NFSPROC_FSSTAT: + printf(" fsstat"); + if ((dp = parsereq(rp, length)) != NULL && + parsefh(dp, v3) != NULL) + return; + break; + + case NFSPROC_FSINFO: + printf(" fsinfo"); + break; + + case NFSPROC_PATHCONF: + printf(" pathconf"); + break; + + case NFSPROC_COMMIT: + printf(" commit"); + if ((dp = parsereq(rp, length)) != NULL && + (dp = parsefh(dp, v3)) != NULL) { + printf(" %u bytes @ ", (u_int32_t) ntohl(dp[2])); + print_int64(dp, UNSIGNED); return; + } break; default: @@ -388,29 +674,31 @@ trunc: * additional hacking on the parser code. */ static void -nfs_printfh(register const u_int32_t *dp) +nfs_printfh(register const u_int32_t *dp, const u_int len) { my_fsid fsid; ino_t ino; char *sfsname = NULL; - Parse_fh((caddr_t *)dp, &fsid, &ino, NULL, &sfsname, 0); + Parse_fh((caddr_t*)dp, len, &fsid, &ino, NULL, &sfsname, 0); if (sfsname) { /* file system ID is ASCII, not numeric, for this server OS */ - static char temp[NFS_FHSIZE+1]; + static char temp[NFSX_V3FHMAX+1]; /* Make sure string is null-terminated */ - strncpy(temp, sfsname, NFS_FHSIZE); + strncpy(temp, sfsname, NFSX_V3FHMAX); /* Remove trailing spaces */ sfsname = strchr(temp, ' '); if (sfsname) *sfsname = 0; - (void)printf(" fh %s/%u", temp, (u_int32_t)ino); - } else { - (void)printf(" fh %u,%u/%u", - fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor, (u_int32_t)ino); + (void)printf(" fh %s/%ld", temp, (long) ino); + } + else { + (void)printf(" fh %d,%d/%ld", + fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor, + (long) ino); } } @@ -425,6 +713,7 @@ struct xid_map_entry { struct in_addr client; /* client IP address (net order) */ struct in_addr server; /* server IP address (net order) */ u_int32_t proc; /* call proc number (host order) */ + u_int32_t vers; /* program version (host order) */ }; /* @@ -454,11 +743,13 @@ xid_map_enter(const struct rpc_msg *rp, const struct ip *ip) xmep->client = ip->ip_src; xmep->server = ip->ip_dst; xmep->proc = ntohl(rp->rm_call.cb_proc); + xmep->vers = ntohl(rp->rm_call.cb_vers); } -/* Returns true and sets proc success or false on failure */ -static u_int32_t -xid_map_find(const struct rpc_msg *rp, const struct ip *ip, u_int32_t *proc) +/* Returns NFSPROC_xxx or -1 on failure */ +static int +xid_map_find(const struct rpc_msg *rp, const struct ip *ip, u_int32_t *proc, + u_int32_t *vers) { int i; struct xid_map_entry *xmep; @@ -475,7 +766,8 @@ xid_map_find(const struct rpc_msg *rp, const struct ip *ip, u_int32_t *proc) /* match */ xid_map_hint = i; *proc = xmep->proc; - return (1); + *vers = xmep->vers; + return 1; } if (++i >= XIDMAPSIZE) i = 0; @@ -568,131 +860,195 @@ parserep(register const struct rpc_msg *rp, register u_int length) /* successful return */ if ((sizeof(astat) + ((u_char *)dp)) < snapend) return ((u_int32_t *) (sizeof(astat) + ((char *)dp))); - trunc: - return (NULL); + return (0); } -static const u_int32_t * -parsestatus(const u_int32_t *dp) +#define T2CHECK(p, l) if ((u_char *)(p) > ((u_char *)snapend) - l) return(0) + +/* + * Not all systems have strerror(). + */ +static const char * +strerr(int errno) { - register int errnum; + return (strerror(errno)); +} - TCHECK(dp[0]); - errnum = ntohl(dp[0]); - if (errnum != 0) { - if (!qflag) - printf(" ERROR: %s", pcap_strerror(errnum)); - nfserr = 1; /* suppress trunc string */ - return (NULL); +static const u_int32_t * +parsestatus(const u_int32_t *dp, int *er) +{ + int errno; + T2CHECK(dp, 4); + + errno = ntohl(dp[0]); + if (er) + *er = errno; + if (errno != 0 && !qflag) { + const char *errmsg; + + errmsg = strerr(errno); + if (errmsg) + printf(" ERROR: '%s'", errmsg); + else + printf(" ERROR: %d", errno); } return (dp + 1); -trunc: - return (NULL); } -static struct tok type2str[] = { - { NFNON, "NON" }, - { NFREG, "REG" }, - { NFDIR, "DIR" }, - { NFBLK, "BLK" }, - { NFCHR, "CHR" }, - { NFLNK, "LNK" }, - { 0, NULL } -}; - static const u_int32_t * -parsefattr(const u_int32_t *dp, int verbose) +parsefattr(const u_int32_t *dp, int verbose, int v3) { - const struct nfsv2_fattr *fap; + const struct nfs_fattr *fap; + + T2CHECK(dp, 5 * sizeof(*dp)); - fap = (const struct nfsv2_fattr *)dp; + fap = (const struct nfs_fattr *)dp; if (verbose) { - TCHECK(fap->fa_nfssize); - printf(" %s %o ids %u/%u sz %u ", + printf(" %s %o ids %d/%d", tok2str(type2str, "unk-ft %d ", (u_int32_t)ntohl(fap->fa_type)), (u_int32_t)ntohl(fap->fa_mode), (u_int32_t)ntohl(fap->fa_uid), - (u_int32_t)ntohl(fap->fa_gid), - (u_int32_t)ntohl(fap->fa_nfssize)); + (u_int32_t) ntohl(fap->fa_gid)); + if (v3) { + T2CHECK(dp, 7 * sizeof(*dp)); + printf(" sz "); + print_int64((u_int32_t *)&fap->fa3_size, UNSIGNED); + putchar(' '); + } + else { + T2CHECK(dp, 6 * sizeof(*dp)); + printf(" sz %d ", (u_int32_t) ntohl(fap->fa2_size)); + } } /* print lots more stuff */ if (verbose > 1) { - TCHECK(fap->fa_nfsfileid); - printf("nlink %u rdev %x fsid %x nodeid %x a/m/ctime ", + if (v3) { + T2CHECK(dp, 64); + printf("nlink %d rdev %d/%d ", (u_int32_t)ntohl(fap->fa_nlink), - (u_int32_t)ntohl(fap->fa_nfsrdev), - (u_int32_t)ntohl(fap->fa_nfsfsid), - (u_int32_t)ntohl(fap->fa_nfsfileid)); - TCHECK(fap->fa_nfsatime); + (u_int32_t) ntohl(fap->fa3_rdev.specdata1), + (u_int32_t) ntohl(fap->fa3_rdev.specdata2)); + printf("fsid "); + print_int64((u_int32_t *)&fap->fa2_fsid, HEX); + printf(" nodeid "); + print_int64((u_int32_t *)&fap->fa2_fileid, HEX); + printf(" a/m/ctime %u.%06u ", + (u_int32_t) ntohl(fap->fa3_atime.nfsv3_sec), + (u_int32_t) ntohl(fap->fa3_atime.nfsv3_nsec)); printf("%u.%06u ", - (u_int32_t)ntohl(fap->fa_nfsatime.nfs_sec), - (u_int32_t)ntohl(fap->fa_nfsatime.nfs_usec)); - TCHECK(fap->fa_nfsmtime); + (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_sec), + (u_int32_t) ntohl(fap->fa3_mtime.nfsv3_nsec)); printf("%u.%06u ", - (u_int32_t)ntohl(fap->fa_nfsmtime.nfs_sec), - (u_int32_t)ntohl(fap->fa_nfsmtime.nfs_usec)); - TCHECK(fap->fa_nfsctime); + (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_sec), + (u_int32_t) ntohl(fap->fa3_ctime.nfsv3_nsec)); + } else { + T2CHECK(dp, 48); + printf("nlink %d rdev %x fsid %x nodeid %x a/m/ctime ", + (u_int32_t) ntohl(fap->fa_nlink), + (u_int32_t) ntohl(fap->fa2_rdev), + (u_int32_t) ntohl(fap->fa2_fsid), + (u_int32_t) ntohl(fap->fa2_fileid)); printf("%u.%06u ", - (u_int32_t)ntohl(fap->fa_nfsctime.nfs_sec), - (u_int32_t)ntohl(fap->fa_nfsctime.nfs_usec)); + (u_int32_t) ntohl(fap->fa2_atime.nfsv2_sec), + (u_int32_t) ntohl(fap->fa2_atime.nfsv2_usec)); + printf("%u.%06u ", + (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_sec), + (u_int32_t) ntohl(fap->fa2_mtime.nfsv2_usec)); + printf("%u.%06u ", + (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_sec), + (u_int32_t) ntohl(fap->fa2_ctime.nfsv2_usec)); } - return ((const u_int32_t *)&fap[1]); -trunc: - return (NULL); + } + return ((const u_int32_t *)((unsigned char *)dp + + (v3 ? NFSX_V3FATTR : NFSX_V2FATTR))); } static int -parseattrstat(const u_int32_t *dp, int verbose) +parseattrstat(const u_int32_t *dp, int verbose, int v3) { + int er; - dp = parsestatus(dp); - if (dp == NULL) + dp = parsestatus(dp, &er); + if (dp == NULL || er) return (0); - return (parsefattr(dp, verbose) != NULL); + return (parsefattr(dp, verbose, v3) != NULL); } static int parsediropres(const u_int32_t *dp) { + int er; - dp = parsestatus(dp); - if (dp == NULL) + if (!(dp = parsestatus(dp, &er)) || er) return (0); - dp = parsefh(dp); + dp = parsefh(dp, 0); if (dp == NULL) return (0); - return (parsefattr(dp, vflag) != NULL); + return (parsefattr(dp, vflag, 0) != NULL); } static int -parselinkres(const u_int32_t *dp) +parselinkres(const u_int32_t *dp, int v3) { - dp = parsestatus(dp); - if (dp == NULL) - return (0); + int er; + dp = parsestatus(dp, &er); + if (dp == NULL || er) + return(0); + if (v3 && !(dp = parse_post_op_attr(dp, vflag))) + return (0); putchar(' '); return (parsefn(dp) != NULL); } static int -parsestatfs(const u_int32_t *dp) +parsestatfs(const u_int32_t *dp, int v3) { - const struct nfsv2_statfs *sfsp; + const struct nfs_statfs *sfsp; + int er; - dp = parsestatus(dp); - if (dp == NULL) + dp = parsestatus(dp, &er); + if (dp == NULL || (!v3 && er)) return (0); - if (!qflag) { - sfsp = (const struct nfsv2_statfs *)dp; - TCHECK(sfsp->sf_bavail); - printf(" tsize %u bsize %u blocks %u bfree %u bavail %u", + if (qflag) + return(1); + + if (v3) { + if (vflag) + printf(" POST:"); + if (!(dp = parse_post_op_attr(dp, vflag))) + return (0); + } + + T2CHECK(dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS)); + + 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); + 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", + (u_int32_t) ntohl(sfsp->sf_invarsec)); + } + } else { + printf(" tsize %d bsize %d blocks %d bfree %d bavail %d", (u_int32_t)ntohl(sfsp->sf_tsize), (u_int32_t)ntohl(sfsp->sf_bsize), (u_int32_t)ntohl(sfsp->sf_blocks), @@ -701,45 +1057,227 @@ parsestatfs(const u_int32_t *dp) } return (1); -trunc: - return (0); } static int parserddires(const u_int32_t *dp) { - dp = parsestatus(dp); - if (dp == NULL) + int er; + + dp = parsestatus(dp, &er); + if (dp == 0 || er) return (0); - if (!qflag) { - TCHECK(dp[0]); - printf(" offset %x", (u_int32_t)ntohl(dp[0])); - TCHECK(dp[1]); - printf(" size %u", (u_int32_t)ntohl(dp[1])); - TCHECK(dp[2]); + if (qflag) + return (1); + + T2CHECK(dp, 12); + printf(" offset %x size %d ", ntohl(dp[0]), ntohl(dp[1])); if (dp[2] != 0) printf(" eof"); + + return (1); +} + +static const u_int32_t * +parse_wcc_attr(const u_int32_t *dp) +{ + printf(" sz "); + print_int64(dp, UNSIGNED); + printf(" mtime %u.%06u ctime %u.%06u", ntohl(dp[2]), ntohl(dp[3]), + ntohl(dp[4]), ntohl(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) +{ + T2CHECK(dp, 4); + if (!ntohl(dp[0])) + return (dp + 1); + dp++; + T2CHECK(dp, 24); + if (verbose > 1) { + return parse_wcc_attr(dp); + } else { + /* If not verbose enough, just skip over wcc_attr */ + return (dp + 6); } +} +/* + * Post operation attributes are printed if vflag >= 1 + */ +static const u_int32_t * +parse_post_op_attr(const u_int32_t *dp, int verbose) +{ + T2CHECK(dp, 4); + if (!ntohl(dp[0])) + return (dp + 1); + dp++; + if (verbose) { + return parsefattr(dp, verbose, 1); + } else + return (dp + (NFSX_V3FATTR / sizeof (u_int32_t))); +} + +static const u_int32_t * +parse_wcc_data(const u_int32_t *dp, int verbose) +{ + if (verbose > 1) + printf(" PRE:"); + if (!(dp = parse_pre_op_attr(dp, verbose))) + return (0); + + if (verbose) + printf(" POST:"); + return parse_post_op_attr(dp, verbose); +} + +static const u_int32_t * +parsecreateopres(const u_int32_t *dp, int verbose) +{ + int er; + + if (!(dp = parsestatus(dp, &er))) + return (0); + if (er) + dp = parse_wcc_data(dp, verbose); + else { + T2CHECK(dp, 4); + if (!ntohl(dp[0])) + return (dp + 1); + dp++; + if (!(dp = parsefh(dp, 1))) + return (0); + if (verbose) { + if (!(dp = parse_post_op_attr(dp, verbose))) + return (0); + if (vflag > 1) { + printf("dir attr:"); + dp = parse_wcc_data(dp, verbose); + } + } + } + return (dp); +} + +static int +parsewccres(const u_int32_t *dp, int verbose) +{ + int er; + + if (!(dp = parsestatus(dp, &er))) + return (0); + return parse_wcc_data(dp, verbose) != 0; +} + +static const u_int32_t * +parsev3rddirres(const u_int32_t *dp, int verbose) +{ + int er; + + if (!(dp = parsestatus(dp, &er))) + return (0); + if (vflag) + printf(" POST:"); + if (!(dp = parse_post_op_attr(dp, verbose))) + return (0); + if (er) + return dp; + if (vflag) { + T2CHECK(dp, 8); + printf(" verf %08x%08x", dp[0], dp[1]); + dp += 2; + } + return dp; + } + +static int +parsefsinfo(const u_int32_t *dp) +{ + struct nfsv3_fsinfo *sfp; + int er; + + if (!(dp = parsestatus(dp, &er))) + return (0); + if (vflag) + printf(" POST:"); + if (!(dp = parse_post_op_attr(dp, vflag))) + return (0); + if (er) return (1); -trunc: + + T2CHECK(dp, sizeof (struct nfsv3_fsinfo)); + + sfp = (struct nfsv3_fsinfo *)dp; + printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u", + (u_int32_t) ntohl(sfp->fs_rtmax), + (u_int32_t) ntohl(sfp->fs_rtpref), + (u_int32_t) ntohl(sfp->fs_wtmax), + (u_int32_t) ntohl(sfp->fs_wtpref), + (u_int32_t) ntohl(sfp->fs_dtpref)); + if (vflag) { + printf(" rtmult %u wtmult %u maxfsz ", + (u_int32_t) ntohl(sfp->fs_rtmult), + (u_int32_t) ntohl(sfp->fs_wtmult)); + print_int64((u_int32_t *)&sfp->fs_maxfilesize, UNSIGNED); + printf(" delta %u.%06u ", + (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_sec), + (u_int32_t) ntohl(sfp->fs_timedelta.nfsv3_nsec)); + } + return (1); +} + +static int +parsepathconf(const u_int32_t *dp) +{ + int er; + struct nfsv3_pathconf *spp; + + if (!(dp = parsestatus(dp, &er))) + return (0); + if (vflag) + printf(" POST:"); + if (!(dp = parse_post_op_attr(dp, vflag))) + return (0); + if (er) + return (1); + + T2CHECK(dp, sizeof (struct nfsv3_pathconf)); + + spp = (struct nfsv3_pathconf *)dp; + + printf(" linkmax %u namemax %u %s %s %s %s", + (u_int32_t) ntohl(spp->pc_linkmax), + (u_int32_t) ntohl(spp->pc_namemax), + ntohl(spp->pc_notrunc) ? "notrunc" : "", + ntohl(spp->pc_chownrestricted) ? "chownres" : "", + ntohl(spp->pc_caseinsensitive) ? "igncase" : "", + ntohl(spp->pc_casepreserving) ? "keepcase" : ""); return (0); } static void -interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int length) +interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int32_t vers, int length) { register const u_int32_t *dp; + register int v3; + int er; + + v3 = (vers == NFS_VER3); + + if (!v3 && proc < NFS_NPROCS) + proc = nfsv3_procid[proc]; switch (proc) { -#ifdef NFSPROC_NOOP case NFSPROC_NOOP: printf(" nop"); return; -#else -#define NFSPROC_NOOP -1 -#endif + case NFSPROC_NULL: printf(" null"); return; @@ -747,115 +1285,286 @@ interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int length) case NFSPROC_GETATTR: printf(" getattr"); dp = parserep(rp, length); - if (dp != NULL && parseattrstat(dp, !qflag) != 0) + if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0) return; break; case NFSPROC_SETATTR: printf(" setattr"); - dp = parserep(rp, length); - if (dp != NULL && parseattrstat(dp, !qflag) != 0) + if (!(dp = parserep(rp, length))) + return; + if (v3) { + if (parsewccres(dp, vflag)) + return; + } else { + if (parseattrstat(dp, !qflag, 0) != 0) return; + } break; -#if NFSPROC_ROOT != NFSPROC_NOOP - case NFSPROC_ROOT: - printf(" root"); - break; -#endif case NFSPROC_LOOKUP: printf(" lookup"); - dp = parserep(rp, length); - if (dp != NULL && parsediropres(dp) != 0) + if (!(dp = parserep(rp, length))) + break; + if (v3) { + if (!(dp = parsestatus(dp, &er))) + break; + if (er) { + if (vflag > 1) { + printf(" post dattr:"); + dp = parse_post_op_attr(dp, vflag); + } + } 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); + } + } + if (dp) + return; + } else { + if (parsediropres(dp) != 0) return; + } break; + case NFSPROC_ACCESS: + printf(" access"); + dp = parserep(rp, length); + if (!(dp = parsestatus(dp, &er))) + break; + if (vflag) + printf(" attr:"); + if (!(dp = parse_post_op_attr(dp, vflag))) + break; + if (!er) + printf(" c %04x", ntohl(dp[0])); + return; + case NFSPROC_READLINK: printf(" readlink"); dp = parserep(rp, length); - if (dp != NULL && parselinkres(dp) != 0) + if (dp != NULL && parselinkres(dp, v3) != 0) return; break; case NFSPROC_READ: printf(" read"); - dp = parserep(rp, length); - if (dp != NULL && parseattrstat(dp, vflag) != 0) + if (!(dp = parserep(rp, length))) + break; + if (v3) { + if (!(dp = parsestatus(dp, &er))) + break; + if (!(dp = parse_post_op_attr(dp, vflag))) + break; + if (er) + return; + if (vflag) { + TCHECK2(dp[0], 8); + printf("%u bytes", (u_int32_t) ntohl(dp[0])); + if (ntohl(dp[1])) + printf(" EOF"); + } + return; + } else { + if (parseattrstat(dp, vflag, 0) != 0) return; + } break; -#if NFSPROC_WRITECACHE != NFSPROC_NOOP - case NFSPROC_WRITECACHE: - printf(" writecache"); - break; -#endif case NFSPROC_WRITE: printf(" write"); - dp = parserep(rp, length); - if (dp != NULL && parseattrstat(dp, vflag) != 0) + if (!(dp = parserep(rp, length))) + break; + if (v3) { + if (!(dp = parsestatus(dp, &er))) + break; + if (!(dp = parse_wcc_data(dp, vflag))) + break; + if (er) return; + if (vflag) { + TCHECK2(dp[0], 4); + printf("%u bytes", (u_int32_t) ntohl(dp[0])); + if (vflag > 1) { + TCHECK2(dp[0], 4); + printf(" <%s>", + nfsv3_writemodes[ntohl(dp[1])]); + } + return; + } + } else { + if (parseattrstat(dp, vflag, v3) != 0) + return; + } break; case NFSPROC_CREATE: printf(" create"); - dp = parserep(rp, length); - if (dp != NULL && parsediropres(dp) != 0) + 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; + if (v3) { + if (parsecreateopres(dp, vflag) != 0) + return; + } else { + if (parsediropres(dp) != 0) + return; + } + break; + + case NFSPROC_SYMLINK: + printf(" symlink"); + if (!(dp = parserep(rp, length))) + break; + if (v3) { + if (parsecreateopres(dp, vflag) != 0) + return; + } else { + if (parsestatus(dp, &er) != 0) + return; + } + break; + + case NFSPROC_MKNOD: + printf(" mknod"); + if (!(dp = parserep(rp, length))) + break; + if (parsecreateopres(dp, vflag) != 0) return; break; case NFSPROC_REMOVE: printf(" remove"); - dp = parserep(rp, length); - if (dp != NULL && parsestatus(dp) != 0) + 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; + if (v3) { + if (parsewccres(dp, vflag)) + return; + } else { + if (parsestatus(dp, &er) != 0) return; + } break; case NFSPROC_RENAME: printf(" rename"); - dp = parserep(rp, length); - if (dp != NULL && parsestatus(dp) != 0) + if (!(dp = parserep(rp, length))) + break; + 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; + } return; + } else { + if (parsestatus(dp, &er) != 0) + return; + } break; case NFSPROC_LINK: printf(" link"); - dp = parserep(rp, length); - if (dp != NULL && parsestatus(dp) != 0) + if (!(dp = parserep(rp, length))) + break; + 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; + } + } else { + if (parsestatus(dp, &er) != 0) return; + } break; - case NFSPROC_SYMLINK: - printf(" symlink"); - dp = parserep(rp, length); - if (dp != NULL && parsestatus(dp) != 0) + case NFSPROC_READDIR: + printf(" readdir"); + if (!(dp = parserep(rp, length))) + break; + if (v3) { + if (parsev3rddirres(dp, vflag)) + return; + } else { + if (parserddires(dp) != 0) return; + } break; - case NFSPROC_MKDIR: - printf(" mkdir"); + case NFSPROC_READDIRPLUS: + printf(" readdirplus"); + if (!(dp = parserep(rp, length))) + break; + if (parsev3rddirres(dp, vflag)) + return; + break; + + case NFSPROC_FSSTAT: + printf(" fsstat"); dp = parserep(rp, length); - if (dp != NULL && parsediropres(dp) != 0) + if (dp != NULL && parsestatfs(dp, v3) != 0) return; break; - case NFSPROC_RMDIR: - printf(" rmdir"); + case NFSPROC_FSINFO: + printf(" fsinfo"); dp = parserep(rp, length); - if (dp != NULL && parsestatus(dp) != 0) + if (dp != NULL && parsefsinfo(dp) != 0) return; break; - case NFSPROC_READDIR: - printf(" readdir"); + case NFSPROC_PATHCONF: + printf(" pathconf"); dp = parserep(rp, length); - if (dp != NULL && parserddires(dp) != 0) + if (dp != NULL && parsepathconf(dp) != 0) return; break; - case NFSPROC_STATFS: - printf(" statfs"); + case NFSPROC_COMMIT: + printf(" commit"); dp = parserep(rp, length); - if (dp != NULL && parsestatfs(dp) != 0) + if (dp != NULL && parsewccres(dp, vflag) != 0) return; break; @@ -865,4 +1574,5 @@ interp_reply(const struct rpc_msg *rp, u_int32_t proc, u_int length) } if (!nfserr) fputs(" [|nfs]", stdout); +trunc:; } |