mirrors/tcpdump
0
0
Fork 0
mirror of https://github.com/the-tcpdump-group/tcpdump.git synced 2024-11-27 03:53:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
7781ecd3a2
tcpdump/print-nfs.c

1852 lines
41 KiB
C
Raw Normal View History

Initial revision
1999-10-08 07:47:09 +08:00
/*
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that: (1) source code distributions
* retain the above copyright notice and this paragraph in its entirety, (2)
* distributions including binary code include the above copyright notice and
* this paragraph in its entirety in the documentation or other materials
* provided with the distribution, and (3) all advertising materials mentioning
* features or use of this software display the following acknowledgement:
* ``This product includes software developed by the University of California,
* Lawrence Berkeley Laboratory and its contributors.'' 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
Have the configure script arrange that the Makefile define _U_ appropriately, and that GNUmakefile and the MSVC++ project file define it apppriately, as we do with libpcap, rather than defining it in "interface.h". Undo the rcsid-shuffling and addition of extra #includes, as we no longer need to arrange that "interface.h" be included before using _U_ in an RCS ID or copyright.
2003-11-16 17:36:07 +08:00
#ifndef lint
static const char rcsid[] _U_ =
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
"@(#) $Header: /tcpdump/master/tcpdump/print-nfs.c,v 1.111 2007-12-22 03:08:04 guy Exp $ (LBL)";
Have the configure script arrange that the Makefile define _U_ appropriately, and that GNUmakefile and the MSVC++ project file define it apppriately, as we do with libpcap, rather than defining it in "interface.h". Undo the rcsid-shuffling and addition of extra #includes, as we no longer need to arrange that "interface.h" be included before using _U_ in an RCS ID or copyright.
2003-11-16 17:36:07 +08:00
#endif
Switch to config.h instead of passing defines in DEFS.
1999-11-21 17:36:43 +08:00
#ifdef HAVE_CONFIG_H
#include "config.h"
Initial revision
1999-10-08 07:47:09 +08:00
#endif
Added support for Win32, based on WinPcap.
2002-08-01 16:52:55 +08:00
#include <tcpdump-stdinc.h>
Initial revision
1999-10-08 07:47:09 +08:00
#include <pcap.h>
#include <stdio.h>
#include <string.h>
#include "interface.h"
#include "addrtoname.h"
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
#include "extract.h"
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
#include "nfs.h"
Initial revision
1999-10-08 07:47:09 +08:00
#include "nfsfh.h"
Add an "ip.h" header, to declare the IP stuff needed by dissectors, and have dissectors include them rather than <netinet/ip.h> or <netinet/ip_var.h>, if they actually need that stuff. Put the declarations of the ICMP stuff directly into "print-icmp.c". Remove all unnecessary includes of <netinet/ip*.h> files. Copy the byte-order stuff from "nameser.h" into "tcp.h".
2000-09-23 16:54:24 +08:00
#include "ip.h"
put stripped-down version of ip6.h and icmp6.h into tcpdump tree. ip6.h is almost normal RFC2292 header. icmp6.h has couple of extensions (not covered by RFC2292), like MLD, ICMPv6 nodeinfo, and router renumber. XXX how to synchronize with future kame changes?
2000-10-07 13:53:09 +08:00
#ifdef INET6
#include "ip6.h"
#endif
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
#include "rpc_auth.h"
#include "rpc_msg.h"
Add an "ip.h" header, to declare the IP stuff needed by dissectors, and have dissectors include them rather than <netinet/ip.h> or <netinet/ip_var.h>, if they actually need that stuff. Put the declarations of the ICMP stuff directly into "print-icmp.c". Remove all unnecessary includes of <netinet/ip*.h> files. Copy the byte-order stuff from "nameser.h" into "tcp.h".
2000-09-23 16:54:24 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
static void nfs_printfh(const u_int32_t *, const u_int);
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
static int xid_map_enter(const struct sunrpc_msg *, const u_char *);
NFS: fix a Windows compile warning 'int32_t' isn't 'int' for all targets. Some Windows targets have it defined as 'signed int' in <win32/Include/bittypes.h>. So print-nfs.c does not compile cleanly; conflicting definition of xid_map_find().
2013-07-11 21:03:03 +08:00
static int xid_map_find(const struct sunrpc_msg *, const u_char *,
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
u_int32_t *, u_int32_t *);
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
static void interp_reply(const struct sunrpc_msg *, u_int32_t, u_int32_t, int);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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);
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
static void print_nfsaddr(const u_char *, const char *, const char *);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
/*
* 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
};
To translate NFS error statuses to strings, use "tok2str()" and a table, rather than using "pcap_strerror()", as 1) not all NFS error statuses are UNIX errno values; 2) even those that are UNIX errno values aren't necessarily errno values for the system on which you're running tcpdump.
2000-08-04 02:52:24 +08:00
/*
* NFS V2 and V3 status values.
*
* Some of these come from the RFCs for NFS V2 and V3, with the message
* strings taken from the FreeBSD C library "errlst.c".
*
* Others are errors that are not in the RFC but that I suspect some
* NFS servers could return; the values are FreeBSD errno values, as
* the first NFS server was the SunOS 2.0 one, and until 5.0 SunOS
* was primarily BSD-derived.
*/
justify declarations of struct tok arrays Make sure all of them are declared const and most of them -- static. Proper declaration of token arrays is a common review point for new code that is based on existing decoders. Thus fix the issue at its root.
2013-09-25 00:46:24 +08:00
static const struct tok status2str[] = {
To translate NFS error statuses to strings, use "tok2str()" and a table, rather than using "pcap_strerror()", as 1) not all NFS error statuses are UNIX errno values; 2) even those that are UNIX errno values aren't necessarily errno values for the system on which you're running tcpdump.
2000-08-04 02:52:24 +08:00
{ 1, "Operation not permitted" }, /* EPERM */
{ 2, "No such file or directory" }, /* ENOENT */
{ 5, "Input/output error" }, /* EIO */
{ 6, "Device not configured" }, /* ENXIO */
{ 11, "Resource deadlock avoided" }, /* EDEADLK */
{ 12, "Cannot allocate memory" }, /* ENOMEM */
{ 13, "Permission denied" }, /* EACCES */
{ 17, "File exists" }, /* EEXIST */
{ 18, "Cross-device link" }, /* EXDEV */
{ 19, "Operation not supported by device" }, /* ENODEV */
{ 20, "Not a directory" }, /* ENOTDIR */
{ 21, "Is a directory" }, /* EISDIR */
{ 22, "Invalid argument" }, /* EINVAL */
{ 26, "Text file busy" }, /* ETXTBSY */
{ 27, "File too large" }, /* EFBIG */
{ 28, "No space left on device" }, /* ENOSPC */
{ 30, "Read-only file system" }, /* EROFS */
{ 31, "Too many links" }, /* EMLINK */
{ 45, "Operation not supported" }, /* EOPNOTSUPP */
{ 62, "Too many levels of symbolic links" }, /* ELOOP */
{ 63, "File name too long" }, /* ENAMETOOLONG */
{ 66, "Directory not empty" }, /* ENOTEMPTY */
{ 69, "Disc quota exceeded" }, /* EDQUOT */
{ 70, "Stale NFS file handle" }, /* ESTALE */
{ 71, "Too many levels of remote in path" }, /* EREMOTE */
{ 99, "Write cache flushed to disk" }, /* NFSERR_WFLUSH (not used) */
{ 10001, "Illegal NFS file handle" }, /* NFS3ERR_BADHANDLE */
{ 10002, "Update synchronization mismatch" }, /* NFS3ERR_NOT_SYNC */
{ 10003, "READDIR/READDIRPLUS cookie is stale" }, /* NFS3ERR_BAD_COOKIE */
{ 10004, "Operation not supported" }, /* NFS3ERR_NOTSUPP */
{ 10005, "Buffer or request is too small" }, /* NFS3ERR_TOOSMALL */
{ 10006, "Unspecified error on server" }, /* NFS3ERR_SERVERFAULT */
{ 10007, "Object of that type not supported" }, /* NFS3ERR_BADTYPE */
{ 10008, "Request couldn't be completed in time" }, /* NFS3ERR_JUKEBOX */
{ 0, NULL }
};
justify declarations of struct tok arrays Make sure all of them are declared const and most of them -- static. Proper declaration of token arrays is a common review point for new code that is based on existing decoders. Thus fix the issue at its root.
2013-09-25 00:46:24 +08:00
static const struct tok nfsv3_writemodes[] = {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
{ 0, "unstable" },
{ 1, "datasync" },
{ 2, "filesync" },
{ 0, NULL }
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
};
justify declarations of struct tok arrays Make sure all of them are declared const and most of them -- static. Proper declaration of token arrays is a common review point for new code that is based on existing decoders. Thus fix the issue at its root.
2013-09-25 00:46:24 +08:00
static const struct tok type2str[] = {
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
{ NFNON, "NON" },
{ NFREG, "REG" },
{ NFDIR, "DIR" },
{ NFBLK, "BLK" },
{ NFCHR, "CHR" },
{ NFLNK, "LNK" },
{ NFFIFO, "FIFO" },
{ 0, NULL }
};
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
static void
print_nfsaddr(const u_char *bp, const char *s, const char *d)
{
struct ip *ip;
#ifdef INET6
struct ip6_hdr *ip6;
char srcaddr[INET6_ADDRSTRLEN], dstaddr[INET6_ADDRSTRLEN];
#else
add fallback definition for INET_ADDRSTRLEN. From: Kevin Steves <stevesk@sweden.hp.com>
2000-06-12 23:45:05 +08:00
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
char srcaddr[INET_ADDRSTRLEN], dstaddr[INET_ADDRSTRLEN];
#endif
srcaddr[0] = dstaddr[0] = '\0';
always use u_intXX_t for protocol format declaration. char/short/int may not come with exact size. while at it, correct signedness of ip/udp header field. nuke most of the use of bitfield. TODO: bitfield in namser.h
2000-10-03 10:54:54 +08:00
switch (IP_V((struct ip *)bp)) {
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
case 4:
ip = (struct ip *)bp;
strlcpy(srcaddr, ipaddr_string(&ip->ip_src), sizeof(srcaddr));
strlcpy(dstaddr, ipaddr_string(&ip->ip_dst), sizeof(dstaddr));
break;
#ifdef INET6
case 6:
ip6 = (struct ip6_hdr *)bp;
strlcpy(srcaddr, ip6addr_string(&ip6->ip6_src),
sizeof(srcaddr));
strlcpy(dstaddr, 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);
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
static const u_int32_t *
parse_sattr3(const u_int32_t *dp, struct nfsv3_sattr *sa3)
{
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_modeset = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_modeset) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_mode = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_uidset = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_uidset) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_uid = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_gidset = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_gidset) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_gid = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_sizeset = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_sizeset) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_size = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_atimetype = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_atimetype == NFSV3SATTRTIME_TOCLIENT) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_atime.nfsv3_sec = EXTRACT_32BITS(dp);
dp++;
sa3->sa_atime.nfsv3_nsec = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_mtimetype = EXTRACT_32BITS(dp);
dp++;
if (sa3->sa_mtimetype == NFSV3SATTRTIME_TOCLIENT) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
sa3->sa_mtime.nfsv3_sec = EXTRACT_32BITS(dp);
dp++;
sa3->sa_mtime.nfsv3_nsec = EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
return dp;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return NULL;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
static int nfserr; /* true if we error rather than trunc */
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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);
}
}
Initial revision
1999-10-08 07:47:09 +08:00
void
nfsreply_print(register const u_char *bp, u_int length,
register const u_char *bp2)
{
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
register const struct sunrpc_msg *rp;
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
u_int32_t proc, vers, reply_stat;
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
char srcid[20], dstid[20]; /*fits 32bit*/
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
enum sunrpc_reject_stat rstat;
u_int32_t rlow;
u_int32_t rhigh;
enum sunrpc_auth_stat rwhy;
Initial revision
1999-10-08 07:47:09 +08:00
nfserr = 0; /* assume no error */
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
rp = (const struct sunrpc_msg *)bp;
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_xid);
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
if (!nflag) {
strlcpy(srcid, "nfs", sizeof(srcid));
snprintf(dstid, sizeof(dstid), "%u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&rp->rm_xid));
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
} else {
snprintf(srcid, sizeof(srcid), "%u", NFS_PORT);
snprintf(dstid, sizeof(dstid), "%u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&rp->rm_xid));
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
}
print_nfsaddr(bp2, srcid, dstid);
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_reply.rp_stat);
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
reply_stat = EXTRACT_32BITS(&rp->rm_reply.rp_stat);
switch (reply_stat) {
Initial revision
1999-10-08 07:47:09 +08:00
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
case SUNRPC_MSG_ACCEPTED:
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("reply ok %u", length);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
if (xid_map_find(rp, bp2, &proc, &vers) >= 0)
interp_reply(rp, proc, vers, length);
break;
case SUNRPC_MSG_DENIED:
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("reply ERR %u: ", length);
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_reply.rp_reject.rj_stat);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
rstat = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_stat);
switch (rstat) {
case SUNRPC_RPC_MISMATCH:
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_reply.rp_reject.rj_vers.high);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
rlow = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.low);
rhigh = EXTRACT_32BITS(&rp->rm_reply.rp_reject.rj_vers.high);
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("RPC Version mismatch (%u-%u)",
rlow, rhigh);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
break;
case SUNRPC_AUTH_ERROR:
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_reply.rp_reject.rj_why);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
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:
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("Invalid failure code %u",
(unsigned int)rwhy);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
break;
}
break;
default:
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("Unknown reason for rejecting rpc message %u",
(unsigned int)rstat);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
break;
}
break;
default:
Print unsigned values as such. Rename a variable to correspond to what it is (a reply status).
2007-06-16 07:17:05 +08:00
(void)printf("reply Unknown rpc response code=%u %u",
reply_stat, length);
Pick up MSG_DENIED response dissection from NetBSD; don't interpret the reply as a possible NFS reply if it got MSG_DENIED.
2007-06-16 03:04:39 +08:00
break;
}
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
return;
trunc:
if (!nfserr)
fputs(" [|nfs]", stdout);
Initial revision
1999-10-08 07:47:09 +08:00
}
/*
* Return a pointer to the first file handle in the packet.
* If the packet was truncated, return 0.
*/
static const u_int32_t *
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
parsereq(register const struct sunrpc_msg *rp, register u_int length)
Initial revision
1999-10-08 07:47:09 +08:00
{
register const u_int32_t *dp;
register u_int len;
/*
* find the start of the req data (if we captured it)
*/
dp = (u_int32_t *)&rp->rm_call.cb_cred;
TCHECK(dp[1]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
len = EXTRACT_32BITS(&dp[1]);
Initial revision
1999-10-08 07:47:09 +08:00
if (len < length) {
dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
TCHECK(dp[1]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
len = EXTRACT_32BITS(&dp[1]);
Initial revision
1999-10-08 07:47:09 +08:00
if (len < length) {
dp += (len + (2 * sizeof(*dp) + 3)) / sizeof(*dp);
TCHECK2(dp[0], 0);
return (dp);
}
}
trunc:
return (NULL);
}
/*
* Print out an NFS file handle and return a pointer to following word.
* If packet was truncated, return 0.
*/
static const u_int32_t *
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parsefh(register const u_int32_t *dp, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
u_int len;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (v3) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
len = EXTRACT_32BITS(dp) / 4;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp++;
} else
len = NFSX_V2FH / 4;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
if (TTEST2(*dp, len * sizeof(*dp))) {
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
nfs_printfh(dp, len);
return (dp + len);
Initial revision
1999-10-08 07:47:09 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
Initial revision
1999-10-08 07:47:09 +08:00
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)
{
register u_int32_t len;
register const u_char *cp;
/* Bail if we don't have the string length */
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(*dp);
Initial revision
1999-10-08 07:47:09 +08:00
/* Fetch string length; convert to host order */
len = *dp++;
NTOHL(len);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK2(*dp, ((len + 3) & ~3));
Initial revision
1999-10-08 07:47:09 +08:00
cp = (u_char *)dp;
/* Update 32-bit pointer (NFS filenames padded to 32-bit boundaries) */
dp += ((len + 3) & ~3) / sizeof(*dp);
putchar('"');
Add an "fn_printzp()" routine for printing null-padded strings (strings with a maximum length, where a string shorter than that length is padded with NULs), as "fn_print()" won't handle the maximum length *and* the snapshot length and "fn_printn()" won't stop on a null string. Use it where appropriate. Always pass "snapend" to "fn_print()" and "fn_printn()" if they're passed a pointer into the packet data; only pass NULL if they're being handed a pointer into a buffer that's not part of the packet data. Always check the return value of "fn_print()", "fn_printn()", and "fn_printzp()" if they're passed "snapend", and do the appropriate string termination and "packet truncated" indication if they return 1.
2005-05-06 15:56:51 +08:00
if (fn_printn(cp, len, snapend)) {
putchar('"');
goto trunc;
}
Initial revision
1999-10-08 07:47:09 +08:00
putchar('"');
return (dp);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return NULL;
Initial revision
1999-10-08 07:47:09 +08:00
}
/*
* Print out file handle and file name.
* 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 *
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parsefhn(register const u_int32_t *dp, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parsefh(dp, v3);
Initial revision
1999-10-08 07:47:09 +08:00
if (dp == NULL)
return (NULL);
putchar(' ');
return (parsefn(dp));
}
void
nfsreq_print(register const u_char *bp, u_int length,
register const u_char *bp2)
{
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
register const struct sunrpc_msg *rp;
Initial revision
1999-10-08 07:47:09 +08:00
register const u_int32_t *dp;
s/nfstype/nfs_type/ to avoid conflict with system header files
2000-07-29 16:05:04 +08:00
nfs_type type;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
int v3;
u_int32_t proc;
Enhance NFS access request messages. When debugging NFS operations one may find it easier to get the actual access flags decoded rather than having to look up the NFS access flags to find which permissions were requested by the client. Reviewed-by: Guy Harris <guy@alum.mit.edu>
2010-01-27 04:09:24 +08:00
u_int32_t access_flags;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
struct nfsv3_sattr sa3;
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
char srcid[20], dstid[20]; /*fits 32bit*/
Initial revision
1999-10-08 07:47:09 +08:00
nfserr = 0; /* assume no error */
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
rp = (const struct sunrpc_msg *)bp;
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
TCHECK(rp->rm_xid);
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
if (!nflag) {
snprintf(srcid, sizeof(srcid), "%u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&rp->rm_xid));
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
strlcpy(dstid, "nfs", sizeof(dstid));
} else {
snprintf(srcid, sizeof(srcid), "%u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&rp->rm_xid));
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
snprintf(dstid, sizeof(dstid), "%u", NFS_PORT);
}
print_nfsaddr(bp2, srcid, dstid);
(void)printf("%d", length);
Initial revision
1999-10-08 07:47:09 +08:00
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
if (!xid_map_enter(rp, bp2)) /* record proc number for later on */
goto trunc;
Initial revision
1999-10-08 07:47:09 +08:00
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
v3 = (EXTRACT_32BITS(&rp->rm_call.cb_vers) == NFS_VER3);
proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (!v3 && proc < NFS_NPROCS)
proc = nfsv3_procid[proc];
switch (proc) {
Initial revision
1999-10-08 07:47:09 +08:00
case NFSPROC_NOOP:
printf(" nop");
return;
case NFSPROC_NULL:
printf(" null");
return;
case NFSPROC_GETATTR:
printf(" getattr");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_SETATTR:
printf(" setattr");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_LOOKUP:
printf(" lookup");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefhn(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_ACCESS:
printf(" access");
if ((dp = parsereq(rp, length)) != NULL &&
(dp = parsefh(dp, v3)) != NULL) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
Enhance NFS access request messages. When debugging NFS operations one may find it easier to get the actual access flags decoded rather than having to look up the NFS access flags to find which permissions were requested by the client. Reviewed-by: Guy Harris <guy@alum.mit.edu>
2010-01-27 04:09:24 +08:00
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);
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return;
}
break;
Initial revision
1999-10-08 07:47:09 +08:00
case NFSPROC_READLINK:
printf(" readlink");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_READ:
printf(" read");
if ((dp = parsereq(rp, length)) != NULL &&
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
(dp = parsefh(dp, v3)) != NULL) {
if (v3) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[2]);
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" %u bytes @ %" PRIu64,
EXTRACT_32BITS(&dp[2]),
EXTRACT_64BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
} else {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
printf(" %u bytes @ %u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[1]),
EXTRACT_32BITS(&dp[0]));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
return;
}
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
Initial revision
1999-10-08 07:47:09 +08:00
case NFSPROC_WRITE:
printf(" write");
if ((dp = parsereq(rp, length)) != NULL &&
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
(dp = parsefh(dp, v3)) != NULL) {
if (v3) {
For NFSv3 writes, show the byte count correctly - and show the length of the data being written, just as we do for NFSv2 writes.
2005-01-05 16:16:45 +08:00
TCHECK(dp[2]);
printf(" %u (%u) bytes @ %" PRIu64,
EXTRACT_32BITS(&dp[4]),
EXTRACT_32BITS(&dp[2]),
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
EXTRACT_64BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag) {
dp += 3;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" <%s>",
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
tok2str(nfsv3_writemodes,
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
NULL, EXTRACT_32BITS(dp)));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
} else {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[3]);
printf(" %u (%u) bytes @ %u (%u)",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[3]),
EXTRACT_32BITS(&dp[2]),
EXTRACT_32BITS(&dp[1]),
EXTRACT_32BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
return;
}
break;
case NFSPROC_CREATE:
printf(" create");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefhn(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_MKDIR:
printf(" mkdir");
if ((dp = parsereq(rp, length)) != 0 && parsefhn(dp, v3) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_SYMLINK:
printf(" symlink");
if ((dp = parsereq(rp, length)) != 0 &&
(dp = parsefhn(dp, v3)) != 0) {
Initial revision
1999-10-08 07:47:09 +08:00
fputs(" ->", stdout);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (v3 && (dp = parse_sattr3(dp, &sa3)) == 0)
break;
if (parsefn(dp) == 0)
break;
if (v3 && vflag)
print_sattr3(&sa3, vflag);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
Initial revision
1999-10-08 07:47:09 +08:00
}
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_MKNOD:
printf(" mknod");
if ((dp = parsereq(rp, length)) != 0 &&
(dp = parsefhn(dp, v3)) != 0) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(*dp);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
type = (nfs_type)EXTRACT_32BITS(dp);
dp++;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if ((dp = parse_sattr3(dp, &sa3)) == 0)
break;
printf(" %s", tok2str(type2str, "unk-ft %d", type));
if (vflag && (type == NFCHR || type == NFBLK)) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
(unsigned) casts in printf to make gcc happy
2000-05-15 08:37:34 +08:00
printf(" %u/%u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[0]),
EXTRACT_32BITS(&dp[1]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp += 2;
}
if (vflag)
print_sattr3(&sa3, vflag);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
Initial revision
1999-10-08 07:47:09 +08:00
}
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_REMOVE:
printf(" remove");
Initial revision
1999-10-08 07:47:09 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parsefhn(dp, v3) != NULL)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
Initial revision
1999-10-08 07:47:09 +08:00
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_RMDIR:
printf(" rmdir");
if ((dp = parsereq(rp, length)) != NULL &&
parsefhn(dp, v3) != NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_READDIR:
printf(" readdir");
if ((dp = parsereq(rp, length)) != NULL &&
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
(dp = parsefh(dp, v3)) != NULL) {
if (v3) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[4]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
/*
* We shouldn't really try to interpret the
* offset cookie here.
*/
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" %u bytes @ %" PRId64,
EXTRACT_32BITS(&dp[4]),
EXTRACT_64BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag)
printf(" verf %08x%08x", dp[2],
dp[3]);
} else {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
/*
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
* Print the offset as signed, since -1 is
* common, but offsets > 2^31 aren't.
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
*/
printf(" %u bytes @ %d",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[1]),
EXTRACT_32BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
return;
}
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_READDIRPLUS:
printf(" readdirplus");
if ((dp = parsereq(rp, length)) != NULL &&
(dp = parsefh(dp, v3)) != NULL) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[4]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
/*
* We don't try to interpret the offset
* cookie here.
*/
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" %u bytes @ %" PRId64,
EXTRACT_32BITS(&dp[4]),
EXTRACT_64BITS(&dp[0]));
if (vflag) {
TCHECK(dp[5]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" max %u verf %08x%08x",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[5]), dp[2], dp[3]);
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return;
}
break;
case NFSPROC_FSSTAT:
printf(" fsstat");
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
return;
break;
case NFSPROC_FSINFO:
printf(" fsinfo");
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
break;
case NFSPROC_PATHCONF:
printf(" pathconf");
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if ((dp = parsereq(rp, length)) != NULL &&
parsefh(dp, v3) != NULL)
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
break;
case NFSPROC_COMMIT:
printf(" commit");
if ((dp = parsereq(rp, length)) != NULL &&
(dp = parsefh(dp, v3)) != NULL) {
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
TCHECK(dp[2]);
printf(" %u bytes @ %" PRIu64,
EXTRACT_32BITS(&dp[2]),
EXTRACT_64BITS(&dp[0]));
Initial revision
1999-10-08 07:47:09 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
default:
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
printf(" proc-%u", EXTRACT_32BITS(&rp->rm_call.cb_proc));
Initial revision
1999-10-08 07:47:09 +08:00
return;
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
Initial revision
1999-10-08 07:47:09 +08:00
trunc:
if (!nfserr)
fputs(" [|nfs]", stdout);
}
/*
* Print out an NFS file handle.
* We assume packet was not truncated before the end of the
* file handle pointed to by dp.
*
* Note: new version (using portable file-handle parser) doesn't produce
* generation number. It probably could be made to do that, with some
* additional hacking on the parser code.
*/
static void
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
nfs_printfh(register const u_int32_t *dp, const u_int len)
Initial revision
1999-10-08 07:47:09 +08:00
{
my_fsid fsid;
NFS: replace ino_t with u_int32_t (GH #335 pt. 1) NFS file handle is an opaque server-issued sequence of bytes. Parse_fh() function implements heuristics to decode file handles generated by some NFS servers, among other information extracting the node (inode) number. It decodes only 32-bit node numbers. NFS implementations use ino_t C type to represent the node number. The type size may vary across implementations/encodings and may be missing during compile time. Tcpdump used to have its own typedef for ino_t. Gisle Vanem points that it caused a problem with MSVC v.16.00.40219.01 for 80x86, which defines the same type in <sys/types.h>. This change fixes tcpdump code to use u_int32_t and removes the typedef.
2013-10-12 17:36:02 +08:00
u_int32_t ino;
Get rid of casts of pointers-to-const to pointers-to-nonconst.
2002-04-24 14:27:05 +08:00
const char *sfsname = NULL;
char *spacep;
Initial revision
1999-10-08 07:47:09 +08:00
Fixes for: parsefattr misuses nfsv2 version members for v3. print_int64 prints at least 9 digits unnecessarily. -u flag doesn't always suppress decoding handles. from Takashi Yamamoto <yamt@mwd.biglobe.ne.jp>.
2002-08-26 17:36:19 +08:00
if (uflag) {
Add a few more GCC warnings on GCC >= 2 for ".devel" builds. From Neil T. Spring: fixes for many of those warnings: addrtoname.c, configure.in: Linux needs netinet/ether.h for ether_ntohost print-*.c: change char *foo = "bar" to const char *foo = "bar" to appease -Wwrite-strings; should affect no run-time behavior. print-*.c: make some variables unsigned. print-bgp.c: plen ('prefix len') is unsigned, no reason to validate by comparing to zero. print-cnfp.c, print-rx.c: use intoa, provided by addrtoname, instead of inet_ntoa. print-domain.c: unsigned int l; (l=foo()) < 0 is guaranteed to be false, so check for (u_int)-1, which represents failure, explicitly. print-isakmp.c: complete initialization of attrmap objects. print-lwres.c: "if(x); print foo;" seemed much more likely to be intended to be "if(x) { print foo; }". print-smb.c: complete initialization of some structures. In addition, add some fixes for the signed vs. unsigned comparison warnings: extract.h: cast the result of the byte-extraction-and-combining, as, at least for the 16-bit version, C's integral promotions will turn "u_int16_t" into "int" if there are other "int"s nearby. print-*.c: make some more variables unsigned, or add casts to an unsigned type of signed values known not to be negative, or add casts to "int" of unsigned values known to fit in an "int", and make other changes needed to handle the aforementioned variables now being unsigned. print-isakmp.c: clean up the handling of error/status indicators in notify messages. print-ppp.c: get rid of a check that an unsigned quantity is >= 0. print-radius.c: clean up some of the bounds checking. print-smb.c: extract the word count into a "u_int" to avoid the aforementioned problems with C's integral promotions. print-snmp.c: change a check that an unsigned variable is >= 0 to a check that it's != 0. Also, fix some formats to use "%u" rather than "%d" for unsigned quantities.
2002-09-05 08:00:07 +08:00
u_int i;
Fixes for: parsefattr misuses nfsv2 version members for v3. print_int64 prints at least 9 digits unnecessarily. -u flag doesn't always suppress decoding handles. from Takashi Yamamoto <yamt@mwd.biglobe.ne.jp>.
2002-08-26 17:36:19 +08:00
char const *sep = "";
printf(" fh[");
for (i=0; i<len; i++) {
(void)printf("%s%x", sep, dp[i]);
sep = ":";
}
printf("]");
return;
}
Get rid of casts of pointers-to-const to pointers-to-nonconst.
2002-04-24 14:27:05 +08:00
Parse_fh((const u_char *)dp, len, &fsid, &ino, NULL, &sfsname, 0);
Initial revision
1999-10-08 07:47:09 +08:00
if (sfsname) {
/* file system ID is ASCII, not numeric, for this server OS */
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
static char temp[NFSX_V3FHMAX+1];
Initial revision
1999-10-08 07:47:09 +08:00
/* Make sure string is null-terminated */
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
strncpy(temp, sfsname, NFSX_V3FHMAX);
strncpy() does not ensure string termination.
2000-06-10 13:26:42 +08:00
temp[sizeof(temp) - 1] = '\0';
Initial revision
1999-10-08 07:47:09 +08:00
/* Remove trailing spaces */
Get rid of casts of pointers-to-const to pointers-to-nonconst.
2002-04-24 14:27:05 +08:00
spacep = strchr(temp, ' ');
if (spacep)
*spacep = '\0';
Initial revision
1999-10-08 07:47:09 +08:00
(nfs_printfh): support print the opaque handle. From Francisco Matias Cuenca-Acuna <mcuenca@george.rutgers.edu>
2000-06-01 09:08:18 +08:00
(void)printf(" fh %s/", temp);
} else {
(void)printf(" fh %d,%d/",
fsid.Fsid_dev.Major, fsid.Fsid_dev.Minor);
Initial revision
1999-10-08 07:47:09 +08:00
}
(nfs_printfh): support print the opaque handle. From Francisco Matias Cuenca-Acuna <mcuenca@george.rutgers.edu>
2000-06-01 09:08:18 +08:00
Fixes for: parsefattr misuses nfsv2 version members for v3. print_int64 prints at least 9 digits unnecessarily. -u flag doesn't always suppress decoding handles. from Takashi Yamamoto <yamt@mwd.biglobe.ne.jp>.
2002-08-26 17:36:19 +08:00
if(fsid.Fsid_dev.Minor == 257)
whitespace cleanup
2002-06-12 01:08:37 +08:00
/* Print the undecoded handle */
(nfs_printfh): support print the opaque handle. From Francisco Matias Cuenca-Acuna <mcuenca@george.rutgers.edu>
2000-06-01 09:08:18 +08:00
(void)printf("%s", fsid.Opaque_Handle);
else
(void)printf("%ld", (long) ino);
Initial revision
1999-10-08 07:47:09 +08:00
}
/*
* Maintain a small cache of recent client.XID.server/proc pairs, to allow
* us to match up replies with requests and thus to know how to parse
* the reply.
*/
struct xid_map_entry {
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
u_int32_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
Initial revision
1999-10-08 07:47:09 +08:00
struct in_addr client; /* client IP address (net order) */
struct in_addr server; /* server IP address (net order) */
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
#endif
u_int32_t proc; /* call proc number (host order) */
u_int32_t vers; /* program version (host order) */
Initial revision
1999-10-08 07:47:09 +08:00
};
/*
* Map entries are kept in an array that we manage as a ring;
* new entries are always added at the tail of the ring. Initially,
* all the entries are zero and hence don't match anything.
*/
#define XIDMAPSIZE 64
struct xid_map_entry xid_map[XIDMAPSIZE];
int xid_map_next = 0;
int xid_map_hint = 0;
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
static int
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
xid_map_enter(const struct sunrpc_msg *rp, const u_char *bp)
Initial revision
1999-10-08 07:47:09 +08:00
{
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
struct ip *ip = NULL;
#ifdef INET6
struct ip6_hdr *ip6 = NULL;
#endif
Initial revision
1999-10-08 07:47:09 +08:00
struct xid_map_entry *xmep;
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
if (!TTEST(rp->rm_call.cb_vers))
return (0);
always use u_intXX_t for protocol format declaration. char/short/int may not come with exact size. while at it, correct signedness of ip/udp header field. nuke most of the use of bitfield. TODO: bitfield in namser.h
2000-10-03 10:54:54 +08:00
switch (IP_V((struct ip *)bp)) {
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
case 4:
ip = (struct ip *)bp;
break;
#ifdef INET6
case 6:
ip6 = (struct ip6_hdr *)bp;
break;
#endif
default:
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
return (1);
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
xmep = &xid_map[xid_map_next];
if (++xid_map_next >= XIDMAPSIZE)
xid_map_next = 0;
xmep->xid = rp->rm_xid;
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
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) {
xmep->ipver = 6;
memcpy(&xmep->client, &ip6->ip6_src, sizeof(ip6->ip6_src));
memcpy(&xmep->server, &ip6->ip6_dst, sizeof(ip6->ip6_dst));
}
#endif
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
xmep->proc = EXTRACT_32BITS(&rp->rm_call.cb_proc);
xmep->vers = EXTRACT_32BITS(&rp->rm_call.cb_vers);
Add more bounds checks to the NFS dissector - check before references to items in the RPC header. When dissecting NFS over TCP, fetch the fragment header length, use it to limit the dissection of the request or reply (in case there's more than one request or reply in the packet), and do the same direction-plus-port checks that are done for NFS over UDP. Also eliminate the bounds check for the RPC header in the TCP dissector code, and do checks for the fields it looks at (other checks are done by the NFS dissector).
2007-12-22 11:08:04 +08:00
return (1);
Initial revision
1999-10-08 07:47:09 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
/*
* Returns 0 and puts NFSPROC_xxx in proc return and
* version in vers return, or returns -1 on failure
*/
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
static int
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
xid_map_find(const struct sunrpc_msg *rp, const u_char *bp, u_int32_t *proc,
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
u_int32_t *vers)
Initial revision
1999-10-08 07:47:09 +08:00
{
int i;
struct xid_map_entry *xmep;
u_int32_t xid = rp->rm_xid;
typo in pointer assignment. from netbsd-current.
2000-07-16 22:32:48 +08:00
struct ip *ip = (struct ip *)bp;
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
#ifdef INET6
struct ip6_hdr *ip6 = (struct ip6_hdr *)bp;
#endif
int cmp;
Initial revision
1999-10-08 07:47:09 +08:00
/* Start searching from where we last left off */
whitespace cleanup
2002-06-12 01:08:37 +08:00
i = xid_map_hint;
Initial revision
1999-10-08 07:47:09 +08:00
do {
xmep = &xid_map[i];
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
cmp = 1;
always use u_intXX_t for protocol format declaration. char/short/int may not come with exact size. while at it, correct signedness of ip/udp header field. nuke most of the use of bitfield. TODO: bitfield in namser.h
2000-10-03 10:54:54 +08:00
if (xmep->ipver != IP_V(ip) || xmep->xid != xid)
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
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) {
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) {
cmp = 0;
}
break;
#endif
default:
cmp = 0;
break;
}
if (cmp) {
Initial revision
1999-10-08 07:47:09 +08:00
/* match */
xid_map_hint = i;
*proc = xmep->proc;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
*vers = xmep->vers;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return 0;
Initial revision
1999-10-08 07:47:09 +08:00
}
correctly handle NFS-over-IPv6.
2000-06-10 13:12:20 +08:00
nextitem:
Initial revision
1999-10-08 07:47:09 +08:00
if (++i >= XIDMAPSIZE)
i = 0;
} while (i != xid_map_hint);
/* search failed */
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return (-1);
Initial revision
1999-10-08 07:47:09 +08:00
}
/*
* Routines for parsing reply packets
*/
/*
* Return a pointer to the beginning of the actual results.
* If the packet was truncated, return 0.
*/
static const u_int32_t *
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
parserep(register const struct sunrpc_msg *rp, register u_int length)
Initial revision
1999-10-08 07:47:09 +08:00
{
register const u_int32_t *dp;
u_int len;
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
enum sunrpc_accept_stat astat;
Initial revision
1999-10-08 07:47:09 +08:00
/*
* 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
* 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",
* whose internal representation contains a pointer, so on a
* 64-bit machine the compiler inserts 32 bits of padding
* before rp->rm_reply.rp_acpt.ar_verf. So, we cannot use
* the internal representation to parse the on-the-wire
* 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;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
len = EXTRACT_32BITS(&dp[1]);
Initial revision
1999-10-08 07:47:09 +08:00
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);
/*
* now we can check the ar_stat field
*/
Attempt to squelch a warning from the SGI C compiler.
2005-04-21 05:52:53 +08:00
astat = (enum sunrpc_accept_stat) EXTRACT_32BITS(dp);
Initial revision
1999-10-08 07:47:09 +08:00
switch (astat) {
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_SUCCESS:
Initial revision
1999-10-08 07:47:09 +08:00
break;
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_PROG_UNAVAIL:
Initial revision
1999-10-08 07:47:09 +08:00
printf(" PROG_UNAVAIL");
nfserr = 1; /* suppress trunc string */
return (NULL);
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_PROG_MISMATCH:
Initial revision
1999-10-08 07:47:09 +08:00
printf(" PROG_MISMATCH");
nfserr = 1; /* suppress trunc string */
return (NULL);
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_PROC_UNAVAIL:
Initial revision
1999-10-08 07:47:09 +08:00
printf(" PROC_UNAVAIL");
nfserr = 1; /* suppress trunc string */
return (NULL);
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_GARBAGE_ARGS:
Initial revision
1999-10-08 07:47:09 +08:00
printf(" GARBAGE_ARGS");
nfserr = 1; /* suppress trunc string */
return (NULL);
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
case SUNRPC_SYSTEM_ERR:
Initial revision
1999-10-08 07:47:09 +08:00
printf(" SYSTEM_ERR");
nfserr = 1; /* suppress trunc string */
return (NULL);
default:
printf(" ar_stat %d", astat);
nfserr = 1; /* suppress trunc string */
return (NULL);
}
/* successful return */
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK2(*dp, sizeof(astat));
return ((u_int32_t *) (sizeof(astat) + ((char *)dp)));
Initial revision
1999-10-08 07:47:09 +08:00
trunc:
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (0);
Initial revision
1999-10-08 07:47:09 +08:00
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
static const u_int32_t *
parsestatus(const u_int32_t *dp, int *er)
{
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
int errnum;
TCHECK(dp[0]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
errnum = EXTRACT_32BITS(&dp[0]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (er)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
*er = errnum;
if (errnum != 0) {
if (!qflag)
To translate NFS error statuses to strings, use "tok2str()" and a table, rather than using "pcap_strerror()", as 1) not all NFS error statuses are UNIX errno values; 2) even those that are UNIX errno values aren't necessarily errno values for the system on which you're running tcpdump.
2000-08-04 02:52:24 +08:00
printf(" ERROR: %s",
tok2str(status2str, "unk %d", errnum));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
nfserr = 1;
Initial revision
1999-10-08 07:47:09 +08:00
}
return (dp + 1);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return NULL;
Initial revision
1999-10-08 07:47:09 +08:00
}
static const u_int32_t *
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parsefattr(const u_int32_t *dp, int verbose, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
const struct nfs_fattr *fap;
fap = (const struct nfs_fattr *)dp;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(fap->fa_gid);
Initial revision
1999-10-08 07:47:09 +08:00
if (verbose) {
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" %s %o ids %d/%d",
Initial revision
1999-10-08 07:47:09 +08:00
tok2str(type2str, "unk-ft %d ",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa_type)),
EXTRACT_32BITS(&fap->fa_mode),
EXTRACT_32BITS(&fap->fa_uid),
EXTRACT_32BITS(&fap->fa_gid));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (v3) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(fap->fa3_size);
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" sz %" PRIu64,
EXTRACT_64BITS((u_int32_t *)&fap->fa3_size));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
} else {
TCHECK(fap->fa2_size);
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" sz %d", EXTRACT_32BITS(&fap->fa2_size));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
}
/* print lots more stuff */
if (verbose > 1) {
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (v3) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(fap->fa3_ctime);
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" nlink %d rdev %d/%d",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa_nlink),
EXTRACT_32BITS(&fap->fa3_rdev.specdata1),
EXTRACT_32BITS(&fap->fa3_rdev.specdata2));
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" fsid %" PRIx64,
EXTRACT_64BITS((u_int32_t *)&fap->fa3_fsid));
printf(" fileid %" PRIx64,
EXTRACT_64BITS((u_int32_t *)&fap->fa3_fileid));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" a/m/ctime %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa3_atime.nfsv3_sec),
EXTRACT_32BITS(&fap->fa3_atime.nfsv3_nsec));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_sec),
EXTRACT_32BITS(&fap->fa3_mtime.nfsv3_nsec));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_sec),
EXTRACT_32BITS(&fap->fa3_ctime.nfsv3_nsec));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
} else {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(fap->fa2_ctime);
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" nlink %d rdev %x fsid %x nodeid %x a/m/ctime",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa_nlink),
EXTRACT_32BITS(&fap->fa2_rdev),
EXTRACT_32BITS(&fap->fa2_fsid),
EXTRACT_32BITS(&fap->fa2_fileid));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa2_atime.nfsv2_sec),
EXTRACT_32BITS(&fap->fa2_atime.nfsv2_usec));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_sec),
EXTRACT_32BITS(&fap->fa2_mtime.nfsv2_usec));
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_sec),
EXTRACT_32BITS(&fap->fa2_ctime.nfsv2_usec));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
return ((const u_int32_t *)((unsigned char *)dp +
(v3 ? NFSX_V3FATTR : NFSX_V2FATTR)));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (NULL);
Initial revision
1999-10-08 07:47:09 +08:00
}
static int
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parseattrstat(const u_int32_t *dp, int verbose, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
int er;
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parsestatus(dp, &er);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (dp == NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return (0);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (er)
return (1);
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (parsefattr(dp, verbose, v3) != NULL);
Initial revision
1999-10-08 07:47:09 +08:00
}
static int
parsediropres(const u_int32_t *dp)
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
int er;
Initial revision
1999-10-08 07:47:09 +08:00
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (!(dp = parsestatus(dp, &er)))
Initial revision
1999-10-08 07:47:09 +08:00
return (0);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (er)
return (1);
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parsefh(dp, 0);
Initial revision
1999-10-08 07:47:09 +08:00
if (dp == NULL)
return (0);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (parsefattr(dp, vflag, 0) != NULL);
Initial revision
1999-10-08 07:47:09 +08:00
}
static int
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parselinkres(const u_int32_t *dp, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
int er;
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parsestatus(dp, &er);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (dp == NULL)
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return(0);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (er)
return(1);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (v3 && !(dp = parse_post_op_attr(dp, vflag)))
return (0);
Initial revision
1999-10-08 07:47:09 +08:00
putchar(' ');
return (parsefn(dp) != NULL);
}
static int
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
parsestatfs(const u_int32_t *dp, int v3)
Initial revision
1999-10-08 07:47:09 +08:00
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
const struct nfs_statfs *sfsp;
int er;
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parsestatus(dp, &er);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (dp == NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return (0);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (!v3 && er)
return (1);
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (qflag)
return(1);
if (v3) {
if (vflag)
printf(" POST:");
if (!(dp = parse_post_op_attr(dp, vflag)))
return (0);
}
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
TCHECK2(*dp, (v3 ? NFSX_V3STATFS : NFSX_V2STATFS));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
sfsp = (const struct nfs_statfs *)dp;
if (v3) {
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
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));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag) {
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
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),
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&sfsp->sf_invarsec));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
} else {
printf(" tsize %d bsize %d blocks %d bfree %d bavail %d",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
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));
Initial revision
1999-10-08 07:47:09 +08:00
}
return (1);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (0);
Initial revision
1999-10-08 07:47:09 +08:00
}
static int
parserddires(const u_int32_t *dp)
{
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
int er;
dp = parsestatus(dp, &er);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (dp == NULL)
Initial revision
1999-10-08 07:47:09 +08:00
return (0);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
if (er)
return (1);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (qflag)
return (1);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[2]);
(unsigned) casts in printf to make gcc happy
2000-05-15 08:37:34 +08:00
printf(" offset %x size %d ",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[0]), EXTRACT_32BITS(&dp[1]));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
if (dp[2] != 0)
printf(" eof");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (1);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (0);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
static const u_int32_t *
parse_wcc_attr(const u_int32_t *dp)
{
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" sz %" PRIu64, EXTRACT_64BITS(&dp[0]));
(unsigned) casts in printf to make gcc happy
2000-05-15 08:37:34 +08:00
printf(" mtime %u.%06u ctime %u.%06u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&dp[2]), EXTRACT_32BITS(&dp[3]),
EXTRACT_32BITS(&dp[4]), EXTRACT_32BITS(&dp[5]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
{
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
if (!EXTRACT_32BITS(&dp[0]))
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (dp + 1);
dp++;
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
TCHECK2(*dp, 24);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (verbose > 1) {
return parse_wcc_attr(dp);
} else {
/* If not verbose enough, just skip over wcc_attr */
return (dp + 6);
Initial revision
1999-10-08 07:47:09 +08:00
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (NULL);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
/*
* Post operation attributes are printed if vflag >= 1
*/
static const u_int32_t *
parse_post_op_attr(const u_int32_t *dp, int verbose)
{
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
if (!EXTRACT_32BITS(&dp[0]))
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return (dp + 1);
dp++;
if (verbose) {
return parsefattr(dp, verbose, 1);
} else
return (dp + (NFSX_V3FATTR / sizeof (u_int32_t)));
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (NULL);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
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 {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
if (!EXTRACT_32BITS(&dp[0]))
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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) {
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" dir attr:");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
dp = parse_wcc_data(dp, verbose);
}
}
}
return (dp);
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (NULL);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
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) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" verf %08x%08x", dp[0], dp[1]);
dp += 2;
}
return dp;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
return (NULL);
}
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return (1);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
sfp = (struct nfsv3_fsinfo *)dp;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(*sfp);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" rtmax %u rtpref %u wtmax %u wtpref %u dtpref %u",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
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));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag) {
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
printf(" rtmult %u wtmult %u maxfsz %" PRIu64,
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&sfp->fs_rtmult),
Get rid of print_int64(), as we can now just use PRI[dux]64 and EXTRACT_64BITS() to directly extract and print 64-bit integers. Add some more bounds checking. Fix the dissection of the arguments to v3 WRITE.
2005-01-05 11:55:05 +08:00
EXTRACT_32BITS(&sfp->fs_wtmult),
EXTRACT_64BITS((u_int32_t *)&sfp->fs_maxfilesize));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" delta %u.%06u ",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_sec),
EXTRACT_32BITS(&sfp->fs_timedelta.nfsv3_nsec));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
return (1);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
trunc:
return (0);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
static int
parsepathconf(const u_int32_t *dp)
{
int er;
struct nfsv3_pathconf *spp;
if (!(dp = parsestatus(dp, &er)))
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return (0);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag)
printf(" POST:");
if (!(dp = parse_post_op_attr(dp, vflag)))
return (0);
if (er)
return (1);
spp = (struct nfsv3_pathconf *)dp;
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(*spp);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" linkmax %u namemax %u %s %s %s %s",
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
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" : "");
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return (1);
V3 FSINFO and PATHCONF requests take a file handle as an argument; parse the request header and the file handle. "parsestatus()" should only return NULL if the packet was truncated, so that its callers can distinguish "packet truncated" from "NFS reply status reports an error". NFS-request-or-reply parsing routines that call "parsestatus()" should not return 0 if "parsestatus()" returns a non-zero NFS reply status, so that non-truncated packets with a non-zero NFS reply status aren't printed as truncated NFS packets. Fix some "TCHECK2()" calls to pass an object, not a pointer to an object, as the first argument (the TCHECK/TTEST macros take objects, not addresses, as the test argument). NFS-request-or-reply parsing routines should return 0 for truncated packets and 1 for non-truncated packets, not *vice versa*.
2002-05-31 17:47:23 +08:00
trunc:
return (0);
Initial revision
1999-10-08 07:47:09 +08:00
}
static void
Have our own headers to declare the format of ONC (Sun) RPC messages on the wire; the definitions in many systems use u_long, which is 64 bits long on many platforms - that's OK for in-memory structures, but it doesn't match what's on the wire. Use headers based on the Sun ones, but use u_int32_t for fields, and otherwise make the structures match what's on the wire, and change some names to avoid collision with <rpc/rpc.h>, which print-sunrpc.c includes to declare "getrpcbynumber()" and the structure it returns. Record whether "getrpcbynumber()" is found, and use it only if it's found, rather than basing the decisison on whether we're building for Win32 or not.
2004-12-27 08:41:29 +08:00
interp_reply(const struct sunrpc_msg *rp, u_int32_t proc, u_int32_t vers, int length)
Initial revision
1999-10-08 07:47:09 +08:00
{
register const u_int32_t *dp;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
register int v3;
int er;
v3 = (vers == NFS_VER3);
if (!v3 && proc < NFS_NPROCS)
proc = nfsv3_procid[proc];
Initial revision
1999-10-08 07:47:09 +08:00
switch (proc) {
case NFSPROC_NOOP:
printf(" nop");
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
Initial revision
1999-10-08 07:47:09 +08:00
case NFSPROC_NULL:
printf(" null");
return;
case NFSPROC_GETATTR:
printf(" getattr");
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parseattrstat(dp, !qflag, v3) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_SETATTR:
printf(" setattr");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (!(dp = parserep(rp, length)))
return;
if (v3) {
if (parsewccres(dp, vflag))
return;
} else {
if (parseattrstat(dp, !qflag, 0) != 0)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_LOOKUP:
printf(" lookup");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_ACCESS:
printf(" access");
Check for parse failure in ACCESS replies. Submitted by: nathanw@MIT.EDU (Nathan J. Williams)
2001-07-05 03:24:10 +08:00
if (!(dp = parserep(rp, length)))
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (!(dp = parsestatus(dp, &er)))
break;
if (vflag)
printf(" attr:");
if (!(dp = parse_post_op_attr(dp, vflag)))
break;
if (!er)
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
printf(" c %04x", EXTRACT_32BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
return;
Initial revision
1999-10-08 07:47:09 +08:00
case NFSPROC_READLINK:
printf(" readlink");
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parselinkres(dp, v3) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_READ:
printf(" read");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
if (EXTRACT_32BITS(&dp[1]))
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" EOF");
}
return;
} else {
if (parseattrstat(dp, vflag, 0) != 0)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_WRITE:
printf(" write");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (!(dp = parserep(rp, length)))
break;
if (v3) {
if (!(dp = parsestatus(dp, &er)))
break;
if (!(dp = parse_wcc_data(dp, vflag)))
break;
if (er)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[0]);
From Charles M. Hannum <mycroft@netbsd.org>: NetBSD whitespace cleanups.
2002-12-12 15:57:50 +08:00
printf(" %u bytes", EXTRACT_32BITS(&dp[0]));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (vflag > 1) {
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
TCHECK(dp[1]);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
printf(" <%s>",
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
tok2str(nfsv3_writemodes,
The "__attribute__((packed))" tag on structures causes some files not to compile with Sun C, as "interface.h" isn't being included before the structures are being declared. Furthermore, in the files that Sun C *can* compile, it doesn't cause Sun C to generate code that's safe with unaligned accesses, as "__attribute__" is defined as a do-nothing macro with compilers that don't support it. Therefore, we get rid of that tag on the structures to which it was added, and instead use "EXTRACT_16BIT()" and "EXTRACT_32BIT()" to fetch 16-bit and 32-bit big-endian quantities from packets. We also fix some other references to multi-byte quantities to get rid of code that tries to do unaligned loads on platforms that don't support them. We also throw in a hack that makes those macros use "__attribute__((packed))" on structures containing only one 16-bit or 32-bit integer to get the compiler to generate unaligned-safe code rather than doing it by hand. (GCC on SPARC produces the same code that doing it by hand does; I don't know if GCC on any other big-endian strict-alignment processor generates better code for that case. On little-endian processors, as "ntohs()" and "ntohl()" might be functions, that might actually produce worse code.) Fix some places to use "%u" rather than "%d" to print unsigned quantities.
2002-12-11 15:13:49 +08:00
NULL, EXTRACT_32BITS(&dp[1])));
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
return;
}
} else {
if (parseattrstat(dp, vflag, v3) != 0)
return;
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_CREATE:
printf(" create");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
break;
case NFSPROC_MKNOD:
printf(" mknod");
if (!(dp = parserep(rp, length)))
break;
if (parsecreateopres(dp, vflag) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
case NFSPROC_REMOVE:
printf(" remove");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_RENAME:
printf(" rename");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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;
}
Initial revision
1999-10-08 07:47:09 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
} else {
if (parsestatus(dp, &er) != 0)
return;
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
case NFSPROC_LINK:
printf(" link");
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
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)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_READDIR:
printf(" readdir");
if (!(dp = parserep(rp, length)))
break;
if (v3) {
if (parsev3rddirres(dp, vflag))
return;
} else {
if (parserddires(dp) != 0)
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
return;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
}
Initial revision
1999-10-08 07:47:09 +08:00
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_READDIRPLUS:
printf(" readdirplus");
if (!(dp = parserep(rp, length)))
break;
if (parsev3rddirres(dp, vflag))
return;
break;
case NFSPROC_FSSTAT:
printf(" fsstat");
Initial revision
1999-10-08 07:47:09 +08:00
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parsestatfs(dp, v3) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_FSINFO:
printf(" fsinfo");
Initial revision
1999-10-08 07:47:09 +08:00
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parsefsinfo(dp) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_PATHCONF:
printf(" pathconf");
Initial revision
1999-10-08 07:47:09 +08:00
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parsepathconf(dp) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
case NFSPROC_COMMIT:
printf(" commit");
Initial revision
1999-10-08 07:47:09 +08:00
dp = parserep(rp, length);
incorporate NFS parsing code from NetBSD. adds support for nfsv3
1999-11-21 13:43:49 +08:00
if (dp != NULL && parsewccres(dp, vflag) != 0)
Initial revision
1999-10-08 07:47:09 +08:00
return;
break;
default:
printf(" proc-%u", proc);
return;
}
Fix confusing indentation. Get rid of T2CHECK() in favor of TCHECK() or TCHECK2(). Use TCHECK() etc. instead of comparing vs. snapend. Replace strerr() with pcap_strerror(), and don't use errno as a local variable. Use tok2str() for nfsv3_writemodes to avoid array overrun by corrupt packets.
2000-01-28 08:04:19 +08:00
trunc:
Initial revision
1999-10-08 07:47:09 +08:00
if (!nfserr)
fputs(" [|nfs]", stdout);
}
Reference in New Issue Copy Permalink