/* packet-nfs.c
* Routines for nfs dissection
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
- * Copyright 2000-2001, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
- *
- * $Id: packet-nfs.c,v 1.57 2001/09/14 08:22:29 guy Exp $
+ * Copyright 2000-2002, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
+ * $Id: packet-nfs.c,v 1.94 2003/09/28 01:52:57 sahlberg Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
#endif
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
#include <string.h>
#include "packet-rpc.h"
#include "packet-nfs.h"
-
+#include "prefs.h"
+#include "epan/int-64bit.h"
static int proto_nfs = -1;
+static int hf_nfs_procedure_v2 = -1;
+static int hf_nfs_procedure_v3 = -1;
+static int hf_nfs_procedure_v4 = -1;
static int hf_nfs_fh_length = -1;
+static int hf_nfs_fh_hash = -1;
static int hf_nfs_fh_fsid_major = -1;
static int hf_nfs_fh_fsid_minor = -1;
static int hf_nfs_fh_fsid_inode = -1;
static int hf_nfs_fh_fileid_type = -1;
static int hf_nfs_stat = -1;
static int hf_nfs_name = -1;
+static int hf_nfs_full_name = -1;
static int hf_nfs_readlink_data = -1;
static int hf_nfs_read_offset = -1;
static int hf_nfs_read_count = -1;
static int hf_nfs_pathconf_chown_restricted = -1;
static int hf_nfs_pathconf_case_insensitive = -1;
static int hf_nfs_pathconf_case_preserving = -1;
-static int hf_nfs_data_follows = -1;
static int hf_nfs_atime = -1;
static int hf_nfs_atime_sec = -1;
static int hf_nfs_tag4 = -1;
static int hf_nfs_component4 = -1;
static int hf_nfs_clientid4 = -1;
-static int hf_nfs_clientid4_verifier = -1;
static int hf_nfs_ace4 = -1;
static int hf_nfs_recall = -1;
static int hf_nfs_open_claim_type4 = -1;
static int hf_nfs_open4_share_access = -1;
static int hf_nfs_open4_share_deny = -1;
static int hf_nfs_seqid4 = -1;
+static int hf_nfs_lock_seqid4 = -1;
static int hf_nfs_mand_attr = -1;
static int hf_nfs_recc_attr = -1;
static int hf_nfs_time_how4 = -1;
static int hf_nfs_attrlist4 = -1;
-static int hf_nfs_fattr4_expire_type = -1;
static int hf_nfs_fattr4_link_support = -1;
static int hf_nfs_fattr4_symlink_support = -1;
static int hf_nfs_fattr4_named_attr = -1;
static int hf_nfs_offset4 = -1;
static int hf_nfs_specdata1 = -1;
static int hf_nfs_specdata2 = -1;
-static int hf_nfs_locktype4 = -1;
+static int hf_nfs_lock_type4 = -1;
static int hf_nfs_reclaim4 = -1;
static int hf_nfs_length4 = -1;
static int hf_nfs_changeid4 = -1;
+static int hf_nfs_changeid4_before = -1;
+static int hf_nfs_changeid4_after = -1;
static int hf_nfs_nfstime4_seconds = -1;
static int hf_nfs_nfstime4_nseconds = -1;
static int hf_nfs_fsid4_major = -1;
static int hf_nfs_acemask4 = -1;
static int hf_nfs_delegate_type = -1;
static int hf_nfs_secinfo_flavor = -1;
+static int hf_nfs_secinfo_arr4 = -1;
static int hf_nfs_num_blocks = -1;
static int hf_nfs_bytes_per_block = -1;
static int hf_nfs_eof = -1;
static int hf_nfs_count4_dircount = -1;
static int hf_nfs_count4_maxcount = -1;
static int hf_nfs_minorversion = -1;
+static int hf_nfs_open_owner4 = -1;
+static int hf_nfs_lock_owner4 = -1;
+static int hf_nfs_new_lock_owner = -1;
+static int hf_nfs_sec_oid4 = -1;
+static int hf_nfs_qop4 = -1;
+static int hf_nfs_secinfo_rpcsec_gss_info_service = -1;
+static int hf_nfs_attrdircreate = -1;
+static int hf_nfs_client_id4_id = -1;
+static int hf_nfs_stateid4_other = -1;
+static int hf_nfs_lock4_reclaim = -1;
+static int hf_nfs_acl4 = -1;
+static int hf_nfs_callback_ident = -1;
+static int hf_nfs_r_netid = -1;
+static int hf_nfs_r_addr = -1;
static gint ett_nfs = -1;
static gint ett_nfs_fh_encoding = -1;
static gint ett_nfs_open_delegation4 = -1;
static gint ett_nfs_open_claim4 = -1;
static gint ett_nfs_opentype4 = -1;
-static gint ett_nfs_lockowner4 = -1;
+static gint ett_nfs_lock_owner4 = -1;
static gint ett_nfs_cb_client4 = -1;
static gint ett_nfs_client_id4 = -1;
static gint ett_nfs_bitmap4 = -1;
static gint ett_nfs_fs_locations4 = -1;
static gint ett_nfs_fs_location4 = -1;
static gint ett_nfs_open4_result_flags = -1;
+static gint ett_nfs_secinfo4_flavor_info = -1;
+static gint ett_nfs_stateid4 = -1;
+static gint ett_nfs_fattr4_fh_expire_type = -1;
+static gint ett_nfs_ace4 = -1;
+static gint ett_nfs_clientaddr4 = -1;
+static gint ett_nfs_aceflag4 = -1;
+static gint ett_nfs_acemask4 = -1;
+
+
+/* fhandle displayfilters to match also corresponding request/response
+ packet in addition to the one containing the actual filehandle */
+gboolean nfs_fhandle_reqrep_matching = FALSE;
+static GMemChunk *nfs_fhandle_data_chunk = NULL;
+static int nfs_fhandle_data_init_count = 100;
+static GHashTable *nfs_fhandle_data_table = NULL;
+GHashTable *nfs_fhandle_frame_table = NULL;
+
+static gint
+nfs_fhandle_data_equal(gconstpointer k1, gconstpointer k2)
+{
+ const nfs_fhandle_data_t *key1 = (const nfs_fhandle_data_t *)k1;
+ const nfs_fhandle_data_t *key2 = (const nfs_fhandle_data_t *)k2;
+
+ return (key1->len==key2->len)
+ &&(!memcmp(key1->fh, key2->fh, key1->len));
+}
+static guint
+nfs_fhandle_data_hash(gconstpointer k)
+{
+ const nfs_fhandle_data_t *key = (const nfs_fhandle_data_t *)k;
+ int i;
+ int hash;
+
+ hash=0;
+ for(i=0;i<key->len;i++)
+ hash ^= key->fh[i];
+
+ return hash;
+}
+static gboolean
+nfs_fhandle_data_free_all(gpointer key_arg _U_, gpointer value, gpointer user_data _U_)
+{
+ nfs_fhandle_data_t *nns = (nfs_fhandle_data_t *)value;
+
+ if(nns->fh){
+ tvb_free(nns->tvb);
+ nns->tvb=NULL;
+ g_free((gpointer)nns->fh);
+ nns->fh=NULL;
+ nns->len=0;
+ }
+
+ return TRUE;
+}
+static gint
+nfs_fhandle_frame_equal(gconstpointer k1, gconstpointer k2)
+{
+ guint32 key1 = (guint32)k1;
+ guint32 key2 = (guint32)k2;
+
+ return key1==key2;
+}
+static guint
+nfs_fhandle_frame_hash(gconstpointer k)
+{
+ guint32 key = (guint32)k;
+
+ return key;
+}
+static gboolean
+nfs_fhandle_frame_free_all(gpointer key_arg _U_, gpointer value _U_, gpointer user_data _U_)
+{
+ return TRUE;
+}
+static void
+nfs_fhandle_reqrep_matching_init(void)
+{
+ if (nfs_fhandle_frame_table != NULL) {
+ g_hash_table_foreach_remove(nfs_fhandle_frame_table,
+ nfs_fhandle_frame_free_all, NULL);
+ } else {
+ nfs_fhandle_frame_table=g_hash_table_new(nfs_fhandle_frame_hash,
+ nfs_fhandle_frame_equal);
+ }
+
+
+ if (nfs_fhandle_data_table != NULL) {
+ g_hash_table_foreach_remove(nfs_fhandle_data_table,
+ nfs_fhandle_data_free_all, NULL);
+ } else {
+ nfs_fhandle_data_table=g_hash_table_new(nfs_fhandle_data_hash,
+ nfs_fhandle_data_equal);
+ }
+
+ if(nfs_fhandle_data_chunk){
+ g_mem_chunk_destroy(nfs_fhandle_data_chunk);
+ nfs_fhandle_data_chunk = NULL;
+ }
+
+ if(nfs_fhandle_reqrep_matching){
+ nfs_fhandle_data_chunk = g_mem_chunk_new("nfs_fhandle_data_chunk",
+ sizeof(nfs_fhandle_data_t),
+ nfs_fhandle_data_init_count * sizeof(nfs_fhandle_data_t),
+ G_ALLOC_ONLY);
+ }
+
+}
+
+
+/* file name snooping */
+gboolean nfs_file_name_snooping = FALSE;
+gboolean nfs_file_name_full_snooping = FALSE;
+typedef struct nfs_name_snoop {
+ int fh_length;
+ unsigned char *fh;
+ int name_len;
+ unsigned char *name;
+ int parent_len;
+ unsigned char *parent;
+ int full_name_len;
+ unsigned char *full_name;
+} nfs_name_snoop_t;
+
+typedef struct nfs_name_snoop_key {
+ int key;
+ int fh_length;
+ const unsigned char *fh;
+} nfs_name_snoop_key_t;
+
+static GMemChunk *nfs_name_snoop_chunk = NULL;
+static int nfs_name_snoop_init_count = 100;
+static GHashTable *nfs_name_snoop_unmatched = NULL;
+
+static GMemChunk *nfs_name_snoop_key_chunk = NULL;
+static int nfs_name_snoop_key_init_count = 100;
+static GHashTable *nfs_name_snoop_matched = NULL;
+
+static GHashTable *nfs_name_snoop_known = NULL;
+
+static gint
+nfs_name_snoop_matched_equal(gconstpointer k1, gconstpointer k2)
+{
+ const nfs_name_snoop_key_t *key1 = (const nfs_name_snoop_key_t *)k1;
+ const nfs_name_snoop_key_t *key2 = (const nfs_name_snoop_key_t *)k2;
+
+ return (key1->key==key2->key)
+ &&(key1->fh_length==key2->fh_length)
+ &&(!memcmp(key1->fh, key2->fh, key1->fh_length));
+}
+static guint
+nfs_name_snoop_matched_hash(gconstpointer k)
+{
+ const nfs_name_snoop_key_t *key = (const nfs_name_snoop_key_t *)k;
+ int i;
+ guint hash;
+
+ hash=key->key;
+ for(i=0;i<key->fh_length;i++)
+ hash ^= key->fh[i];
+
+ return hash;
+}
+static gint
+nfs_name_snoop_unmatched_equal(gconstpointer k1, gconstpointer k2)
+{
+ guint32 key1 = (guint32)k1;
+ guint32 key2 = (guint32)k2;
+
+ return key1==key2;
+}
+static guint
+nfs_name_snoop_unmatched_hash(gconstpointer k)
+{
+ guint32 key = (guint32)k;
+
+ return key;
+}
+static gboolean
+nfs_name_snoop_unmatched_free_all(gpointer key_arg _U_, gpointer value, gpointer user_data _U_)
+{
+ nfs_name_snoop_t *nns = (nfs_name_snoop_t *)value;
+
+ if(nns->name){
+ g_free((gpointer)nns->name);
+ nns->name=NULL;
+ nns->name_len=0;
+ }
+ if(nns->full_name){
+ g_free((gpointer)nns->full_name);
+ nns->full_name=NULL;
+ nns->full_name_len=0;
+ }
+ if(nns->parent){
+ g_free((gpointer)nns->parent);
+ nns->parent=NULL;
+ nns->parent_len=0;
+ }
+ if(nns->fh){
+ g_free((gpointer)nns->fh);
+ nns->fh=NULL;
+ nns->fh_length=0;
+ }
+ return TRUE;
+}
+
+static void
+nfs_name_snoop_init(void)
+{
+ if (nfs_name_snoop_unmatched != NULL) {
+ g_hash_table_foreach_remove(nfs_name_snoop_unmatched,
+ nfs_name_snoop_unmatched_free_all, NULL);
+ } else {
+ /* The fragment table does not exist. Create it */
+ nfs_name_snoop_unmatched=g_hash_table_new(nfs_name_snoop_unmatched_hash,
+ nfs_name_snoop_unmatched_equal);
+ }
+ if (nfs_name_snoop_matched != NULL) {
+ g_hash_table_foreach_remove(nfs_name_snoop_matched,
+ nfs_name_snoop_unmatched_free_all, NULL);
+ } else {
+ /* The fragment table does not exist. Create it */
+ nfs_name_snoop_matched=g_hash_table_new(nfs_name_snoop_matched_hash,
+ nfs_name_snoop_matched_equal);
+ }
+ if (nfs_name_snoop_known != NULL) {
+ g_hash_table_foreach_remove(nfs_name_snoop_known,
+ nfs_name_snoop_unmatched_free_all, NULL);
+ } else {
+ /* The fragment table does not exist. Create it */
+ nfs_name_snoop_known=g_hash_table_new(nfs_name_snoop_matched_hash,
+ nfs_name_snoop_matched_equal);
+ }
+
+ if(nfs_name_snoop_chunk){
+ g_mem_chunk_destroy(nfs_name_snoop_chunk);
+ nfs_name_snoop_chunk = NULL;
+ }
+ if(nfs_name_snoop_key_chunk){
+ g_mem_chunk_destroy(nfs_name_snoop_key_chunk);
+ nfs_name_snoop_key_chunk = NULL;
+ }
+
+ if(nfs_file_name_snooping){
+ nfs_name_snoop_chunk = g_mem_chunk_new("nfs_name_snoop_chunk",
+ sizeof(nfs_name_snoop_t),
+ nfs_name_snoop_init_count * sizeof(nfs_name_snoop_t),
+ G_ALLOC_ONLY);
+ nfs_name_snoop_key_chunk = g_mem_chunk_new("nfs_name_snoop_key_chunk",
+ sizeof(nfs_name_snoop_key_t),
+ nfs_name_snoop_key_init_count * sizeof(nfs_name_snoop_key_t),
+ G_ALLOC_ONLY);
+ }
+
+}
+
+void
+nfs_name_snoop_add_name(int xid, tvbuff_t *tvb, int name_offset, int name_len, int parent_offset, int parent_len, unsigned char *name)
+{
+ nfs_name_snoop_t *nns, *old_nns;
+ const unsigned char *ptr=NULL;
+
+ /* filter out all '.' and '..' names */
+ if(!name){
+ ptr=(const unsigned char *)tvb_get_ptr(tvb, name_offset, name_len);
+ if(ptr[0]=='.'){
+ if(ptr[1]==0){
+ return;
+ }
+ if(ptr[1]=='.'){
+ if(ptr[2]==0){
+ return;
+ }
+ }
+ }
+ }
+
+ nns=g_mem_chunk_alloc(nfs_name_snoop_chunk);
+
+ nns->fh_length=0;
+ nns->fh=NULL;
+
+ if(parent_len){
+ nns->parent_len=parent_len;
+ nns->parent=g_malloc(parent_len);
+ memcpy(nns->parent, tvb_get_ptr(tvb, parent_offset, parent_len), parent_len);
+ } else {
+ nns->parent_len=0;
+ nns->parent=NULL;
+ }
+
+ nns->name_len=name_len;
+ if(name){
+ nns->name=name;
+ } else {
+ nns->name=g_malloc(name_len+1);
+ memcpy(nns->name, ptr, name_len);
+ }
+ nns->name[name_len]=0;
+
+ nns->full_name_len=0;
+ nns->full_name=NULL;
+
+ /* remove any old entry for this */
+ old_nns=g_hash_table_lookup(nfs_name_snoop_unmatched, (gconstpointer)xid);
+ if(old_nns){
+ /* if we haven't seen the reply yet, then there are no
+ matched entries for it, thus we can dealloc the arrays*/
+ if(!old_nns->fh){
+ g_free(old_nns->name);
+ old_nns->name=NULL;
+ old_nns->name_len=0;
+
+ g_free(old_nns->parent);
+ old_nns->parent=NULL;
+ old_nns->parent_len=0;
+
+ g_mem_chunk_free(nfs_name_snoop_chunk, old_nns);
+ }
+ g_hash_table_remove(nfs_name_snoop_unmatched, (gconstpointer)xid);
+ }
+
+ g_hash_table_insert(nfs_name_snoop_unmatched, (gpointer)xid, nns);
+}
+
+static void
+nfs_name_snoop_add_fh(int xid, tvbuff_t *tvb, int fh_offset, int fh_length)
+{
+ unsigned char *fh;
+ nfs_name_snoop_t *nns, *old_nns;
+ nfs_name_snoop_key_t *key;
+
+ /* find which request we correspond to */
+ nns=g_hash_table_lookup(nfs_name_snoop_unmatched, (gconstpointer)xid);
+ if(!nns){
+ /* oops couldnt find matching request, bail out */
+ return;
+ }
+
+ /* if we have already seen this response earlier */
+ if(nns->fh){
+ return;
+ }
+
+ /* oki, we have a new entry */
+ fh=g_malloc(fh_length);
+ memcpy(fh, tvb_get_ptr(tvb, fh_offset, fh_length), fh_length);
+ nns->fh=fh;
+ nns->fh_length=fh_length;
+
+ key=g_mem_chunk_alloc(nfs_name_snoop_key_chunk);
+ key->key=0;
+ key->fh_length=nns->fh_length;
+ key->fh =nns->fh;
+
+ /* already have something matched for this fh, remove it from
+ the table */
+ old_nns=g_hash_table_lookup(nfs_name_snoop_matched, key);
+ if(old_nns){
+ g_hash_table_remove(nfs_name_snoop_matched, key);
+ }
+
+ g_hash_table_remove(nfs_name_snoop_unmatched, (gconstpointer)xid);
+ g_hash_table_insert(nfs_name_snoop_matched, key, nns);
+}
+
+static void
+nfs_full_name_snoop(nfs_name_snoop_t *nns, int *len, unsigned char **name, unsigned char **pos)
+{
+ nfs_name_snoop_t *parent_nns = NULL;
+ nfs_name_snoop_key_t key;
+
+ /* check if the nns component ends with a '/' else we just allocate
+ an extra byte to len to accommodate for it later */
+ if(nns->name[nns->name_len-1]!='/'){
+ (*len)++;
+ }
+
+ (*len) += nns->name_len;
+
+ if(nns->parent==NULL){
+ *name = g_malloc((*len)+1);
+ *pos = *name;
+
+ strcpy(*pos, nns->name);
+ *pos += nns->name_len;
+ return;
+ }
+
+ key.key=0;
+ key.fh_length=nns->parent_len;
+ key.fh=nns->parent;
+
+ parent_nns=g_hash_table_lookup(nfs_name_snoop_matched, &key);
+
+ if(parent_nns){
+ nfs_full_name_snoop(parent_nns, len, name, pos);
+ if(*name){
+ /* make sure components are '/' separated */
+ if( (*pos)[-1] != '/'){
+ **pos='/';
+ (*pos)++;
+ **pos=0;
+ }
+ strcpy(*pos, nns->name);
+ *pos += nns->name_len;
+ }
+ return;
+ }
+
+ return;
+}
+
+static void
+nfs_name_snoop_fh(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int fh_offset, int fh_length, gboolean hidden)
+{
+ nfs_name_snoop_key_t key;
+ nfs_name_snoop_t *nns = NULL;
+
+ /* if this is a new packet, see if we can register the mapping */
+ if(!pinfo->fd->flags.visited){
+ key.key=0;
+ key.fh_length=fh_length;
+ key.fh=(const unsigned char *)tvb_get_ptr(tvb, fh_offset, fh_length);
+
+ nns=g_hash_table_lookup(nfs_name_snoop_matched, &key);
+ if(nns){
+ nfs_name_snoop_key_t *k;
+ k=g_mem_chunk_alloc(nfs_name_snoop_key_chunk);
+ k->key=pinfo->fd->num;
+ k->fh_length=nns->fh_length;
+ k->fh=nns->fh;
+ g_hash_table_insert(nfs_name_snoop_known, k, nns);
+
+ if(nfs_file_name_full_snooping){
+ unsigned char *name=NULL, *pos=NULL;
+ int len=0;
+
+ nfs_full_name_snoop(nns, &len, &name, &pos);
+ if(name){
+ nns->full_name=name;
+ nns->full_name_len=len;
+ }
+ }
+ }
+ }
+
+ /* see if we know this mapping */
+ if(!nns){
+ key.key=pinfo->fd->num;
+ key.fh_length=fh_length;
+ key.fh=(const unsigned char *)tvb_get_ptr(tvb, fh_offset, fh_length);
+
+ nns=g_hash_table_lookup(nfs_name_snoop_known, &key);
+ }
+
+ /* if we know the mapping, print the filename */
+ if(nns){
+ if(hidden){
+ proto_tree_add_string_hidden(tree, hf_nfs_name, tvb,
+ fh_offset, 0, nns->name);
+ }else {
+ proto_tree_add_string_format(tree, hf_nfs_name, tvb,
+ fh_offset, 0, nns->name, "Name: %s", nns->name);
+ }
+ if(nns->full_name){
+ if(hidden){
+ proto_tree_add_string_hidden(tree, hf_nfs_full_name, tvb,
+ fh_offset, 0, nns->name);
+ } else {
+ proto_tree_add_string_format(tree, hf_nfs_full_name, tvb,
+ fh_offset, 0, nns->name, "Full Name: %s", nns->full_name);
+ }
+ }
+ }
+}
/* file handle dissection */
static void
dissect_fhandle_data_SVR4(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint32 nof = offset;
if (tree) {
proto_item* fsid_item = NULL;
proto_tree* fsid_tree = NULL;
-
+
fsid_item = proto_tree_add_text(tree, tvb,
- fsid_O, fsid_L,
+ fsid_O, fsid_L,
"file system ID: %d,%d", fsid_major, fsid_minor);
if (fsid_item) {
- fsid_tree = proto_item_add_subtree(fsid_item,
+ fsid_tree = proto_item_add_subtree(fsid_item,
ett_nfs_fh_fsid);
proto_tree_add_uint(fsid_tree, hf_nfs_fh_fsid_major,
tvb, fsid_O, 2, fsid_major);
guint32 fn_data_gen_L;
guint32 gen;
guint32 fn_L;
-
+
fn_O = nof;
fn_len_O = fn_O;
fn_len_L = 2;
if (tree) {
proto_item* fn_item = NULL;
proto_tree* fn_tree = NULL;
-
+
fn_item = proto_tree_add_uint(tree, hf_nfs_fh_fn, tvb,
fn_O, fn_L, inode);
if (fn_item) {
- fn_tree = proto_item_add_subtree(fn_item,
+ fn_tree = proto_item_add_subtree(fn_item,
ett_nfs_fh_fn);
proto_tree_add_uint(fn_tree, hf_nfs_fh_fn_len,
tvb, fn_len_O, fn_len_L, fn_len);
guint32 xfn_data_gen_L;
guint32 xgen;
guint32 xfn_L;
-
+
xfn_O = nof;
xfn_len_O = xfn_O;
xfn_len_L = 2;
if (tree) {
proto_item* xfn_item = NULL;
proto_tree* xfn_tree = NULL;
-
+
xfn_item = proto_tree_add_uint(tree, hf_nfs_fh_xfn, tvb,
xfn_O, xfn_L, xinode);
if (xfn_item) {
- xfn_tree = proto_item_add_subtree(xfn_item,
+ xfn_tree = proto_item_add_subtree(xfn_item,
ett_nfs_fh_xfn);
proto_tree_add_uint(xfn_tree, hf_nfs_fh_xfn_len,
tvb, xfn_len_O, xfn_len_L, xfn_len);
static void
dissect_fhandle_data_LINUX_KNFSD_LE(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint32 dentry;
guint32 inode;
proto_tree* fsid_tree = NULL;
fsid_item = proto_tree_add_text(tree, tvb,
- offset+12, 4,
+ offset+12, 4,
"file system ID: %d,%d", fsid_major, fsid_minor);
if (fsid_item) {
- fsid_tree = proto_item_add_subtree(fsid_item,
+ fsid_tree = proto_item_add_subtree(fsid_item,
ett_nfs_fh_fsid);
proto_tree_add_uint(fsid_tree, hf_nfs_fh_fsid_major,
tvb, offset+13, 1, fsid_major);
proto_tree* xfsid_tree = NULL;
xfsid_item = proto_tree_add_text(tree, tvb,
- offset+16, 4,
+ offset+16, 4,
"exported file system ID: %d,%d", xfsid_major, xfsid_minor);
if (xfsid_item) {
- xfsid_tree = proto_item_add_subtree(xfsid_item,
+ xfsid_tree = proto_item_add_subtree(xfsid_item,
ett_nfs_fh_xfsid);
proto_tree_add_uint(xfsid_tree, hf_nfs_fh_xfsid_major,
tvb, offset+17, 1, xfsid_major);
/* Checked with RedHat Linux 5.2 (nfs-server 2.2beta47 user-land nfsd) */
-void
+static void
dissect_fhandle_data_LINUX_NFSD_LE(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
/* pseudo inode */
{
"hash path: %s",
tvb_bytes_to_str(tvb,offset+5,hashlen));
if (hash_item) {
- hash_tree = proto_item_add_subtree(hash_item,
+ hash_tree = proto_item_add_subtree(hash_item,
ett_nfs_fh_hp);
if (hash_tree) {
proto_tree_add_uint(hash_tree,
static void
dissect_fhandle_data_LINUX_KNFSD_NEW(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint8 version;
guint8 auth_type;
goto out;
}
}
-
+
switch (auth_type) {
case 0: {
/* no authentication */
fsid_inode = tvb_get_letohl(tvb, offset + 4);
if (tree) {
proto_item* fsid_item = proto_tree_add_text(tree, tvb,
- offset+0, 8,
+ offset+0, 8,
"file system ID: %u,%u (inode %u)",
fsid_major, fsid_minor, fsid_inode);
if (fsid_item) {
- proto_tree* fsid_tree = proto_item_add_subtree(fsid_item,
+ proto_tree* fsid_tree = proto_item_add_subtree(fsid_item,
ett_nfs_fh_fsid);
if (fsid_tree) {
proto_tree_add_uint(fsid_tree, hf_nfs_fh_fsid_major,
static void
dissect_fhandle_data_unknown(tvbuff_t *tvb, int offset, proto_tree *tree,
- int fhlen)
+ guint fhlen)
{
- int sublen;
- int bytes_left;
+ guint sublen;
+ guint bytes_left;
gboolean first_line;
bytes_left = fhlen;
static void
dissect_fhandle_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, unsigned int fhlen)
+ proto_tree *tree, unsigned int fhlen, gboolean hidden, guint32 *hash)
{
unsigned int fhtype = FHT_UNKNOWN;
/* Not all bytes there. Any attempt to deduce the type would be
senseless. */
if (!tvb_bytes_exist(tvb,offset,fhlen)) goto type_ready;
-
- /* calculate (heuristically) fhtype */
- switch (fhlen) {
- case 12: {
- if (tvb_get_ntohl(tvb,offset) == 0x01000000) {
- fhtype=FHT_LINUX_KNFSD_NEW;
+
+ /* this is to set up fhandle display filters to find both packets
+ of an RPC call */
+ if(nfs_fhandle_reqrep_matching && (!hidden) ){
+ nfs_fhandle_data_t *old_fhd=NULL;
+ unsigned char *fh;
+
+ if( !pinfo->fd->flags.visited ){
+ nfs_fhandle_data_t fhd;
+
+ /* first check if we have seen this fhandle before */
+ fhd.len=fhlen;
+ fhd.fh=(const unsigned char *)tvb_get_ptr(tvb, offset, fhlen);
+ old_fhd=g_hash_table_lookup(nfs_fhandle_data_table,
+ (gconstpointer)&fhd);
+ if(!old_fhd){
+ /* oh, a new fhandle, alloc struct and store it in the table*/
+ old_fhd=g_mem_chunk_alloc(nfs_fhandle_data_chunk);
+ old_fhd->len=fhlen;
+ fh=g_malloc(fhlen);
+ memcpy(fh, fhd.fh, fhlen);
+ old_fhd->fh=fh;
+ old_fhd->tvb=tvb_new_real_data(old_fhd->fh, old_fhd->len, old_fhd->len);
+ g_hash_table_insert(nfs_fhandle_data_table,
+ (gpointer)old_fhd, (gpointer)old_fhd);
}
- } break;
- case 20: {
+
+ /* XXX here we should really check that we havent stored
+ this fhandle for this frame number already.
+ We should also make sure we can handle when we have multiple
+ fhandles seen for the same frame, which WILL happen for certain
+ nfs calls. For now, we dont handle this and those calls will
+ not work properly with this feature
+ */
+ g_hash_table_insert(nfs_fhandle_frame_table,
+ (gpointer)pinfo->fd->num,
+ (gpointer)old_fhd);
+ }
+ }
+
+ /* create a semiunique hash value for the filehandle */
+ {
+ guint32 fhhash;
+ guint32 i;
+
+ for(fhhash=0,i=0;i<(fhlen-3);i+=4){
+ guint32 val;
+ val = tvb_get_ntohl(tvb, offset+i);
+ fhhash ^= val;
+ fhhash += val;
+ }
+ if(hidden){
+ proto_tree_add_uint_hidden(tree, hf_nfs_fh_hash, tvb, offset,
+ fhlen, fhhash);
+ } else {
+ proto_tree_add_uint(tree, hf_nfs_fh_hash, tvb, offset,
+ fhlen, fhhash);
+ }
+ if(hash){
+ *hash=fhhash;
+ }
+ }
+ if(nfs_file_name_snooping){
+ nfs_name_snoop_fh(pinfo, tree, tvb, offset, fhlen, hidden);
+ }
+
+ if(!hidden){
+ /* calculate (heuristically) fhtype */
+ switch (fhlen) {
+ case 12:
+ if (tvb_get_ntohl(tvb,offset) == 0x01000000) {
+ fhtype=FHT_LINUX_KNFSD_NEW;
+ }
+ break;
+ case 20:
if (tvb_get_ntohl(tvb,offset) == 0x01000001) {
fhtype=FHT_LINUX_KNFSD_NEW;
}
- } break;
- case 24: {
+ break;
+ case 24:
if (tvb_get_ntohl(tvb,offset) == 0x01000002) {
fhtype=FHT_LINUX_KNFSD_NEW;
}
- } break;
+ break;
case 32: {
guint32 len1;
guint32 len2;
int wrong=0;
for (len2=5+len1;len2<32;len2++) {
if (tvb_get_guint8(tvb,offset+len2)) {
- wrong=1;
+ wrong=1;
break;
}
}
}
}
}
- } break;
+ } break;
+ }
}
type_ready:
- proto_tree_add_text(tree, tvb, offset, 0,
- "type: %s", val_to_str(fhtype, names_fhtype, "Unknown"));
+ if(!hidden){
+ proto_tree_add_text(tree, tvb, offset, 0,
+ "type: %s", val_to_str(fhtype, names_fhtype, "Unknown"));
- switch (fhtype) {
+
+ switch (fhtype) {
case FHT_SVR4:
dissect_fhandle_data_SVR4 (tvb, offset, tree,
fhlen);
default:
dissect_fhandle_data_unknown(tvb, offset, tree, fhlen);
break;
+ }
+ }
+}
+
+void
+dissect_fhandle_hidden(packet_info *pinfo, proto_tree *tree, nfs_fhandle_data_t *nfd)
+{
+ if(nfd && nfd->len){
+ dissect_fhandle_data(nfd->tvb, 0, pinfo, tree, nfd->len, TRUE, NULL);
}
}
/* RFC 1094, Page 12..14 */
-const value_string names_nfs_stat[] =
+static const value_string names_nfs_stat[] =
{
{ 0, "OK" },
{ 1, "ERR_PERM" },
};
/* NFSv4 Draft Specification, Page 198-199 */
-const value_string names_nfs_stat4[] = {
- { 0, "NFS4_OK" },
- { 1, "NFS4ERR_PERM" },
- { 2, "NFS4ERR_NOENT" },
- { 5, "NFS4ERR_IO" },
- { 6, "NFS4ERR_NXIO" },
- { 13, "NFS4ERR_ACCES" },
- { 17, "NFS4ERR_EXIST" },
- { 18, "NFS4ERR_XDEV" },
- { 19, "NFS4ERR_NODEV" },
- { 20, "NFS4ERR_NOTDIR" },
- { 21, "NFS4ERR_ISDIR" },
- { 22, "NFS4ERR_INVAL" },
- { 27, "NFS4ERR_FBIG" },
- { 28, "NFS4ERR_NOSPC" },
- { 30, "NFS4ERR_ROFS" },
- { 31, "NFS4ERR_MLINK" },
- { 63, "NFS4ERR_NAMETOOLONG" },
- { 66, "NFS4ERR_NOTEMPTY" },
- { 69, "NFS4ERR_DQUOT" },
- { 70, "NFS4ERR_STALE" },
+static const value_string names_nfs_stat4[] = {
+ { 0, "NFS4_OK" },
+ { 1, "NFS4ERR_PERM" },
+ { 2, "NFS4ERR_NOENT" },
+ { 5, "NFS4ERR_IO" },
+ { 6, "NFS4ERR_NXIO" },
+ { 13, "NFS4ERR_ACCES" },
+ { 17, "NFS4ERR_EXIST" },
+ { 18, "NFS4ERR_XDEV" },
+ { 19, "NFS4ERR_NODEV" },
+ { 20, "NFS4ERR_NOTDIR" },
+ { 21, "NFS4ERR_ISDIR" },
+ { 22, "NFS4ERR_INVAL" },
+ { 27, "NFS4ERR_FBIG" },
+ { 28, "NFS4ERR_NOSPC" },
+ { 30, "NFS4ERR_ROFS" },
+ { 31, "NFS4ERR_MLINK" },
+ { 63, "NFS4ERR_NAMETOOLONG" },
+ { 66, "NFS4ERR_NOTEMPTY" },
+ { 69, "NFS4ERR_DQUOT" },
+ { 70, "NFS4ERR_STALE" },
{ 10001, "NFS4ERR_BADHANDLE" },
{ 10003, "NFS4ERR_BAD_COOKIE" },
- { 10004, "NFS4ERR_NOTSUPP" },
+ { 10004, "NFS4ERR_NOTSUPP" },
{ 10005, "NFS4ERR_TOOSMALL" },
- { 10006, "NFS4ERR_SERVERFAULT" },
- { 10007, "NFS4ERR_BADTYPE" },
+ { 10006, "NFS4ERR_SERVERFAULT" },
+ { 10007, "NFS4ERR_BADTYPE" },
{ 10008, "NFS4ERR_DELAY" },
- { 10009, "NFS4ERR_SAME" },
- { 10010, "NFS4ERR_DENIED" },
- { 10011, "NFS4ERR_EXPIRED" },
- { 10012, "NFS4ERR_LOCKED" },
+ { 10009, "NFS4ERR_SAME" },
+ { 10010, "NFS4ERR_DENIED" },
+ { 10011, "NFS4ERR_EXPIRED" },
+ { 10012, "NFS4ERR_LOCKED" },
{ 10013, "NFS4ERR_GRACE" },
{ 10014, "NFS4ERR_FHEXPIRED" },
- { 10015, "NFS4ERR_SHARE_DENIED" },
+ { 10015, "NFS4ERR_SHARE_DENIED" },
{ 10016, "NFS4ERR_WRONGSEC" },
{ 10017, "NFS4ERR_CLID_INUSE" },
{ 10018, "NFS4ERR_RESOURCE" },
{ 10019, "NFS4ERR_MOVED" },
- { 10020, "NFS4ERR_NOFILEHANDLE" },
- { 10021, "NFS4ERR_MINOR_VERS_MISMATCH" },
- { 10022, "NFS4ERR_STALE_CLIENTID" },
- { 10023, "NFS4ERR_STALE_STATEID" },
- { 10024, "NFS4ERR_OLD_STATEID" },
- { 10025, "NFS4ERR_BAD_STATEID" },
+ { 10020, "NFS4ERR_NOFILEHANDLE" },
+ { 10021, "NFS4ERR_MINOR_VERS_MISMATCH" },
+ { 10022, "NFS4ERR_STALE_CLIENTID" },
+ { 10023, "NFS4ERR_STALE_STATEID" },
+ { 10024, "NFS4ERR_OLD_STATEID" },
+ { 10025, "NFS4ERR_BAD_STATEID" },
{ 10026, "NFS4ERR_BAD_SEQID" },
{ 10027, "NFS4ERR_NOT_SAME" },
{ 10028, "NFS4ERR_LOCK_RANGE" },
- { 10029, "NFS4ERR_SYMLINK" },
- { 10030, "NFS4ERR_READDIR_NOSPC" },
- { 10031, "NFS4ERR_LEASE_MOVED" },
+ { 10029, "NFS4ERR_SYMLINK" },
+ { 10030, "NFS4ERR_READDIR_NOSPC" },
+ { 10031, "NFS4ERR_LEASE_MOVED" },
+ { 10032, "NFS4ERR_ATTRNOTSUPP" },
+ { 10033, "NFS4ERR_NO_GRACE" },
+ { 10034, "NFS4ERR_RECLAIM_BAD" },
+ { 10035, "NFS4ERR_RECLAIM_CONFLICT" },
+ { 10036, "NFS4ERR_BADXDR" },
+ { 10037, "NFS4ERR_LOCKS_HELD" },
+ { 10038, "NFS4ERR_OPENMODE" },
+ { 10039, "NFS4ERR_BADOWNER" },
+ { 10040, "NFS4ERR_BADCHAR" },
+ { 10041, "NFS4ERR_BADNAME" },
+ { 10042, "NFS4ERR_BAD_RANGE" },
+ { 10043, "NFS4ERR_LOCK_NOTSUPP" },
+ { 10044, "NFS4ERR_OP_ILLEGAL" },
+ { 10045, "NFS4ERR_DEADLOCK" },
+ { 10046, "NFS4ERR_FILE_OPEN" },
+ { 10047, "NFS4ERR_ADMIN_REVOKED" },
+ { 10048, "NFS4ERR_CB_PATH_DOWN" },
{ 0, NULL }
};
/* This function has been modified to support NFSv4 style error codes as
* well as being backwards compatible with NFSv2 and NFSv3.
*/
-int
-dissect_stat_internal(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_stat_internal(tvbuff_t *tvb, int offset,
proto_tree *tree, guint32* status, int nfsvers)
{
guint32 stat;
stat = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
/* this gives the right NFSv2 number<->message relation */
/* and makes it searchable via "nfs.status" */
proto_tree_add_uint_format(tree, hf_nfs_nfsstat3, tvb,
- offset+0, 4, stat, "Status: %s (%u)",
- val_to_str(stat,
+ offset+0, 4, stat, "Status: %s (%u)",
+ val_to_str(stat,
(nfsvers != 4)? names_nfs_stat: names_nfs_stat4,"%u"), stat);
}
offset += 4;
- *status = stat;
+
+ if (status) *status = stat;
+
return offset;
}
/* RFC 1094, Page 12..14 */
-int
-dissect_stat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+static int
+dissect_stat(tvbuff_t *tvb, int offset, proto_tree *tree,
guint32 *status)
{
- return dissect_stat_internal(tvb, offset, pinfo, tree, status, !4);
+ return dissect_stat_internal(tvb, offset, tree, status, !4);
}
/* RFC 1094, Page 12..14 */
-int
-dissect_nfs2_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+static int
+dissect_nfs2_rmdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ proto_item_append_text(tree, ", RMDIR Reply");
+ break;
+ default:
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", RMDIR Reply Error:%s", err);
+ }
return offset;
}
-
-int
-dissect_nfs_nfsstat4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, guint32 *status)
+static int
+dissect_nfs2_symlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
- return dissect_stat_internal(tvb, offset, pinfo, tree, status, 4);
-}
+ guint32 status;
+ char *err;
+
+ offset = dissect_stat(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ proto_item_append_text(tree, ", SYMLINK Reply");
+ break;
+ default:
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", SYMLINK Reply Error:%s", err);
+ }
+ return offset;
+}
-/* RFC 1094, Page 15 */
-int
-dissect_ftype(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
-char* name)
+static int
+dissect_nfs2_link_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
- guint32 ftype;
- char* ftype_name = NULL;
-
- const value_string nfs2_ftype[] =
- {
- { 0, "Non-File" },
- { 1, "Regular File" },
- { 2, "Directory" },
- { 3, "Block Special Device" },
- { 4, "Character Special Device" },
- { 5, "Symbolic Link" },
- { 0, NULL }
- };
+ guint32 status;
+ char *err;
- ftype = tvb_get_ntohl(tvb, offset+0);
- ftype_name = val_to_str(ftype, nfs2_ftype, "%u");
-
- if (tree) {
- proto_tree_add_text(tree, tvb, offset, 4,
- "%s: %s (%u)", name, ftype_name, ftype);
+ offset = dissect_stat(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ proto_item_append_text(tree, ", LINK Reply");
+ break;
+ default:
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", LINK Reply Error:%s", err);
}
- offset += 4;
+ return offset;
+}
+
+static int
+dissect_nfs2_rename_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_stat(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ proto_item_append_text(tree, ", RENAME Reply");
+ break;
+ default:
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", RENAME Reply Error:%s", err);
+ }
+
+ return offset;
+}
+
+static int
+dissect_nfs2_remove_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_stat(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ proto_item_append_text(tree, ", REMOVE Reply");
+ break;
+ default:
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", REMOVE Reply Error:%s", err);
+ }
+
+ return offset;
+}
+
+
+static int
+dissect_nfs_nfsstat4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, guint32 *status)
+{
+ return dissect_stat_internal(tvb, offset, tree, status, 4);
+}
+
+
+/* RFC 1094, Page 15 */
+static int
+dissect_ftype(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
+{
+ guint32 ftype;
+ char* ftype_name = NULL;
+
+ const value_string nfs2_ftype[] =
+ {
+ { 0, "Non-File" },
+ { 1, "Regular File" },
+ { 2, "Directory" },
+ { 3, "Block Special Device" },
+ { 4, "Character Special Device" },
+ { 5, "Symbolic Link" },
+ { 0, NULL }
+ };
+
+ ftype = tvb_get_ntohl(tvb, offset+0);
+ ftype_name = val_to_str(ftype, nfs2_ftype, "%u");
+
+ if (tree) {
+ proto_tree_add_text(tree, tvb, offset, 4,
+ "%s: %s (%u)", name, ftype_name, ftype);
+ }
+
+ offset += 4;
return offset;
}
/* RFC 1094, Page 15 */
int
dissect_fhandle(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
- char *name)
+ char *name, guint32 *hash)
{
proto_item* fitem;
proto_tree* ftree = NULL;
ftree = proto_item_add_subtree(fitem, ett_nfs_fhandle);
}
- if (ftree)
- dissect_fhandle_data(tvb, offset, pinfo, ftree, FHSIZE);
+ /* are we snooping fh to filenames ?*/
+ if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
+ rpc_call_info_value *civ=pinfo->private_data;
+
+ /* NFS v2 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
+ if( (civ->prog==100003)
+ &&(civ->vers==2)
+ &&(!civ->request)
+ &&((civ->proc==4)||(civ->proc==9)||(civ->proc==14))
+ ) {
+ nfs_name_snoop_add_fh(civ->xid, tvb,
+ offset, 32);
+ }
+
+ /* MOUNT v1,v2 MNT replies might give us a filehandle*/
+ if( (civ->prog==100005)
+ &&(civ->proc==1)
+ &&((civ->vers==1)||(civ->vers==2))
+ &&(!civ->request)
+ ) {
+ nfs_name_snoop_add_fh(civ->xid, tvb,
+ offset, 32);
+ }
+ }
+
+ dissect_fhandle_data(tvb, offset, pinfo, ftree, FHSIZE, FALSE, hash);
offset += FHSIZE;
return offset;
}
/* RFC 1094, Page 15 */
-int
-dissect_nfs2_fhandle_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+static int
+dissect_nfs2_statfs_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+{
+ guint32 hash;
+
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", STATFS Call FH:0x%08x", hash);
+
+ return offset;
+}
+
+static int
+dissect_nfs2_readlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+{
+ guint32 hash;
+
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", READLINK Call FH:0x%08x", hash);
+
+ return offset;
+}
+
+static int
+dissect_nfs2_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_fhandle(tvb, offset, pinfo, tree, "object");
+ guint32 hash;
+
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", GETATTR Call FH:0x%08x", hash);
return offset;
}
/* RFC 1094, Page 15 */
-int
-dissect_timeval(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_usec)
+static int
+dissect_timeval(tvbuff_t *tvb, int offset, proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_usec)
{
guint32 seconds;
guint32 useconds;
/* RFC 1094, Page 16 */
-const value_string nfs2_mode_names[] = {
+static const value_string nfs2_mode_names[] = {
{ 0040000, "Directory" },
{ 0020000, "Character Special Device" },
{ 0060000, "Block Special Device" },
{ 0000000, NULL },
};
-int
-dissect_mode(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
-char* name)
+static int
+dissect_mode(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
guint32 mode;
proto_item* mode_item = NULL;
proto_tree* mode_tree = NULL;
mode = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
mode_item = proto_tree_add_text(tree, tvb, offset, 4,
"%s: 0%o", name, mode);
/* RFC 1094, Page 15 */
int
-dissect_fattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* name)
+dissect_fattr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* fattr_item = NULL;
proto_tree* fattr_tree = NULL;
int old_offset = offset;
if (tree) {
- fattr_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
+ fattr_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
fattr_tree = proto_item_add_subtree(fattr_item, ett_nfs_fattr);
}
- offset = dissect_ftype(tvb, offset, pinfo, fattr_tree, "type");
- offset = dissect_mode(tvb, offset, pinfo, fattr_tree, "mode");
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_nlink, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_uid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_gid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_size, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocksize, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_rdev, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_fsid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_fileid, offset);
+ offset = dissect_ftype(tvb, offset, fattr_tree, "type");
+ offset = dissect_mode(tvb, offset, fattr_tree, "mode");
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_nlink, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_uid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_gid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_size, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_blocksize, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_rdev, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_blocks, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_fsid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_fileid, offset);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_usec);
/* now we know, that fattr is shorter */
if (fattr_item) {
/* RFC 1094, Page 17 */
-int
-dissect_sattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* name)
+static int
+dissect_sattr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* sattr_item = NULL;
proto_tree* sattr_tree = NULL;
int old_offset = offset;
if (tree) {
- sattr_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
+ sattr_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
sattr_tree = proto_item_add_subtree(sattr_item, ett_nfs_sattr);
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_mode(tvb, offset, pinfo, sattr_tree, "mode");
+ offset = dissect_mode(tvb, offset, sattr_tree, "mode");
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "mode: no value");
offset += 4;
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_uid,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_uid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "uid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_gid,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_gid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "gid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_size,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_size,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "size: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff) {
- offset = dissect_timeval(tvb, offset, pinfo, sattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
+ offset = dissect_timeval(tvb, offset, sattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
} else {
proto_tree_add_text(sattr_tree, tvb, offset, 8, "atime: no value");
offset += 8;
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff) {
- offset = dissect_timeval(tvb, offset, pinfo, sattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
+ offset = dissect_timeval(tvb, offset, sattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
} else {
proto_tree_add_text(sattr_tree, tvb, offset, 8, "mtime: no value");
offset += 8;
/* RFC 1094, Page 17 */
-int
-dissect_filename(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_filename(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, string_ret);
return offset;
}
/* RFC 1094, Page 17 */
-int
-dissect_path(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hf)
+static int
+dissect_path(tvbuff_t *tvb, int offset, proto_tree *tree, int hf, char **name)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, name);
return offset;
}
/* RFC 1094, Page 17,18 */
-int
-dissect_attrstat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree){
+static int
+dissect_attrstat(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info *pinfo, char *funcname)
+{
guint32 status;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr(tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_fattr(tvb, offset, tree, "attributes");
+ proto_item_append_text(tree, ", %s Reply", funcname);
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", %s Reply Error:%s", funcname, err);
break;
}
/* RFC 1094, Page 17,18 */
-int
-dissect_nfs2_attrstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+static int
+dissect_nfs2_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
+{
+ offset = dissect_attrstat(tvb, offset, tree, pinfo, "WRITE");
+
+ return offset;
+}
+
+static int
+dissect_nfs2_setattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
- offset = dissect_attrstat(tvb, offset, pinfo, tree);
+ offset = dissect_attrstat(tvb, offset, tree, pinfo, "SETATTR");
+
+ return offset;
+}
+
+static int
+dissect_nfs2_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
+{
+ offset = dissect_attrstat(tvb, offset, tree, pinfo, "GETATTR");
return offset;
}
/* RFC 1094, Page 18 */
-int
-dissect_diropargs(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* name)
+static int
+dissect_diropargs(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* label, guint32 *hash, char **name)
{
proto_item* diropargs_item = NULL;
proto_tree* diropargs_tree = NULL;
int old_offset = offset;
if (tree) {
- diropargs_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
+ diropargs_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", label);
diropargs_tree = proto_item_add_subtree(diropargs_item, ett_nfs_diropargs);
}
- offset = dissect_fhandle (tvb,offset,pinfo,diropargs_tree,"dir");
- offset = dissect_filename(tvb,offset,pinfo,diropargs_tree,hf_nfs_name,NULL);
+ /* are we snooping fh to filenames ?*/
+ if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
+ /* v2 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
+ rpc_call_info_value *civ=pinfo->private_data;
+
+ if( (civ->prog==100003)
+ &&(civ->vers==2)
+ &&(civ->request)
+ &&((civ->proc==4)||(civ->proc==9)||(civ->proc==14))
+ ) {
+ nfs_name_snoop_add_name(civ->xid, tvb,
+ offset+36, tvb_get_ntohl(tvb, offset+32),
+ offset, 32, NULL);
+ }
+ }
+
+ offset = dissect_fhandle(tvb, offset, pinfo, diropargs_tree, "dir", hash);
+ offset = dissect_filename(tvb, offset, diropargs_tree, hf_nfs_name, name);
/* now we know, that diropargs is shorter */
if (diropargs_item) {
/* RFC 1094, Page 18 */
-int
-dissect_nfs2_diropargs_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+static int
+dissect_nfs2_rmdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+{
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "where", &hash, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", RMDIR Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
+ return offset;
+}
+
+static int
+dissect_nfs2_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+{
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "where", &hash, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", REMOVE Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
+ return offset;
+}
+
+static int
+dissect_nfs2_lookup_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "where");
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "where", &hash, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", LOOKUP Call DH:0x%08x/%s", hash, name);
+ g_free(name);
return offset;
}
/* RFC 1094, Page 18 */
-int
-dissect_diropres(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+static int
+dissect_diropres(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char *funcname)
{
guint32 status;
+ guint32 hash;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fhandle(tvb, offset, pinfo, tree, "file");
- offset = dissect_fattr (tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "file", &hash);
+ offset = dissect_fattr (tvb, offset, tree, "attributes");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", %s Reply FH:0x%08x", funcname, hash);
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", %s Reply Error:%s", funcname, err);
break;
}
/* nfsdata is simply a chunk of RPC opaque data (length, data, fill bytes) */
-int
-dissect_nfsdata(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, int hf)
+static int
+dissect_nfsdata(tvbuff_t *tvb, int offset, proto_tree *tree, int hf)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf, offset);
+ offset = dissect_rpc_data(tvb, tree, hf, offset);
return offset;
}
/* RFC 1094, Page 18 */
-int
-dissect_nfs2_diropres_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_mkdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ offset = dissect_diropres(tvb, offset, pinfo, tree, "MKDIR");
+ return offset;
+}
+
+static int
+dissect_nfs2_create_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ offset = dissect_diropres(tvb, offset, pinfo, tree, "CREATE");
+ return offset;
+}
+
+static int
+dissect_nfs2_lookup_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_diropres(tvb, offset, pinfo, tree);
+ offset = dissect_diropres(tvb, offset, pinfo, tree, "LOOKUP");
return offset;
}
/* RFC 1094, Page 6 */
-int
-dissect_nfs2_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_fhandle(tvb, offset, pinfo, tree, "file" );
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes");
+ guint32 hash;
+
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "file", &hash);
+ offset = dissect_sattr (tvb, offset, tree, "attributes");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", SETATTR Call FH:0x%08x", hash);
return offset;
}
/* RFC 1094, Page 6 */
-int
-dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 status;
+ char *err;
+ char *name=NULL;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_path(tvb, offset, pinfo, tree, hf_nfs_readlink_data);
+ offset = dissect_path(tvb, offset, tree, hf_nfs_readlink_data, &name);
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Path:%s", name);
+ }
+ proto_item_append_text(tree, ", READLINK Reply Path:%s", name);
+ g_free(name);
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READLINK Reply Error:%s", err);
break;
}
/* RFC 1094, Page 7 */
-int
-dissect_nfs2_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 offset_value;
guint32 count;
guint32 totalcount;
+ guint32 hash;
- offset = dissect_fhandle(tvb, offset, pinfo, tree, "file" );
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "file", &hash);
offset_value = tvb_get_ntohl(tvb, offset+0);
count = tvb_get_ntohl(tvb, offset+4);
totalcount = tvb_get_ntohl(tvb, offset+8);
if (tree) {
- proto_tree_add_uint(tree, hf_nfs_read_offset, tvb,
+ proto_tree_add_uint(tree, hf_nfs_read_offset, tvb,
offset+0, 4, offset_value);
- proto_tree_add_uint(tree, hf_nfs_read_count, tvb,
+ proto_tree_add_uint(tree, hf_nfs_read_count, tvb,
offset+4, 4, count);
- proto_tree_add_uint(tree, hf_nfs_read_totalcount, tvb,
+ proto_tree_add_uint(tree, hf_nfs_read_totalcount, tvb,
offset+8, 4, totalcount);
}
offset += 12;
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x Offset:%d Count:%d TotalCount:%d", hash, offset_value, count, totalcount);
+ }
+ proto_item_append_text(tree, ", READ Call FH:0x%08x Offset:%d Count:%d TotalCount:%d", hash, offset_value, count, totalcount);
+
return offset;
}
/* RFC 1094, Page 7 */
-int
-dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr(tvb, offset, pinfo, tree, "attributes");
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ offset = dissect_fattr(tvb, offset, tree, "attributes");
+ proto_item_append_text(tree, ", READ Reply");
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READ Reply Error:%s", err);
break;
}
/* RFC 1094, Page 8 */
-int
-dissect_nfs2_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 beginoffset;
guint32 offset_value;
guint32 totalcount;
+ guint32 hash;
- offset = dissect_fhandle(tvb, offset, pinfo, tree, "file" );
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "file", &hash);
beginoffset = tvb_get_ntohl(tvb, offset+0);
offset_value = tvb_get_ntohl(tvb, offset+4);
totalcount = tvb_get_ntohl(tvb, offset+8);
if (tree) {
- proto_tree_add_uint(tree, hf_nfs_write_beginoffset, tvb,
+ proto_tree_add_uint(tree, hf_nfs_write_beginoffset, tvb,
offset+0, 4, beginoffset);
- proto_tree_add_uint(tree, hf_nfs_write_offset, tvb,
+ proto_tree_add_uint(tree, hf_nfs_write_offset, tvb,
offset+4, 4, offset_value);
- proto_tree_add_uint(tree, hf_nfs_write_totalcount, tvb,
+ proto_tree_add_uint(tree, hf_nfs_write_totalcount, tvb,
offset+8, 4, totalcount);
}
offset += 12;
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x BeginOffset:%d Offset:%d TotalCount:%d", hash, beginoffset, offset_value, totalcount);
+ }
+ proto_item_append_text(tree, ", WRITE Call FH:0x%08x BeginOffset:%d Offset:%d TotalCount:%d", hash, beginoffset, offset_value, totalcount);
+
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
return offset;
}
/* RFC 1094, Page 8 */
-int
-dissect_nfs2_createargs_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_mkdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree)
+{
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "where", &hash, &name);
+ offset = dissect_sattr (tvb, offset, tree, "attributes");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", MKDIR Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
+ return offset;
+}
+
+static int
+dissect_nfs2_create_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "where" );
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes");
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "where", &hash, &name);
+ offset = dissect_sattr (tvb, offset, tree, "attributes");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", CREATE Call DH:0x%08x/%s", hash, name);
+ g_free(name);
return offset;
}
/* RFC 1094, Page 9 */
-int
-dissect_nfs2_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "from");
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "to" );
+ guint32 from_hash;
+ char *from_name=NULL;
+ guint32 to_hash;
+ char *to_name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "from", &from_hash, &from_name);
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "to", &to_hash, &to_name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x/%s To DH:0x%08x/%s", from_hash, from_name, to_hash, to_name);
+ }
+ proto_item_append_text(tree, ", RENAME Call From DH:0x%08x/%s To DH:0x%08x/%s", from_hash, from_name, to_hash, to_name);
+ g_free(from_name);
+ g_free(to_name);
return offset;
}
/* RFC 1094, Page 9 */
-int
-dissect_nfs2_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_fhandle (tvb, offset, pinfo, tree, "from");
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "to" );
+ guint32 from_hash;
+ guint32 to_hash;
+ char *to_name=NULL;
+
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "from", &from_hash);
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "to", &to_hash, &to_name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x To DH:0x%08x/%s", from_hash, to_hash, to_name);
+ }
+ proto_item_append_text(tree, ", LINK Call From DH:0x%08x To DH:0x%08x/%s", from_hash, to_hash, to_name);
+ g_free(to_name);
return offset;
}
/* RFC 1094, Page 10 */
-int
-dissect_nfs2_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_diropargs(tvb, offset, pinfo, tree, "from" );
- offset = dissect_path (tvb, offset, pinfo, tree, hf_nfs_symlink_to);
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes" );
+ guint32 from_hash;
+ char *from_name=NULL;
+ char *to_name=NULL;
+
+ offset = dissect_diropargs(tvb, offset, pinfo, tree, "from", &from_hash, &from_name);
+ offset = dissect_path(tvb, offset, tree, hf_nfs_symlink_to, &to_name);
+ offset = dissect_sattr(tvb, offset, tree, "attributes");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x/%s To %s", from_hash, from_name, to_name);
+ }
+ proto_item_append_text(tree, ", SYMLINK Call From DH:0x%08x/%s To %s", from_hash, from_name, to_name);
+ g_free(from_name);
+ g_free(to_name);
return offset;
}
/* RFC 1094, Page 11 */
-int
-dissect_nfs2_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 cookie;
guint32 count;
+ guint32 hash;
- offset = dissect_fhandle (tvb, offset, pinfo, tree, "dir");
+ offset = dissect_fhandle(tvb, offset, pinfo, tree, "dir", &hash);
cookie = tvb_get_ntohl(tvb, offset+ 0);
count = tvb_get_ntohl(tvb, offset+ 4);
if (tree) {
}
offset += 8;
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", READDIR Call FH:0x%08x", hash);
+
return offset;
}
/* RFC 1094, Page 11 */
-int
-dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
proto_item* entry_item = NULL;
if (tree) {
entry_item = proto_tree_add_item(tree, hf_nfs_readdir_entry, tvb,
- offset+0, tvb_length_remaining(tvb, offset), FALSE);
+ offset+0, -1, FALSE);
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
offset+0, 4, fileid);
offset += 4;
- offset = dissect_filename(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename(tvb, offset, entry_tree,
hf_nfs_readdir_entry_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: file ID %u, name %s",
fileid, name);
g_free(name);
-
+
cookie = tvb_get_ntohl(tvb, offset + 0);
if (entry_tree)
proto_tree_add_uint(entry_tree, hf_nfs_readdir_entry_cookie, tvb,
}
/* RFC 1094, Page 11 */
-int
-dissect_nfs2_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
guint32 eof_value;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ proto_item_append_text(tree, ", READDIR Reply");
+
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_readdir_entry);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
offset += 4;
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READDIR Reply Error:%s", err);
break;
}
/* RFC 1094, Page 12 */
-int
-dissect_nfs2_statfs_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs2_statfs_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 blocks;
guint32 bfree;
guint32 bavail;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
tsize = tvb_get_ntohl(tvb, offset+ 0);
offset+16, 4, bavail);
}
offset += 20;
+ proto_item_append_text(tree, ", STATFS Reply");
break;
default:
- /* do nothing */
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", STATFS Reply Error:%s", err);
break;
}
{ 0, "NULL", /* OK */
NULL, NULL },
{ 1, "GETATTR", /* OK */
- dissect_nfs2_fhandle_call, dissect_nfs2_attrstat_reply },
+ dissect_nfs2_getattr_call, dissect_nfs2_getattr_reply },
{ 2, "SETATTR", /* OK */
- dissect_nfs2_setattr_call, dissect_nfs2_attrstat_reply },
+ dissect_nfs2_setattr_call, dissect_nfs2_setattr_reply },
{ 3, "ROOT", /* OK */
NULL, NULL },
{ 4, "LOOKUP", /* OK */
- dissect_nfs2_diropargs_call, dissect_nfs2_diropres_reply },
+ dissect_nfs2_lookup_call, dissect_nfs2_lookup_reply },
{ 5, "READLINK", /* OK */
- dissect_nfs2_fhandle_call, dissect_nfs2_readlink_reply },
+ dissect_nfs2_readlink_call, dissect_nfs2_readlink_reply },
{ 6, "READ", /* OK */
dissect_nfs2_read_call, dissect_nfs2_read_reply },
{ 7, "WRITECACHE", /* OK */
NULL, NULL },
{ 8, "WRITE", /* OK */
- dissect_nfs2_write_call, dissect_nfs2_attrstat_reply },
+ dissect_nfs2_write_call, dissect_nfs2_write_reply },
{ 9, "CREATE", /* OK */
- dissect_nfs2_createargs_call, dissect_nfs2_diropres_reply },
+ dissect_nfs2_create_call, dissect_nfs2_create_reply },
{ 10, "REMOVE", /* OK */
- dissect_nfs2_diropargs_call, dissect_nfs2_stat_reply },
+ dissect_nfs2_remove_call, dissect_nfs2_remove_reply },
{ 11, "RENAME", /* OK */
- dissect_nfs2_rename_call, dissect_nfs2_stat_reply },
+ dissect_nfs2_rename_call, dissect_nfs2_rename_reply },
{ 12, "LINK", /* OK */
- dissect_nfs2_link_call, dissect_nfs2_stat_reply },
+ dissect_nfs2_link_call, dissect_nfs2_link_reply },
{ 13, "SYMLINK", /* OK */
- dissect_nfs2_symlink_call, dissect_nfs2_stat_reply },
+ dissect_nfs2_symlink_call, dissect_nfs2_symlink_reply },
{ 14, "MKDIR", /* OK */
- dissect_nfs2_createargs_call, dissect_nfs2_diropres_reply },
+ dissect_nfs2_mkdir_call, dissect_nfs2_mkdir_reply },
{ 15, "RMDIR", /* OK */
- dissect_nfs2_diropargs_call, dissect_nfs2_stat_reply },
+ dissect_nfs2_rmdir_call, dissect_nfs2_rmdir_reply },
{ 16, "READDIR", /* OK */
dissect_nfs2_readdir_call, dissect_nfs2_readdir_reply },
{ 17, "STATFS", /* OK */
- dissect_nfs2_fhandle_call, dissect_nfs2_statfs_reply },
+ dissect_nfs2_statfs_call, dissect_nfs2_statfs_reply },
{ 0,NULL,NULL,NULL }
};
+
+static const value_string nfsv2_proc_vals[] = {
+ { 0, "NULL" },
+ { 1, "GETATTR" },
+ { 2, "SETATTR" },
+ { 3, "ROOT" },
+ { 4, "LOOKUP" },
+ { 5, "READLINK" },
+ { 6, "READ" },
+ { 7, "WRITECACHE" },
+ { 8, "WRITE" },
+ { 9, "CREATE" },
+ { 10, "REMOVE" },
+ { 11, "RENAME" },
+ { 12, "LINK" },
+ { 13, "SYMLINK" },
+ { 14, "MKDIR" },
+ { 15, "RMDIR" },
+ { 16, "READDIR" },
+ { 17, "STATFS" },
+ { 0, NULL }
+};
+
/* end of NFS Version 2 */
/* RFC 1813, Page 15 */
-int
-dissect_filename3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_filename3(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, string_ret);
return offset;
}
/* RFC 1813, Page 15 */
-int
-dissect_nfspath3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, int hf)
+static int
+dissect_nfspath3(tvbuff_t *tvb, int offset, proto_tree *tree, int hf, char **name)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, name);
return offset;
}
/* RFC 1813, Page 15 */
-int
-dissect_cookieverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+static int
+dissect_cookieverf3(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_COOKIEVERFSIZE,
"Verifier: Opaque Data");
/* RFC 1813, Page 16 */
-int
-dissect_createverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+static int
+dissect_createverf3(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_CREATEVERFSIZE,
"Verifier: Opaque Data");
/* RFC 1813, Page 16 */
-int
-dissect_writeverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+static int
+dissect_writeverf3(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_WRITEVERFSIZE,
"Verifier: Opaque Data");
}
/* RFC 1813, Page 16 */
-int
-dissect_mode3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
- char* name)
+static int
+dissect_mode3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
guint32 mode3;
proto_item* mode3_item = NULL;
proto_tree* mode3_tree = NULL;
mode3 = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
mode3_item = proto_tree_add_text(tree, tvb, offset, 4,
"%s: 0%o", name, mode3);
}
/* RFC 1813, Page 16,17 */
-const value_string names_nfs_nfsstat3[] =
+static const value_string names_nfs_nfsstat3[] =
{
{ 0, "OK" },
{ 1, "ERR_PERM" },
/* RFC 1813, Page 16 */
-int
-dissect_nfsstat3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfsstat3(tvbuff_t *tvb, int offset,
proto_tree *tree,guint32 *status)
{
guint32 nfsstat3;
nfsstat3 = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
proto_tree_add_uint(tree, hf_nfs_nfsstat3, tvb,
offset, 4, nfsstat3);
}
-const value_string names_nfs_ftype3[] =
+static const value_string names_nfs_ftype3[] =
{
{ NF3REG, "Regular File" },
{ NF3DIR, "Directory" },
/* RFC 1813, Page 20 */
-int
-dissect_ftype3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+static int
+dissect_ftype3(tvbuff_t *tvb, int offset, proto_tree *tree,
int hf, guint32* ftype3)
{
guint32 type;
type = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
proto_tree_add_uint(tree, hf, tvb, offset, 4, type);
}
/* RFC 1813, Page 20 */
-int
-dissect_specdata3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_specdata3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
guint32 specdata1;
guint32 specdata2;
specdata1 = tvb_get_ntohl(tvb, offset+0);
specdata2 = tvb_get_ntohl(tvb, offset+4);
-
+
if (tree) {
specdata3_item = proto_tree_add_text(tree, tvb, offset, 8,
"%s: %u,%u", name, specdata1, specdata2);
/* RFC 1813, Page 21 */
int
-dissect_nfs_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, char *name, guint32 *hash)
{
guint fh3_len;
guint fh3_len_full;
guint fh3_fill;
- proto_item* fitem;
+ proto_item* fitem = NULL;
proto_tree* ftree = NULL;
+ int fh_offset,fh_length;
fh3_len = tvb_get_ntohl(tvb, offset+0);
fh3_len_full = rpc_roundup(fh3_len);
fh3_fill = fh3_len_full - fh3_len;
-
+
if (tree) {
fitem = proto_tree_add_text(tree, tvb, offset, 4+fh3_len_full,
"%s", name);
ftree = proto_item_add_subtree(fitem, ett_nfs_fh3);
}
- if (ftree) {
- proto_tree_add_uint(ftree, hf_nfs_fh_length, tvb, offset+0, 4,
- fh3_len);
- dissect_fhandle_data(tvb, offset+4, pinfo, ftree, fh3_len);
+ /* are we snooping fh to filenames ?*/
+ if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
+ rpc_call_info_value *civ=pinfo->private_data;
+
+ /* NFS v3 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
+ if( (civ->prog==100003)
+ &&(civ->vers==3)
+ &&(!civ->request)
+ &&((civ->proc==3)||(civ->proc==8)||(civ->proc==9))
+ ) {
+ fh_length=tvb_get_ntohl(tvb, offset);
+ fh_offset=offset+4;
+ nfs_name_snoop_add_fh(civ->xid, tvb,
+ fh_offset, fh_length);
+ }
+
+ /* MOUNT v3 MNT replies might give us a filehandle */
+ if( (civ->prog==100005)
+ &&(civ->vers==3)
+ &&(!civ->request)
+ &&(civ->proc==1)
+ ) {
+ fh_length=tvb_get_ntohl(tvb, offset);
+ fh_offset=offset+4;
+ nfs_name_snoop_add_fh(civ->xid, tvb,
+ fh_offset, fh_length);
+ }
+ }
+
+ proto_tree_add_uint(ftree, hf_nfs_fh_length, tvb, offset+0, 4,
+ fh3_len);
+
+ /* Handle WebNFS requests where filehandle may be 0 length */
+ if (fh3_len > 0)
+ {
+ dissect_fhandle_data(tvb, offset+4, pinfo, ftree, fh3_len, FALSE, hash);
+
+ offset += fh3_len_full;
}
- offset += 4 + fh3_len_full;
+
+ offset += 4;
+
return offset;
}
/* RFC 1813, Page 21 */
-int
-dissect_nfstime3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfstime3(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_nsec)
{
guint32 seconds;
nseconds = tvb_get_ntohl(tvb, offset+4);
ts.secs = seconds;
ts.nsecs = nseconds;
-
+
if (tree) {
time_item = proto_tree_add_time(tree, hf_time, tvb, offset, 8,
&ts);
/* RFC 1813, Page 22 */
int
-dissect_fattr3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
- char* name)
+dissect_nfs_fattr3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* fattr3_item = NULL;
proto_tree* fattr3_tree = NULL;
guint32 type;
if (tree) {
- fattr3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
+ fattr3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
fattr3_tree = proto_item_add_subtree(fattr3_item, ett_nfs_fattr3);
}
- offset = dissect_ftype3(tvb,offset,pinfo,fattr3_tree,hf_nfs_fattr3_type,&type);
- offset = dissect_mode3(tvb,offset,pinfo,fattr3_tree,"mode");
- offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_nlink,
+ offset = dissect_ftype3(tvb,offset,fattr3_tree,hf_nfs_fattr3_type,&type);
+ offset = dissect_mode3(tvb,offset,fattr3_tree,"mode");
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_nlink,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_uid,
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_uid,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_gid,
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_gid,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_size,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_size,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_used,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_used,
offset);
- offset = dissect_specdata3(tvb,offset,pinfo,fattr3_tree,"rdev");
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fsid,
+ offset = dissect_specdata3(tvb,offset,fattr3_tree,"rdev");
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_fsid,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fileid,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_fileid,
offset);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_atime,hf_nfs_atime_sec,hf_nfs_atime_nsec);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_mtime,hf_nfs_mtime_sec,hf_nfs_mtime_nsec);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_ctime,hf_nfs_ctime_sec,hf_nfs_ctime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_atime,hf_nfs_atime_sec,hf_nfs_atime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_mtime,hf_nfs_mtime_sec,hf_nfs_mtime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_ctime,hf_nfs_ctime_sec,hf_nfs_ctime_nsec);
/* now we know, that fattr3 is shorter */
if (fattr3_item) {
}
-const value_string value_follows[] =
+static const value_string value_follows[] =
{
{ 0, "no value" },
{ 1, "value follows"},
/* RFC 1813, Page 23 */
int
-dissect_post_op_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+dissect_nfs_post_op_attr(tvbuff_t *tvb, int offset, proto_tree *tree,
+ char* name)
{
proto_item* post_op_attr_item = NULL;
proto_tree* post_op_attr_tree = NULL;
guint32 attributes_follow;
if (tree) {
- post_op_attr_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- post_op_attr_tree = proto_item_add_subtree(post_op_attr_item,
+ post_op_attr_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
+ post_op_attr_tree = proto_item_add_subtree(post_op_attr_item,
ett_nfs_post_op_attr);
}
attributes_follow = tvb_get_ntohl(tvb, offset+0);
proto_tree_add_text(post_op_attr_tree, tvb, offset, 4,
- "attributes_follow: %s (%u)",
+ "attributes_follow: %s (%u)",
val_to_str(attributes_follow,value_follows,"Unknown"), attributes_follow);
offset += 4;
switch (attributes_follow) {
case TRUE:
- offset = dissect_fattr3(tvb, offset, pinfo, post_op_attr_tree,
+ offset = dissect_nfs_fattr3(tvb, offset, post_op_attr_tree,
"attributes");
break;
case FALSE:
/* void */
break;
}
-
+
/* now we know, that post_op_attr_tree is shorter */
if (post_op_attr_item) {
proto_item_set_len(post_op_attr_item, offset - old_offset);
/* RFC 1813, Page 24 */
-int
-dissect_wcc_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_wcc_attr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* wcc_attr_item = NULL;
proto_tree* wcc_attr_tree = NULL;
int old_offset = offset;
if (tree) {
- wcc_attr_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- wcc_attr_tree = proto_item_add_subtree(wcc_attr_item,
+ wcc_attr_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
+ wcc_attr_tree = proto_item_add_subtree(wcc_attr_item,
ett_nfs_wcc_attr);
}
- offset = dissect_rpc_uint64(tvb, pinfo, wcc_attr_tree, hf_nfs_wcc_attr_size,
+ offset = dissect_rpc_uint64(tvb, wcc_attr_tree, hf_nfs_wcc_attr_size,
offset);
- offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_nsec);
- offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
+ offset = dissect_nfstime3(tvb, offset, wcc_attr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_nsec);
+ offset = dissect_nfstime3(tvb, offset, wcc_attr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
/* now we know, that wcc_attr_tree is shorter */
if (wcc_attr_item) {
proto_item_set_len(wcc_attr_item, offset - old_offset);
/* RFC 1813, Page 24 */
-int
-dissect_pre_op_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_pre_op_attr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* pre_op_attr_item = NULL;
proto_tree* pre_op_attr_tree = NULL;
guint32 attributes_follow;
if (tree) {
- pre_op_attr_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- pre_op_attr_tree = proto_item_add_subtree(pre_op_attr_item,
+ pre_op_attr_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
+ pre_op_attr_tree = proto_item_add_subtree(pre_op_attr_item,
ett_nfs_pre_op_attr);
}
attributes_follow = tvb_get_ntohl(tvb, offset+0);
proto_tree_add_text(pre_op_attr_tree, tvb, offset, 4,
- "attributes_follow: %s (%u)",
+ "attributes_follow: %s (%u)",
val_to_str(attributes_follow,value_follows,"Unknown"), attributes_follow);
offset += 4;
switch (attributes_follow) {
case TRUE:
- offset = dissect_wcc_attr(tvb, offset, pinfo, pre_op_attr_tree,
+ offset = dissect_wcc_attr(tvb, offset, pre_op_attr_tree,
"attributes");
break;
case FALSE:
/* void */
break;
}
-
+
/* now we know, that pre_op_attr_tree is shorter */
if (pre_op_attr_item) {
proto_item_set_len(pre_op_attr_item, offset - old_offset);
/* RFC 1813, Page 24 */
-int
-dissect_wcc_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_wcc_data(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* wcc_data_item = NULL;
proto_tree* wcc_data_tree = NULL;
int old_offset = offset;
if (tree) {
- wcc_data_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- wcc_data_tree = proto_item_add_subtree(wcc_data_item,
+ wcc_data_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
+ wcc_data_tree = proto_item_add_subtree(wcc_data_item,
ett_nfs_wcc_data);
}
- offset = dissect_pre_op_attr (tvb, offset, pinfo, wcc_data_tree, "before");
- offset = dissect_post_op_attr(tvb, offset, pinfo, wcc_data_tree, "after" );
+ offset = dissect_pre_op_attr (tvb, offset, wcc_data_tree, "before");
+ offset = dissect_nfs_post_op_attr(tvb, offset, wcc_data_tree, "after" );
/* now we know, that wcc_data is shorter */
if (wcc_data_item) {
/* RFC 1813, Page 25 */
-int
-dissect_post_op_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_post_op_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char* name)
{
proto_item* post_op_fh3_item = NULL;
guint32 handle_follows;
if (tree) {
- post_op_fh3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- post_op_fh3_tree = proto_item_add_subtree(post_op_fh3_item,
+ post_op_fh3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
+ post_op_fh3_tree = proto_item_add_subtree(post_op_fh3_item,
ett_nfs_post_op_fh3);
}
handle_follows = tvb_get_ntohl(tvb, offset+0);
proto_tree_add_text(post_op_fh3_tree, tvb, offset, 4,
- "handle_follows: %s (%u)",
+ "handle_follows: %s (%u)",
val_to_str(handle_follows,value_follows,"Unknown"), handle_follows);
offset += 4;
switch (handle_follows) {
case TRUE:
offset = dissect_nfs_fh3(tvb, offset, pinfo, post_op_fh3_tree,
- "handle");
+ "handle", NULL);
break;
case FALSE:
/* void */
break;
}
-
+
/* now we know, that post_op_fh3_tree is shorter */
if (post_op_fh3_item) {
proto_item_set_len(post_op_fh3_item, offset - old_offset);
/* RFC 1813, Page 25 */
-int
-dissect_set_mode3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_mode3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_mode3_item = NULL;
proto_tree* set_mode3_tree = NULL;
set_it_name = val_to_str(set_it,value_follows,"Unknown");
if (tree) {
- set_mode3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_mode3_tree = proto_item_add_subtree(set_mode3_item,
+ set_mode3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_mode3_tree = proto_item_add_subtree(set_mode3_item,
ett_nfs_set_mode3);
}
switch (set_it) {
case 1:
- offset = dissect_mode3(tvb, offset, pinfo, set_mode3_tree,
+ offset = dissect_mode3(tvb, offset, set_mode3_tree,
"mode");
break;
default:
/* void */
break;
}
-
+
/* now we know, that set_mode3 is shorter */
if (set_mode3_item) {
proto_item_set_len(set_mode3_item, offset - old_offset);
/* RFC 1813, Page 26 */
-int
-dissect_set_uid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_uid3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_uid3_item = NULL;
proto_tree* set_uid3_tree = NULL;
set_it_name = val_to_str(set_it,value_follows,"Unknown");
if (tree) {
- set_uid3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_uid3_tree = proto_item_add_subtree(set_uid3_item,
+ set_uid3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_uid3_tree = proto_item_add_subtree(set_uid3_item,
ett_nfs_set_uid3);
}
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32(tvb, pinfo, set_uid3_tree,
+ offset = dissect_rpc_uint32(tvb, set_uid3_tree,
hf_nfs_uid3, offset);
break;
default:
/* RFC 1813, Page 26 */
-int
-dissect_set_gid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_gid3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_gid3_item = NULL;
proto_tree* set_gid3_tree = NULL;
set_it_name = val_to_str(set_it,value_follows,"Unknown");
if (tree) {
- set_gid3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_gid3_tree = proto_item_add_subtree(set_gid3_item,
+ set_gid3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_gid3_tree = proto_item_add_subtree(set_gid3_item,
ett_nfs_set_gid3);
}
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32(tvb, pinfo, set_gid3_tree,
+ offset = dissect_rpc_uint32(tvb, set_gid3_tree,
hf_nfs_gid3, offset);
break;
default:
/* RFC 1813, Page 26 */
-int
-dissect_set_size3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_size3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_size3_item = NULL;
proto_tree* set_size3_tree = NULL;
set_it_name = val_to_str(set_it,value_follows,"Unknown");
if (tree) {
- set_size3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_size3_tree = proto_item_add_subtree(set_size3_item,
+ set_size3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_size3_tree = proto_item_add_subtree(set_size3_item,
ett_nfs_set_size3);
}
switch (set_it) {
case 1:
- offset = dissect_rpc_uint64(tvb, pinfo, set_size3_tree,
+ offset = dissect_rpc_uint64(tvb, set_size3_tree,
hf_nfs_set_size3_size, offset);
break;
default:
#define SET_TO_SERVER_TIME 1
#define SET_TO_CLIENT_TIME 2
-const value_string time_how[] =
+static const value_string time_how[] =
{
{ DONT_CHANGE, "don't change" },
{ SET_TO_SERVER_TIME, "set to server time" },
/* RFC 1813, Page 26 */
-int
-dissect_set_atime(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_atime(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_atime_item = NULL;
proto_tree* set_atime_tree = NULL;
set_it_name = val_to_str(set_it,time_how,"Unknown");
if (tree) {
- set_atime_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_atime_tree = proto_item_add_subtree(set_atime_item,
+ set_atime_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_atime_tree = proto_item_add_subtree(set_atime_item,
ett_nfs_set_atime);
}
switch (set_it) {
case SET_TO_CLIENT_TIME:
if (set_atime_item) {
- offset = dissect_nfstime3(tvb, offset, pinfo, set_atime_tree,
+ offset = dissect_nfstime3(tvb, offset, set_atime_tree,
hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_nsec);
}
break;
/* RFC 1813, Page 26 */
-int
-dissect_set_mtime(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_set_mtime(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* set_mtime_item = NULL;
proto_tree* set_mtime_tree = NULL;
set_it_name = val_to_str(set_it,time_how,"Unknown");
if (tree) {
- set_mtime_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, set_it_name);
- set_mtime_tree = proto_item_add_subtree(set_mtime_item,
+ set_mtime_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, set_it_name);
+ set_mtime_tree = proto_item_add_subtree(set_mtime_item,
ett_nfs_set_mtime);
}
switch (set_it) {
case SET_TO_CLIENT_TIME:
if (set_mtime_item) {
- offset = dissect_nfstime3(tvb, offset, pinfo, set_mtime_tree,
+ offset = dissect_nfstime3(tvb, offset, set_mtime_tree,
hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_nsec);
}
break;
/* RFC 1813, Page 25..27 */
-int
-dissect_sattr3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
- char* name)
+static int
+dissect_sattr3(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* sattr3_item = NULL;
proto_tree* sattr3_tree = NULL;
int old_offset = offset;
if (tree) {
- sattr3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
+ sattr3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", name);
sattr3_tree = proto_item_add_subtree(sattr3_item, ett_nfs_sattr3);
}
- offset = dissect_set_mode3(tvb, offset, pinfo, sattr3_tree, "mode");
- offset = dissect_set_uid3 (tvb, offset, pinfo, sattr3_tree, "uid");
- offset = dissect_set_gid3 (tvb, offset, pinfo, sattr3_tree, "gid");
- offset = dissect_set_size3(tvb, offset, pinfo, sattr3_tree, "size");
- offset = dissect_set_atime(tvb, offset, pinfo, sattr3_tree, "atime");
- offset = dissect_set_mtime(tvb, offset, pinfo, sattr3_tree, "mtime");
+ offset = dissect_set_mode3(tvb, offset, sattr3_tree, "mode");
+ offset = dissect_set_uid3 (tvb, offset, sattr3_tree, "uid");
+ offset = dissect_set_gid3 (tvb, offset, sattr3_tree, "gid");
+ offset = dissect_set_size3(tvb, offset, sattr3_tree, "size");
+ offset = dissect_set_atime(tvb, offset, sattr3_tree, "atime");
+ offset = dissect_set_mtime(tvb, offset, sattr3_tree, "mtime");
/* now we know, that sattr3 is shorter */
if (sattr3_item) {
/* RFC 1813, Page 27 */
-int
-dissect_diropargs3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char* name)
+static int
+dissect_diropargs3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree, char* label, guint32 *hash, char **name)
{
proto_item* diropargs3_item = NULL;
proto_tree* diropargs3_tree = NULL;
int old_offset = offset;
+ int parent_offset, parent_len;
+ int name_offset, name_len;
if (tree) {
- diropargs3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s", name);
- diropargs3_tree = proto_item_add_subtree(diropargs3_item,
+ diropargs3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s", label);
+ diropargs3_tree = proto_item_add_subtree(diropargs3_item,
ett_nfs_diropargs3);
}
- offset = dissect_nfs_fh3(tvb, offset, pinfo, diropargs3_tree, "dir");
- offset = dissect_filename3(tvb, offset, pinfo, diropargs3_tree,
- hf_nfs_name, NULL);
+ parent_offset=offset+4;
+ parent_len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, diropargs3_tree, "dir", hash);
+ name_offset=offset+4;
+ name_len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_filename3(tvb, offset, diropargs3_tree,
+ hf_nfs_name, name);
+
+ /* are we snooping fh to filenames ?*/
+ if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
+ /* v3 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
+ rpc_call_info_value *civ=pinfo->private_data;
+
+ if( (civ->prog==100003)
+ &&(civ->vers==3)
+ &&(civ->request)
+ &&((civ->proc==3)||(civ->proc==8)||(civ->proc==9))
+ ) {
+ nfs_name_snoop_add_name(civ->xid, tvb,
+ name_offset, name_len,
+ parent_offset, parent_len, NULL);
+ }
+ }
+
/* now we know, that diropargs3 is shorter */
if (diropargs3_item) {
return offset;
}
+static int
+dissect_nfs3_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree)
+{
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "object", &hash, &name);
-/* RFC 1813, Page 27 */
-int
-dissect_nfs3_diropargs3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", REMOVE Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
+ return offset;
+}
+
+static int
+dissect_nfs3_null_call(tvbuff_t *tvb _U_, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "object");
+ proto_item_append_text(tree, ", NULL Call");
+
+ return offset;
+}
+
+static int
+dissect_nfs3_null_reply(tvbuff_t *tvb _U_, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
+{
+ proto_item_append_text(tree, ", NULL Reply");
+
+ return offset;
+}
+
+static int
+dissect_nfs3_rmdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree)
+{
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "object", &hash, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", RMDIR Call DH:0x%08x/%s", hash, name);
+ g_free(name);
return offset;
}
/* RFC 1813, Page 40 */
int
-dissect_access(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_access(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
guint32 access;
proto_tree* access_tree = NULL;
access = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
access_item = proto_tree_add_text(tree, tvb, offset, 4,
"%s: 0x%02x", name, access);
}
-/* NFS3 file handle dissector */
-int
-dissect_nfs3_nfs_fh3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+/* RFC 1813, Page 32,33 */
+static int
+dissect_nfs3_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- return offset;
-}
-
+ guint32 hash;
-/* generic NFS3 reply dissector */
-int
-dissect_nfs3_any_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree)
-{
- guint32 status;
-
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
-
- return offset;
-
-}
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", GETATTR Call FH:0x%08x", hash);
-/* RFC 1813, Page 32,33 */
-int
-dissect_nfs3_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree)
-{
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
return offset;
}
/* RFC 1813, Page 32,33 */
-int
-dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr3(tvb, offset, pinfo, tree, "obj_attributes");
+ offset = dissect_nfs_fattr3(tvb, offset, tree, "obj_attributes");
+ proto_item_append_text(tree, ", GETATTR Reply");
break;
default:
/* void */
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", GETATTR Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 33 */
-int
-dissect_sattrguard3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree, char *name)
+static int
+dissect_sattrguard3(tvbuff_t *tvb, int offset, proto_tree* tree, char *name)
{
proto_item* sattrguard3_item = NULL;
proto_tree* sattrguard3_tree = NULL;
check_name = val_to_str(check,value_follows,"Unknown");
if (tree) {
- sattrguard3_item = proto_tree_add_text(tree, tvb, offset,
- tvb_length_remaining(tvb, offset), "%s: %s",
- name, check_name);
- sattrguard3_tree = proto_item_add_subtree(sattrguard3_item,
+ sattrguard3_item = proto_tree_add_text(tree, tvb, offset, -1,
+ "%s: %s", name, check_name);
+ sattrguard3_tree = proto_item_add_subtree(sattrguard3_item,
ett_nfs_sattrguard3);
}
switch (check) {
case TRUE:
- offset = dissect_nfstime3(tvb, offset, pinfo, sattrguard3_tree,
+ offset = dissect_nfstime3(tvb, offset, sattrguard3_tree,
hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
break;
case FALSE:
/* RFC 1813, Page 33..36 */
-int
-dissect_nfs3_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "object");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "new_attributes");
- offset = dissect_sattrguard3(tvb, offset, pinfo, tree, "guard");
+ guint32 hash;
+
+ offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "object", &hash);
+ offset = dissect_sattr3 (tvb, offset, tree, "new_attributes");
+ offset = dissect_sattrguard3(tvb, offset, tree, "guard");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", SETATTR Call FH:0x%08x", hash);
+
return offset;
}
/* RFC 1813, Page 33..36 */
-int
-dissect_nfs3_setattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_setattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "obj_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "obj_wcc");
+ proto_item_append_text(tree, ", SETATTR Reply");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "obj_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "obj_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", SETATTR Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 37..39 */
-int
-dissect_nfs3_lookup_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_lookup_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "what");
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "what", &hash, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", LOOKUP Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
return offset;
}
/* RFC 1813, Page 37..39 */
-int
-dissect_nfs3_lookup_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_lookup_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
+ char *err;
+ guint32 hash;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", LOOKUP Reply FH:0x%08x", hash);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", LOOKUP Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 40..43 */
-int
-dissect_nfs3_access_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_access_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- offset = dissect_access (tvb, offset, pinfo, tree, "access");
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+ offset = dissect_access (tvb, offset, tree, "access");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", ACCESS Call FH:0x%08x", hash);
return offset;
}
/* RFC 1813, Page 40..43 */
-int
-dissect_nfs3_access_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_access_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_access(tvb, offset, pinfo, tree, "access");
+ offset = dissect_access(tvb, offset, tree, "access");
+
+ proto_item_append_text(tree, ", ACCESS Reply");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", ACCESS Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 44,45 */
-int
-dissect_nfs3_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_readlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", READLINK Call FH:0x%08x", hash);
+
+ return offset;
+}
+static int
+dissect_nfs3_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
+ char *name=NULL;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"symlink_attributes");
- offset = dissect_nfspath3(tvb, offset, pinfo, tree,
- hf_nfs_readlink_data);
+ offset = dissect_nfspath3(tvb, offset, tree,
+ hf_nfs_readlink_data, &name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Path:%s", name);
+ }
+ proto_item_append_text(tree, ", READLINK Reply Path:%s", name);
+ g_free(name);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"symlink_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READLINK Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 46..48 */
-int
-dissect_nfs3_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
+ unsigned char *off;
+ guint32 len;
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file", &hash);
+
+ off=u64toa(tvb_get_ptr(tvb, offset, 8));
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+
+ len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
+
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x Offset:%s Len:%d", hash, off, len);
+ }
+ proto_item_append_text(tree, ", READ Call FH:0x%08x Offset:%s Len:%d", hash, off, len);
return offset;
}
/* RFC 1813, Page 46..48 */
-int
-dissect_nfs3_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ guint32 len;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
+ len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_read_eof,
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_read_eof,
offset);
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Len:%d", len);
+ }
+ proto_item_append_text(tree, ", READ Reply Len:%d", len);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"file_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READ Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 49 */
-int
-dissect_stable_how(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree, int hfindex)
+static int
+dissect_stable_how(tvbuff_t *tvb, int offset, proto_tree* tree, int hfindex)
{
guint32 stable_how;
stable_how = tvb_get_ntohl(tvb,offset+0);
if (tree) {
proto_tree_add_uint(tree, hfindex, tvb,
- offset, 4, stable_how);
+ offset, 4, stable_how);
}
offset += 4;
/* RFC 1813, Page 49..54 */
-int
-dissect_nfs3_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
- offset = dissect_stable_how(tvb, offset, pinfo, tree, hf_nfs_write_stable);
- offset = dissect_nfsdata (tvb, offset, pinfo, tree, hf_nfs_data);
+ unsigned char *off;
+ guint32 len;
+ guint32 stable;
+ guint32 hash;
+
+ offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file", &hash);
+
+ off=u64toa(tvb_get_ptr(tvb, offset, 8));
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+
+ len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
+
+ stable=tvb_get_ntohl(tvb, offset);
+ offset = dissect_stable_how(tvb, offset, tree, hf_nfs_write_stable);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x Offset:%s Len:%d %s", hash, off, len, val_to_str(stable, names_stable_how, "Stable:%u"));
+ }
+ proto_item_append_text(tree, ", WRITE Call FH:0x%08x Offset:%s Len:%d %s", hash, off, len, val_to_str(stable, names_stable_how, "Stable:%u"));
+
+ offset = dissect_nfsdata (tvb, offset, tree, hf_nfs_data);
return offset;
}
/* RFC 1813, Page 49..54 */
-int
-dissect_nfs3_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ guint32 len;
+ guint32 stable;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "file_wcc");
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
+ offset = dissect_wcc_data (tvb, offset, tree, "file_wcc");
+ len=tvb_get_ntohl(tvb, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
- offset = dissect_stable_how(tvb, offset, pinfo, tree,
+ stable=tvb_get_ntohl(tvb, offset);
+ offset = dissect_stable_how(tvb, offset, tree,
hf_nfs_write_committed);
- offset = dissect_writeverf3(tvb, offset, pinfo, tree);
+ offset = dissect_writeverf3(tvb, offset, tree);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Len:%d %s", len, val_to_str(stable, names_stable_how, "Stable:%u"));
+ }
+ proto_item_append_text(tree, ", WRITE Reply Len:%d %s", len, val_to_str(stable, names_stable_how, "Stable:%u"));
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "file_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "file_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", WRITE Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 54 */
-int
-dissect_createmode3(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree, guint32* mode)
+static int
+dissect_createmode3(tvbuff_t *tvb, int offset, proto_tree* tree, guint32* mode)
{
guint32 mode_value;
-
+
mode_value = tvb_get_ntohl(tvb, offset + 0);
if (tree) {
proto_tree_add_uint(tree, hf_nfs_createmode3, tvb,
/* RFC 1813, Page 54..58 */
-int
-dissect_nfs3_create_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_create_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 mode;
+ guint32 hash;
+ char *name=NULL;
- offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "where");
- offset = dissect_createmode3(tvb, offset, pinfo, tree, &mode);
+ offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "where", &hash, &name);
+ offset = dissect_createmode3(tvb, offset, tree, &mode);
switch (mode) {
case UNCHECKED:
case GUARDED:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "obj_attributes");
+ offset = dissect_sattr3(tvb, offset, tree, "obj_attributes");
break;
case EXCLUSIVE:
- offset = dissect_createverf3(tvb, offset, pinfo, tree);
+ offset = dissect_createverf3(tvb, offset, tree);
break;
}
-
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s Mode:%s", hash, name, val_to_str(mode, names_createmode3, "Unknown Mode:%u"));
+ }
+ proto_item_append_text(tree, ", CREATE Call DH:0x%08x/%s Mode:%s", hash, name, val_to_str(mode, names_createmode3, "Unknown Mode:%u"));
+ g_free(name);
+
return offset;
}
/* RFC 1813, Page 54..58 */
-int
-dissect_nfs3_create_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_create_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", CREATE Reply");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", CREATE Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 58..60 */
-int
-dissect_nfs3_mkdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_mkdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "attributes");
-
+ guint32 hash;
+ char *name=NULL;
+
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where", &hash, &name);
+ offset = dissect_sattr3 (tvb, offset, tree, "attributes");
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", DH:0x%08x/%s", hash, name);
+ }
+ proto_item_append_text(tree, ", MKDIR Call DH:0x%08x/%s", hash, name);
+ g_free(name);
+
+ return offset;
+}
+
+static int
+dissect_nfs3_mkdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
+ "obj_attributes");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", MKDIR Reply");
+ break;
+ default:
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", MKDIR Reply Error:%s", err);
+ break;
+ }
+
return offset;
}
/* RFC 1813, Page 61..63 */
-int
-dissect_nfs3_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "symlink_attributes");
- offset = dissect_nfspath3 (tvb, offset, pinfo, tree, hf_nfs_symlink_to);
-
+ guint32 from_hash;
+ char *from_name=NULL;
+ char *to_name=NULL;
+
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where", &from_hash, &from_name);
+ offset = dissect_sattr3 (tvb, offset, tree, "symlink_attributes");
+ offset = dissect_nfspath3 (tvb, offset, tree, hf_nfs_symlink_to, &to_name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x/%s To %s", from_hash, from_name, to_name);
+ }
+ proto_item_append_text(tree, ", SYMLINK Call From DH:0x%08x/%s To %s", from_hash, from_name, to_name);
+ g_free(from_name);
+ g_free(to_name);
+
+ return offset;
+}
+static int
+dissect_nfs3_symlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
+ "obj_attributes");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", SYMLINK Reply");
+ break;
+ default:
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", SYMLINK Reply Error:%s", err);
+ break;
+ }
+
return offset;
}
/* RFC 1813, Page 63..66 */
-int
-dissect_nfs3_mknod_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_mknod_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 type;
+ guint32 hash;
+ char *name=NULL;
+ char *type_str;
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_ftype3(tvb, offset, pinfo, tree, hf_nfs_ftype3, &type);
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where", &hash, &name);
+ offset = dissect_ftype3(tvb, offset, tree, hf_nfs_ftype3, &type);
switch (type) {
case NF3CHR:
case NF3BLK:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "dev_attributes");
- offset = dissect_specdata3(tvb, offset, pinfo, tree, "spec");
+ offset = dissect_sattr3(tvb, offset, tree, "dev_attributes");
+ offset = dissect_specdata3(tvb, offset, tree, "spec");
break;
case NF3SOCK:
case NF3FIFO:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "pipe_attributes");
+ offset = dissect_sattr3(tvb, offset, tree, "pipe_attributes");
break;
default:
/* nothing to do */
break;
}
-
+
+ type_str=val_to_str(type, names_nfs_ftype3, "Unknown type:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x/%s %s", hash, name, type_str);
+ }
+ proto_item_append_text(tree, ", MKNOD Call FH:0x%08x/%s %s", hash, name, type_str);
+ g_free(name);
+
+ return offset;
+}
+static int
+dissect_nfs3_mknod_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
+ "obj_attributes");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", MKNOD Reply");
+ break;
+ default:
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", MKNOD Reply Error:%s", err);
+ break;
+ }
+
return offset;
}
/* RFC 1813, Page 67..69 */
-int
-dissect_nfs3_remove_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_remove_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree* tree)
+{
+ guint32 status;
+ char *err;
+
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
+ switch (status) {
+ case 0:
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", REMOVE Reply");
+ break;
+ default:
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", REMOVE Reply Error:%s", err);
+ break;
+ }
+
+ return offset;
+}
+static int
+dissect_nfs3_rmdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ proto_item_append_text(tree, ", RMDIR Reply");
break;
default:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", RMDIR Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 71..74 */
-int
-dissect_nfs3_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "from");
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "to");
-
+ guint32 from_hash;
+ char *from_name=NULL;
+ guint32 to_hash;
+ char *to_name=NULL;
+
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "from", &from_hash, &from_name);
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "to", &to_hash, &to_name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x/%s To DH:0x%08x/%s", from_hash, from_name, to_hash, to_name);
+ }
+ proto_item_append_text(tree, ", RENAME Call From DH:0x%08x/%s To DH:0x%08x/%s", from_hash, from_name, to_hash, to_name);
+
+ g_free(from_name);
+ g_free(to_name);
return offset;
}
/* RFC 1813, Page 71..74 */
-int
-dissect_nfs3_rename_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_rename_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "fromdir_wcc");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "todir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "fromdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "todir_wcc");
+ proto_item_append_text(tree, ", RENAME Reply");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "fromdir_wcc");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "todir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "fromdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "todir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", RENAME Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 74..76 */
-int
-dissect_nfs3_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file");
- offset = dissect_diropargs3(tvb, offset, pinfo, tree, "link");
-
+ guint32 from_hash;
+ guint32 to_hash;
+ char *to_name=NULL;
+
+ offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file", &from_hash);
+ offset = dissect_diropargs3(tvb, offset, pinfo, tree, "link", &to_hash, &to_name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", From DH:0x%08x To DH:0x%08x/%s", from_hash, to_hash, to_name);
+ }
+ proto_item_append_text(tree, ", LINK Call From DH:0x%08x To DH:0x%08x/%s", from_hash, to_hash, to_name);
+
+ g_free(to_name);
return offset;
}
/* RFC 1813, Page 74..76 */
-int
-dissect_nfs3_link_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_link_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "linkdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
+ proto_item_append_text(tree, ", LINK Reply");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "linkdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", LINK Reply Error:%s", err);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 76..80 */
-int
-dissect_nfs3_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
-
+ guint32 hash;
+
+ offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir", &hash);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_cookie3, offset);
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", READDIR Call FH:0x%08x", hash);
+
return offset;
}
/* RFC 1813, Page 76..80 */
-int
-dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+static int
+dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree* tree)
{
proto_item* entry_item = NULL;
proto_tree* entry_tree = NULL;
int old_offset = offset;
- char *name;
+ char *name=NULL;
if (tree) {
entry_item = proto_tree_add_item(tree, hf_nfs_readdir_entry, tvb,
- offset+0, tvb_length_remaining(tvb, offset), FALSE);
+ offset+0, -1, FALSE);
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_fileid,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdir_entry3_fileid,
offset);
- offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename3(tvb, offset, entry_tree,
hf_nfs_readdir_entry3_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: name %s", name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," %s", name);
+ }
g_free(name);
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_cookie,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdir_entry3_cookie,
offset);
/* now we know, that a readdir entry is shorter */
/* RFC 1813, Page 76..80 */
-int
-dissect_nfs3_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
guint32 eof_value;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ proto_item_append_text(tree, ", READDIR Reply");
+
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entry3);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READDIR Reply Error:%s", err);
break;
}
/* RFC 1813, Page 80..83 */
-int
-dissect_nfs3_readdirplus_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_readdirplus_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_dircount,
+ guint32 hash;
+
+ offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir", &hash);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_cookie3, offset);
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3_dircount,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_maxcount,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3_maxcount,
offset);
-
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", READDIRPLUS Call FH:0x%08x", hash);
+
return offset;
}
/* RFC 1813, Page 80..83 */
-int
-dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
proto_item* entry_item = NULL;
proto_tree* entry_tree = NULL;
int old_offset = offset;
- char *name;
+ char *name=NULL;
if (tree) {
entry_item = proto_tree_add_item(tree, hf_nfs_readdir_entry, tvb,
- offset+0, tvb_length_remaining(tvb, offset), FALSE);
+ offset+0, -1, FALSE);
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree,
+ offset = dissect_rpc_uint64(tvb, entry_tree,
hf_nfs_readdirplus_entry_fileid, offset);
- offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename3(tvb, offset, entry_tree,
hf_nfs_readdirplus_entry_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: name %s", name);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," %s", name);
+ }
g_free(name);
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdirplus_entry_cookie,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdirplus_entry_cookie,
offset);
- offset = dissect_post_op_attr(tvb, offset, pinfo, entry_tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, entry_tree,
"name_attributes");
offset = dissect_post_op_fh3(tvb, offset, pinfo, entry_tree, "name_handle");
/* RFC 1813, Page 80..83 */
-int
-dissect_nfs3_readdirplus_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_readdirplus_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
guint32 eof_value;
+ char *err;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ proto_item_append_text(tree, ", READDIRPLUS Reply");
+
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entryplus3);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"dir_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", READDIRPLUS Reply Error:%s", err);
break;
}
/* RFC 1813, Page 84..86 */
-int
-dissect_nfs3_fsstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_fsstat_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", FSSTAT Call DH:0x%08x", hash);
+ return offset;
+}
+
+
+static int
+dissect_nfs3_fsstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 invarsec;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tbytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_tbytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_fbytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_fbytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_abytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_abytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tfiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_tfiles,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_ffiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_ffiles,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_afiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_afiles,
offset);
invarsec = tvb_get_ntohl(tvb, offset + 0);
if (tree)
proto_tree_add_uint(tree, hf_nfs_fsstat_invarsec, tvb,
offset+0, 4, invarsec);
offset += 4;
+
+ proto_item_append_text(tree, ", FSSTAT Reply");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", FSSTAT Reply Error:%s", err);
break;
}
/* RFC 1813, Page 86..90 */
-int
-dissect_nfs3_fsinfo_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_fsinfo_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", FSINFO Call DH:0x%08x", hash);
+ return offset;
+}
+static int
+dissect_nfs3_fsinfo_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 properties;
proto_item* properties_item = NULL;
proto_tree* properties_tree = NULL;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
rtmax = tvb_get_ntohl(tvb, offset+0);
if (tree)
offset+0, 4, dtpref);
offset += 4;
- offset = dissect_rpc_uint64(tvb, pinfo, tree,
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_fsinfo_maxfilesize, offset);
- offset = dissect_nfstime3(tvb, offset, pinfo, tree, hf_nfs_dtime, hf_nfs_dtime_sec, hf_nfs_dtime_nsec);
+ offset = dissect_nfstime3(tvb, offset, tree, hf_nfs_dtime, hf_nfs_dtime_sec, hf_nfs_dtime_nsec);
properties = tvb_get_ntohl(tvb, offset+0);
if (tree) {
properties_item = proto_tree_add_uint(tree,
hf_nfs_fsinfo_properties,
tvb, offset+0, 4, properties);
- if (properties_item)
- properties_tree = proto_item_add_subtree(properties_item,
+ if (properties_item)
+ properties_tree = proto_item_add_subtree(properties_item,
ett_nfs_fsinfo_properties);
if (properties_tree) {
proto_tree_add_text(properties_tree, tvb,
}
}
offset += 4;
+
+ proto_item_append_text(tree, ", FSINFO Reply");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", FSINFO Reply Error:%s", err);
break;
}
/* RFC 1813, Page 90..92 */
-int
-dissect_nfs3_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_pathconf_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree* tree)
+{
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object", &hash);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", PATHCONF Call DH:0x%08x", hash);
+ return offset;
+}
+static int
+dissect_nfs3_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 linkmax;
guint32 name_max;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
linkmax = tvb_get_ntohl(tvb, offset + 0);
if (tree)
proto_tree_add_uint(tree, hf_nfs_pathconf_name_max, tvb,
offset+0, 4, name_max);
offset += 4;
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_no_trunc, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_chown_restricted, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_insensitive, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_preserving, offset);
+
+ proto_item_append_text(tree, ", PATHCONF Reply");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_post_op_attr(tvb, offset, tree,
"obj_attributes");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", PATHCONF Reply Error:%s", err);
break;
}
/* RFC 1813, Page 92..95 */
-int
-dissect_nfs3_commit_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_commit_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
+ guint32 hash;
+
+ offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file", &hash);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
+
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO,", FH:0x%08x", hash);
+ }
+ proto_item_append_text(tree, ", COMMIT Call FH:0x%08x", hash);
+
return offset;
}
/* RFC 1813, Page 92..95 */
-int
-dissect_nfs3_commit_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs3_commit_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
+ char *err;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "file_wcc");
- offset = dissect_writeverf3(tvb, offset, pinfo, tree);
+ offset = dissect_wcc_data (tvb, offset, tree, "file_wcc");
+ offset = dissect_writeverf3(tvb, offset, tree);
+
+ proto_item_append_text(tree, ", COMMIT Reply");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "file_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "file_wcc");
+
+ err=val_to_str(status, names_nfs_stat, "Unknown error:%u");
+ if (check_col(pinfo->cinfo, COL_INFO)) {
+ col_append_fstr(pinfo->cinfo, COL_INFO," Error:%s", err);
+ }
+ proto_item_append_text(tree, ", COMMIT Reply Error:%s", err);
break;
}
-
- return offset;
-}
-
-/* 1 missing functions */
-
-/* NFS Version 4 Protocol Draft Specification 07 */
-
-int
-dissect_nfs_utf8string(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, int hf, char **string_ret)
-{
- /* TODO: this needs to be fixed */
- return dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
-}
-
-int
-dissect_nfs_seqid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
-{
- guint seqid;
-
- seqid = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_seqid4, tvb, offset, 4, seqid);
- offset += 4;
return offset;
}
-int
-dissect_nfs_linktext4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_linktext4,
- NULL);
-}
+/**********************************************************/
+/* NFS Version 4, RFC 3010 with nfs4_prot.x 1.103 changes */
+/**********************************************************/
-int
-dissect_nfs_specdata4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_utf8string(tvbuff_t *tvb, int offset,
+ proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata1, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata2, offset);
-
- return offset;
+ /* TODO: this dissector is subject to change; do not remove */
+ return dissect_rpc_string(tvb, tree, hf, offset, string_ret);
}
-int
-dissect_nfs_client_id4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_specdata4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_clientid4_verifier,
- offset);
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_specdata1, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_specdata2, offset);
return offset;
}
{ 0, NULL }
};
-int
-dissect_nfs_ftype4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- guint ftype4;
-
- ftype4 = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_ftype4, tvb, offset, 4, ftype4);
- offset += 4;
-
- return offset;
-}
-
-int
-dissect_nfs_component4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_component4,
- NULL);
-}
-
-int
-dissect_nfs_reclaim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_reclaim4, offset);
- return offset;
-}
-
-int
-dissect_nfs_length4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_length4, offset);
- return offset;
-}
-
-int
-dissect_nfs_opaque4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name);
-
-int
-dissect_nfs_lockowner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_lock_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
fitem = proto_tree_add_text(tree, tvb, offset, 4, "Owner");
- if (fitem) {
- newftree = proto_item_add_subtree(fitem, ett_nfs_lockowner4);
+ if (fitem)
+ {
+ newftree = proto_item_add_subtree(fitem, ett_nfs_lock_owner4);
- if (newftree) {
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_clientid4,
- offset);
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "Owner");
+ if (newftree)
+ {
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4, offset);
+ offset = dissect_nfsdata(tvb, offset, newftree, hf_nfs_data);
}
}
return offset;
}
-int
-dissect_nfs_pathname4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_pathname4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- guint comp_count, i;
+ guint32 comp_count, i;
proto_item *fitem = NULL;
proto_tree *newftree = NULL;
comp_count=tvb_get_ntohl(tvb, offset);
- fitem = proto_tree_add_text(tree, tvb, offset, 4,
- "pathname components (%d)", comp_count);
+ fitem = proto_tree_add_text(tree, tvb, offset, 4,
+ "pathname components (%u)", comp_count);
offset += 4;
- if (fitem) {
+ if (fitem)
+ {
newftree = proto_item_add_subtree(fitem, ett_nfs_pathname4);
- if (newftree) {
- for (i=0; i<comp_count; i++)
- offset=dissect_nfs_component4(tvb, offset, pinfo, newftree, "comp");
+ if (newftree)
+ {
+ for (i = 0; i < comp_count; i++)
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
}
}
return offset;
}
-int
-dissect_nfs_changeid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_nfstime4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_changeid4, offset);
- return offset;
-}
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_nfstime4_seconds, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_nfstime4_nseconds, offset);
-int
-dissect_nfs_nfstime4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_nfstime4_seconds,
- offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_nfstime4_nseconds,
- offset);
return offset;
}
{ 0, NULL },
};
-int
-dissect_nfs_settime4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_settime4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
guint32 set_it;
set_it = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_time_how4, tvb, offset+0,
+ proto_tree_add_uint(tree, hf_nfs_time_how4, tvb, offset+0,
4, set_it);
offset += 4;
if (set_it == SET_TO_CLIENT_TIME4)
- offset = dissect_nfs_nfstime4(tvb, offset, pinfo, tree, NULL);
-
- return offset;
-}
-
-static const value_string names_fattr4_expire_type[] = {
-#define FH4_PERSISTENT 0x00000000
- { FH4_PERSISTENT, "FH4_PERSISTENT" },
-#define FH4_NOEXPIRE_WITH_OPEN 0x00000001
- { FH4_NOEXPIRE_WITH_OPEN, "FH4_NOEXPIRE_WITH_OPEN" },
-#define FH4_VOLATILE_ANY 0x00000002
- { FH4_NOEXPIRE_WITH_OPEN, "FH4_NOEXPIRE_WITH_OPEN" },
-#define FH4_VOL_MIGRATION 0x00000004
- { FH4_VOL_MIGRATION, "FH4_VOL_MIGRATION" },
-#define FH4_VOL_RENAME 0x00000008
- { FH4_VOL_RENAME, "FH4_VOL_RENAME" },
- { 0, NULL }
-};
-
-int
-dissect_nfs_fh_expire_type(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
-{
- guint32 fattr4_fh_expire_type;
-
- fattr4_fh_expire_type = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_fattr4_expire_type, tvb, offset+0,
- 4, fattr4_fh_expire_type);
- offset += 4;
+ offset = dissect_nfs_nfstime4(tvb, offset, tree);
return offset;
}
-int
-dissect_nfs_fsid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_fsid4(tvbuff_t *tvb, int offset, proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
if (newftree == NULL) return offset;
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_major,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_fsid4_major,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_minor,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_fsid4_minor,
offset);
return offset;
}
-int
-dissect_nfs_acetype4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acetype4, offset);
- return offset;
-}
+static const value_string names_acetype4[] = {
+#define ACE4_ACCESS_ALLOWED_ACE_TYPE 0x00000000
+ { ACE4_ACCESS_ALLOWED_ACE_TYPE, "ACE4_ACCESS_ALLOWED_ACE_TYPE" },
+#define ACE4_ACCESS_DENIED_ACE_TYPE 0x00000001
+ { ACE4_ACCESS_DENIED_ACE_TYPE, "ACE4_ACCESS_DENIED_ACE_TYPE" },
+#define ACE4_SYSTEM_AUDIT_ACE_TYPE 0x00000002
+ { ACE4_SYSTEM_AUDIT_ACE_TYPE, "ACE4_SYSTEM_AUDIT_ACE_TYPE" },
+#define ACE4_SYSTEM_ALARM_ACE_TYPE 0x00000003
+ { ACE4_SYSTEM_ALARM_ACE_TYPE, "ACE4_SYSTEM_ALARM_ACE_TYPE" },
+ { 0, NULL }
+};
+
+/* ACE mask values */
+#define ACE4_READ_DATA 0x00000001
+#define ACE4_LIST_DIRECTORY 0x00000001
+#define ACE4_WRITE_DATA 0x00000002
+#define ACE4_ADD_FILE 0x00000002
+#define ACE4_APPEND_DATA 0x00000004
+#define ACE4_ADD_SUBDIRECTORY 0x00000004
+#define ACE4_READ_NAMED_ATTRS 0x00000008
+#define ACE4_WRITE_NAMED_ATTRS 0x00000010
+#define ACE4_EXECUTE 0x00000020
+#define ACE4_DELETE_CHILD 0x00000040
+#define ACE4_READ_ATTRIBUTES 0x00000080
+#define ACE4_WRITE_ATTRIBUTES 0x00000100
+#define ACE4_DELETE 0x00010000
+#define ACE4_READ_ACL 0x00020000
+#define ACE4_WRITE_ACL 0x00040000
+#define ACE4_WRITE_OWNER 0x00080000
+#define ACE4_SYNCHRONIZE 0x00100000
+
+static int
+dissect_nfs_acemask4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ guint32 acemask;
+ proto_item *acemask_item = NULL;
+ proto_tree *acemask_tree = NULL;
+
+ acemask = tvb_get_ntohl(tvb, offset);
+
+ acemask_item = proto_tree_add_text(tree, tvb, offset, 4,
+ "acemask: 0x%08x", acemask);
+
+ if (acemask_item)
+ acemask_tree = proto_item_add_subtree(acemask_item, ett_nfs_acemask4);
+
+ if (acemask_tree)
+ {
+ if (acemask & ACE4_READ_DATA)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_READ_DATA/ACE4_LIST_DIRECTORY (0x%08x)",
+ ACE4_READ_DATA);
+
+ if (acemask & ACE4_WRITE_DATA)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_WRITE_DATA/ACE4_ADD_FILE (0x%08x)",
+ ACE4_WRITE_DATA);
+
+ if (acemask & ACE4_APPEND_DATA)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_ADD_FILE/ACE4_ADD_SUBDIRECTORY (0x%08x)",
+ ACE4_APPEND_DATA);
+
+ if (acemask & ACE4_READ_NAMED_ATTRS)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_READ_NAMED_ATTRS (0x%08x)",
+ ACE4_READ_NAMED_ATTRS);
+
+ if (acemask & ACE4_WRITE_NAMED_ATTRS)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_WRITE_NAMED_ATTRS (0x%08x)",
+ ACE4_WRITE_NAMED_ATTRS);
+
+ if (acemask & ACE4_EXECUTE)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_EXECUTE (0x%08x)",
+ ACE4_EXECUTE);
+
+ if (acemask & ACE4_DELETE_CHILD)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_DELETE_CHILD (0x%08x)",
+ ACE4_DELETE_CHILD);
+
+ if (acemask & ACE4_READ_ATTRIBUTES)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_READ_ATTRIBUTES (0x%08x)",
+ ACE4_READ_ATTRIBUTES);
+
+ if (acemask & ACE4_WRITE_ATTRIBUTES)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_WRITE_ATTRIBUTES (0x%08x)",
+ ACE4_WRITE_ATTRIBUTES);
+
+ if (acemask & ACE4_DELETE)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_DELETE (0x%08x)",
+ ACE4_DELETE);
+
+ if (acemask & ACE4_READ_ACL)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_READ_ACL (0x%08x)",
+ ACE4_READ_ACL);
+
+ if (acemask & ACE4_WRITE_ACL)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_WRITE_ACL (0x%08x)",
+ ACE4_WRITE_ACL);
+
+ if (acemask & ACE4_WRITE_OWNER)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_WRITE_OWNER (0x%08x)",
+ ACE4_WRITE_OWNER);
+
+ if (acemask & ACE4_SYNCHRONIZE)
+ proto_tree_add_text(acemask_tree, tvb, offset, 4,
+ "ACE4_SYNCHRONIZE (0x%08x)",
+ ACE4_SYNCHRONIZE);
+ }
+
+ offset += 4;
-int
-dissect_nfs_aceflag4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_aceflag4, offset);
return offset;
}
-int
-dissect_nfs_acemask4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- return dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acemask4, offset);
-}
+/* ACE flag values */
+#define ACE4_FILE_INHERIT_ACE 0x00000001
+#define ACE4_DIRECTORY_INHERIT_ACE 0x00000002
+#define ACE4_NO_PROPAGATE_INHERIT_ACE 0x00000004
+#define ACE4_INHERIT_ONLY_ACE 0x00000008
+#define ACE4_SUCCESSFUL_ACCESS_ACE_FLAG 0x00000010
+#define ACE4_FAILED_ACCESS_ACE_FLAG 0x00000020
+#define ACE4_IDENTIFIER_GROUP 0x00000040
-int
-dissect_nfs_nfsace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+
+static int
+dissect_nfs_ace4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
{
- proto_tree *newftree = NULL;
- proto_item *fitem = NULL;
- int nextentry;
+ proto_item* ace_item = NULL;
+ proto_tree* ace_tree = NULL;
+ proto_item *aceflag_item = NULL;
+ proto_tree *aceflag_tree = NULL;
+ guint32 aceflag4;
- fitem = proto_tree_add_text(tree, tvb, offset, 0, "%s", name);
+ if (tree) {
+ ace_item = proto_tree_add_text(tree, tvb, offset, 4,
+ "ACE");
- if (fitem == NULL) return offset;
+ if (ace_item)
+ ace_tree = proto_item_add_subtree(ace_item, ett_nfs_ace4);
+ }
- newftree = proto_item_add_subtree(fitem, ett_nfs_fsid4);
+ if (ace_tree) {
+ offset = dissect_rpc_uint32(tvb, ace_tree, hf_nfs_acetype4, offset);
- if (newftree == NULL) return offset;
+ aceflag4 = tvb_get_ntohl(tvb, offset);
- nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
- offset);
+ aceflag_item = proto_tree_add_text(ace_tree, tvb, offset, 4,
+ "aceflag: 0x%08x", aceflag4);
+
+ if (aceflag_item)
+ {
+ aceflag_tree = proto_item_add_subtree(aceflag_item, ett_nfs_aceflag4);
+
+ if (aceflag_tree)
+ {
+ if (aceflag4 & ACE4_FILE_INHERIT_ACE)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_FILE_INHERIT_ACE (0x%08x)", ACE4_FILE_INHERIT_ACE);
+
+ if (aceflag4 & ACE4_DIRECTORY_INHERIT_ACE)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_DIRECTORY_INHERIT_ACE (0x%08x)",
+ ACE4_DIRECTORY_INHERIT_ACE);
+
+ if (aceflag4 & ACE4_INHERIT_ONLY_ACE)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_INHERIT_ONLY_ACE (0x%08x)",
+ ACE4_INHERIT_ONLY_ACE);
+
+ if (aceflag4 & ACE4_SUCCESSFUL_ACCESS_ACE_FLAG)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_SUCCESSFUL_ACCESS_ACE_FLAG (0x%08x)",
+ ACE4_SUCCESSFUL_ACCESS_ACE_FLAG);
+
+ if (aceflag4 & ACE4_FAILED_ACCESS_ACE_FLAG)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_FAILED_ACCESS_ACE_FLAG (0x%08x)",
+ ACE4_FAILED_ACCESS_ACE_FLAG);
+
+ if (aceflag4 & ACE4_IDENTIFIER_GROUP)
+ proto_tree_add_text(aceflag_tree, tvb, offset, 4,
+ "ACE4_IDENTIFIER_GROUP (0x%08x)",
+ ACE4_IDENTIFIER_GROUP);
+ }
+ }
- while (nextentry)
- {
- offset = dissect_nfs_acetype4(tvb, offset, pinfo, newftree, "type");
- offset = dissect_nfs_aceflag4(tvb, offset, pinfo, newftree, "flag");
- offset = dissect_nfs_acemask4(tvb, offset, pinfo, newftree,
- "access_mask");
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, newftree,
- hf_nfs_who, NULL);
- nextentry = tvb_get_ntohl(tvb, offset);
offset += 4;
+
+ offset = dissect_nfs_acemask4(tvb, offset, ace_tree);
+
+ offset = dissect_nfs_utf8string(tvb, offset, ace_tree, hf_nfs_who, NULL);
}
return offset;
}
-int
+static int
+dissect_nfs_fattr4_acl(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree)
+{
+ return dissect_rpc_array(tvb, pinfo, tree, offset, dissect_nfs_ace4,
+ hf_nfs_acl4);
+}
+
+static int
dissect_nfs_fh4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- return dissect_nfs_fh3(tvb, offset, pinfo, tree, name);
+ return dissect_nfs_fh3(tvb, offset, pinfo, tree, name, NULL);
}
-int
-dissect_nfs_fs_location4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_fs_location4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
{
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
- fitem = proto_tree_add_text(tree, tvb, offset, 0, "%s", name);
+ fitem = proto_tree_add_text(tree, tvb, offset, 0, "rootpath");
if (fitem == NULL) return offset;
if (newftree == NULL) return offset;
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_server,
- NULL);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_server, NULL);
return offset;
}
-int
-dissect_nfs_fs_locations4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_fs_locations4(tvbuff_t *tvb, packet_info *pinfo, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
- int nextentry;
fitem = proto_tree_add_text(tree, tvb, offset, 0, "%s", name);
if (newftree == NULL) return offset;
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree, "fs_root");
-
- nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
- offset);
+ offset = dissect_nfs_pathname4(tvb, offset, newftree);
- while (nextentry)
- {
- offset = dissect_nfs_fs_location4(tvb, offset, pinfo, newftree,
- "locations");
- nextentry = tvb_get_ntohl(tvb, offset);
- offset += 4;
- }
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ dissect_nfs_fs_location4);
return offset;
}
-int
-dissect_nfs_mode4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_mode4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
- return dissect_mode(tvb, offset, pinfo, tree, name);
+ return dissect_mode(tvb, offset, tree, name);
+}
+
+static const value_string nfs4_fattr4_fh_expire_type_names[] = {
+#define FH4_PERSISTENT 0x00000000
+ { FH4_PERSISTENT, "FH4_PERSISTENT" },
+#define FH4_NOEXPIRE_WITH_OPEN 0x00000001
+ { FH4_NOEXPIRE_WITH_OPEN, "FH4_NOEXPIRE_WITH_OPEN" },
+#define FH4_VOLATILE_ANY 0x00000002
+ { FH4_VOLATILE_ANY, "FH4_VOLATILE_ANY" },
+#define FH4_VOL_MIGRATION 0x00000004
+ { FH4_VOL_MIGRATION, "FH4_VOL_MIGRATION" },
+#define FH4_VOL_RENAME 0x00000008
+ { FH4_VOL_RENAME, "FH4_VOL_RENAME" },
+ { 0, NULL }
+};
+
+
+static int
+dissect_nfs_fattr4_fh_expire_type(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ guint32 expire_type;
+ proto_item *expire_type_item = NULL;
+ proto_tree *expire_type_tree = NULL;
+
+ expire_type = tvb_get_ntohl(tvb, offset + 0);
+
+ if (tree)
+ {
+ expire_type_item = proto_tree_add_text(tree, tvb, offset, 4,
+ "fattr4_fh_expire_type: 0x%08x", expire_type);
+ if (expire_type_item)
+ expire_type_tree = proto_item_add_subtree(expire_type_item,
+ ett_nfs_fattr4_fh_expire_type);
+ }
+
+ if (expire_type_tree)
+ {
+ if (expire_type == FH4_PERSISTENT)
+ {
+ proto_tree_add_text(expire_type_tree, tvb, offset, 4, "%s",
+ decode_enumerated_bitfield(expire_type, FH4_PERSISTENT, 8,
+ nfs4_fattr4_fh_expire_type_names, "%s"));
+ }
+ else
+ {
+ if (expire_type & FH4_NOEXPIRE_WITH_OPEN)
+ proto_tree_add_text(expire_type_tree, tvb, offset, 4,
+ "FH4_NOEXPIRE_WITH_OPEN (0x%08x)", FH4_NOEXPIRE_WITH_OPEN);
+
+ if (expire_type & FH4_VOLATILE_ANY)
+ proto_tree_add_text(expire_type_tree, tvb, offset, 4,
+ "FH4_VOLATILE_ANY (0x%08x)", FH4_VOLATILE_ANY);
+
+ if (expire_type & FH4_VOL_MIGRATION)
+ proto_tree_add_text(expire_type_tree, tvb, offset, 4,
+ "FH4_VOL_MIGRATION (0x%08x)", FH4_VOL_MIGRATION);
+
+ if (expire_type & FH4_VOL_RENAME)
+ proto_tree_add_text(expire_type_tree, tvb, offset, 4,
+ "FH4_VOL_RENAME (0x%08x)", FH4_VOL_RENAME);
+ }
+ }
+
+ offset += 4;
+
+ return offset;
}
static const value_string names_fattr4[] = {
{ FATTR4_TIME_MODIFY, "FATTR4_TIME_MODIFY" },
#define FATTR4_TIME_MODIFY_SET 54
{ FATTR4_TIME_MODIFY_SET, "FATTR4_TIME_MODIFY_SET" },
+#define FATTR4_MOUNTED_ON_FILEID 55
+ { FATTR4_MOUNTED_ON_FILEID, "FATTR4_MOUNTED_ON_FILEID" },
{ 0, NULL }
};
+#define FATTR4_BITMAP_ONLY 0
+#define FATTR4_FULL_DISSECT 1
-int
+static int
dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name, int type)
+ proto_tree *tree, int type)
{
guint32 bitmap_len;
proto_item *fitem = NULL;
proto_tree *newftree = NULL;
proto_item *attr_fitem = NULL;
proto_tree *attr_newftree = NULL;
- unsigned int i;
- int j, fattr;
+ guint32 i;
+ gint j;
+ guint32 fattr;
guint32 *bitmap;
guint32 sl;
int attr_vals_offset;
attr_vals_offset = offset + 4 + bitmap_len * 4;
- bitmap = g_malloc(bitmap_len * sizeof(guint32));
+ bitmap = g_malloc(bitmap_len * sizeof(guint32));
if (bitmap == NULL) return offset;
for (i = 0; i < bitmap_len; i++)
if (bitmap[i] & sl)
{
/* switch label if attribute is recommended vs. mandatory */
- attr_fitem = proto_tree_add_uint(newftree,
- (fattr < FATTR4_ACL)? hf_nfs_mand_attr: hf_nfs_recc_attr,
+ attr_fitem = proto_tree_add_uint(newftree,
+ (fattr < FATTR4_ACL)? hf_nfs_mand_attr: hf_nfs_recc_attr,
tvb, offset, 4, fattr);
- if (attr_fitem == NULL)
- continue;
+ if (attr_fitem == NULL) break;
attr_newftree = proto_item_add_subtree(attr_fitem, ett_nfs_bitmap4);
- if (attr_newftree == NULL)
- continue;
+ if (attr_newftree == NULL) break;
- if (type == 1)
+ if (type == FATTR4_FULL_DISSECT)
{
/* do a full decode of the arguments for the set flag */
switch(fattr)
{
case FATTR4_SUPPORTED_ATTRS:
- attr_vals_offset = dissect_nfs_attributes(tvb,
- attr_vals_offset, pinfo, attr_newftree,
- "fattr4_supported_attrs", 0);
+ attr_vals_offset = dissect_nfs_attributes(tvb,
+ attr_vals_offset, pinfo, attr_newftree,
+ FATTR4_BITMAP_ONLY);
break;
-
+
case FATTR4_TYPE:
- attr_vals_offset = dissect_nfs_ftype4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "fattr4_type");
+ attr_vals_offset = dissect_rpc_uint32(tvb,
+ attr_newftree, hf_nfs_ftype4, attr_vals_offset);
break;
case FATTR4_FH_EXPIRE_TYPE:
- attr_vals_offset = dissect_nfs_fh_expire_type(tvb,
- attr_vals_offset, pinfo, attr_newftree);
+ attr_vals_offset = dissect_nfs_fattr4_fh_expire_type(tvb,
+ attr_vals_offset, attr_newftree);
break;
case FATTR4_CHANGE:
- attr_vals_offset = dissect_nfs_changeid4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_change");
+ attr_vals_offset = dissect_rpc_uint64(tvb, attr_newftree,
+ hf_nfs_changeid4, attr_vals_offset);
break;
case FATTR4_SIZE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_size, attr_vals_offset);
break;
case FATTR4_LINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_link_support,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_link_support,
attr_vals_offset);
break;
case FATTR4_SYMLINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_symlink_support,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_symlink_support,
attr_vals_offset);
break;
case FATTR4_NAMED_ATTR:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_named_attr, attr_vals_offset);
break;
case FATTR4_FSID:
attr_vals_offset = dissect_nfs_fsid4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "fattr4_fsid");
+ attr_newftree, "fattr4_fsid");
break;
case FATTR4_UNIQUE_HANDLES:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_unique_handles,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_unique_handles,
attr_vals_offset);
break;
case FATTR4_LEASE_TIME:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_lease_time, offset);
+ attr_vals_offset = dissect_rpc_uint32(tvb,
+ attr_newftree, hf_nfs_fattr4_lease_time,
+ attr_vals_offset);
break;
case FATTR4_RDATTR_ERROR:
- attr_vals_offset = dissect_nfs_nfsstat4(tvb, attr_vals_offset,
- pinfo, attr_newftree, NULL);
+ attr_vals_offset = dissect_nfs_nfsstat4(tvb,
+ attr_vals_offset, attr_newftree, NULL);
break;
case FATTR4_ACL:
- attr_vals_offset = dissect_nfs_nfsace4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "fattr4_acl");
+ attr_vals_offset = dissect_nfs_fattr4_acl(tvb,
+ attr_vals_offset, pinfo, attr_newftree);
break;
case FATTR4_ACLSUPPORT:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_aclsupport, offset);
+ attr_vals_offset = dissect_rpc_uint32(tvb,
+ attr_newftree, hf_nfs_fattr4_aclsupport,
+ attr_vals_offset);
break;
case FATTR4_ARCHIVE:
- attr_vals_offset = dissect_rpc_bool(tvb,
- pinfo, attr_newftree, hf_nfs_fattr4_archive,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_archive,
attr_vals_offset);
break;
case FATTR4_CANSETTIME:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_cansettime, attr_vals_offset);
break;
case FATTR4_CASE_INSENSITIVE:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_case_insensitive,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_case_insensitive,
attr_vals_offset);
break;
case FATTR4_CASE_PRESERVING:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_case_preserving,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_case_preserving,
attr_vals_offset);
break;
case FATTR4_CHOWN_RESTRICTED:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_chown_restricted,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_chown_restricted,
attr_vals_offset);
break;
case FATTR4_FILEID:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_fileid, attr_vals_offset);
break;
case FATTR4_FILES_AVAIL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_files_avail,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
+ attr_newftree, hf_nfs_fattr4_files_avail,
attr_vals_offset);
break;
break;
case FATTR4_FILES_FREE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_files_free, attr_vals_offset);
break;
case FATTR4_FILES_TOTAL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_files_total,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
+ attr_newftree, hf_nfs_fattr4_files_total,
attr_vals_offset);
break;
case FATTR4_FS_LOCATIONS:
- attr_vals_offset = dissect_nfs_fs_locations4(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset = dissect_nfs_fs_locations4(tvb, pinfo,
+ attr_vals_offset, attr_newftree,
"fattr4_fs_locations");
break;
case FATTR4_HIDDEN:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_hidden, attr_vals_offset);
break;
case FATTR4_HOMOGENEOUS:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_homogeneous,
+ attr_vals_offset = dissect_rpc_bool(tvb,
+ attr_newftree, hf_nfs_fattr4_homogeneous,
attr_vals_offset);
break;
case FATTR4_MAXFILESIZE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_maxfilesize,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
+ attr_newftree, hf_nfs_fattr4_maxfilesize,
attr_vals_offset);
break;
case FATTR4_MAXLINK:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_maxlink, attr_vals_offset);
break;
case FATTR4_MAXNAME:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_maxname, attr_vals_offset);
break;
case FATTR4_MAXREAD:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_maxread, attr_vals_offset);
break;
case FATTR4_MAXWRITE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_maxwrite, attr_vals_offset);
break;
case FATTR4_MIMETYPE:
- attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset = dissect_nfs_utf8string(tvb,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_mimetype, NULL);
break;
-
+
case FATTR4_MODE:
attr_vals_offset = dissect_nfs_mode4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_mode");
+ attr_vals_offset, attr_newftree, "fattr4_mode");
break;
case FATTR4_NO_TRUNC:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_no_trunc, attr_vals_offset);
break;
case FATTR4_NUMLINKS:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_numlinks, attr_vals_offset);
break;
case FATTR4_OWNER:
- attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset = dissect_nfs_utf8string(tvb,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_owner,
NULL);
break;
case FATTR4_OWNER_GROUP:
- attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset = dissect_nfs_utf8string(tvb,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_owner_group, NULL);
break;
case FATTR4_QUOTA_AVAIL_HARD:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_hard, attr_vals_offset);
break;
case FATTR4_QUOTA_AVAIL_SOFT:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_soft, attr_vals_offset);
break;
case FATTR4_QUOTA_USED:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_used, attr_vals_offset);
break;
case FATTR4_RAWDEV:
- attr_vals_offset = dissect_nfs_specdata4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_rawdev");
+ attr_vals_offset = dissect_nfs_specdata4(tvb,
+ attr_vals_offset, attr_newftree);
break;
case FATTR4_SPACE_AVAIL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_space_avail,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
+ attr_newftree, hf_nfs_fattr4_space_avail,
attr_vals_offset);
break;
case FATTR4_SPACE_FREE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_free, attr_vals_offset);
break;
case FATTR4_SPACE_TOTAL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
- attr_newftree, hf_nfs_fattr4_space_total,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
+ attr_newftree, hf_nfs_fattr4_space_total,
attr_vals_offset);
break;
case FATTR4_SPACE_USED:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_used, attr_vals_offset);
break;
-
+
case FATTR4_SYSTEM:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_system, attr_vals_offset);
break;
case FATTR4_TIME_METADATA:
case FATTR4_TIME_MODIFY:
attr_vals_offset = dissect_nfs_nfstime4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "nfstime4");
+ attr_newftree);
break;
case FATTR4_TIME_ACCESS_SET:
case FATTR4_TIME_MODIFY_SET:
- attr_vals_offset = dissect_nfs_settime4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "settime4");
+ attr_vals_offset = dissect_nfs_settime4(tvb,
+ attr_vals_offset, attr_newftree, "settime4");
break;
default:
return offset;
}
-int
-dissect_nfs_attrlist4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
-{
- return dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_attrlist4);
-}
-
-int
+static int
dissect_nfs_fattr4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree)
{
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
if (newftree == NULL) return offset;
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree, name, 1);
- offset = dissect_nfs_attrlist4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_FULL_DISSECT);
+
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_attrlist4);
return offset;
}
static const value_string names_open4_share_access[] = {
#define OPEN4_SHARE_ACCESS_READ 0x00000001
- { OPEN4_SHARE_ACCESS_READ, "OPEN4_SHARE_ACCESS_READ" },
+ { OPEN4_SHARE_ACCESS_READ, "OPEN4_SHARE_ACCESS_READ" },
#define OPEN4_SHARE_ACCESS_WRITE 0x00000002
{ OPEN4_SHARE_ACCESS_WRITE, "OPEN4_SHARE_ACCESS_WRITE" },
#define OPEN4_SHARE_ACCESS_BOTH 0x00000003
{ 0, NULL }
};
-int
-dissect_nfs_open4_share_access(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_open4_share_access(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
guint share_access;
share_access = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_open4_share_access, tvb, offset, 4,
+ proto_tree_add_uint(tree, hf_nfs_open4_share_access, tvb, offset, 4,
share_access);
offset += 4;
{ 0, NULL }
};
-int
-dissect_nfs_open4_share_deny(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_open4_share_deny(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
guint deny_access;
return offset;
}
-int
+static int
+dissect_nfs_open_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_clientid4, offset);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_open_owner4);
+
+ return offset;
+}
+
+static int
dissect_nfs_open_claim_delegate_cur4(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree, char *name)
+ proto_tree *tree)
{
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree,
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_stateid4_delegate_stateid, offset);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_component4, NULL);
+
return offset;
}
{ 0, NULL }
};
-int
-dissect_nfs_open_claim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_open_claim4(tvbuff_t *tvb, int offset,
+ proto_tree *tree)
{
guint open_claim_type4;
proto_item *fitem = NULL;
switch(open_claim_type4)
{
case CLAIM_NULL:
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree,
- "file");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
break;
case CLAIM_PREVIOUS:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_delegate_type, offset);
break;
case CLAIM_DELEGATE_CUR:
- offset = dissect_nfs_open_claim_delegate_cur4(tvb, offset, pinfo,
- newftree, "delegate_cur_info");
+ offset = dissect_nfs_open_claim_delegate_cur4(tvb, offset,
+ newftree);
break;
case CLAIM_DELEGATE_PREV:
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree,
- "file_delegate_prev");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
break;
default:
return offset;
}
-int
-dissect_nfs_verifier4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name);
-
-int
+static int
dissect_nfs_createhow4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree)
{
guint mode;
mode = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint(tree, hf_nfs_createmode3, tvb, offset, 4, mode);
offset += 4;
-
+
switch(mode)
{
case UNCHECKED: /* UNCHECKED4 */
case GUARDED: /* GUARDED4 */
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, tree, "createattrs");
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, tree);
break;
case EXCLUSIVE: /* EXCLUSIVE4 */
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, tree, "createverf");
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_verifier4, offset);
break;
-
+
default:
break;
}
{ 0, NULL }
};
-int
+static int
dissect_nfs_openflag4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
switch(opentype4)
{
case OPEN4_CREATE:
- offset = dissect_nfs_createhow4(tvb, offset, pinfo, newftree,
- "how");
+ offset = dissect_nfs_createhow4(tvb, offset, pinfo, newftree);
break;
default:
return offset;
}
-int
-dissect_nfs_verifier4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_clientaddr4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_verifier4, offset);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_r_netid);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_r_addr);
+
+ return offset;
}
-int
-dissect_nfs_cookie4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_cb_client4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie4, offset);
-}
+ proto_tree *cb_location = NULL;
+ proto_item *fitem = NULL;
-int
-dissect_nfs_cookieverf4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookieverf4, offset);
-}
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_cb_program, offset);
+ fitem = proto_tree_add_text(tree, tvb, offset, 0, "cb_location");
-int
-dissect_nfs_clientaddr4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, tree, "network id");
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, tree, "universal address");
+ if (fitem)
+ {
+ cb_location = proto_item_add_subtree(fitem, ett_nfs_clientaddr4);
- return offset;
-}
-
+ offset = dissect_nfs_clientaddr4(tvb, offset, cb_location);
+ }
-int
-dissect_nfs_cb_client4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_cb_program,
- offset);
- offset = dissect_nfs_clientaddr4(tvb, offset, pinfo, tree, "cb_location");
return offset;
}
{ 0, NULL }
};
-int
-dissect_nfs_stable_how4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_stable_how4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
guint stable_how4;
return offset;
}
-int
-dissect_nfs_opaque4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
-{
- return dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
-}
-
-/* There is probably a better (built-in?) way to do this, but this works
- * for now.
- */
-
static const value_string names_nfsv4_operation[] = {
{ NFS4_OP_ACCESS, "ACCESS" },
{ NFS4_OP_CLOSE, "CLOSE" },
{ NFS4_OP_LOCKT, "LOCKT" },
{ NFS4_OP_LOCKU, "LOCKU" },
{ NFS4_OP_LOOKUP, "LOOKUP" },
+ { NFS4_OP_LOOKUPP, "LOOKUPP" },
{ NFS4_OP_NVERIFY, "NVERIFY" },
{ NFS4_OP_OPEN, "OPEN" },
{ NFS4_OP_OPENATTR, "OPENATTR" },
&ett_nfs_setclientid4 ,
&ett_nfs_setclientid_confirm4 ,
&ett_nfs_verify4 ,
- &ett_nfs_write4
+ &ett_nfs_write4
};
-int
+static int
+dissect_nfs_entry4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
+{
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_cookie4, offset);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_component4, NULL);
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, tree);
+
+ return offset;
+}
+
+static int
dissect_nfs_dirlist4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree)
{
proto_tree *newftree = NULL;
- guint nextentry;
newftree = proto_item_add_subtree(tree, ett_nfs_dirlist4);
if (newftree==NULL) return offset;
- nextentry = tvb_get_ntohl(tvb, offset);
-
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
- offset);
-
- while (nextentry)
- {
- offset = dissect_nfs_cookie4(tvb, offset, pinfo, newftree, "cookie");
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree, "name");
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree, "attrs");
- nextentry = tvb_get_ntohl(tvb, offset);
- offset += 4;
- }
-
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_dirlist4_eof,
- offset);
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_nfs_entry4);
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_dirlist4_eof, offset);
return offset;
}
-int
-dissect_nfs_change_info4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_change_info4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
fitem = proto_tree_add_text(tree, tvb, offset, 0, "%s", name);
if (fitem) {
- newftree=proto_item_add_subtree(fitem, ett_nfs_change_info4);
+ newftree = proto_item_add_subtree(fitem, ett_nfs_change_info4);
if (newftree) {
- offset = dissect_rpc_bool(tvb, pinfo, newftree,
+ offset = dissect_rpc_bool(tvb, newftree,
hf_nfs_change_info4_atomic, offset);
- offset = dissect_nfs_changeid4(tvb, offset, pinfo, newftree, "before");
- offset = dissect_nfs_changeid4(tvb, offset, pinfo, newftree, "after");
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_before,
+ offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_after,
+ offset);
}
}
return offset;
}
-int
-dissect_nfs_lock4denied(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static const value_string names_nfs_lock_type4[] =
{
- offset = dissect_nfs_lockowner4(tvb, offset, pinfo, tree, "owner");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset4, offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, tree, "length");
- return offset;
-}
-
+#define READ_LT 1
+ { READ_LT, "READ_LT" },
+#define WRITE_LT 2
+ { WRITE_LT, "WRITE_LT" },
+#define READW_LT 3
+ { READW_LT, "READW_LT" },
+#define WRITEW_LT 4
+ { WRITEW_LT, "WRITEW_LT" },
+#define RELEASE_STATE 5
+ { RELEASE_STATE, "RELEASE_STATE" },
+ { 0, NULL }
+};
-int
-dissect_nfs_ace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_lock4denied(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_nfs_acetype4(tvb, offset, pinfo, tree, "type");
- offset = dissect_nfs_aceflag4(tvb, offset, pinfo, tree, "flag");
- offset = dissect_nfs_acemask4(tvb, offset, pinfo, tree, "access_mask");
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_ace4, NULL);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset4, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_length4, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_type4, offset);
+ offset = dissect_nfs_lock_owner4(tvb, offset, tree);
+
+ return offset;
}
+
static const value_string names_open4_result_flags[] = {
#define OPEN4_RESULT_MLOCK 0x00000001
- { OPEN4_RESULT_MLOCK, "OPEN4_RESULT_MLOCK" },
+ { OPEN4_RESULT_MLOCK, "OPEN4_RESULT_MLOCK" },
#define OPEN4_RESULT_CONFIRM 0x00000002
{ OPEN4_RESULT_CONFIRM, "OPEN4_RESULT_CONFIRM" },
{ 0, NULL }
};
-int
-dissect_nfs_open4_rflags(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs_open4_rflags(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
guint rflags;
"%s: 0x%08x", name, rflags);
if (rflags_item)
- rflags_tree = proto_item_add_subtree(rflags_item,
+ {
+ rflags_tree = proto_item_add_subtree(rflags_item,
ett_nfs_open4_result_flags);
- }
- if (rflags_tree)
- {
- proto_tree_add_text(rflags_tree, tvb, offset, 4, "%s",
- decode_enumerated_bitfield(rflags, OPEN4_RESULT_MLOCK, 2,
- names_open4_result_flags, "%s"));
+ if (rflags_tree)
+ {
+ proto_tree_add_text(rflags_tree, tvb, offset, 4, "%s",
+ decode_enumerated_bitfield(rflags, OPEN4_RESULT_MLOCK, 2,
+ names_open4_result_flags, "%s"));
- proto_tree_add_text(rflags_tree, tvb, offset, 4, "%s",
- decode_enumerated_bitfield(rflags, OPEN4_RESULT_CONFIRM, 2,
- names_open4_result_flags, "%s"));
+ proto_tree_add_text(rflags_tree, tvb, offset, 4, "%s",
+ decode_enumerated_bitfield(rflags, OPEN4_RESULT_CONFIRM, 2,
+ names_open4_result_flags, "%s"));
+ }
+ }
}
-
+
offset += 4;
return offset;
}
-int
-dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+static int
+dissect_nfs_stateid4(tvbuff_t *tvb, int offset,
+ proto_tree *tree)
+{
+ proto_item *fitem = NULL;
+ proto_tree *newftree = NULL;
+ int sublen;
+ int bytes_left;
+ gboolean first_line;
+
+ fitem = proto_tree_add_text(tree, tvb, offset, 4, "stateid");
+
+ if (fitem) {
+ newftree = proto_item_add_subtree(fitem, ett_nfs_stateid4);
+ if (newftree) {
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ offset);
+
+ bytes_left = 12;
+ first_line = TRUE;
+
+ while (bytes_left != 0)
+ {
+ sublen = 12;
+ if (sublen > bytes_left)
+ sublen = bytes_left;
+
+ proto_tree_add_text(newftree, tvb, offset, sublen, "%s%s",
+ first_line ? "other: " : " ",
+ tvb_bytes_to_str(tvb, offset, sublen));
+
+ bytes_left -= sublen;
+ offset += sublen;
+ first_line = FALSE;
+ }
+ }
+ }
+
+ return offset;
+}
+
+static int
+dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_stateid4, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_recall4, offset);
- offset = dissect_nfs_ace4(tvb, offset, pinfo, tree, "permissions");
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_recall4, offset);
+ offset = dissect_nfs_ace4(tvb, offset, pinfo, tree);
return offset;
}
-int
-dissect_nfs_modified_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_modified_limit4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_num_blocks,
- offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_bytes_per_block,
- offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_num_blocks, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_bytes_per_block, offset);
+
return offset;
}
{ 0, NULL }
};
-int
-dissect_nfs_space_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_space_limit4(tvbuff_t *tvb, int offset,
+ proto_tree *tree)
{
guint limitby;
switch(limitby)
{
case NFS_LIMIT_SIZE:
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_filesize,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_filesize,
offset);
break;
case NFS_LIMIT_BLOCKS:
- offset = dissect_nfs_modified_limit4(tvb, offset, pinfo, tree,
- "mod_blocks");
+ offset = dissect_nfs_modified_limit4(tvb, offset, tree);
break;
default:
return offset;
}
-int
-dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
+static int
+dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_stateid4, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_recall, offset);
- offset = dissect_nfs_space_limit4(tvb, offset, pinfo, tree, "space_limit");
- return dissect_nfs_ace4(tvb, offset, pinfo, tree, "permissions");
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_recall, offset);
+ offset = dissect_nfs_space_limit4(tvb, offset, tree);
+ offset = dissect_nfs_ace4(tvb, offset, pinfo, tree);
+
+ return offset;
}
#define OPEN_DELEGATE_NONE 0
{ 0, NULL }
};
-int
+static int
dissect_nfs_open_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree)
{
guint delegation_type;
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
delegation_type = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(tree, hf_nfs_open_delegation_type4, tvb, offset+0,
+ proto_tree_add_uint(tree, hf_nfs_open_delegation_type4, tvb, offset+0,
4, delegation_type);
offset += 4;
break;
case OPEN_DELEGATE_READ:
- offset = dissect_nfs_open_read_delegation4(tvb, offset, pinfo,
+ offset = dissect_nfs_open_read_delegation4(tvb, offset, pinfo,
newftree);
break;
case OPEN_DELEGATE_WRITE:
- offset = dissect_nfs_open_write_delegation4(tvb, offset, pinfo,
+ offset = dissect_nfs_open_write_delegation4(tvb, offset, pinfo,
newftree);
break;
return offset;
}
+static int
+dissect_nfs_rpcsec_gss_info(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL,
+ hf_nfs_sec_oid4, FALSE, 0, FALSE, NULL, NULL);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_qop4, offset);
+ offset = dissect_rpc_uint32(tvb, tree,
+ hf_nfs_secinfo_rpcsec_gss_info_service, offset);
-int
-dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ return offset;
+}
+
+static int
+dissect_nfs_open_to_lock_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_seqid4, offset);
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_seqid4, offset);
+ offset = dissect_nfs_lock_owner4(tvb, offset, tree);
+
+ return offset;
+}
+
+static int
+dissect_nfs_exist_lock_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_seqid4, offset);
+
+ return offset;
+}
+
+static int
+dissect_nfs_locker4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ guint new_lock_owner;
+
+ new_lock_owner = tvb_get_ntohl(tvb, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_new_lock_owner, offset);
+
+ if (new_lock_owner)
+ offset = dissect_nfs_open_to_lock_owner4(tvb, offset, tree);
+ else
+ offset = dissect_nfs_exist_lock_owner4(tvb, offset, tree);
+
+ return offset;
+}
+
+static int
+dissect_nfs_client_id4(tvbuff_t *tvb, int offset, proto_tree *tree)
+{
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_verifier4, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nfs_client_id4_id, offset);
+
+ return offset;
+}
+
+static int
+dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- guint ops, ops_counter;
+ guint32 ops, ops_counter;
guint opcode;
proto_item *fitem;
proto_tree *ftree = NULL;
ops = tvb_get_ntohl(tvb, offset+0);
- fitem = proto_tree_add_text(tree, tvb, offset, 4,
- "Operations (count: %d)", ops);
+ fitem = proto_tree_add_text(tree, tvb, offset, 4,
+ "Operations (count: %u)", ops);
offset += 4;
if (fitem == NULL) return offset;
for (ops_counter=0; ops_counter<ops; ops_counter++)
{
opcode = tvb_get_ntohl(tvb, offset);
- fitem = proto_tree_add_uint(ftree, hf_nfs_argop4, tvb, offset, 4,
+
+ fitem = proto_tree_add_uint(ftree, hf_nfs_argop4, tvb, offset, 4,
opcode);
offset += 4;
- if (opcode < NFS4_OP_ACCESS || opcode >NFS4_OP_WRITE)
+ if (opcode < NFS4_OP_ACCESS || opcode > NFS4_OP_WRITE)
break;
if (fitem == NULL) break;
newftree = proto_item_add_subtree(fitem, *nfsv4_operation_ett[opcode-3]);
-
if (newftree == NULL) break;
switch(opcode)
{
case NFS4_OP_ACCESS:
- offset = dissect_access(tvb, offset, pinfo, newftree, "access");
+ offset = dissect_access(tvb, offset, newftree, "access");
break;
case NFS4_OP_CLOSE:
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_COMMIT:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
break;
{
guint create_type;
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
- "objname");
-
create_type = tvb_get_ntohl(tvb, offset);
- offset = dissect_nfs_ftype4(tvb, offset, pinfo, newftree, "type");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_ftype4,
+ offset);
switch(create_type)
{
case NF4LNK:
- offset = dissect_nfs_linktext4(tvb, offset, pinfo, newftree,
- "linkdata");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_linktext4, NULL);
break;
-
+
case NF4BLK:
case NF4CHR:
- offset = dissect_nfs_specdata4(tvb, offset, pinfo,
- newftree, "devdata");
+ offset = dissect_nfs_specdata4(tvb, offset, newftree);
break;
case NF4SOCK:
default:
break;
}
+
+ offset = dissect_nfs_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
+
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
}
break;
case NFS4_OP_DELEGPURGE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree,
- hf_nfs_clientid4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4, offset);
break;
case NFS4_OP_DELEGRETURN:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_GETATTR:
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
- "attr_request", 0);
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_GETFH:
break;
case NFS4_OP_LINK:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
- "newname");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
break;
case NFS4_OP_LOCK:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
- offset);
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_reclaim4(tvb, offset, pinfo, newftree, "reclaim");
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
- offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4, offset);
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_lock4_reclaim, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_length4, offset);
+ offset = dissect_nfs_locker4(tvb, offset, newftree);
break;
case NFS4_OP_LOCKT:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
- offset);
- offset = dissect_nfs_lockowner4(tvb, offset, pinfo, newftree, "owner");
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
- offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_length4, offset);
+ offset = dissect_nfs_lock_owner4(tvb, offset, newftree);
break;
case NFS4_OP_LOCKU:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
- offset);
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
- offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_seqid4, offset);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_length4, offset);
break;
case NFS4_OP_LOOKUP:
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree, "path");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
break;
case NFS4_OP_LOOKUPP:
break;
case NFS4_OP_NVERIFY:
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "obj_attributes");
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_OPEN:
- offset = dissect_nfs_open_claim4(tvb, offset, pinfo, newftree,
- "claim");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ offset);
+ offset = dissect_nfs_open4_share_access(tvb, offset, newftree);
+ offset = dissect_nfs_open4_share_deny(tvb, offset, newftree);
+ offset = dissect_nfs_open_owner4(tvb, offset, newftree);
offset = dissect_nfs_openflag4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_lockowner4(tvb, offset, pinfo, newftree, "Owner");
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_access(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_deny(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_open_claim4(tvb, offset, newftree);
break;
case NFS4_OP_OPENATTR:
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_attrdircreate,
+ offset);
break;
case NFS4_OP_OPEN_CONFIRM:
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "verifier");
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ offset);
break;
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
- offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_access(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_deny(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_open4_share_access(tvb, offset, newftree);
+ offset = dissect_nfs_open4_share_deny(tvb, offset, newftree);
break;
case NFS4_OP_PUTFH:
break;
case NFS4_OP_READ:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
break;
case NFS4_OP_READDIR:
- offset = dissect_nfs_cookie4(tvb, offset, pinfo, newftree, "cookie");
- offset = dissect_nfs_cookieverf4(tvb, offset, pinfo, newftree,
- "cookieverf");
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookie4,
+ offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookieverf4,
+ offset);
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_dircount, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_maxcount, offset);
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree, "attr",
- 0);
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_READLINK:
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
- "target");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
- "oldname");
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
- "newname");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
break;
case NFS4_OP_RENEW:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4, offset);
break;
-
+
case NFS4_OP_RESTOREFH:
case NFS4_OP_SAVEFH:
break;
case NFS4_OP_SECINFO:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree, "name");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
break;
case NFS4_OP_SETATTR:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "obj_attributes");
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_SETCLIENTID:
{
proto_tree *client_tree = NULL;
+ proto_tree *callback_tree = NULL;
- fitem = proto_tree_add_text(newftree, tvb, offset, 0, "Client");
-
- if (fitem) {
- client_tree = proto_item_add_subtree(fitem,
- ett_nfs_client_id4);
+ fitem = proto_tree_add_text(newftree, tvb, offset, 0, "client");
+ if (fitem)
+ {
+ client_tree = proto_item_add_subtree(fitem, ett_nfs_client_id4);
- if (newftree)
- offset = dissect_nfs_client_id4(tvb, offset, pinfo,
- client_tree, "client");
+ if (client_tree)
+ offset = dissect_nfs_client_id4(tvb, offset, client_tree);
}
- fitem = proto_tree_add_text(newftree, tvb, offset, 0,
- "Callback");
- if (fitem) {
- newftree = proto_item_add_subtree(fitem, ett_nfs_cb_client4);
- if (newftree)
- offset = dissect_nfs_cb_client4(tvb, offset, pinfo, newftree,
- "callback");
+ fitem = proto_tree_add_text(newftree, tvb, offset, 0, "callback");
+ if (fitem)
+ {
+ callback_tree = proto_item_add_subtree(fitem,
+ ett_nfs_cb_client4);
+
+ if (callback_tree)
+ offset = dissect_nfs_cb_client4(tvb, offset, callback_tree);
}
+
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_callback_ident,
+ offset);
}
break;
case NFS4_OP_SETCLIENTID_CONFIRM:
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "setclientid_confirm");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4, offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4, offset);
break;
-
+
case NFS4_OP_VERIFY:
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "obj_attributes");
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_WRITE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
- offset);
- offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
- "stable");
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "data");
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4, offset);
+ offset = dissect_nfs_stable_how4(tvb, offset, newftree, "stable");
+ offset = dissect_nfsdata(tvb, offset, newftree, hf_nfs_data);
break;
-
+
default:
break;
}
return offset;
}
-int
-dissect_nfs4_compound_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs4_compound_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_tag4, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_minorversion,
- offset);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_tag4, NULL);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_minorversion, offset);
offset = dissect_nfs_argop4(tvb, offset, pinfo, tree);
+
return offset;
}
-int
-dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+static int
+dissect_nfs_secinfo4_res(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
{
- guint ops, ops_counter;
- guint opcode;
+ guint flavor;
+ proto_item *fitem;
+ proto_tree *secftree;
+
+ flavor = tvb_get_ntohl(tvb, offset);
+ fitem = proto_tree_add_uint(tree, hf_nfs_secinfo_flavor, tvb, offset, 4,
+ flavor);
+ offset += 4;
+
+ if (fitem)
+ {
+ switch(flavor)
+ {
+ case RPCSEC_GSS:
+ secftree = proto_item_add_subtree(fitem, ett_nfs_secinfo4_flavor_info);
+ if (secftree)
+ offset = dissect_nfs_rpcsec_gss_info(tvb, offset, secftree);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return offset;
+}
+
+static int
+dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ proto_tree *tree)
+{
+ guint32 ops, ops_counter;
+ guint32 opcode;
proto_item *fitem;
proto_tree *ftree = NULL;
proto_tree *newftree = NULL;
guint32 status;
ops = tvb_get_ntohl(tvb, offset+0);
- fitem = proto_tree_add_text(tree, tvb, offset, 4,
- "Operations (count: %d)", ops);
+
+ fitem = proto_tree_add_text(tree, tvb, offset, 4,
+ "Operations (count: %u)", ops);
offset += 4;
if (fitem == NULL) return offset;
/* sanity check for bogus packets */
if (opcode < NFS4_OP_ACCESS || opcode > NFS4_OP_WRITE) break;
- fitem = proto_tree_add_uint(ftree, hf_nfs_resop4, tvb, offset, 4,
+ fitem = proto_tree_add_uint(ftree, hf_nfs_resop4, tvb, offset, 4,
opcode);
offset += 4;
if (newftree == NULL)
break; /* error adding new subtree to operation item */
- offset = dissect_nfs_nfsstat4(tvb, offset, pinfo, newftree, &status);
+ offset = dissect_nfs_nfsstat4(tvb, offset, newftree, &status);
/*
- * With the exception of NFS4_OP_LOCK, NFS4_OP_LOCKT, and
+ * With the exception of NFS4_OP_LOCK, NFS4_OP_LOCKT, and
* NFS4_OP_SETATTR, all other ops do *not* return data with the
- * failed status code.
+ * failed status code.
*/
if ((status != NFS4_OK) &&
((opcode != NFS4_OP_LOCK) && (opcode != NFS4_OP_LOCKT) &&
switch(opcode)
{
case NFS4_OP_ACCESS:
- offset = dissect_access(tvb, offset, pinfo, newftree, "Supported");
- offset = dissect_access(tvb, offset, pinfo, newftree, "Access");
+ offset = dissect_access(tvb, offset, newftree, "Supported");
+ offset = dissect_access(tvb, offset, newftree, "Access");
break;
case NFS4_OP_CLOSE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_COMMIT:
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "writeverf");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
+ offset);
break;
case NFS4_OP_CREATE:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
- break;
-
- case NFS4_OP_DELEGPURGE:
- /* void */
- break;
-
- case NFS4_OP_DELEGRETURN:
- /* void */
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_GETATTR:
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "obj_attributes");
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_GETFH:
break;
case NFS4_OP_LINK:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
break;
case NFS4_OP_LOCK:
case NFS4_OP_LOCKT:
if (status == NFS4_OK)
- offset = dissect_rpc_uint64(tvb, pinfo, newftree,
- hf_nfs_stateid4, offset);
+ {
+ if (opcode == NFS4_OP_LOCK)
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ }
else
if (status == NFS4ERR_DENIED)
- offset = dissect_nfs_lock4denied(tvb, offset, pinfo, newftree,
- "denied");
+ offset = dissect_nfs_lock4denied(tvb, offset, newftree);
break;
case NFS4_OP_LOCKU:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- break;
-
- case NFS4_OP_LOOKUP:
- /* void */
- break;
-
- case NFS4_OP_LOOKUPP:
- /* void */
- break;
-
- case NFS4_OP_NVERIFY:
- /* void */
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_OPEN:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
- offset = dissect_nfs_open4_rflags(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_open4_rflags(tvb, offset, newftree,
"result_flags");
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "verifier");
- offset = dissect_nfs_open_delegation4(tvb, offset, pinfo, newftree,
- "delegation");
- break;
-
- case NFS4_OP_OPENATTR:
- /* void */
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_BITMAP_ONLY);
+ offset = dissect_nfs_open_delegation4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_OPEN_CONFIRM:
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
- offset);
- break;
-
- case NFS4_OP_PUTFH:
- /* void */
- break;
-
- case NFS4_OP_PUTPUBFH:
- /* void */
- break;
-
- case NFS4_OP_PUTROOTFH:
- /* void */
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_READ:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_eof,
- offset);
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "data");
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_eof, offset);
+ offset = dissect_nfsdata(tvb, offset, newftree, hf_nfs_data);
break;
case NFS4_OP_READDIR:
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "cookieverf");
- offset = dissect_nfs_dirlist4(tvb, offset, pinfo, newftree, "reply");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4, offset);
+ offset = dissect_nfs_dirlist4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_READLINK:
- offset = dissect_nfs_linktext4(tvb, offset, pinfo, newftree, "link");
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_linktext4, NULL);
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"source_cinfo");
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"target_cinfo");
break;
- case NFS4_OP_RENEW:
- /* void */
- break;
-
- case NFS4_OP_RESTOREFH:
- /* void */
- break;
-
- case NFS4_OP_SAVEFH:
- /* void */
- break;
-
case NFS4_OP_SECINFO:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
- hf_nfs_secinfo_flavor, offset);
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree,
- "flavor_info");
+ offset = dissect_rpc_array(tvb, pinfo, newftree, offset,
+ dissect_nfs_secinfo4_res, hf_nfs_secinfo_arr4);
break;
case NFS4_OP_SETATTR:
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
- "attrsset", 0);
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_SETCLIENTID:
if (status == NFS4_OK)
{
- offset = dissect_rpc_uint64(tvb, pinfo, newftree,
- hf_nfs_clientid4, offset);
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "setclientid_confirm");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4,
+ offset);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
+ offset);
}
else
if (status == NFS4ERR_CLID_INUSE)
- {
- offset = dissect_nfs_clientaddr4(tvb, offset, pinfo, newftree,
- "client_using");
- }
- break;
-
- case NFS4_OP_SETCLIENTID_CONFIRM:
- /* void */
- break;
-
- case NFS4_OP_VERIFY:
- /* void */
+ offset = dissect_nfs_clientaddr4(tvb, offset, newftree);
break;
case NFS4_OP_WRITE:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
- offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_stable_how4(tvb, offset, newftree,
"committed");
- offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
- "writeverf");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
+ offset);
break;
default:
return offset;
}
-int
-dissect_nfs4_compound_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+static int
+dissect_nfs4_compound_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfs_nfsstat4(tvb, offset, pinfo, tree, &status);
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_tag4, NULL);
- offset = dissect_nfs_resop4(tvb, offset, pinfo, tree, "arguments");
+ offset = dissect_nfs_nfsstat4(tvb, offset, tree, &status);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_tag4, NULL);
+ offset = dissect_nfs_resop4(tvb, offset, pinfo, tree);
return offset;
}
/* NULL as function pointer means: type of arguments is "void". */
static const vsff nfs3_proc[] = {
{ 0, "NULL", /* OK */
- NULL, NULL },
+ dissect_nfs3_null_call, dissect_nfs3_null_reply },
{ 1, "GETATTR", /* OK */
dissect_nfs3_getattr_call, dissect_nfs3_getattr_reply },
{ 2, "SETATTR", /* OK */
{ 4, "ACCESS", /* OK */
dissect_nfs3_access_call, dissect_nfs3_access_reply },
{ 5, "READLINK", /* OK */
- dissect_nfs3_nfs_fh3_call, dissect_nfs3_readlink_reply },
+ dissect_nfs3_readlink_call, dissect_nfs3_readlink_reply },
{ 6, "READ", /* OK */
dissect_nfs3_read_call, dissect_nfs3_read_reply },
{ 7, "WRITE", /* OK */
{ 8, "CREATE", /* OK */
dissect_nfs3_create_call, dissect_nfs3_create_reply },
{ 9, "MKDIR", /* OK */
- dissect_nfs3_mkdir_call, dissect_nfs3_create_reply },
+ dissect_nfs3_mkdir_call, dissect_nfs3_mkdir_reply },
{ 10, "SYMLINK", /* OK */
- dissect_nfs3_symlink_call, dissect_nfs3_create_reply },
+ dissect_nfs3_symlink_call, dissect_nfs3_symlink_reply },
{ 11, "MKNOD", /* OK */
- dissect_nfs3_mknod_call, dissect_nfs3_create_reply },
+ dissect_nfs3_mknod_call, dissect_nfs3_mknod_reply },
{ 12, "REMOVE", /* OK */
- dissect_nfs3_diropargs3_call, dissect_nfs3_remove_reply },
+ dissect_nfs3_remove_call, dissect_nfs3_remove_reply },
{ 13, "RMDIR", /* OK */
- dissect_nfs3_diropargs3_call, dissect_nfs3_remove_reply },
+ dissect_nfs3_rmdir_call, dissect_nfs3_rmdir_reply },
{ 14, "RENAME", /* OK */
dissect_nfs3_rename_call, dissect_nfs3_rename_reply },
{ 15, "LINK", /* OK */
{ 17, "READDIRPLUS", /* OK */
dissect_nfs3_readdirplus_call, dissect_nfs3_readdirplus_reply },
{ 18, "FSSTAT", /* OK */
- dissect_nfs3_nfs_fh3_call, dissect_nfs3_fsstat_reply },
+ dissect_nfs3_fsstat_call, dissect_nfs3_fsstat_reply },
{ 19, "FSINFO", /* OK */
- dissect_nfs3_nfs_fh3_call, dissect_nfs3_fsinfo_reply },
+ dissect_nfs3_fsinfo_call, dissect_nfs3_fsinfo_reply },
{ 20, "PATHCONF", /* OK */
- dissect_nfs3_nfs_fh3_call, dissect_nfs3_pathconf_reply },
+ dissect_nfs3_pathconf_call, dissect_nfs3_pathconf_reply },
{ 21, "COMMIT", /* OK */
dissect_nfs3_commit_call, dissect_nfs3_commit_reply },
{ 0,NULL,NULL,NULL }
};
+
+static const value_string nfsv3_proc_vals[] = {
+ { 0, "NULL" },
+ { 1, "GETATTR" },
+ { 2, "SETATTR" },
+ { 3, "LOOKUP" },
+ { 4, "ACCESS" },
+ { 5, "READLINK" },
+ { 6, "READ" },
+ { 7, "WRITE" },
+ { 8, "CREATE" },
+ { 9, "MKDIR" },
+ { 10, "SYMLINK" },
+ { 11, "MKNOD" },
+ { 12, "REMOVE" },
+ { 13, "RMDIR" },
+ { 14, "RENAME" },
+ { 15, "LINK" },
+ { 16, "READDIR" },
+ { 17, "READDIRPLUS" },
+ { 18, "FSSTAT" },
+ { 19, "FSINFO" },
+ { 20, "PATHCONF" },
+ { 21, "COMMIT" },
+ { 0, NULL }
+};
+
/* end of NFS Version 3 */
static const vsff nfs4_proc[] = {
{ 0, NULL, NULL, NULL }
};
+static const value_string nfsv4_proc_vals[] = {
+ { 0, "NULL" },
+ { 1, "COMPOUND" },
+ { 0, NULL }
+};
static struct true_false_string yesno = { "Yes", "No" };
proto_register_nfs(void)
{
static hf_register_info hf[] = {
+ { &hf_nfs_procedure_v2, {
+ "V2 Procedure", "nfs.procedure_v2", FT_UINT32, BASE_DEC,
+ VALS(nfsv2_proc_vals), 0, "V2 Procedure", HFILL }},
+ { &hf_nfs_procedure_v3, {
+ "V3 Procedure", "nfs.procedure_v3", FT_UINT32, BASE_DEC,
+ VALS(nfsv3_proc_vals), 0, "V3 Procedure", HFILL }},
+ { &hf_nfs_procedure_v4, {
+ "V4 Procedure", "nfs.procedure_v4", FT_UINT32, BASE_DEC,
+ VALS(nfsv4_proc_vals), 0, "V4 Procedure", HFILL }},
{ &hf_nfs_fh_length, {
"length", "nfs.fh.length", FT_UINT32, BASE_DEC,
NULL, 0, "file handle length", HFILL }},
+ { &hf_nfs_fh_hash, {
+ "hash", "nfs.fh.hash", FT_UINT32, BASE_HEX,
+ NULL, 0, "file handle hash", HFILL }},
{ &hf_nfs_fh_fsid_major, {
"major", "nfs.fh.fsid.major", FT_UINT32, BASE_DEC,
NULL, 0, "major file system ID", HFILL }},
{ &hf_nfs_stat, {
"Status", "nfs.status2", FT_UINT32, BASE_DEC,
VALS(names_nfs_stat), 0, "Reply status", HFILL }},
+ { &hf_nfs_full_name, {
+ "Full Name", "nfs.full_name", FT_STRING, BASE_DEC,
+ NULL, 0, "Full Name", HFILL }},
{ &hf_nfs_name, {
"Name", "nfs.name", FT_STRING, BASE_DEC,
NULL, 0, "Name", HFILL }},
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdir_entry3_fileid, {
- "File ID", "nfs.readdir.entry3.fileid", FT_UINT32, BASE_DEC,
+ "File ID", "nfs.readdir.entry3.fileid", FT_UINT64, BASE_DEC,
NULL, 0, "File ID", HFILL }},
{ &hf_nfs_readdir_entry3_name, {
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdir_entry3_cookie, {
- "Cookie", "nfs.readdir.entry3.cookie", FT_UINT32, BASE_DEC,
+ "Cookie", "nfs.readdir.entry3.cookie", FT_UINT64, BASE_DEC,
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdirplus_entry_fileid, {
- "File ID", "nfs.readdirplus.entry.fileid", FT_UINT32, BASE_DEC,
+ "File ID", "nfs.readdirplus.entry.fileid", FT_UINT64, BASE_DEC,
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdirplus_entry_name, {
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdirplus_entry_cookie, {
- "Cookie", "nfs.readdirplus.entry.cookie", FT_UINT32, BASE_DEC,
+ "Cookie", "nfs.readdirplus.entry.cookie", FT_UINT64, BASE_DEC,
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdir_eof, {
"dtpref", "nfs.fsinfo.dtpref", FT_UINT32, BASE_DEC,
NULL, 0, "Preferred READDIR request", HFILL }},
{ &hf_nfs_fsinfo_maxfilesize, {
- "maxfilesize", "nfs.fsinfo.maxfilesize", FT_UINT32, BASE_DEC,
+ "maxfilesize", "nfs.fsinfo.maxfilesize", FT_UINT64, BASE_DEC,
NULL, 0, "Maximum file size", HFILL }},
{ &hf_nfs_fsinfo_properties, {
"Properties", "nfs.fsinfo.propeties", FT_UINT32, BASE_HEX,
"no_trunc", "nfs.pathconf.no_trunc", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "No long file name truncation", HFILL }},
{ &hf_nfs_pathconf_chown_restricted, {
- "chown_restricted", "nfs.pathconf.chown_restricted", FT_BOOLEAN,
+ "chown_restricted", "nfs.pathconf.chown_restricted", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "chown is restricted to root", HFILL }},
{ &hf_nfs_pathconf_case_insensitive, {
- "case_insensitive", "nfs.pathconf.case_insensitive", FT_BOOLEAN,
+ "case_insensitive", "nfs.pathconf.case_insensitive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "file names are treated case insensitive", HFILL }},
{ &hf_nfs_pathconf_case_preserving, {
- "case_preserving", "nfs.pathconf.case_preserving", FT_BOOLEAN,
+ "case_preserving", "nfs.pathconf.case_preserving", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "file name cases are preserved", HFILL }},
{ &hf_nfs_fattr_type, {
NULL, 0, "nfs.fattr3.gid", HFILL }},
{ &hf_nfs_fattr3_size, {
- "size", "nfs.fattr3.size", FT_UINT32, BASE_DEC,
+ "size", "nfs.fattr3.size", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr3.size", HFILL }},
{ &hf_nfs_fattr3_used, {
- "used", "nfs.fattr3.used", FT_UINT32, BASE_DEC,
+ "used", "nfs.fattr3.used", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr3.used", HFILL }},
{ &hf_nfs_fattr3_rdev, {
NULL, 0, "nfs.fattr3.rdev", HFILL }},
{ &hf_nfs_fattr3_fsid, {
- "fsid", "nfs.fattr3.fsid", FT_UINT32, BASE_DEC,
+ "fsid", "nfs.fattr3.fsid", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr3.fsid", HFILL }},
{ &hf_nfs_fattr3_fileid, {
- "fileid", "nfs.fattr3.fileid", FT_UINT32, BASE_DEC,
+ "fileid", "nfs.fattr3.fileid", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr3.fileid", HFILL }},
{ &hf_nfs_wcc_attr_size, {
- "size", "nfs.wcc_attr.size", FT_UINT32, BASE_DEC,
+ "size", "nfs.wcc_attr.size", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.wcc_attr.size", HFILL }},
{ &hf_nfs_set_size3_size, {
- "size", "nfs.set_size3.size", FT_UINT32, BASE_DEC,
+ "size", "nfs.set_size3.size", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.set_size3.size", HFILL }},
{ &hf_nfs_uid3, {
NULL, 0, "nfs.gid3", HFILL }},
{ &hf_nfs_cookie3, {
- "cookie", "nfs.cookie3", FT_UINT32, BASE_DEC,
+ "cookie", "nfs.cookie3", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.cookie3", HFILL }},
{ &hf_nfs_offset3, {
- "offset", "nfs.offset3", FT_UINT32, BASE_DEC,
+ "offset", "nfs.offset3", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.offset3", HFILL }},
{ &hf_nfs_count3, {
NULL, 0, "nfs.count3_dircount", HFILL }},
{ &hf_nfs_fsstat3_resok_tbytes, {
- "tbytes", "nfs.fsstat3_resok.tbytes", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.tbytes", HFILL }},
+ "Total bytes", "nfs.fsstat3_resok.tbytes", FT_UINT64, BASE_DEC,
+ NULL, 0, "Total bytes", HFILL }},
{ &hf_nfs_fsstat3_resok_fbytes, {
- "fbytes", "nfs.fsstat3_resok.fbytes", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.fbytes", HFILL }},
+ "Free bytes", "nfs.fsstat3_resok.fbytes", FT_UINT64, BASE_DEC,
+ NULL, 0, "Free bytes", HFILL }},
{ &hf_nfs_fsstat3_resok_abytes, {
- "abytes", "nfs.fsstat3_resok.abytes", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.abytes", HFILL }},
+ "Available free bytes", "nfs.fsstat3_resok.abytes", FT_UINT64, BASE_DEC,
+ NULL, 0, "Available free bytes", HFILL }},
{ &hf_nfs_fsstat3_resok_tfiles, {
- "tfiles", "nfs.fsstat3_resok.tfiles", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.tfiles", HFILL }},
+ "Total file slots", "nfs.fsstat3_resok.tfiles", FT_UINT64, BASE_DEC,
+ NULL, 0, "Total file slots", HFILL }},
{ &hf_nfs_fsstat3_resok_ffiles, {
- "ffiles", "nfs.fsstat3_resok.ffiles", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.ffiles", HFILL }},
+ "Free file slots", "nfs.fsstat3_resok.ffiles", FT_UINT64, BASE_DEC,
+ NULL, 0, "Free file slots", HFILL }},
{ &hf_nfs_fsstat3_resok_afiles, {
- "afiles", "nfs.fsstat3_resok.afiles", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.fsstat3_resok.afiles", HFILL }},
+ "Available free file slots", "nfs.fsstat3_resok.afiles", FT_UINT64, BASE_DEC,
+ NULL, 0, "Available free file slots", HFILL }},
/* NFSv4 */
NULL, 0, "Tag", HFILL }},
{ &hf_nfs_clientid4, {
- "clientid", "nfs.clientid", FT_UINT32, BASE_DEC,
+ "clientid", "nfs.clientid", FT_UINT64, BASE_HEX,
NULL, 0, "Client ID", HFILL }},
- { &hf_nfs_clientid4_verifier, {
- "verifier", "nfs.clientid.verifier", FT_UINT32, BASE_DEC,
- NULL, 0, "Verifier Client ID", HFILL }},
-
{ &hf_nfs_ace4, {
"ace", "nfs.ace", FT_STRING, BASE_DEC,
NULL, 0, "Access Control Entry", HFILL }},
"seqid", "nfs.seqid", FT_UINT32, BASE_HEX,
NULL, 0, "Sequence ID", HFILL }},
+ { &hf_nfs_lock_seqid4, {
+ "lock_seqid", "nfs.lock_seqid", FT_UINT32, BASE_HEX,
+ NULL, 0, "Lock Sequence ID", HFILL }},
+
{ &hf_nfs_mand_attr, {
"mand_attr", "nfs.attr", FT_UINT32, BASE_DEC,
VALS(names_fattr4), 0, "Mandatory Attribute", HFILL }},
"attr_vals", "nfs.fattr4.attr_vals", FT_BYTES, BASE_DEC,
NULL, 0, "attr_vals", HFILL }},
- { &hf_nfs_fattr4_expire_type, {
- "fattr4_expire_type", "nfs.fattr4_expire_type", FT_UINT32, BASE_DEC,
- VALS(names_fattr4_expire_type), 0, "fattr4_expire_type", HFILL }},
-
{ &hf_nfs_fattr4_link_support, {
- "fattr4_link_support", "nfs.fattr4_link_support", FT_BOOLEAN,
+ "fattr4_link_support", "nfs.fattr4_link_support", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_link_support", HFILL }},
{ &hf_nfs_fattr4_symlink_support, {
- "fattr4_symlink_support", "nfs.fattr4_symlink_support", FT_BOOLEAN,
+ "fattr4_symlink_support", "nfs.fattr4_symlink_support", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_symlink_support", HFILL }},
{ &hf_nfs_fattr4_named_attr, {
&yesno, 0, "nfs.fattr4_named_attr", HFILL }},
{ &hf_nfs_fattr4_unique_handles, {
- "fattr4_unique_handles", "nfs.fattr4_unique_handles", FT_BOOLEAN,
+ "fattr4_unique_handles", "nfs.fattr4_unique_handles", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_unique_handles", HFILL }},
{ &hf_nfs_fattr4_archive, {
- "fattr4_archive", "nfs.fattr4_archive", FT_BOOLEAN,
+ "fattr4_archive", "nfs.fattr4_archive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_archive", HFILL }},
{ &hf_nfs_fattr4_cansettime, {
- "fattr4_cansettime", "nfs.fattr4_cansettime", FT_BOOLEAN,
+ "fattr4_cansettime", "nfs.fattr4_cansettime", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_cansettime", HFILL }},
{ &hf_nfs_fattr4_case_insensitive, {
- "fattr4_case_insensitive", "nfs.fattr4_case_insensitive", FT_BOOLEAN,
+ "fattr4_case_insensitive", "nfs.fattr4_case_insensitive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_case_insensitive", HFILL }},
{ &hf_nfs_fattr4_case_preserving, {
- "fattr4_case_preserving", "nfs.fattr4_case_preserving", FT_BOOLEAN,
+ "fattr4_case_preserving", "nfs.fattr4_case_preserving", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_case_preserving", HFILL }},
{ &hf_nfs_fattr4_chown_restricted, {
- "fattr4_chown_restricted", "nfs.fattr4_chown_restricted", FT_BOOLEAN,
+ "fattr4_chown_restricted", "nfs.fattr4_chown_restricted", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_chown_restricted", HFILL }},
{ &hf_nfs_fattr4_hidden, {
- "fattr4_hidden", "nfs.fattr4_hidden", FT_BOOLEAN,
+ "fattr4_hidden", "nfs.fattr4_hidden", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_hidden", HFILL }},
{ &hf_nfs_fattr4_homogeneous, {
- "fattr4_homogeneous", "nfs.fattr4_homogeneous", FT_BOOLEAN,
+ "fattr4_homogeneous", "nfs.fattr4_homogeneous", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_homogeneous", HFILL }},
{ &hf_nfs_fattr4_mimetype, {
NULL, 0, "nfs.fattr4_mimetype", HFILL }},
{ &hf_nfs_fattr4_no_trunc, {
- "fattr4_no_trunc", "nfs.fattr4_no_trunc", FT_BOOLEAN,
+ "fattr4_no_trunc", "nfs.fattr4_no_trunc", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_no_trunc", HFILL }},
{ &hf_nfs_fattr4_system, {
- "fattr4_system", "nfs.fattr4_system", FT_BOOLEAN,
+ "fattr4_system", "nfs.fattr4_system", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_system", HFILL }},
{ &hf_nfs_who, {
"eof", "nfs.dirlist4.eof", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.dirlist4.eof", HFILL }},
- { &hf_nfs_data_follows, {
- "data_follows", "nfs.data_follows", FT_BOOLEAN,
- BASE_NONE, &yesno, 0, "nfs.data_follows", HFILL }},
-
{ &hf_nfs_stateid4, {
- "stateid", "nfs.stateid4", FT_UINT32, BASE_DEC,
+ "stateid", "nfs.stateid4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.stateid4", HFILL }},
{ &hf_nfs_offset4, {
- "offset", "nfs.offset4", FT_UINT32, BASE_DEC,
+ "offset", "nfs.offset4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.offset4", HFILL }},
{ &hf_nfs_specdata1, {
"specdata2", "nfs.specdata2", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.specdata2", HFILL }},
- { &hf_nfs_locktype4, {
+ { &hf_nfs_lock_type4, {
"locktype", "nfs.locktype4", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.locktype4", HFILL }},
+ VALS(names_nfs_lock_type4), 0, "nfs.locktype4", HFILL }},
{ &hf_nfs_reclaim4, {
- "reclaim", "nfs.reclaim4", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.reclaim4", HFILL }},
+ "reclaim", "nfs.reclaim4", FT_BOOLEAN,
+ BASE_NONE, &yesno, 0, "Reclaim", HFILL }},
{ &hf_nfs_length4, {
- "length", "nfs.length4", FT_UINT32, BASE_DEC,
+ "length", "nfs.length4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.length4", HFILL }},
{ &hf_nfs_changeid4, {
- "changeid", "nfs.changeid4", FT_UINT32, BASE_DEC,
+ "changeid", "nfs.changeid4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.changeid4", HFILL }},
+ { &hf_nfs_changeid4_before, {
+ "changeid", "nfs.changeid4.before", FT_UINT64, BASE_DEC,
+ NULL, 0, "nfs.changeid4.before", HFILL }},
+
+ { &hf_nfs_changeid4_after, {
+ "changeid", "nfs.changeid4.after", FT_UINT64, BASE_DEC,
+ NULL, 0, "nfs.changeid4.after", HFILL }},
+
{ &hf_nfs_nfstime4_seconds, {
- "seconds", "nfs.nfstime4.seconds", FT_UINT32, BASE_DEC,
+ "seconds", "nfs.nfstime4.seconds", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.nfstime4.seconds", HFILL }},
{ &hf_nfs_nfstime4_nseconds, {
NULL, 0, "nfs.nfstime4.nseconds", HFILL }},
{ &hf_nfs_fsid4_major, {
- "fsid4.major", "nfs.fsid4.major", FT_UINT32, BASE_DEC,
+ "fsid4.major", "nfs.fsid4.major", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.nfstime4.fsid4.major", HFILL }},
{ &hf_nfs_fsid4_minor, {
- "fsid4.minor", "nfs.fsid4.minor", FT_UINT32, BASE_DEC,
+ "fsid4.minor", "nfs.fsid4.minor", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fsid4.minor", HFILL }},
{ &hf_nfs_acetype4, {
"acetype", "nfs.acetype4", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.acetype4", HFILL }},
+ VALS(names_acetype4), 0, "nfs.acetype4", HFILL }},
{ &hf_nfs_aceflag4, {
"aceflag", "nfs.aceflag4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.acemask4", HFILL }},
{ &hf_nfs_fattr4_size, {
- "size", "nfs.fattr4.size", FT_UINT32, BASE_DEC,
+ "size", "nfs.fattr4.size", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.size", HFILL }},
{ &hf_nfs_fattr4_lease_time, {
NULL, 0, "nfs.fattr4.aclsupport", HFILL }},
{ &hf_nfs_fattr4_fileid, {
- "fileid", "nfs.fattr4.fileid", FT_UINT32, BASE_DEC,
+ "fileid", "nfs.fattr4.fileid", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.fileid", HFILL }},
{ &hf_nfs_fattr4_files_avail, {
- "files_avail", "nfs.fattr4.files_avail", FT_UINT32, BASE_DEC,
+ "files_avail", "nfs.fattr4.files_avail", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.files_avail", HFILL }},
{ &hf_nfs_fattr4_files_free, {
- "files_free", "nfs.fattr4.files_free", FT_UINT32, BASE_DEC,
+ "files_free", "nfs.fattr4.files_free", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.files_free", HFILL }},
{ &hf_nfs_fattr4_files_total, {
- "files_total", "nfs.fattr4.files_total", FT_UINT32, BASE_DEC,
+ "files_total", "nfs.fattr4.files_total", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.files_total", HFILL }},
{ &hf_nfs_fattr4_maxfilesize, {
- "maxfilesize", "nfs.fattr4.maxfilesize", FT_UINT32, BASE_DEC,
+ "maxfilesize", "nfs.fattr4.maxfilesize", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.maxfilesize", HFILL }},
{ &hf_nfs_fattr4_maxlink, {
NULL, 0, "nfs.delegate_type", HFILL }},
{ &hf_nfs_secinfo_flavor, {
- "secinfo_flavor", "nfs.secinfo_flavor", FT_UINT32, BASE_DEC,
- NULL, 0, "nfs.secinfo_flavor", HFILL }},
+ "flavor", "nfs.secinfo.flavor", FT_UINT32, BASE_DEC,
+ VALS(rpc_auth_flavor), 0, "nfs.secinfo.flavor", HFILL }},
{ &hf_nfs_num_blocks, {
"num_blocks", "nfs.num_blocks", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.eof", HFILL }},
{ &hf_nfs_fattr4_maxread, {
- "maxread", "nfs.fattr4.maxread", FT_UINT32, BASE_DEC,
+ "maxread", "nfs.fattr4.maxread", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.maxread", HFILL }},
{ &hf_nfs_fattr4_maxwrite, {
- "maxwrite", "nfs.fattr4.maxwrite", FT_UINT32, BASE_DEC,
+ "maxwrite", "nfs.fattr4.maxwrite", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.maxwrite", HFILL }},
{ &hf_nfs_fattr4_quota_hard, {
- "quota_hard", "nfs.fattr4.quota_hard", FT_UINT32, BASE_DEC,
+ "quota_hard", "nfs.fattr4.quota_hard", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_hard", HFILL }},
{ &hf_nfs_fattr4_quota_soft, {
- "quota_soft", "nfs.fattr4.quota_soft", FT_UINT32, BASE_DEC,
+ "quota_soft", "nfs.fattr4.quota_soft", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_soft", HFILL }},
{ &hf_nfs_fattr4_quota_used, {
- "quota_used", "nfs.fattr4.quota_used", FT_UINT32, BASE_DEC,
+ "quota_used", "nfs.fattr4.quota_used", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_used", HFILL }},
{ &hf_nfs_fattr4_space_avail, {
- "space_avail", "nfs.fattr4.space_avail", FT_UINT32, BASE_DEC,
+ "space_avail", "nfs.fattr4.space_avail", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.space_avail", HFILL }},
{ &hf_nfs_fattr4_space_free, {
- "space_free", "nfs.fattr4.space_free", FT_UINT32, BASE_DEC,
+ "space_free", "nfs.fattr4.space_free", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.space_free", HFILL }},
{ &hf_nfs_fattr4_space_total, {
- "space_total", "nfs.fattr4.space_total", FT_UINT32, BASE_DEC,
+ "space_total", "nfs.fattr4.space_total", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.space_total", HFILL }},
{ &hf_nfs_fattr4_space_used, {
- "space_used", "nfs.fattr4.space_used", FT_UINT32, BASE_DEC,
+ "space_used", "nfs.fattr4.space_used", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.fattr4.space_used", HFILL }},
{ &hf_nfs_stateid4_delegate_stateid, {
- "delegate_stateid", "nfs.delegate_stateid", FT_UINT32, BASE_DEC,
+ "delegate_stateid", "nfs.delegate_stateid", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.delegate_stateid", HFILL }},
{ &hf_nfs_verifier4, {
- "verifier", "nfs.verifier4", FT_UINT32, BASE_DEC,
+ "verifier", "nfs.verifier4", FT_UINT64, BASE_HEX,
NULL, 0, "nfs.verifier4", HFILL }},
{ &hf_nfs_cookie4, {
- "cookie", "nfs.cookie4", FT_UINT32, BASE_DEC,
+ "cookie", "nfs.cookie4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.cookie4", HFILL }},
{ &hf_nfs_cookieverf4, {
- "cookieverf", "nfs.cookieverf4", FT_UINT32, BASE_DEC,
+ "cookieverf", "nfs.cookieverf4", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.cookieverf4", HFILL }},
{ &hf_nfs_cb_location, {
NULL, 0, "nfs.cb_location", HFILL }},
{ &hf_nfs_cb_program, {
- "cb_program", "nfs.cb_program", FT_UINT32, BASE_DEC,
+ "cb_program", "nfs.cb_program", FT_UINT32, BASE_HEX,
NULL, 0, "nfs.cb_program", HFILL }},
{ &hf_nfs_recall4, {
- "recall", "nfs.recall4", FT_BOOLEAN,
+ "recall", "nfs.recall4", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.recall4", HFILL }},
{ &hf_nfs_filesize, {
- "filesize", "nfs.filesize", FT_UINT32, BASE_DEC,
+ "filesize", "nfs.filesize", FT_UINT64, BASE_DEC,
NULL, 0, "nfs.filesize", HFILL }},
{ &hf_nfs_count4, {
"nano seconds", "nfs.dtime.nsec", FT_UINT32, BASE_DEC,
NULL, 0, "Time Delta, Nano-seconds", HFILL }},
+ { &hf_nfs_open_owner4, {
+ "owner", "nfs.open_owner4", FT_BYTES, BASE_DEC,
+ NULL, 0, "owner", HFILL }},
+
+ { &hf_nfs_lock_owner4, {
+ "owner", "nfs.lock_owner4", FT_BYTES, BASE_DEC,
+ NULL, 0, "owner", HFILL }},
+
+ { &hf_nfs_secinfo_rpcsec_gss_info_service, {
+ "service", "nfs.secinfo.rpcsec_gss_info.service", FT_UINT32,
+ BASE_DEC, VALS(rpc_authgss_svc), 0, "service", HFILL }},
+
+ { &hf_nfs_attrdircreate, {
+ "attribute dir create", "nfs.openattr4.createdir", FT_BOOLEAN,
+ BASE_NONE, &yesno, 0, "nfs.openattr4.createdir", HFILL }},
+
+ { &hf_nfs_new_lock_owner, {
+ "new lock owner?", "nfs.lock.locker.new_lock_owner", FT_BOOLEAN,
+ BASE_NONE, &yesno, 0, "nfs.lock.locker.new_lock_owner", HFILL }},
+
+ { &hf_nfs_lock4_reclaim, {
+ "reclaim?", "nfs.lock.reclaim", FT_BOOLEAN,
+ BASE_NONE, &yesno, 0, "nfs.lock.reclaim", HFILL }},
+
+ { &hf_nfs_sec_oid4, {
+ "oid", "nfs.secinfo.flavor_info.rpcsec_gss_info.oid", FT_BYTES,
+ BASE_DEC, NULL, 0, "oid", HFILL }},
+
+ { &hf_nfs_qop4, {
+ "qop", "nfs.secinfo.flavor_info.rpcsec_gss_info.qop", FT_UINT32,
+ BASE_DEC, NULL, 0, "qop", HFILL }},
+
+ { &hf_nfs_client_id4_id, {
+ "id", "nfs.nfs_client_id4.id", FT_BYTES, BASE_DEC,
+ NULL, 0, "nfs.nfs_client_id4.id", HFILL }},
+
+ { &hf_nfs_stateid4_other, {
+ "Data", "nfs.stateid4.other", FT_BYTES, BASE_DEC,
+ NULL, 0, "Data", HFILL }},
+
+ { &hf_nfs_acl4, {
+ "ACL", "nfs.acl", FT_NONE, BASE_NONE,
+ NULL, 0, "Access Control List", HFILL }},
+
+ { &hf_nfs_callback_ident, {
+ "callback_ident", "nfs.callback.ident", FT_UINT32, BASE_HEX,
+ NULL, 0, "Callback Identifier", HFILL }},
+
+ { &hf_nfs_r_netid, {
+ "r_netid", "nfs.r_netid", FT_BYTES, BASE_DEC, NULL, 0,
+ "r_netid", HFILL }},
+
+ { &hf_nfs_r_addr, {
+ "r_addr", "nfs.r_addr", FT_BYTES, BASE_DEC, NULL, 0,
+ "r_addr", HFILL }},
+
+ { &hf_nfs_secinfo_arr4, {
+ "Flavors Info", "nfs.flavors.info", FT_NONE, BASE_NONE,
+ NULL, 0, "Flavors Info", HFILL }},
};
static gint *ett[] = {
&ett_nfs_renew4,
&ett_nfs_restorefh4,
&ett_nfs_savefh4,
- &ett_nfs_secinfo4,
&ett_nfs_setattr4,
&ett_nfs_setclientid4,
&ett_nfs_setclientid_confirm4,
&ett_nfs_open_delegation4,
&ett_nfs_open_claim4,
&ett_nfs_opentype4,
- &ett_nfs_lockowner4,
+ &ett_nfs_lock_owner4,
&ett_nfs_cb_client4,
&ett_nfs_client_id4,
&ett_nfs_bitmap4,
&ett_nfs_fsid4,
&ett_nfs_fs_locations4,
&ett_nfs_fs_location4,
- &ett_nfs_open4_result_flags
+ &ett_nfs_open4_result_flags,
+ &ett_nfs_secinfo4,
+ &ett_nfs_secinfo4_flavor_info,
+ &ett_nfs_stateid4,
+ &ett_nfs_fattr4_fh_expire_type,
+ &ett_nfs_ace4,
+ &ett_nfs_clientaddr4,
+ &ett_nfs_aceflag4,
+ &ett_nfs_acemask4,
};
+ module_t *nfs_module;
+
proto_nfs = proto_register_protocol("Network File System", "NFS", "nfs");
proto_register_field_array(proto_nfs, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
+
+ nfs_module=prefs_register_protocol(proto_nfs, NULL);
+ prefs_register_bool_preference(nfs_module, "file_name_snooping",
+ "Snoop FH to filename mappings",
+ "Whether the dissector should snoop the FH to filename mappings by looking inside certain packets",
+ &nfs_file_name_snooping);
+ prefs_register_bool_preference(nfs_module, "file_full_name_snooping",
+ "Snoop full path to filenames",
+ "Whether the dissector should snoop the full pathname for files for matching FH's",
+ &nfs_file_name_full_snooping);
+ prefs_register_bool_preference(nfs_module, "fhandle_find_both_reqrep",
+ "Fhandle filters finds both request/response",
+ "With this option display filters for nfs fhandles (nfs.fh.{name|full_name|hash}) will find both the request and response packets for a RPC call, even if the actual fhandle is only present in one of the packets",
+ &nfs_fhandle_reqrep_matching);
+ register_init_routine(nfs_name_snoop_init);
+ register_init_routine(nfs_fhandle_reqrep_matching_init);
}
void
/* Register the protocol as RPC */
rpc_init_prog(proto_nfs, NFS_PROGRAM, ett_nfs);
/* Register the procedure tables */
- rpc_init_proc_table(NFS_PROGRAM, 2, nfs2_proc);
- rpc_init_proc_table(NFS_PROGRAM, 3, nfs3_proc);
- rpc_init_proc_table(NFS_PROGRAM, 4, nfs4_proc);
+ rpc_init_proc_table(NFS_PROGRAM, 2, nfs2_proc, hf_nfs_procedure_v2);
+ rpc_init_proc_table(NFS_PROGRAM, 3, nfs3_proc, hf_nfs_procedure_v3);
+ rpc_init_proc_table(NFS_PROGRAM, 4, nfs4_proc, hf_nfs_procedure_v4);
}
git.samba.org / obnox / wireshark / wip.git / blobdiff