* Routines for nfs dissection
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
* Copyright 2000-2002, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
- * $Id: packet-nfs.c,v 1.71 2002/05/21 21:13:41 guy Exp $
+ * $Id: packet-nfs.c,v 1.84 2002/12/02 23:43:28 guy 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>
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_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_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_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
static gint
nfs_fhandle_data_equal(gconstpointer k1, gconstpointer k2)
{
- nfs_fhandle_data_t *key1 = (nfs_fhandle_data_t *)k1;
- nfs_fhandle_data_t *key2 = (nfs_fhandle_data_t *)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)
{
- nfs_fhandle_data_t *key = (nfs_fhandle_data_t *)k;
+ const nfs_fhandle_data_t *key = (const nfs_fhandle_data_t *)k;
int i;
int hash;
if(nns->fh){
tvb_free(nns->tvb);
- nns->tvb=NULL;
+ nns->tvb=NULL;
g_free((gpointer)nns->fh);
nns->fh=NULL;
nns->len=0;
static gint
nfs_fhandle_frame_equal(gconstpointer k1, gconstpointer k2)
{
- int key1 = (int)k1;
- int key2 = (int)k2;
+ guint32 key1 = (guint32)k1;
+ guint32 key2 = (guint32)k2;
return key1==key2;
}
static guint
nfs_fhandle_frame_hash(gconstpointer k)
{
- int key = (int)k;
+ guint32 key = (guint32)k;
return key;
}
nfs_fhandle_data_init_count * sizeof(nfs_fhandle_data_t),
G_ALLOC_ONLY);
}
-
+
}
typedef struct nfs_name_snoop_key {
int key;
int fh_length;
- unsigned char *fh;
+ const unsigned char *fh;
} nfs_name_snoop_key_t;
static GMemChunk *nfs_name_snoop_chunk = NULL;
static gint
nfs_name_snoop_matched_equal(gconstpointer k1, gconstpointer k2)
{
- nfs_name_snoop_key_t *key1 = (nfs_name_snoop_key_t *)k1;
- nfs_name_snoop_key_t *key2 = (nfs_name_snoop_key_t *)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)
static guint
nfs_name_snoop_matched_hash(gconstpointer k)
{
- nfs_name_snoop_key_t *key = (nfs_name_snoop_key_t *)k;
+ const nfs_name_snoop_key_t *key = (const nfs_name_snoop_key_t *)k;
int i;
- int hash;
+ guint hash;
hash=key->key;
for(i=0;i<key->fh_length;i++)
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;
- unsigned char *ptr=NULL;
+ const unsigned char *ptr=NULL;
/* filter out all '.' and '..' names */
if(!name){
- ptr=(unsigned char *)tvb_get_ptr(tvb, name_offset, name_len);
+ ptr=(const unsigned char *)tvb_get_ptr(tvb, name_offset, name_len);
if(ptr[0]=='.'){
if(ptr[1]==0){
return;
/* remove any old entry for this */
old_nns=g_hash_table_lookup(nfs_name_snoop_unmatched, (gconstpointer)xid);
if(old_nns){
- /* if we havnt seen the reply yet, then there are no
+ /* 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);
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;
}
/* oki, we have a new entry */
- nns->fh=g_malloc(fh_length);
- memcpy(nns->fh, tvb_get_ptr(tvb, fh_offset, fh_length), fh_length);
+ 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;
if(!pinfo->fd->flags.visited){
key.key=0;
key.fh_length=fh_length;
- key.fh=(unsigned char *)tvb_get_ptr(tvb, fh_offset, 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){
if(!nns){
key.key=pinfo->fd->num;
key.fh_length=fh_length;
- key.fh=(unsigned char *)tvb_get_ptr(tvb, fh_offset, 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,
+ 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,
+ 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,
+ 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,
+ proto_tree_add_string_format(tree, hf_nfs_full_name, tvb,
fh_offset, 0, nns->name, "Full Name: %s", nns->full_name);
}
}
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);
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);
"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,
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,
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=(unsigned char *)tvb_get_ptr(tvb, offset, fhlen);
- old_fhd=g_hash_table_lookup(nfs_fhandle_data_table,
+ 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;
- old_fhd->fh=g_malloc(fhlen);
- memcpy(old_fhd->fh, fhd.fh, 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,
+ g_hash_table_insert(nfs_fhandle_data_table,
(gpointer)old_fhd, (gpointer)old_fhd);
}
-
+
/* 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
+ 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
+ not work properly with this feature
*/
g_hash_table_insert(nfs_fhandle_frame_table,
(gpointer)pinfo->fd->num,
fhhash += val;
}
if(hidden){
- proto_tree_add_uint_hidden(tree, hf_nfs_fh_hash, tvb, offset,
+ 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,
+ proto_tree_add_uint(tree, hf_nfs_fh_hash, tvb, offset,
fhlen, fhhash);
}
}
nfs_name_snoop_fh(pinfo, tree, tvb, offset, fhlen, hidden);
}
- if(!hidden){
+ if(!hidden){
/* calculate (heuristically) fhtype */
switch (fhlen) {
case 12:
int wrong=0;
for (len2=5+len1;len2<32;len2++) {
if (tvb_get_guint8(tvb,offset+len2)) {
- wrong=1;
+ wrong=1;
break;
}
}
type_ready:
if(!hidden){
- proto_tree_add_text(tree, tvb, offset, 0,
+ proto_tree_add_text(tree, tvb, offset, 0,
"type: %s", val_to_str(fhtype, names_fhtype, "Unknown"));
-
+
switch (fhtype) {
case FHT_SVR4:
{ 10035, "NFS4ERR_RECLAIM_CONFLICT" },
{ 10036, "NFS4ERR_BADXDR" },
{ 10037, "NFS4ERR_LOCKS_HELD" },
+ { 10038, "NFS4ERR_OPENMODE" },
+ { 10039, "NFS4ERR_BADOWNER" },
{ 0, NULL }
};
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);
}
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);
&&(!civ->request)
&&((civ->proc==4)||(civ->proc==9)||(civ->proc==14))
) {
- nfs_name_snoop_add_fh(civ->xid, tvb,
+ nfs_name_snoop_add_fh(civ->xid, tvb,
offset, 32);
}
&&((civ->vers==1)||(civ->vers==2))
&&(!civ->request)
) {
- nfs_name_snoop_add_fh(civ->xid, tvb,
+ nfs_name_snoop_add_fh(civ->xid, tvb,
offset, 32);
}
}
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);
&&(civ->request)
&&((civ->proc==4)||(civ->proc==9)||(civ->proc==14))
) {
- nfs_name_snoop_add_name(civ->xid, tvb,
+ nfs_name_snoop_add_name(civ->xid, tvb,
offset+36, tvb_get_ntohl(tvb, offset+32),
offset, 32, NULL);
}
/* RFC 1094, Page 18 */
static int
-dissect_nfs2_diropres_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_diropres_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_diropres(tvb, offset, pinfo, tree);
/* RFC 1094, Page 6 */
static int
-dissect_nfs2_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_fhandle(tvb, offset, pinfo, tree, "file" );
/* RFC 1094, Page 6 */
static int
-dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 status;
/* RFC 1094, Page 7 */
static int
-dissect_nfs2_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 offset_value;
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;
/* RFC 1094, Page 7 */
static int
-dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
switch (status) {
case 0:
offset = dissect_fattr(tvb, offset, tree, "attributes");
- offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
/* do nothing */
/* RFC 1094, Page 8 */
static int
-dissect_nfs2_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 beginoffset;
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, tree, hf_nfs_data);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
return offset;
}
/* RFC 1094, Page 8 */
static int
-dissect_nfs2_createargs_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_createargs_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_diropargs(tvb, offset, pinfo, tree, "where" );
/* RFC 1094, Page 9 */
static int
-dissect_nfs2_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_diropargs(tvb, offset, pinfo, tree, "from");
/* RFC 1094, Page 9 */
static int
-dissect_nfs2_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_fhandle (tvb, offset, pinfo, tree, "from");
/* RFC 1094, Page 10 */
static int
-dissect_nfs2_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_diropargs(tvb, offset, pinfo, tree, "from" );
/* RFC 1094, Page 11 */
static int
-dissect_nfs2_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
guint32 cookie;
/* RFC 1094, Page 11 */
static int
-dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
proto_item* entry_item = NULL;
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 */
static int
-dissect_nfs2_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_readdir_entry);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
dissect_nfs2_fhandle_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 */
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);
guint32 nfsstat3;
nfsstat3 = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
proto_tree_add_uint(tree, hf_nfs_nfsstat3, tvb,
offset, 4, nfsstat3);
guint32 type;
type = tvb_get_ntohl(tvb, offset+0);
-
+
if (tree) {
proto_tree_add_uint(tree, hf, tvb, offset, 4, type);
}
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,
+dissect_nfs_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
guint fh3_len;
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);
) {
fh_length=tvb_get_ntohl(tvb, offset);
fh_offset=offset+4;
- nfs_name_snoop_add_fh(civ->xid, tvb,
+ nfs_name_snoop_add_fh(civ->xid, tvb,
fh_offset, fh_length);
}
) {
fh_length=tvb_get_ntohl(tvb, offset);
fh_offset=offset+4;
- nfs_name_snoop_add_fh(civ->xid, tvb,
+ nfs_name_snoop_add_fh(civ->xid, tvb,
fh_offset, fh_length);
}
}
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);
offset);
offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_gid,
offset);
- offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_size,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_size,
offset);
offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_used,
offset);
if (tree) {
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,
+ 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) {
/* 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);
if (tree) {
wcc_attr_item = proto_tree_add_text(tree, tvb, offset, -1,
"%s", name);
- wcc_attr_tree = proto_item_add_subtree(wcc_attr_item,
+ wcc_attr_tree = proto_item_add_subtree(wcc_attr_item,
ett_nfs_wcc_attr);
}
- offset = dissect_rpc_uint64(tvb, 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, 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);
if (tree) {
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,
+ 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) {
/* 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);
if (tree) {
wcc_data_item = proto_tree_add_text(tree, tvb, offset, -1,
"%s", name);
- wcc_data_tree = proto_item_add_subtree(wcc_data_item,
+ wcc_data_tree = proto_item_add_subtree(wcc_data_item,
ett_nfs_wcc_data);
}
/* RFC 1813, Page 25 */
static int
-dissect_post_op_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_post_op_fh3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char* name)
{
proto_item* post_op_fh3_item = NULL;
if (tree) {
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,
+ 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) {
/* 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);
if (tree) {
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,
+ set_mode3_tree = proto_item_add_subtree(set_mode3_item,
ett_nfs_set_mode3);
}
/* void */
break;
}
-
+
/* now we know, that set_mode3 is shorter */
if (set_mode3_item) {
proto_item_set_len(set_mode3_item, offset - old_offset);
if (tree) {
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,
+ set_uid3_tree = proto_item_add_subtree(set_uid3_item,
ett_nfs_set_uid3);
}
if (tree) {
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,
+ set_gid3_tree = proto_item_add_subtree(set_gid3_item,
ett_nfs_set_gid3);
}
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32(tvb, set_gid3_tree,
+ offset = dissect_rpc_uint32(tvb, set_gid3_tree,
hf_nfs_gid3, offset);
break;
default:
if (tree) {
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,
+ set_size3_tree = proto_item_add_subtree(set_size3_item,
ett_nfs_set_size3);
}
if (tree) {
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,
+ set_atime_tree = proto_item_add_subtree(set_atime_item,
ett_nfs_set_atime);
}
if (tree) {
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,
+ set_mtime_tree = proto_item_add_subtree(set_mtime_item,
ett_nfs_set_mtime);
}
/* RFC 1813, Page 27 */
static int
-dissect_diropargs3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_diropargs3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char* name)
{
proto_item* diropargs3_item = NULL;
if (tree) {
diropargs3_item = proto_tree_add_text(tree, tvb, offset, -1,
"%s", name);
- diropargs3_tree = proto_item_add_subtree(diropargs3_item,
+ diropargs3_tree = proto_item_add_subtree(diropargs3_item,
ett_nfs_diropargs3);
}
offset = dissect_nfs_fh3(tvb, offset, pinfo, diropargs3_tree, "dir");
name_offset=offset+4;
name_len=tvb_get_ntohl(tvb, offset);
- offset = dissect_filename3(tvb, offset, diropargs3_tree,
+ offset = dissect_filename3(tvb, offset, diropargs3_tree,
hf_nfs_name, NULL);
/* are we snooping fh to filenames ?*/
&&(civ->request)
&&((civ->proc==3)||(civ->proc==8)||(civ->proc==9))
) {
- nfs_name_snoop_add_name(civ->xid, tvb,
+ nfs_name_snoop_add_name(civ->xid, tvb,
name_offset, name_len,
parent_offset, parent_len, NULL);
}
/* RFC 1813, Page 27 */
static int
-dissect_nfs3_diropargs3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_diropargs3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_diropargs3(tvb, offset, pinfo, tree, "object");
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 */
static int
-dissect_nfs3_nfs_fh3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_nfs_fh3_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
/* RFC 1813, Page 32,33 */
static int
-dissect_nfs3_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
/* RFC 1813, Page 32,33 */
static int
-dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
/* void */
break;
}
-
+
return offset;
}
if (tree) {
sattrguard3_item = proto_tree_add_text(tree, tvb, offset, -1,
"%s: %s", name, check_name);
- sattrguard3_tree = proto_item_add_subtree(sattrguard3_item,
+ sattrguard3_tree = proto_item_add_subtree(sattrguard3_item,
ett_nfs_sattrguard3);
}
/* RFC 1813, Page 33..36 */
static int
-dissect_nfs3_setattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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_wcc_data(tvb, offset, tree, "obj_wcc");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 37..39 */
static int
-dissect_nfs3_lookup_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_lookup_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "what");
/* RFC 1813, Page 37..39 */
static int
-dissect_nfs3_lookup_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_lookup_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
switch (status) {
case 0:
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 40..43 */
static int
-dissect_nfs3_access_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
offset = dissect_access(tvb, offset, tree, "access");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
-
+
return offset;
}
offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"symlink_attributes");
- offset = dissect_nfspath3(tvb, offset, tree,
+ offset = dissect_nfspath3(tvb, offset, tree,
hf_nfs_readlink_data);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"symlink_attributes");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 46..48 */
static int
-dissect_nfs3_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
- offset = dissect_rpc_bool(tvb, tree, hf_nfs_read_eof,
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_read_eof,
offset);
offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
break;
}
-
+
return offset;
}
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 */
static int
-dissect_nfs3_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file");
switch (status) {
case 0:
offset = dissect_wcc_data (tvb, offset, tree, "file_wcc");
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
offset = dissect_stable_how(tvb, offset, tree,
hf_nfs_write_committed);
offset = dissect_wcc_data(tvb, offset, tree, "file_wcc");
break;
}
-
+
return offset;
}
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 */
static int
-dissect_nfs3_create_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_create_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 mode;
offset = dissect_createverf3(tvb, offset, tree);
break;
}
-
+
return offset;
}
/* RFC 1813, Page 54..58 */
static int
-dissect_nfs3_create_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_create_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
switch (status) {
case 0:
offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 58..60 */
static int
-dissect_nfs3_mkdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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, tree, "attributes");
-
+
return offset;
}
/* RFC 1813, Page 61..63 */
static int
-dissect_nfs3_symlink_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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, tree, "symlink_attributes");
offset = dissect_nfspath3 (tvb, offset, tree, hf_nfs_symlink_to);
-
+
return offset;
}
/* RFC 1813, Page 63..66 */
static int
-dissect_nfs3_mknod_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_mknod_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 type;
/* nothing to do */
break;
}
-
+
return offset;
}
offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 71..74 */
static int
-dissect_nfs3_rename_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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");
-
+
return offset;
}
offset = dissect_wcc_data(tvb, offset, tree, "todir_wcc");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 74..76 */
static int
-dissect_nfs3_link_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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");
-
+
return offset;
}
offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
break;
}
-
+
return offset;
}
/* RFC 1813, Page 76..80 */
static int
-dissect_nfs3_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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, tree, hf_nfs_cookie3, offset);
offset = dissect_cookieverf3(tvb, offset, tree);
offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
-
+
return offset;
}
proto_item_set_text(entry_item, "Entry: name %s", name);
g_free(name);
- offset = dissect_rpc_uint64(tvb, 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 */
static int
-dissect_nfs3_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
offset = dissect_cookieverf3(tvb, offset, tree);
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ 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, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
/* RFC 1813, Page 80..83 */
static int
-dissect_nfs3_readdirplus_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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);
offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3_maxcount,
offset);
-
+
return offset;
}
/* RFC 1813, Page 80..83 */
static int
-dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
proto_item* entry_item = NULL;
offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdirplus_entry_cookie,
offset);
- offset = dissect_post_op_attr(tvb, offset, entry_tree,
+ offset = dissect_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 */
static int
-dissect_nfs3_readdirplus_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_readdirplus_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
offset = dissect_cookieverf3(tvb, offset, tree);
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ 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, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_tbytes,
offset);
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_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, tree,
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_fsinfo_maxfilesize, offset);
offset = dissect_nfstime3(tvb, offset, tree, hf_nfs_dtime, hf_nfs_dtime_sec, hf_nfs_dtime_nsec);
properties = tvb_get_ntohl(tvb, offset+0);
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;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_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, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_no_trunc, offset);
- offset = dissect_rpc_bool(tvb, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_chown_restricted, offset);
- offset = dissect_rpc_bool(tvb, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_insensitive, offset);
- offset = dissect_rpc_bool(tvb, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_preserving, offset);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
/* RFC 1813, Page 92..95 */
static int
-dissect_nfs3_commit_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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_wcc_data(tvb, offset, tree, "file_wcc");
break;
}
-
+
return offset;
}
fitem = proto_tree_add_text(tree, tvb, offset, 4, "Owner");
- if (fitem)
+ if (fitem)
{
newftree = proto_item_add_subtree(fitem, ett_nfs_lock_owner4);
- if (newftree)
+ if (newftree)
{
offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4, offset);
offset = dissect_nfsdata(tvb, offset, newftree, hf_nfs_data);
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_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
+ if (newftree)
+ {
+ for (i = 0; i < comp_count; i++)
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ hf_nfs_component4, NULL);
}
}
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, tree);
-
+
return offset;
}
return offset;
}
-static int
-dissect_nfs_nfsace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
-{
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_acetype4, offset);
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_aceflag4, offset);
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_acemask4, offset);
- offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_who, NULL);
+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;
return 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
+
+
static int
-dissect_nfs_fattr4_acl(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_ace4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree)
{
- proto_tree *newftree = NULL;
- proto_item *fitem = NULL;
+ 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);
- offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_nfs_nfsace4);
+ 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);
+ }
+ }
+
+ offset += 4;
+
+ offset = dissect_nfs_acemask4(tvb, offset, ace_tree);
+
+ offset = dissect_nfs_utf8string(tvb, offset, ace_tree, hf_nfs_who, NULL);
+ }
return offset;
}
+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)
}
static int
-dissect_nfs_fs_location4(tvbuff_t *tvb, int offset,
- proto_tree *tree, char *name)
+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;
}
static int
-dissect_nfs_fs_locations4(tvbuff_t *tvb, int offset,
+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);
offset = dissect_nfs_pathname4(tvb, offset, newftree);
- nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, newftree, hf_nfs_data_follows, offset);
-
- while (nextentry)
- {
- offset = dissect_nfs_fs_location4(tvb, offset, newftree,
- "locations");
- nextentry = tvb_get_ntohl(tvb, offset);
- offset += 4;
- }
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ dissect_nfs_fs_location4);
return offset;
}
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,
+ expire_type_tree = proto_item_add_subtree(expire_type_item,
ett_nfs_fattr4_fh_expire_type);
}
if (expire_type == FH4_PERSISTENT)
{
proto_tree_add_text(expire_type_tree, tvb, offset, 4, "%s",
- decode_enumerated_bitfield(expire_type, FH4_PERSISTENT, 8,
+ decode_enumerated_bitfield(expire_type, FH4_PERSISTENT, 8,
nfs4_fattr4_fh_expire_type_names, "%s"));
}
else
{ 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 }
};
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) break;
switch(fattr)
{
case FATTR4_SUPPORTED_ATTRS:
- attr_vals_offset = dissect_nfs_attributes(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset = dissect_nfs_attributes(tvb,
+ attr_vals_offset, pinfo, attr_newftree,
FATTR4_BITMAP_ONLY);
break;
-
+
case FATTR4_TYPE:
attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_ftype4, attr_vals_offset);
break;
case FATTR4_CHANGE:
- attr_vals_offset = dissect_rpc_uint64(tvb, attr_newftree,
+ attr_vals_offset = dissect_rpc_uint64(tvb, attr_newftree,
hf_nfs_changeid4, attr_vals_offset);
break;
case FATTR4_LINK_SUPPORT:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_link_support,
+ attr_newftree, hf_nfs_fattr4_link_support,
attr_vals_offset);
break;
case FATTR4_SYMLINK_SUPPORT:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_symlink_support,
+ attr_newftree, hf_nfs_fattr4_symlink_support,
attr_vals_offset);
break;
case FATTR4_UNIQUE_HANDLES:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_unique_handles,
+ attr_newftree, hf_nfs_fattr4_unique_handles,
attr_vals_offset);
break;
case FATTR4_LEASE_TIME:
attr_vals_offset = dissect_rpc_uint32(tvb,
- attr_newftree, hf_nfs_fattr4_lease_time,
+ 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,
- 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_fattr4_acl(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,
- attr_newftree, hf_nfs_fattr4_aclsupport, offset);
+ attr_newftree, hf_nfs_fattr4_aclsupport,
+ attr_vals_offset);
break;
case FATTR4_ARCHIVE:
- attr_vals_offset = dissect_rpc_bool(tvb,
- 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_CASE_INSENSITIVE:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_case_insensitive,
+ attr_newftree, hf_nfs_fattr4_case_insensitive,
attr_vals_offset);
break;
case FATTR4_CASE_PRESERVING:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_case_preserving,
+ attr_newftree, hf_nfs_fattr4_case_preserving,
attr_vals_offset);
break;
case FATTR4_CHOWN_RESTRICTED:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_chown_restricted,
+ attr_newftree, hf_nfs_fattr4_chown_restricted,
attr_vals_offset);
break;
case FATTR4_FILES_AVAIL:
attr_vals_offset = dissect_rpc_uint64(tvb,
- attr_newftree, hf_nfs_fattr4_files_avail,
+ attr_newftree, hf_nfs_fattr4_files_avail,
attr_vals_offset);
break;
case FATTR4_FILES_TOTAL:
attr_vals_offset = dissect_rpc_uint64(tvb,
- attr_newftree, hf_nfs_fattr4_files_total,
+ 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, attr_newftree,
+ attr_vals_offset = dissect_nfs_fs_locations4(tvb, pinfo,
+ attr_vals_offset, attr_newftree,
"fattr4_fs_locations");
break;
case FATTR4_HOMOGENEOUS:
attr_vals_offset = dissect_rpc_bool(tvb,
- attr_newftree, hf_nfs_fattr4_homogeneous,
+ attr_newftree, hf_nfs_fattr4_homogeneous,
attr_vals_offset);
break;
case FATTR4_MAXFILESIZE:
attr_vals_offset = dissect_rpc_uint64(tvb,
- attr_newftree, hf_nfs_fattr4_maxfilesize,
+ attr_newftree, hf_nfs_fattr4_maxfilesize,
attr_vals_offset);
break;
break;
case FATTR4_MIMETYPE:
- attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, 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, attr_newftree, "fattr4_mode");
break;
case FATTR4_OWNER:
- attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, 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, attr_newftree,
+ attr_vals_offset = dissect_nfs_utf8string(tvb,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_owner_group, NULL);
break;
break;
case FATTR4_RAWDEV:
- attr_vals_offset = dissect_nfs_specdata4(tvb,
+ attr_vals_offset = dissect_nfs_specdata4(tvb,
attr_vals_offset, attr_newftree);
break;
case FATTR4_SPACE_AVAIL:
attr_vals_offset = dissect_rpc_uint64(tvb,
- attr_newftree, hf_nfs_fattr4_space_avail,
+ attr_newftree, hf_nfs_fattr4_space_avail,
attr_vals_offset);
break;
case FATTR4_SPACE_TOTAL:
attr_vals_offset = dissect_rpc_uint64(tvb,
- attr_newftree, hf_nfs_fattr4_space_total,
+ attr_newftree, hf_nfs_fattr4_space_total,
attr_vals_offset);
break;
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,
attr_newftree, hf_nfs_fattr4_system, attr_vals_offset);
case FATTR4_TIME_ACCESS_SET:
case FATTR4_TIME_MODIFY_SET:
- attr_vals_offset = dissect_nfs_settime4(tvb,
+ attr_vals_offset = dissect_nfs_settime4(tvb,
attr_vals_offset, attr_newftree, "settime4");
break;
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,
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
FATTR4_FULL_DISSECT);
offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_attrlist4);
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
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;
dissect_nfs_open_claim_delegate_cur4(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, tree,
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_stateid4_delegate_stateid, offset);
offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_component4, NULL);
break;
case CLAIM_PREVIOUS:
- offset = dissect_rpc_uint32(tvb, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_delegate_type, offset);
break;
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_rpc_uint64(tvb, tree, hf_nfs_verifier4, offset);
break;
-
+
default:
break;
}
static int
dissect_nfs_clientaddr4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
- offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_r_netid);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_r_addr);
return offset;
}
-
+
static int
-dissect_nfs_cb_client4(tvbuff_t *tvb, int offset,
- proto_tree *tree)
+dissect_nfs_cb_client4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
+ proto_tree *cb_location = NULL;
+ proto_item *fitem = NULL;
+
offset = dissect_rpc_uint32(tvb, tree, hf_nfs_cb_program, offset);
- offset = dissect_nfs_clientaddr4(tvb, offset, tree);
+
+ fitem = proto_tree_add_text(tree, tvb, offset, 0, "cb_location");
+
+ if (fitem)
+ {
+ cb_location = proto_item_add_subtree(fitem, ett_nfs_clientaddr4);
+
+ offset = dissect_nfs_clientaddr4(tvb, offset, cb_location);
+ }
return offset;
}
{ 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
};
+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)
{
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, newftree, hf_nfs_data_follows,
- offset);
-
- while (nextentry)
- {
- /* offset = dissect_nfs_cookie4(tvb, offset, pinfo, newftree); */
- offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookie4, offset);
- offset = dissect_nfs_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree, "attrs");
- nextentry = tvb_get_ntohl(tvb, offset);
- offset += 4;
- }
-
- offset = dissect_rpc_bool(tvb, 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;
}
newftree = proto_item_add_subtree(fitem, ett_nfs_change_info4);
if (newftree) {
- offset = dissect_rpc_bool(tvb, newftree,
+ offset = dissect_rpc_bool(tvb, newftree,
hf_nfs_change_info4_atomic, offset);
- offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_before,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_before,
offset);
- offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_after,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4_after,
offset);
}
}
}
-static int
-dissect_nfs_ace4(tvbuff_t *tvb, int offset, proto_tree *tree)
-{
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_acetype4, offset);
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_aceflag4, offset);
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_acemask4, offset);
- offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_ace4, NULL);
-
- 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 }
};
-static int
+static int
dissect_nfs_open4_rflags(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
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)
}
}
}
-
+
offset += 4;
return offset;
if (fitem) {
newftree = proto_item_add_subtree(fitem, ett_nfs_stateid4);
if (newftree) {
- offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
bytes_left = 12;
static int
dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset,
- proto_tree *tree)
+ packet_info *pinfo, proto_tree *tree)
{
offset = dissect_nfs_stateid4(tvb, offset, tree);
offset = dissect_rpc_bool(tvb, tree, hf_nfs_recall4, offset);
- offset = dissect_nfs_ace4(tvb, offset, tree);
+ offset = dissect_nfs_ace4(tvb, offset, pinfo, tree);
return offset;
}
switch(limitby)
{
case NFS_LIMIT_SIZE:
- offset = dissect_rpc_uint64(tvb, tree, hf_nfs_filesize,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_filesize,
offset);
break;
}
static int
-dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
- proto_tree *tree)
+dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
+ packet_info *pinfo, proto_tree *tree)
{
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, tree);
+ offset = dissect_nfs_ace4(tvb, offset, pinfo, tree);
return offset;
}
};
static int
-dissect_nfs_open_delegation4(tvbuff_t *tvb, int offset, proto_tree *tree)
+dissect_nfs_open_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+ 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,
+ offset = dissect_nfs_open_read_delegation4(tvb, offset, pinfo,
newftree);
break;
case OPEN_DELEGATE_WRITE:
- offset = dissect_nfs_open_write_delegation4(tvb, offset,
+ offset = dissect_nfs_open_write_delegation4(tvb, offset, pinfo,
newftree);
break;
static int
dissect_nfs_rpcsec_gss_info(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- guint data_follows;
-
- while ((data_follows = tvb_get_ntohl(tvb, offset)))
- {
- offset += 4;
- offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_sec_oid4);
- offset = dissect_rpc_uint32(tvb, tree, hf_nfs_qop4, offset);
- offset = dissect_rpc_uint32(tvb, tree,
- hf_nfs_secinfo_rpcsec_gss_info_service, offset);
- }
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_sec_oid4);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_qop4, offset);
+ offset = dissect_rpc_uint32(tvb, tree,
+ hf_nfs_secinfo_rpcsec_gss_info_service, offset);
return offset;
}
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
}
static int
-dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+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;
{
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;
guint create_type;
create_type = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_ftype4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_ftype4,
offset);
switch(create_type)
{
case NF4LNK:
- offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_linktext4, NULL);
break;
-
+
case NF4BLK:
case NF4CHR:
offset = dissect_nfs_specdata4(tvb, offset, newftree);
offset = dissect_nfs_utf8string(tvb, offset, newftree, hf_nfs_component4, NULL);
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "createattrs");
+ offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree);
}
break;
break;
case NFS4_OP_GETATTR:
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
FATTR4_BITMAP_ONLY);
break;
break;
case NFS4_OP_LINK:
- 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_LOCK:
- 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_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, newftree, hf_nfs_lock_type4,
- offset);
- offset = dissect_nfs_lock_owner4(tvb, offset, newftree);
- offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
- offset);
+ 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, newftree, hf_nfs_lock_type4,
- offset);
+ 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_offset4, offset);
offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_length4, offset);
break;
case NFS4_OP_LOOKUP:
- 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_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_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ 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);
case NFS4_OP_OPEN_CONFIRM:
offset = dissect_nfs_stateid4(tvb, offset, newftree);
- offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
break;
case NFS4_OP_OPEN_DOWNGRADE:
offset = dissect_nfs_stateid4(tvb, offset, newftree);
- offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
+ 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);
offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookieverf4,
offset);
- offset = dissect_rpc_uint32(tvb, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_dircount, offset);
offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_maxcount, offset);
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
FATTR4_BITMAP_ONLY);
break;
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_component4, NULL);
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_component4, NULL);
- offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_component4, NULL);
break;
case NFS4_OP_RENEW:
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_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_component4, NULL);
break;
case NFS4_OP_SETATTR:
offset = dissect_nfs_stateid4(tvb, offset, newftree);
- offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
- "obj_attributes");
+ 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)
+ if (fitem)
{
client_tree = proto_item_add_subtree(fitem, ett_nfs_client_id4);
- if (newftree)
- {
- offset = dissect_rpc_uint64(tvb, ftree, hf_nfs_clientid4,
- offset);
- offset = dissect_nfsdata(tvb, offset, client_tree,
- hf_nfs_client_id4_id);
- }
+ 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, newftree);
+ 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_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_nfs_stable_how4(tvb, offset, newftree, "stable");
offset = dissect_nfsdata(tvb, offset, newftree, hf_nfs_data);
break;
-
+
default:
break;
}
}
static int
-dissect_nfs4_compound_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs4_compound_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_tag4, NULL);
}
static int
-dissect_nfs_secinfo4_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_secinfo4_res(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
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,
+ fitem = proto_tree_add_uint(tree, hf_nfs_secinfo_flavor, tvb, offset, 4,
flavor);
offset += 4;
- if (fitem)
+ if (fitem)
{
switch(flavor)
{
}
static int
-dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- guint ops, ops_counter;
- guint opcode;
+ guint32 ops, ops_counter;
+ guint32 opcode;
proto_item *fitem;
proto_tree *ftree = NULL;
proto_tree *newftree = NULL;
ops = tvb_get_ntohl(tvb, offset+0);
- if (ops < 0)
- return offset; /* malformed result */
-
- 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;
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.
*/
break;
case NFS4_OP_COMMIT:
- offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
offset);
break;
case NFS4_OP_CREATE:
- offset = dissect_nfs_change_info4(tvb, offset, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
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, 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_nfs_stateid4(tvb, offset, newftree);
+ {
+ if (opcode == NFS4_OP_LOCK)
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ }
else
if (status == NFS4ERR_DENIED)
offset = dissect_nfs_lock4denied(tvb, offset, newftree);
case NFS4_OP_OPEN:
offset = dissect_nfs_stateid4(tvb, offset, newftree);
- offset = dissect_nfs_change_info4(tvb, offset, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
- offset = dissect_nfs_open4_rflags(tvb, offset, newftree,
+ offset = dissect_nfs_open4_rflags(tvb, offset, newftree,
"result_flags");
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
FATTR4_BITMAP_ONLY);
- offset = dissect_nfs_open_delegation4(tvb, offset, newftree);
+ offset = dissect_nfs_open_delegation4(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_OPEN_CONFIRM:
break;
case NFS4_OP_READLINK:
- offset = dissect_nfs_utf8string(tvb, offset, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_linktext4, NULL);
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_change_info4(tvb, offset, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_change_info4(tvb, offset, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"source_cinfo");
offset = dissect_nfs_change_info4(tvb, offset, newftree,
"target_cinfo");
break;
case NFS4_OP_SECINFO:
- offset = dissect_rpc_list(tvb, pinfo, tree, offset,
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_nfs_secinfo4_res);
break;
case NFS4_OP_SETATTR:
- offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
+ 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, newftree, hf_nfs_clientid4,
+ {
+ 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, newftree);
case NFS4_OP_WRITE:
offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
- offset = dissect_nfs_stable_how4(tvb, offset, newftree,
+ offset = dissect_nfs_stable_how4(tvb, offset, newftree,
"committed");
- offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
offset);
break;
}
static int
-dissect_nfs4_compound_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs4_compound_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree* tree)
{
guint32 status;
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 }},
"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, "Tag", HFILL }},
{ &hf_nfs_clientid4, {
- "clientid", "nfs.clientid", FT_UINT64, BASE_DEC,
+ "clientid", "nfs.clientid", FT_UINT64, BASE_HEX,
NULL, 0, "Client ID", HFILL }},
{ &hf_nfs_ace4, {
NULL, 0, "attr_vals", 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_UINT64, BASE_DEC,
NULL, 0, "nfs.stateid4", 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_UINT64, BASE_DEC,
{ &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.delegate_stateid", HFILL }},
{ &hf_nfs_verifier4, {
- "verifier", "nfs.verifier4", FT_UINT64, BASE_DEC,
+ "verifier", "nfs.verifier4", FT_UINT64, BASE_HEX,
NULL, 0, "nfs.verifier4", HFILL }},
{ &hf_nfs_cookie4, {
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, {
BASE_DEC, VALS(rpc_authgss_svc), 0, "service", HFILL }},
{ &hf_nfs_attrdircreate, {
- "attribute dir create", "nfs.openattr4.createdir", FT_BOOLEAN,
+ "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,
+ "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,
+ "reclaim?", "nfs.lock.reclaim", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.lock.reclaim", HFILL }},
{ &hf_nfs_sec_oid4, {
BASE_DEC, NULL, 0, "oid", HFILL }},
{ &hf_nfs_qop4, {
- "qop", "nfs.secinfo.flavor_info.rpcsec_gss_info.qop", FT_UINT32,
+ "qop", "nfs.secinfo.flavor_info.rpcsec_gss_info.qop", FT_UINT32,
BASE_DEC, NULL, 0, "qop", HFILL }},
{ &hf_nfs_client_id4_id, {
- "Data", "nfs.nfs_client_id4.id", FT_BYTES, BASE_DEC,
- NULL, 0, "Data", HFILL }},
+ "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 }},
};
static gint *ett[] = {
&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;
/* 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);
}