nexmon – Rev 1
?pathlinks?
/* packet-glusterfs.c
* Routines for GlusterFS dissection
* Copyright 2012, Niels de Vos <ndevos@redhat.com>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*
* References to source files point in general to the glusterfs sources.
* There is currently no RFC or other document where the protocol is
* completely described. The glusterfs sources can be found at:
* - http://git.gluster.com/?p=glusterfs.git
* - https://github.com/gluster/glusterfs
*
* The coding-style is roughly the same as the one use in the Linux kernel,
* see http://www.kernel.org/doc/Documentation/CodingStyle.
*/
#include "config.h"
#include <epan/packet.h>
#include <epan/to_str.h>
#include "packet-rpc.h"
#include "packet-gluster.h"
void proto_register_glusterfs(void);
void proto_reg_handoff_glusterfs(void);
/* Initialize the protocol and registered fields */
static gint proto_glusterfs = -1;
/* programs and procedures */
static gint hf_glusterfs_proc = -1;
/* fields used by multiple programs/procedures */
static gint hf_gluster_op_ret = -1;
static gint hf_gluster_op_errno = -1;
/* GlusterFS specific */
static gint hf_glusterfs_gfid = -1;
static gint hf_glusterfs_pargfid = -1;
static gint hf_glusterfs_oldgfid = -1;
static gint hf_glusterfs_newgfid = -1;
static gint hf_glusterfs_path = -1;
static gint hf_glusterfs_bname = -1;
static gint hf_glusterfs_dict = -1;
static gint hf_glusterfs_fd = -1;
static gint hf_glusterfs_offset = -1;
static gint hf_glusterfs_size = -1;
static gint hf_glusterfs_size64 = -1;
static gint hf_glusterfs_volume = -1;
static gint hf_glusterfs_cmd = -1;
static gint hf_glusterfs_type = -1;
static gint hf_glusterfs_entries = -1;
static gint hf_glusterfs_xflags = -1;
static gint hf_glusterfs_linkname = -1;
static gint hf_glusterfs_umask = -1;
static gint hf_glusterfs_mask = -1;
static gint hf_glusterfs_name = -1;
static gint hf_glusterfs_namelen = -1;
static gint hf_glusterfs_whence = -1;
/* flags passed on to OPEN, CREATE etc.*/
static gint hf_glusterfs_flags = -1;
static gint hf_glusterfs_flags_rdonly = -1;
static gint hf_glusterfs_flags_wronly = -1;
static gint hf_glusterfs_flags_rdwr = -1;
static gint hf_glusterfs_flags_accmode = -1;
static gint hf_glusterfs_flags_append = -1;
static gint hf_glusterfs_flags_async = -1;
static gint hf_glusterfs_flags_cloexec = -1;
static gint hf_glusterfs_flags_creat = -1;
static gint hf_glusterfs_flags_direct = -1;
static gint hf_glusterfs_flags_directory = -1;
static gint hf_glusterfs_flags_excl = -1;
static gint hf_glusterfs_flags_largefile = -1;
static gint hf_glusterfs_flags_noatime = -1;
static gint hf_glusterfs_flags_noctty = -1;
static gint hf_glusterfs_flags_nofollow = -1;
static gint hf_glusterfs_flags_nonblock = -1;
static gint hf_glusterfs_flags_ndelay = -1;
static gint hf_glusterfs_flags_sync = -1;
static gint hf_glusterfs_flags_trunc = -1;
static gint hf_glusterfs_flags_reserved = -1;
/* access modes */
static gint hf_glusterfs_mode = -1;
static gint hf_glusterfs_mode_suid = -1;
static gint hf_glusterfs_mode_sgid = -1;
static gint hf_glusterfs_mode_svtx = -1;
static gint hf_glusterfs_mode_rusr = -1;
static gint hf_glusterfs_mode_wusr = -1;
static gint hf_glusterfs_mode_xusr = -1;
static gint hf_glusterfs_mode_rgrp = -1;
static gint hf_glusterfs_mode_wgrp = -1;
static gint hf_glusterfs_mode_xgrp = -1;
static gint hf_glusterfs_mode_roth = -1;
static gint hf_glusterfs_mode_woth = -1;
static gint hf_glusterfs_mode_xoth = -1;
static gint hf_glusterfs_mode_reserved = -1;
/* dir-entry */
static gint hf_glusterfs_entry_ino = -1;
static gint hf_glusterfs_entry_off = -1;
static gint hf_glusterfs_entry_len = -1;
static gint hf_glusterfs_entry_type = -1;
static gint hf_glusterfs_entry_path = -1;
/* gf_iatt */
static gint hf_glusterfs_iatt = -1;
static gint hf_glusterfs_preparent_iatt = -1;
static gint hf_glusterfs_postparent_iatt = -1;
static gint hf_glusterfs_preop_iatt = -1;
static gint hf_glusterfs_postop_iatt = -1;
static gint hf_glusterfs_ia_ino = -1;
static gint hf_glusterfs_ia_dev = -1;
static gint hf_glusterfs_ia_mode = -1;
static gint hf_glusterfs_ia_nlink = -1;
static gint hf_glusterfs_ia_uid = -1;
static gint hf_glusterfs_ia_gid = -1;
static gint hf_glusterfs_ia_rdev = -1;
static gint hf_glusterfs_ia_size = -1;
static gint hf_glusterfs_ia_blksize = -1;
static gint hf_glusterfs_ia_blocks = -1;
static gint hf_glusterfs_ia_atime = -1;
static gint hf_glusterfs_ia_mtime = -1;
static gint hf_glusterfs_ia_ctime = -1;
/* gf_flock */
static gint hf_glusterfs_flock_type = -1;
static gint hf_glusterfs_flock_whence = -1;
static gint hf_glusterfs_flock_start = -1;
static gint hf_glusterfs_flock_len = -1;
static gint hf_glusterfs_flock_pid = -1;
static gint hf_glusterfs_flock_owner = -1;
/* statfs */
static gint hf_glusterfs_bsize = -1;
static gint hf_glusterfs_frsize = -1;
static gint hf_glusterfs_blocks = -1;
static gint hf_glusterfs_bfree = -1;
static gint hf_glusterfs_bavail = -1;
static gint hf_glusterfs_files = -1;
static gint hf_glusterfs_ffree = -1;
static gint hf_glusterfs_favail = -1;
static gint hf_glusterfs_id = -1;
static gint hf_glusterfs_mnt_flags = -1;
static gint hf_glusterfs_mnt_flag_rdonly = -1;
static gint hf_glusterfs_mnt_flag_nosuid = -1;
static gint hf_glusterfs_mnt_flag_nodev = -1;
static gint hf_glusterfs_mnt_flag_noexec = -1;
static gint hf_glusterfs_mnt_flag_synchronous = -1;
static gint hf_glusterfs_mnt_flag_mandlock = -1;
static gint hf_glusterfs_mnt_flag_write = -1;
static gint hf_glusterfs_mnt_flag_append = -1;
static gint hf_glusterfs_mnt_flag_immutable = -1;
static gint hf_glusterfs_mnt_flag_noatime = -1;
static gint hf_glusterfs_mnt_flag_nodiratime = -1;
static gint hf_glusterfs_mnt_flag_relatime = -1;
static gint hf_glusterfs_namemax = -1;
static gint hf_glusterfs_setattr_valid = -1;
/* flags for setattr.valid */
static gint hf_glusterfs_setattr_set_mode = -1;
static gint hf_glusterfs_setattr_set_uid = -1;
static gint hf_glusterfs_setattr_set_gid = -1;
static gint hf_glusterfs_setattr_set_size = -1;
static gint hf_glusterfs_setattr_set_atime = -1;
static gint hf_glusterfs_setattr_set_mtime = -1;
static gint hf_glusterfs_setattr_set_reserved = -1;
/* Rename */
static gint hf_glusterfs_oldbname = -1;
static gint hf_glusterfs_newbname = -1;
/* for FSYNC/FSYNCDIR */
static gint hf_glusterfs_fsync_flags = -1;
static gint hf_glusterfs_fsync_flag_datasync = -1;
static gint hf_glusterfs_fsync_flag_unknown = -1;
/* for entrylk */
static gint hf_glusterfs_entrylk_namelen = -1;
static gint hf_gluster_dict_size = -1;
static gint hf_gluster_num_dict_items = -1;
static gint hf_gluster_rpc_roundup_bytes = -1;
static gint hf_gluster_trusted_afr_key = -1;
static gint hf_gluster_dict_value = -1;
/* Initialize the subtree pointers */
static gint ett_glusterfs = -1;
static gint ett_glusterfs_flags = -1;
static gint ett_glusterfs_mnt_flags = -1;
static gint ett_glusterfs_mode = -1;
static gint ett_glusterfs_setattr_valid = -1;
static gint ett_glusterfs_parent_iatt = -1;
static gint ett_glusterfs_iatt = -1;
static gint ett_glusterfs_entry = -1;
static gint ett_glusterfs_flock = -1;
static gint ett_glusterfs_fsync_flags = -1;
static gint ett_gluster_dict = -1;
static gint ett_gluster_dict_items = -1;
static int
glusterfs_rpc_dissect_gfid(proto_tree *tree, tvbuff_t *tvb, int hfindex, int offset)
{
if (tree)
proto_tree_add_item(tree, hfindex, tvb, offset, 16, ENC_NA);
offset += 16;
return offset;
}
static int
glusterfs_rpc_dissect_mode(proto_tree *tree, tvbuff_t *tvb, int hfindex,
int offset)
{
static const int *mode_bits[] = {
&hf_glusterfs_mode_suid,
&hf_glusterfs_mode_sgid,
&hf_glusterfs_mode_svtx,
&hf_glusterfs_mode_rusr,
&hf_glusterfs_mode_wusr,
&hf_glusterfs_mode_xusr,
&hf_glusterfs_mode_rgrp,
&hf_glusterfs_mode_wgrp,
&hf_glusterfs_mode_xgrp,
&hf_glusterfs_mode_roth,
&hf_glusterfs_mode_woth,
&hf_glusterfs_mode_xoth,
&hf_glusterfs_mode_reserved,
NULL
};
if (tree)
proto_tree_add_bitmask(tree, tvb, offset, hfindex,
ett_glusterfs_mode, mode_bits, ENC_BIG_ENDIAN);
offset += 4;
return offset;
}
/*
* from rpc/xdr/src/glusterfs3-xdr.c:xdr_gf_iatt()
*/
int
glusterfs_rpc_dissect_gf_iatt(proto_tree *tree, tvbuff_t *tvb, int hfindex,
int offset)
{
proto_item *iatt_item;
proto_tree *iatt_tree;
nstime_t timestamp;
int start_offset = offset;
iatt_item = proto_tree_add_item(tree, hfindex, tvb, offset, -1,
ENC_NA);
iatt_tree = proto_item_add_subtree(iatt_item, ett_glusterfs_iatt);
offset = glusterfs_rpc_dissect_gfid(iatt_tree, tvb, hf_glusterfs_gfid,
offset);
offset = dissect_rpc_uint64(tvb, iatt_tree, hf_glusterfs_ia_ino,
offset);
offset = dissect_rpc_uint64(tvb, iatt_tree, hf_glusterfs_ia_dev,
offset);
offset = glusterfs_rpc_dissect_mode(iatt_tree, tvb,
hf_glusterfs_ia_mode, offset);
offset = dissect_rpc_uint32(tvb, iatt_tree, hf_glusterfs_ia_nlink,
offset);
offset = dissect_rpc_uint32(tvb, iatt_tree, hf_glusterfs_ia_uid,
offset);
offset = dissect_rpc_uint32(tvb, iatt_tree, hf_glusterfs_ia_gid,
offset);
offset = dissect_rpc_uint64(tvb, iatt_tree, hf_glusterfs_ia_rdev,
offset);
offset = dissect_rpc_uint64(tvb, iatt_tree, hf_glusterfs_ia_size,
offset);
offset = dissect_rpc_uint32(tvb, iatt_tree, hf_glusterfs_ia_blksize,
offset);
offset = dissect_rpc_uint64(tvb, iatt_tree, hf_glusterfs_ia_blocks,
offset);
timestamp.secs = tvb_get_ntohl(tvb, offset);
timestamp.nsecs = tvb_get_ntohl(tvb, offset + 4);
if (tree)
proto_tree_add_time(iatt_tree, hf_glusterfs_ia_atime, tvb,
offset, 8, ×tamp);
offset += 8;
timestamp.secs = tvb_get_ntohl(tvb, offset);
timestamp.nsecs = tvb_get_ntohl(tvb, offset + 4);
if (tree)
proto_tree_add_time(iatt_tree, hf_glusterfs_ia_mtime, tvb,
offset, 8, ×tamp);
offset += 8;
timestamp.secs = tvb_get_ntohl(tvb, offset);
timestamp.nsecs = tvb_get_ntohl(tvb, offset + 4);
if (tree)
proto_tree_add_time(iatt_tree, hf_glusterfs_ia_ctime, tvb,
offset, 8, ×tamp);
offset += 8;
proto_item_set_len (iatt_item, offset - start_offset);
return offset;
}
static int
glusterfs_rpc_dissect_gf_flock(proto_tree *tree, tvbuff_t *tvb, int offset)
{
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_flock_type, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_flock_whence, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_flock_start, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_flock_len, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_flock_pid, offset);
if (tree)
proto_tree_add_item(tree, hf_glusterfs_flock_owner, tvb,
offset, 8, ENC_NA);
offset += 8;
return offset;
}
static int
glusterfs_rpc_dissect_gf_2_flock(proto_tree *tree, tvbuff_t *tvb, int offset)
{
proto_item *flock_item;
proto_tree *flock_tree;
int len;
int start_offset = offset;
flock_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_glusterfs_flock, &flock_item, "Flock");
offset = dissect_rpc_uint32(tvb, flock_tree, hf_glusterfs_flock_type,
offset);
offset = dissect_rpc_uint32(tvb, flock_tree, hf_glusterfs_flock_whence,
offset);
offset = dissect_rpc_uint64(tvb, flock_tree, hf_glusterfs_flock_start,
offset);
offset = dissect_rpc_uint64(tvb, flock_tree, hf_glusterfs_flock_len,
offset);
offset = dissect_rpc_uint32(tvb, flock_tree, hf_glusterfs_flock_pid,
offset);
len = tvb_get_ntohl(tvb, offset);
offset += 4;
if (tree)
proto_tree_add_item(flock_tree, hf_glusterfs_flock_owner, tvb,
offset, len, ENC_NA);
offset += len;
proto_item_set_len (flock_item, offset - start_offset);
return offset;
}
static const true_false_string glusterfs_notset_set = {
"Not set",
"Set"
};
static const value_string glusterfs_accmode_vals[] = {
{ 0, "Not set"},
{ 1, "Not set"},
{ 2, "Not set"},
{ 3, "Set"},
{ 0, NULL}
};
static int
glusterfs_rpc_dissect_flags(proto_tree *tree, tvbuff_t *tvb, int offset)
{
gboolean rdonly;
guint32 accmode;
proto_item *flag_tree;
header_field_info *rdonly_hf, *accmode_hf;
static const int *flag_bits[] = {
&hf_glusterfs_flags_wronly,
&hf_glusterfs_flags_rdwr,
&hf_glusterfs_flags_creat,
&hf_glusterfs_flags_excl,
&hf_glusterfs_flags_noctty,
&hf_glusterfs_flags_trunc,
&hf_glusterfs_flags_append,
&hf_glusterfs_flags_nonblock,
&hf_glusterfs_flags_ndelay,
&hf_glusterfs_flags_sync,
&hf_glusterfs_flags_async,
&hf_glusterfs_flags_direct,
&hf_glusterfs_flags_largefile,
&hf_glusterfs_flags_directory,
&hf_glusterfs_flags_nofollow,
&hf_glusterfs_flags_noatime,
&hf_glusterfs_flags_cloexec,
&hf_glusterfs_flags_reserved,
NULL
};
if (tree) {
flag_tree = proto_tree_add_bitmask(tree, tvb, offset, hf_glusterfs_flags, ett_glusterfs_flags, flag_bits, ENC_BIG_ENDIAN);
/* rdonly is TRUE only when no flags are set */
rdonly = (tvb_get_ntohl(tvb, offset) == 0);
proto_tree_add_item(flag_tree, hf_glusterfs_flags_rdonly, tvb, offset, 4, ENC_BIG_ENDIAN);
if (rdonly) {
rdonly_hf = proto_registrar_get_nth(hf_glusterfs_flags_rdonly);
proto_item_append_text(flag_tree, ", %s", rdonly_hf->name);
}
/* hf_glusterfs_flags_accmode is TRUE if bits 0 and 1 are set */
accmode_hf = proto_registrar_get_nth(hf_glusterfs_flags_accmode);
accmode = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint_format_value(flag_tree, hf_glusterfs_flags_accmode, tvb, offset, 4, accmode,
"%s", val_to_str_const((accmode & (guint32)(accmode_hf->bitmask)), glusterfs_accmode_vals, "Unknown"));
if ((accmode & accmode_hf->bitmask) == accmode_hf->bitmask)
proto_item_append_text(flag_tree, ", %s", proto_registrar_get_nth(hf_glusterfs_flags_accmode)->name);
}
offset += 4;
return offset;
}
static int
glusterfs_rpc_dissect_statfs(proto_tree *tree, tvbuff_t *tvb, int offset)
{
static const int *flag_bits[] = {
&hf_glusterfs_mnt_flag_rdonly,
&hf_glusterfs_mnt_flag_nosuid,
&hf_glusterfs_mnt_flag_nodev,
&hf_glusterfs_mnt_flag_noexec,
&hf_glusterfs_mnt_flag_synchronous,
&hf_glusterfs_mnt_flag_mandlock,
&hf_glusterfs_mnt_flag_write,
&hf_glusterfs_mnt_flag_append,
&hf_glusterfs_mnt_flag_immutable,
&hf_glusterfs_mnt_flag_noatime,
&hf_glusterfs_mnt_flag_nodiratime,
&hf_glusterfs_mnt_flag_relatime,
NULL
};
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_bsize, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_frsize, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_blocks, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_bfree, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_bavail, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_files, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_ffree, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_favail, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_id, offset);
if (tree)
proto_tree_add_bitmask(tree, tvb, offset,
hf_glusterfs_mnt_flags, ett_glusterfs_mnt_flags,
flag_bits, ENC_BIG_ENDIAN);
offset += 8;
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_namemax, offset);
return offset;
}
/* function for dissecting and adding a gluster dict_t to the tree */
int
gluster_rpc_dissect_dict(proto_tree *tree, tvbuff_t *tvb, int hfindex, int offset)
{
gchar *key, *value;
const gchar *name;
gint roundup, value_len, key_len;
guint32 i, items, len;
int start_offset, start_offset2;
proto_item *subtree_item, *ti;
proto_tree *subtree;
proto_item *dict_item = NULL;
/* create a subtree for all the items in the dict */
if (hfindex >= 0) {
header_field_info *hfinfo = proto_registrar_get_nth(hfindex);
name = hfinfo->name;
} else
name = "<NAMELESS DICT STRUCTURE>";
start_offset = offset;
subtree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_gluster_dict, &subtree_item, name);
len = tvb_get_ntohl(tvb, offset);
roundup = rpc_roundup(len) - len;
ti = proto_tree_add_item_ret_uint(subtree, hf_gluster_dict_size, tvb, offset, 4, ENC_BIG_ENDIAN, &len);
proto_item_append_text(ti, " (%d bytes inc. RPC-roundup)", rpc_roundup(len));
PROTO_ITEM_SET_GENERATED(ti);
offset += 4;
if (len == 0)
items = 0;
else
items = tvb_get_ntohl(tvb, offset);
proto_item_append_text(subtree_item, ", contains %d item%s", items, items == 1 ? "" : "s");
if (len == 0)
return offset;
proto_tree_add_uint(subtree, hf_gluster_num_dict_items, tvb, offset, 4, items);
offset += 4;
for (i = 0; i < items; i++) {
/* key_len is the length of the key without the terminating '\0' */
/* key_len = tvb_get_ntohl(tvb, offset) + 1; // will be read later */
offset += 4;
value_len = tvb_get_ntohl(tvb, offset);
offset += 4;
/* read the key, '\0' terminated */
key = tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, &key_len, ENC_ASCII);
start_offset2 = offset;
offset += key_len;
/* read the value, possibly '\0' terminated */
if (tree) {
/* keys named "gfid-req" contain a GFID in hex */
if (value_len == 16 && (
!strncmp("gfid-req", key, 8) ||
!strncmp("transaction_id", key, 14) ||
!strncmp("originator_uuid", key, 15))) {
char *gfid_s;
e_guid_t gfid;
tvb_get_ntohguid(tvb, offset, &gfid);
gfid_s = guid_to_str(wmem_packet_scope(), &gfid);
dict_item = proto_tree_add_guid_format(subtree, hf_glusterfs_gfid,
tvb, offset, 16, &gfid,
"%s: %s", key, gfid_s);
/* this is a changelog in binary format */
} else if (value_len == 12 && !strncmp("trusted.afr.", key, 12)) {
dict_item = proto_tree_add_bytes_format(subtree, hf_gluster_trusted_afr_key, tvb, offset, 12,
NULL, "%s: 0x%.8x%.8x%.8x", key,
tvb_get_letohl(tvb, offset + 0),
tvb_get_letohl(tvb, offset + 4),
tvb_get_letohl(tvb, offset + 8));
} else {
value = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, value_len, ENC_ASCII);
dict_item = proto_tree_add_string_format(subtree, hf_gluster_dict_value, tvb, offset, value_len, value, "%s: %s",
key, value);
}
}
offset += value_len;
if (tree)
proto_item_set_len (dict_item, offset - start_offset2);
}
if (roundup) {
ti = proto_tree_add_item(subtree, hf_gluster_rpc_roundup_bytes, tvb, offset, -1, ENC_NA);
PROTO_ITEM_SET_GENERATED(ti);
offset += roundup;
}
proto_item_set_len (subtree_item, offset - start_offset);
return offset;
}
int
gluster_dissect_common_reply(tvbuff_t *tvb, int offset,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
proto_item *errno_item;
guint op_errno;
offset = dissect_rpc_uint32(tvb, tree, hf_gluster_op_ret, offset);
if (tree) {
op_errno = tvb_get_ntohl(tvb, offset);
errno_item = proto_tree_add_int(tree, hf_gluster_op_errno, tvb,
offset, 4, op_errno);
proto_item_append_text(errno_item, " (%s)",
g_strerror(op_errno));
}
offset += 4;
return offset;
}
static int
gluster_local_dissect_common_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
return gluster_dissect_common_reply(tvb, 0, pinfo, tree, data);
}
static int
_glusterfs_gfs3_common_readdir_reply(tvbuff_t *tvb, proto_tree *tree, int offset)
{
proto_item *errno_item;
guint op_errno;
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_entries, offset);
if (tree) {
op_errno = tvb_get_ntohl(tvb, offset);
errno_item = proto_tree_add_int(tree, hf_gluster_op_errno, tvb,
offset, 4, op_errno);
if (op_errno == 0)
proto_item_append_text(errno_item,
" (More replies follow)");
else if (op_errno == 2 /* ENOENT */)
proto_item_append_text(errno_item,
" (Last reply)");
}
offset += 4;
return offset;
}
static int
glusterfs_gfs3_op_unlink_reply(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
return offset;
}
static int
glusterfs_gfs3_op_unlink_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
return offset;
}
static int
glusterfs_gfs3_op_statfs_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_statfs(tree, tvb, offset);
return offset;
}
static int
glusterfs_gfs3_op_statfs_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
return offset;
}
static int
glusterfs_gfs3_op_flush_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
return offset;
}
static int
glusterfs_gfs3_op_setxattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
return offset;
}
static int
glusterfs_gfs3_op_opendir_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
return offset;
}
static int
glusterfs_gfs3_op_opendir_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
return offset;
}
/* rpc/xdr/src/glusterfs3-xdr.c:xdr_gfs3_create_rsp */
static int
glusterfs_gfs3_op_create_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
return offset;
}
/* rpc/xdr/src/glusterfs3-xdr.c:xdr_gfs3_create_req */
static int
glusterfs_gfs3_op_create_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_mode, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_op_lookup_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_op_lookup_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_op_inodelk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
proto_item *flock_item;
proto_tree *flock_tree;
int start_offset;
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
start_offset = offset;
flock_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_glusterfs_flock, &flock_item, "Flock");
offset = glusterfs_rpc_dissect_gf_flock(flock_tree, tvb, offset);
proto_item_set_len (flock_item, offset - start_offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_volume, offset, NULL);
return offset;
}
static int
_glusterfs_gfs_op_readdir_entry(tvbuff_t *tvb, int offset, proto_tree *tree,
gboolean iatt, gboolean dict)
{
proto_item *entry_item;
proto_tree *entry_tree;
const gchar* path = NULL;
int start_offset = offset;
entry_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_glusterfs_entry, &entry_item, "Entry");
offset = dissect_rpc_uint64(tvb, entry_tree, hf_glusterfs_entry_ino, offset);
offset = dissect_rpc_uint64(tvb, entry_tree, hf_glusterfs_entry_off, offset);
offset = dissect_rpc_uint32(tvb, entry_tree, hf_glusterfs_entry_len, offset);
offset = dissect_rpc_uint32(tvb, entry_tree, hf_glusterfs_entry_type, offset);
offset = dissect_rpc_string(tvb, entry_tree, hf_glusterfs_entry_path, offset, &path);
proto_item_append_text(entry_item, " Path: %s", path);
if (iatt)
offset = glusterfs_rpc_dissect_gf_iatt(entry_tree, tvb,
hf_glusterfs_iatt, offset);
if (dict)
offset = gluster_rpc_dissect_dict(entry_tree, tvb, hf_glusterfs_dict, offset);
proto_item_set_len (entry_item, offset - start_offset);
return offset;
}
static int
glusterfs_gfs3_op_readdirp_entry(tvbuff_t *tvb, int offset,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
return _glusterfs_gfs_op_readdir_entry(tvb, offset, tree, TRUE, FALSE);
}
static int
glusterfs_gfs3_3_op_readdir_entry(tvbuff_t *tvb, int offset,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
return _glusterfs_gfs_op_readdir_entry(tvb, offset, tree, FALSE, FALSE);
}
static int
glusterfs_gfs3_3_op_readdirp_entry(tvbuff_t *tvb, int offset,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
return _glusterfs_gfs_op_readdir_entry(tvb, offset, tree, TRUE, TRUE);
}
/* details in xlators/storage/posix/src/posix.c:posix_fill_readdir() */
static int
glusterfs_gfs3_op_readdirp_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = _glusterfs_gfs3_common_readdir_reply(tvb, tree, offset);
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
glusterfs_gfs3_op_readdirp_entry, NULL);
return offset;
}
static int
glusterfs_gfs3_op_readdirp_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
return offset;
}
static int
glusterfs_gfs3_op_setattr_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preop_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postop_iatt, offset);
return offset;
}
static int
glusterfs_rpc_dissect_setattr(proto_tree *tree, tvbuff_t *tvb, int offset)
{
static const int *flag_bits[] = {
&hf_glusterfs_setattr_set_mode,
&hf_glusterfs_setattr_set_uid,
&hf_glusterfs_setattr_set_gid,
&hf_glusterfs_setattr_set_size,
&hf_glusterfs_setattr_set_atime,
&hf_glusterfs_setattr_set_mtime,
&hf_glusterfs_setattr_set_reserved,
NULL
};
if (tree)
proto_tree_add_bitmask(tree, tvb, offset,
hf_glusterfs_setattr_valid,
ett_glusterfs_setattr_valid, flag_bits, ENC_NA);
offset += 4;
return offset;
}
static int
glusterfs_gfs3_op_setattr_call(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid,
offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = glusterfs_rpc_dissect_setattr(tree, tvb, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset, NULL);
return offset;
}
/*GlusterFS 3_3 fops */
static int
glusterfs_gfs3_3_op_stat_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_stat_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict,
offset);
return offset;
}
/* glusterfs_gfs3_3_op_mknod_reply() is also used as a ..mkdir_reply() */
static int
glusterfs_gfs3_3_op_mknod_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict,
offset);
return offset;
}
static int
glusterfs_gfs3_3_op_mknod_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_mode, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_umask, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_mkdir_call(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data _U_)
{
int offset = 0;
const char *name = NULL;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_mode, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_umask, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, &name);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
col_append_fstr(pinfo->cinfo, COL_INFO, ", Filename: %s", name);
return offset;
}
static int
glusterfs_gfs3_3_op_readlink_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_path, offset,
NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict,
offset);
return offset;
}
static int
glusterfs_gfs3_3_op_readlink_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
/* glusterfs_gfs3_3_op_unlink_reply() is also used for ...rmdir_reply() */
static int
glusterfs_gfs3_3_op_unlink_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_unlink_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
guint xflags;
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
xflags = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint_format(tree, hf_glusterfs_xflags, tvb, offset, 4, xflags, "Flags: 0%02o", xflags);
offset += 4;
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_rmdir_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
guint xflags;
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
xflags = tvb_get_ntohl(tvb, offset);
proto_tree_add_uint_format(tree, hf_glusterfs_xflags, tvb, offset, 4, xflags, "Flags: 0%02o", xflags);
offset += 4;
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_symlink_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, NULL);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_umask, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_linkname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_rename_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_oldgfid, offset);
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_newgfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_oldbname, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_newbname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_rename_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
proto_tree *old_tree, *new_tree;
proto_item *old_item, *new_item;
int start_offset;
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
start_offset = offset;
old_tree = proto_tree_add_subtree(tree, tvb, offset, -1,
ett_glusterfs_parent_iatt, &old_item, "Old parent");
offset = glusterfs_rpc_dissect_gf_iatt(old_tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(old_tree, tvb,
hf_glusterfs_postparent_iatt, offset);
proto_item_set_len (old_item, offset - start_offset);
start_offset = offset;
new_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_glusterfs_parent_iatt, &new_item, "New parent");
offset = glusterfs_rpc_dissect_gf_iatt(new_tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(new_tree, tvb,
hf_glusterfs_postparent_iatt, offset);
proto_item_set_len (new_item, offset - start_offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_link_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_oldgfid, offset);
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_newgfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_newbname, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_truncate_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_open_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_open_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_read_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict,
offset);
return offset;
}
static int
glusterfs_gfs3_3_op_read_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_write_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_statfs_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_statfs(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_statfs_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_flush_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_setxattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_getxattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_namelen, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_getxattr_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_removexattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fsync_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
static const int *flag_bits[] = {
&hf_glusterfs_fsync_flag_datasync,
&hf_glusterfs_fsync_flag_unknown,
NULL
};
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
proto_tree_add_bitmask(tree, tvb, offset,
hf_glusterfs_fsync_flags,
ett_glusterfs_fsync_flags, flag_bits, ENC_NA);
offset += 4;
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_opendir_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_opendir_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_create_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preparent_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postparent_iatt, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_create_call(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data _U_)
{
const char *name = NULL;
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_mode, offset);
offset = glusterfs_rpc_dissect_mode(tree, tvb, hf_glusterfs_umask, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, &name);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
col_append_fstr(pinfo->cinfo, COL_INFO, ", Filename: %s", name);
return offset;
}
static int
glusterfs_gfs3_3_op_ftruncate_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fstat_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fstat_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict,
offset);
return offset;
}
static int
glusterfs_gfs3_3_op_lk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
offset = glusterfs_rpc_dissect_gf_2_flock(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_lk_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_2_flock(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_access_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_mask, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_lookup_call(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data _U_)
{
const char *name = NULL;
int length;
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_pargfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
length = tvb_get_letohl(tvb, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_bname, offset, &name);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
if(length == 0)
col_append_fstr(pinfo->cinfo, COL_INFO, ", Filename: (nameless, by GFID)");
else
col_append_fstr(pinfo->cinfo, COL_INFO, ", Filename: %s", name);
return offset;
}
static int
glusterfs_gfs3_3_op_readdir_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = _glusterfs_gfs3_common_readdir_reply(tvb, tree, offset);
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
glusterfs_gfs3_3_op_readdir_entry, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_readdir_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_inodelk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
offset = glusterfs_rpc_dissect_gf_2_flock(tree, tvb, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_volume, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_finodelk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
offset = glusterfs_rpc_dissect_gf_2_flock(tree, tvb, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_volume, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_entrylk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_entrylk_namelen, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_volume, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fentrylk_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_cmd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_type, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_entrylk_namelen, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_volume, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_xattrop_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_xattrop_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fxattrop_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fgetxattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_namelen, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
gluter_gfs3_3_op_fsetxattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_setattr_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_preop_iatt, offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb,
hf_glusterfs_postop_iatt, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_setattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid,
offset);
offset = glusterfs_rpc_dissect_gf_iatt(tree, tvb, hf_glusterfs_iatt,
offset);
offset = glusterfs_rpc_dissect_setattr(tree, tvb, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_readdirp_reply(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = _glusterfs_gfs3_common_readdir_reply(tvb, tree, offset);
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
glusterfs_gfs3_3_op_readdirp_entry, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
/* READDIRP and DISCARD both use this */
static int
glusterfs_gfs3_3_op_readdirp_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_release_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_releasedir_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fremovexattr_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_string(tvb, tree, hf_glusterfs_name, offset, NULL);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_fallocate_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = glusterfs_rpc_dissect_flags(tree, tvb, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_size, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_zerofill_call(tvbuff_t *tvb,
packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_size64, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_seek_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
static int
glusterfs_gfs3_3_op_seek_call(tvbuff_t *tvb, packet_info *pinfo _U_,
proto_tree *tree, void* data _U_)
{
int offset = 0;
offset = glusterfs_rpc_dissect_gfid(tree, tvb, hf_glusterfs_gfid, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_fd, offset);
offset = dissect_rpc_uint64(tvb, tree, hf_glusterfs_offset, offset);
offset = dissect_rpc_uint32(tvb, tree, hf_glusterfs_whence, offset);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
/* This function is for common replay. RELEASE , RELEASEDIR and some other function use this method */
int
glusterfs_gfs3_3_op_common_reply(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, void* data)
{
int offset = 0;
offset = gluster_dissect_common_reply(tvb, offset, pinfo, tree, data);
offset = gluster_rpc_dissect_dict(tree, tvb, hf_glusterfs_dict, offset);
return offset;
}
/*
* GLUSTER3_1_FOP_PROGRAM
* - xlators/protocol/client/src/client3_1-fops.c
* - xlators/protocol/server/src/server3_1-fops.c
*/
static const vsff glusterfs3_1_fop_proc[] = {
{
GFS3_OP_NULL, "NULL",
dissect_rpc_void, dissect_rpc_void
},
{ GFS3_OP_STAT, "STAT", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_READLINK, "READLINK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_MKNOD, "MKNOD", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_MKDIR, "MKDIR", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_UNLINK, "UNLINK",
glusterfs_gfs3_op_unlink_call, glusterfs_gfs3_op_unlink_reply
},
{ GFS3_OP_RMDIR, "RMDIR", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_SYMLINK, "SYMLINK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_RENAME, "RENAME", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_LINK, "LINK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_TRUNCATE, "TRUNCATE", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_OPEN, "OPEN", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_READ, "READ", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_WRITE, "WRITE", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_STATFS, "STATFS",
glusterfs_gfs3_op_statfs_call, glusterfs_gfs3_op_statfs_reply
},
{
GFS3_OP_FLUSH, "FLUSH",
glusterfs_gfs3_op_flush_call, gluster_local_dissect_common_reply
},
{ GFS3_OP_FSYNC, "FSYNC", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_SETXATTR, "SETXATTR",
glusterfs_gfs3_op_setxattr_call, gluster_local_dissect_common_reply
},
{ GFS3_OP_GETXATTR, "GETXATTR", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_REMOVEXATTR, "REMOVEXATTR", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_OPENDIR, "OPENDIR",
glusterfs_gfs3_op_opendir_call, glusterfs_gfs3_op_opendir_reply
},
{ GFS3_OP_FSYNCDIR, "FSYNCDIR", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_ACCESS, "ACCESS", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_CREATE, "CREATE",
glusterfs_gfs3_op_create_call, glusterfs_gfs3_op_create_reply
},
{ GFS3_OP_FTRUNCATE, "FTRUNCATE", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_FSTAT, "FSTAT", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_LK, "LK", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_LOOKUP, "LOOKUP",
glusterfs_gfs3_op_lookup_call, glusterfs_gfs3_op_lookup_reply
},
{ GFS3_OP_READDIR, "READDIR", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_INODELK, "INODELK",
glusterfs_gfs3_op_inodelk_call, gluster_local_dissect_common_reply
},
{ GFS3_OP_FINODELK, "FINODELK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_ENTRYLK, "ENTRYLK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_FENTRYLK, "FENTRYLK", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_XATTROP, "XATTROP", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_FXATTROP, "FXATTROP", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_FGETXATTR, "FGETXATTR", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_FSETXATTR, "FSETXATTR", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_RCHECKSUM, "RCHECKSUM", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_SETATTR, "SETATTR",
glusterfs_gfs3_op_setattr_call, glusterfs_gfs3_op_setattr_reply
},
{
GFS3_OP_FSETATTR, "FSETATTR",
/* SETATTR and SETFATTS calls and reply are encoded the same */
glusterfs_gfs3_op_setattr_call, glusterfs_gfs3_op_setattr_reply
},
{
GFS3_OP_READDIRP, "READDIRP",
glusterfs_gfs3_op_readdirp_call, glusterfs_gfs3_op_readdirp_reply
},
{ GFS3_OP_RELEASE, "RELEASE", dissect_rpc_unknown, dissect_rpc_unknown },
{ GFS3_OP_RELEASEDIR, "RELEASEDIR", dissect_rpc_unknown, dissect_rpc_unknown },
{ 0, NULL, NULL, NULL }
};
/*
* GLUSTER3_1_FOP_PROGRAM for 3_3
* - xlators/protocol/client/src/client3_1-fops.c
* - xlators/protocol/server/src/server3_1-fops.c
*/
static const vsff glusterfs3_3_fop_proc[] = {
{
GFS3_OP_NULL, "NULL",
dissect_rpc_void, dissect_rpc_void
},
{
GFS3_OP_STAT, "STAT",
glusterfs_gfs3_3_op_stat_call, glusterfs_gfs3_3_op_stat_reply
},
{
GFS3_OP_READLINK, "READLINK",
glusterfs_gfs3_3_op_readlink_call, glusterfs_gfs3_3_op_readlink_reply
},
{
GFS3_OP_MKNOD, "MKNOD",
glusterfs_gfs3_3_op_mknod_call, glusterfs_gfs3_3_op_mknod_reply
},
{
GFS3_OP_MKDIR, "MKDIR",
glusterfs_gfs3_3_op_mkdir_call, glusterfs_gfs3_3_op_mknod_reply
},
{
GFS3_OP_UNLINK, "UNLINK",
glusterfs_gfs3_3_op_unlink_call, glusterfs_gfs3_3_op_unlink_reply
},
{
GFS3_OP_RMDIR, "RMDIR",
glusterfs_gfs3_3_op_rmdir_call, glusterfs_gfs3_3_op_unlink_reply
},
{
GFS3_OP_SYMLINK, "SYMLINK",
glusterfs_gfs3_3_op_symlink_call, glusterfs_gfs3_3_op_mknod_reply
},
{
GFS3_OP_RENAME, "RENAME",
glusterfs_gfs3_3_op_rename_call, glusterfs_gfs3_3_op_rename_reply
},
{
GFS3_OP_LINK, "LINK",
glusterfs_gfs3_3_op_link_call, glusterfs_gfs3_3_op_mknod_reply
},
{
GFS3_OP_TRUNCATE, "TRUNCATE",
glusterfs_gfs3_3_op_truncate_call, glusterfs_gfs3_3_op_unlink_reply
},
{
GFS3_OP_OPEN, "OPEN",
glusterfs_gfs3_3_op_open_call, glusterfs_gfs3_3_op_open_reply
},
{
GFS3_OP_READ, "READ",
glusterfs_gfs3_3_op_read_call, glusterfs_gfs3_3_op_read_reply
},
{
GFS3_OP_WRITE, "WRITE",
glusterfs_gfs3_3_op_write_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_STATFS, "STATFS",
glusterfs_gfs3_3_op_statfs_call, glusterfs_gfs3_3_op_statfs_reply
},
{
GFS3_OP_FLUSH, "FLUSH",
glusterfs_gfs3_3_op_flush_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_FSYNC, "FSYNC",
glusterfs_gfs3_3_op_fsync_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_SETXATTR, "SETXATTR",
glusterfs_gfs3_3_op_setxattr_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_GETXATTR, "GETXATTR",
glusterfs_gfs3_3_op_getxattr_call, glusterfs_gfs3_3_op_getxattr_reply
},
{
GFS3_OP_REMOVEXATTR, "REMOVEXATTR",
glusterfs_gfs3_3_op_removexattr_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_OPENDIR, "OPENDIR",
glusterfs_gfs3_3_op_opendir_call, glusterfs_gfs3_3_op_opendir_reply
},
{
GFS3_OP_FSYNCDIR, "FSYNCDIR",
glusterfs_gfs3_3_op_fsync_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_ACCESS, "ACCESS",
glusterfs_gfs3_3_op_access_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_CREATE, "CREATE",
glusterfs_gfs3_3_op_create_call, glusterfs_gfs3_3_op_create_reply
},
{
GFS3_OP_FTRUNCATE, "FTRUNCATE",
glusterfs_gfs3_3_op_ftruncate_call, glusterfs_gfs3_3_op_unlink_reply
},
{
GFS3_OP_FSTAT, "FSTAT",
glusterfs_gfs3_3_op_fstat_call, glusterfs_gfs3_3_op_fstat_reply
},
{
GFS3_OP_LK, "LK",
glusterfs_gfs3_3_op_lk_call, glusterfs_gfs3_3_op_lk_reply
},
{
GFS3_OP_LOOKUP, "LOOKUP",
glusterfs_gfs3_3_op_lookup_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_READDIR, "READDIR",
glusterfs_gfs3_3_op_readdir_call, glusterfs_gfs3_3_op_readdir_reply
},
{
GFS3_OP_INODELK, "INODELK",
glusterfs_gfs3_3_op_inodelk_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_FINODELK, "FINODELK",
glusterfs_gfs3_3_op_finodelk_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_ENTRYLK, "ENTRYLK",
glusterfs_gfs3_3_op_entrylk_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_FENTRYLK, "FENTRYLK",
glusterfs_gfs3_3_op_fentrylk_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_XATTROP, "XATTROP",
glusterfs_gfs3_3_op_xattrop_call, glusterfs_gfs3_3_op_xattrop_reply
},
/*xattrop and fxattrop replay both are same */
{
GFS3_OP_FXATTROP, "FXATTROP",
glusterfs_gfs3_3_op_fxattrop_call, glusterfs_gfs3_3_op_xattrop_reply
},
{
GFS3_OP_FGETXATTR, "FGETXATTR",
glusterfs_gfs3_3_op_fgetxattr_call, glusterfs_gfs3_3_op_xattrop_reply
},
{
GFS3_OP_FSETXATTR, "FSETXATTR",
gluter_gfs3_3_op_fsetxattr_call, glusterfs_gfs3_3_op_common_reply
},
{ GFS3_OP_RCHECKSUM, "RCHECKSUM", dissect_rpc_unknown, dissect_rpc_unknown },
{
GFS3_OP_SETATTR, "SETATTR",
glusterfs_gfs3_3_op_setattr_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_FSETATTR, "FSETATTR",
/* SETATTR and SETFATTS calls and reply are encoded the same */
glusterfs_gfs3_3_op_setattr_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_READDIRP, "READDIRP",
glusterfs_gfs3_3_op_readdirp_call, glusterfs_gfs3_3_op_readdirp_reply
},
{
GFS3_OP_RELEASE, "RELEASE",
glusterfs_gfs3_3_op_release_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_RELEASEDIR, "RELEASEDIR",
glusterfs_gfs3_3_op_releasedir_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_FREMOVEXATTR, "FREMOVEXATTR",
glusterfs_gfs3_3_op_fremovexattr_call, glusterfs_gfs3_3_op_common_reply
},
{
GFS3_OP_FALLOCATE, "FALLOCATE",
glusterfs_gfs3_3_op_fallocate_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_DISCARD, "DISCARD",
glusterfs_gfs3_3_op_readdirp_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_ZEROFILL, "ZEROFILL",
glusterfs_gfs3_3_op_zerofill_call, glusterfs_gfs3_3_op_setattr_reply
},
{
GFS3_OP_SEEK, "SEEK",
glusterfs_gfs3_3_op_seek_call, glusterfs_gfs3_3_op_seek_reply
},
{ 0, NULL, NULL, NULL }
};
static const rpc_prog_vers_info glusterfs_vers_info[] = {
{ 310, glusterfs3_1_fop_proc, &hf_glusterfs_proc },
{ 330, glusterfs3_3_fop_proc, &hf_glusterfs_proc },
};
static const value_string glusterfs3_1_fop_proc_vals[] = {
{ GFS3_OP_NULL, "NULL" },
{ GFS3_OP_STAT, "STAT" },
{ GFS3_OP_READLINK, "READLINK" },
{ GFS3_OP_MKNOD, "MKNOD" },
{ GFS3_OP_MKDIR, "MKDIR" },
{ GFS3_OP_UNLINK, "UNLINK" },
{ GFS3_OP_RMDIR, "RMDIR" },
{ GFS3_OP_SYMLINK, "SYMLINK" },
{ GFS3_OP_RENAME, "RENAME" },
{ GFS3_OP_LINK, "LINK" },
{ GFS3_OP_TRUNCATE, "TRUNCATE" },
{ GFS3_OP_OPEN, "OPEN" },
{ GFS3_OP_READ, "READ" },
{ GFS3_OP_WRITE, "WRITE" },
{ GFS3_OP_STATFS, "STATFS" },
{ GFS3_OP_FLUSH, "FLUSH" },
{ GFS3_OP_FSYNC, "FSYNC" },
{ GFS3_OP_SETXATTR, "SETXATTR" },
{ GFS3_OP_GETXATTR, "GETXATTR" },
{ GFS3_OP_REMOVEXATTR, "REMOVEXATTR" },
{ GFS3_OP_OPENDIR, "OPENDIR" },
{ GFS3_OP_FSYNCDIR, "FSYNCDIR" },
{ GFS3_OP_ACCESS, "ACCESS" },
{ GFS3_OP_CREATE, "CREATE" },
{ GFS3_OP_FTRUNCATE, "FTRUNCATE" },
{ GFS3_OP_FSTAT, "FSTAT" },
{ GFS3_OP_LK, "LK" },
{ GFS3_OP_LOOKUP, "LOOKUP" },
{ GFS3_OP_READDIR, "READDIR" },
{ GFS3_OP_INODELK, "INODELK" },
{ GFS3_OP_FINODELK, "FINODELK" },
{ GFS3_OP_ENTRYLK, "ENTRYLK" },
{ GFS3_OP_FENTRYLK, "FENTRYLK" },
{ GFS3_OP_XATTROP, "XATTROP" },
{ GFS3_OP_FXATTROP, "FXATTROP" },
{ GFS3_OP_FGETXATTR, "FGETXATTR" },
{ GFS3_OP_FSETXATTR, "FSETXATTR" },
{ GFS3_OP_RCHECKSUM, "RCHECKSUM" },
{ GFS3_OP_SETATTR, "SETATTR" },
{ GFS3_OP_FSETATTR, "FSETATTR" },
{ GFS3_OP_READDIRP, "READDIRP" },
{ GFS3_OP_RELEASE, "RELEASE" },
{ GFS3_OP_RELEASEDIR, "RELEASEDIR" },
{ GFS3_OP_FREMOVEXATTR, "FREMOVEXATTR" },
{ GFS3_OP_FALLOCATE, "FALLOCATE" },
{ GFS3_OP_DISCARD, "DISCARD" },
{ GFS3_OP_ZEROFILL, "ZEROFILL" },
{ GFS3_OP_IPC, "IPC" },
{ GFS3_OP_SEEK, "SEEK" },
{ 0, NULL }
};
static value_string_ext glusterfs3_1_fop_proc_vals_ext = VALUE_STRING_EXT_INIT(glusterfs3_1_fop_proc_vals);
/* dir-entry types */
static const value_string glusterfs_entry_type_names[] = {
{ GLUSTER_DT_UNKNOWN, "DT_UNKNOWN" },
{ GLUSTER_DT_FIFO, "DT_FIFO" },
{ GLUSTER_DT_CHR, "DT_CHR" },
{ GLUSTER_DT_DIR, "DT_DIR" },
{ GLUSTER_DT_BLK, "DT_BLK" },
{ GLUSTER_DT_REG, "DT_REG" },
{ GLUSTER_DT_LNK, "DT_LNK" },
{ GLUSTER_DT_SOCK, "DT_SOCK" },
{ GLUSTER_DT_WHT, "DT_WHT" },
{ 0, NULL }
};
static value_string_ext glusterfs_entry_type_names_ext = VALUE_STRING_EXT_INIT(glusterfs_entry_type_names);
/* Normal locking commands */
static const value_string glusterfs_lk_cmd_names[] = {
{ GF_LK_GETLK, "GF_LK_GETLK" },
{ GF_LK_SETLK, "GF_LK_SETLK" },
{ GF_LK_SETLKW, "GF_LK_SETLKW" },
{ GF_LK_RESLK_LCK, "GF_LK_RESLK_LCK" },
{ GF_LK_RESLK_LCKW, "GF_LK_RESLK_LCKW" },
{ GF_LK_RESLK_UNLCK, "GF_LK_RESLK_UNLCK" },
{ GF_LK_GETLK_FD, "GF_LK_GETLK_FD" },
{ 0, NULL }
};
static value_string_ext glusterfs_lk_cmd_names_ext = VALUE_STRING_EXT_INIT(glusterfs_lk_cmd_names);
/* Different lock types */
static const value_string glusterfs_lk_type_names[] = {
{ GF_LK_F_RDLCK, "GF_LK_F_RDLCK" },
{ GF_LK_F_WRLCK, "GF_LK_F_WRLCK" },
{ GF_LK_F_UNLCK, "GF_LK_F_UNLCK" },
{ GF_LK_EOL, "GF_LK_EOL" },
{ 0, NULL }
};
static const value_string glusterfs_lk_whence[] = {
{ GF_LK_SEEK_SET, "SEEK_SET" },
{ GF_LK_SEEK_CUR, "SEEK_CUR" },
{ GF_LK_SEEK_END, "SEEK_END" },
{ 0, NULL }
};
static const value_string glusterfs_seek_whence[] = {
{ GF_SEEK_DATA, "SEEK_DATA" },
{ GF_SEEK_HOLE, "SEEK_HOLE" },
{ 0, NULL }
};
void
proto_register_glusterfs(void)
{
/* Setup list of header fields See Section 1.6.1 for details */
static hf_register_info hf[] = {
/* programs */
{ &hf_glusterfs_proc,
{ "GlusterFS", "glusterfs.proc", FT_UINT32, BASE_DEC | BASE_EXT_STRING,
&glusterfs3_1_fop_proc_vals_ext, 0, NULL, HFILL }
},
/* fields used by multiple programs/procedures and other
* Gluster dissectors with gluster_dissect_common_reply() */
{ &hf_gluster_op_ret,
{ "Return value", "gluster.op_ret", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_op_errno,
{ "Errno", "gluster.op_errno", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
/* GlusterFS specific */
{ &hf_glusterfs_gfid,
{ "GFID", "glusterfs.gfid", FT_GUID,
BASE_NONE, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_pargfid,
{ "Parent GFID", "glusterfs.pargfid", FT_GUID,
BASE_NONE, NULL, 0,
"GFID of the parent directory", HFILL }
},
{ &hf_glusterfs_oldgfid,
{ "Old GFID", "glusterfs.oldgfid", FT_GUID,
BASE_NONE, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_newgfid,
{ "New GFID", "glusterfs.newgfid", FT_GUID,
BASE_NONE, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_path,
{ "Path", "glusterfs.path", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_bname,
{ "Basename", "glusterfs.bname", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_dict,
{ "Dict", "glusterfs.dict", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_fd,
{ "File Descriptor", "glusterfs.fd", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_offset,
{ "Offset", "glusterfs.offset", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_size,
{ "Size", "glusterfs.size", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_size64,
{ "Size", "glusterfs.size64", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_type,
{ "Type", "glusterfs.type", FT_INT32, BASE_DEC,
VALS(glusterfs_lk_type_names), 0, NULL, HFILL }
},
{ &hf_glusterfs_cmd,
{ "Command", "glusterfs.cmd", FT_INT32, BASE_DEC | BASE_EXT_STRING,
&glusterfs_lk_cmd_names_ext, 0, NULL, HFILL }
},
{ &hf_glusterfs_volume,
{ "Volume", "glusterfs.volume", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_namelen,
{ "Name Lenth", "glusterfs.namelen", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_linkname,
{ "Linkname", "glusterfs.linkname", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_umask,
{ "Umask", "glusterfs.umask", FT_UINT32, BASE_OCT,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_mask,
{ "Mask", "glusterfs.mask", FT_UINT32, BASE_OCT,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_entries, /* READDIRP returned <x> entries */
{ "Entries returned", "glusterfs.entries", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_whence,
{ "Whence", "glusterfs.whence", FT_UINT32, BASE_DEC,
VALS(glusterfs_seek_whence), 0, NULL, HFILL }
},
/* Flags passed on to OPEN, CREATE etc, based on */
{ &hf_glusterfs_flags,
{ "Flags", "glusterfs.flags", FT_UINT32, BASE_OCT,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_flags_rdonly,
{ "O_RDONLY", "glusterfs.flags.rdonly", FT_BOOLEAN, 32,
TFS(&glusterfs_notset_set), 0xffffffff, NULL, HFILL }
},
{ &hf_glusterfs_flags_wronly,
{ "O_WRONLY", "glusterfs.flags.wronly", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00000001, NULL, HFILL }
},
{ &hf_glusterfs_flags_rdwr,
{ "O_RDWR", "glusterfs.flags.rdwr", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00000002, NULL, HFILL }
},
{ &hf_glusterfs_flags_accmode,
{ "O_ACCMODE", "glusterfs.flags.accmode", FT_UINT32, BASE_DEC,
VALS(glusterfs_accmode_vals), 00000003, NULL, HFILL }
},
{ &hf_glusterfs_flags_append,
{ "O_APPEND", "glusterfs.flags.append", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00002000, NULL, HFILL }
},
{ &hf_glusterfs_flags_async,
{ "O_ASYNC", "glusterfs.flags.async", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00020000, NULL, HFILL }
},
{ &hf_glusterfs_flags_cloexec,
{ "O_CLOEXEC", "glusterfs.flags.cloexec", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 02000000, NULL, HFILL }
},
{ &hf_glusterfs_flags_creat,
{ "O_CREAT", "glusterfs.flags.creat", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00000100, NULL, HFILL }
},
{ &hf_glusterfs_flags_direct,
{ "O_DIRECT", "glusterfs.flags.direct", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00040000, NULL, HFILL }
},
{ &hf_glusterfs_flags_directory,
{ "O_DIRECTORY", "glusterfs.flags.directory", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00200000, NULL, HFILL }
},
{ &hf_glusterfs_flags_excl,
{ "O_EXCL", "glusterfs.flags.excl", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00000200, NULL, HFILL }
},
{ &hf_glusterfs_flags_largefile,
{ "O_LARGEFILE", "glusterfs.flags.largefile", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00100000, NULL, HFILL }
},
{ &hf_glusterfs_flags_noatime,
{ "O_NOATIME", "glusterfs.flags.noatime", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 01000000, NULL, HFILL }
},
{ &hf_glusterfs_flags_noctty,
{ "O_NOCTTY", "glusterfs.flags.noctty", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00000400, NULL, HFILL }
},
{ &hf_glusterfs_flags_nofollow,
{ "O_NOFOLLOW", "glusterfs.flags.nofollow", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00400000, NULL, HFILL }
},
{ &hf_glusterfs_flags_nonblock,
{ "O_NONBLOCK", "glusterfs.flags.nonblock", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00004000, NULL, HFILL }
},
{ &hf_glusterfs_flags_ndelay,
{ "O_NDELAY", "glusterfs.flags.ndelay", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00004000, NULL, HFILL }
},
{ &hf_glusterfs_flags_sync,
{ "O_SYNC", "glusterfs.flags.sync", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00010000, NULL, HFILL }
},
{ &hf_glusterfs_flags_trunc,
{ "O_TRUNC", "glusterfs.flags.trunc", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 00001000, NULL, HFILL }
},
{ &hf_glusterfs_flags_reserved,
{ "Unused", "glusterfs.flags.reserved", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), 037774000074, NULL, HFILL }
},
/* access modes */
{ &hf_glusterfs_mode,
{ "Mode", "glusterfs.mode", FT_UINT32, BASE_OCT,
NULL, 0, "Access Permissions", HFILL }
},
{ &hf_glusterfs_mode_suid,
{ "S_ISUID", "glusterfs.mode.s_isuid", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (04000), "set-user-ID", HFILL }
},
{ &hf_glusterfs_mode_sgid,
{ "S_ISGID", "glusterfs.mode.s_isgid", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (02000), "set-group-ID", HFILL }
},
{ &hf_glusterfs_mode_svtx,
{ "S_ISVTX", "glusterfs.mode.s_isvtx", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (01000), "sticky bit", HFILL }
},
{ &hf_glusterfs_mode_rusr,
{ "S_IRUSR", "glusterfs.mode.s_irusr", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00400), "read by owner", HFILL }
},
{ &hf_glusterfs_mode_wusr,
{ "S_IWUSR", "glusterfs.mode.s_iwusr", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00200), "write by owner", HFILL }
},
{ &hf_glusterfs_mode_xusr,
{ "S_IXUSR", "glusterfs.mode.s_ixusr", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00100), "execute/search by owner", HFILL }
},
{ &hf_glusterfs_mode_rgrp,
{ "S_IRGRP", "glusterfs.mode.s_irgrp", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00040), "read by group", HFILL }
},
{ &hf_glusterfs_mode_wgrp,
{ "S_IWGRP", "glusterfs.mode.s_iwgrp", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00020), "write by group", HFILL }
},
{ &hf_glusterfs_mode_xgrp,
{ "S_IXGRP", "glusterfs.mode.s_ixgrp", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00010), "execute/search by group", HFILL }
},
{ &hf_glusterfs_mode_roth,
{ "S_IROTH", "glusterfs.mode.s_iroth", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00004), "read by others", HFILL }
},
{ &hf_glusterfs_mode_woth,
{ "S_IWOTH", "glusterfs.mode.s_iwoth", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00002), "write by others", HFILL }
},
{ &hf_glusterfs_mode_xoth,
{ "S_IXOTH", "glusterfs.mode.s_ixoth", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (00001), "execute/search by others", HFILL }
},
{ &hf_glusterfs_mode_reserved,
{ "Reserved", "glusterfs.mode.reserved", FT_BOOLEAN, 32,
TFS(&tfs_set_notset), (~07777), "execute/search by others", HFILL }
},
/* the dir-entry structure */
{ &hf_glusterfs_entry_ino,
{ "Inode", "glusterfs.entry.ino", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_entry_off, /* like telldir() */
{ "Offset", "glusterfs.entry.d_off", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_entry_len, /* length of the path string */
{ "Path length", "glusterfs.entry.len", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_entry_type,
{ "Type", "glusterfs.entry.d_type", FT_UINT32, BASE_DEC | BASE_EXT_STRING,
&glusterfs_entry_type_names_ext, 0, NULL, HFILL }
},
{ &hf_glusterfs_entry_path,
{ "Path", "glusterfs.entry.path", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
/* the IATT structure */
{ &hf_glusterfs_iatt,
{ "IATT", "glusterfs.iatt", FT_NONE, BASE_NONE, NULL,
0, NULL, HFILL }
},
{ &hf_glusterfs_preparent_iatt,
{ "Pre-operation parent IATT", "glusterfs.preparent_iatt", FT_NONE, BASE_NONE, NULL,
0, NULL, HFILL }
},
{ &hf_glusterfs_postparent_iatt,
{ "Post-operation parent IATT", "glusterfs.postparent_iatt", FT_NONE, BASE_NONE, NULL,
0, NULL, HFILL }
},
{ &hf_glusterfs_preop_iatt,
{ "Pre-operation IATT", "glusterfs.preop_iatt", FT_NONE, BASE_NONE, NULL,
0, NULL, HFILL }
},
{ &hf_glusterfs_postop_iatt,
{ "Post-operation IATT", "glusterfs.postop_iatt", FT_NONE, BASE_NONE, NULL,
0, NULL, HFILL }
},
{ &hf_glusterfs_ia_ino,
{ "Inode", "glusterfs.ia_ino", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_dev,
{ "Device", "glusterfs.ia_dev", FT_UINT64, BASE_HEX,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_mode,
{ "Mode", "glusterfs.ia_mode", FT_UINT32, BASE_OCT,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_nlink,
{ "Number of hard links", "glusterfs.ia_nlink",
FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_uid,
{ "UID", "glusterfs.ia_uid", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_gid,
{ "GID", "glusterfs.ia_gid", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_rdev,
{ "Root device", "glusterfs.ia_rdev", FT_UINT64,
BASE_HEX, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_size,
{ "Size", "glusterfs.ia_size", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_blksize,
{ "Block size", "glusterfs.ia_blksize", FT_INT32,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_blocks,
{ "Blocks", "glusterfs.ia_blocks", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ia_atime,
{ "Time of last access", "glusterfs.ia_atime",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0,
NULL, HFILL }
},
{ &hf_glusterfs_ia_mtime,
{ "Time of last modification", "glusterfs.ia_mtime",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0,
NULL, HFILL }
},
{ &hf_glusterfs_ia_ctime,
{ "Time of last status change", "glusterfs.ia_ctime",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0,
NULL, HFILL }
},
/* gf_flock */
{ &hf_glusterfs_flock_type,
{ "Type", "glusterfs.flock.type", FT_UINT32, BASE_DEC,
VALS(glusterfs_lk_type_names), 0, NULL, HFILL }
},
{ &hf_glusterfs_flock_whence,
{ "Whence", "glusterfs.flock.whence", FT_UINT32,
BASE_DEC, VALS(glusterfs_lk_whence), 0, NULL,
HFILL }
},
{ &hf_glusterfs_flock_start,
{ "Start", "glusterfs.flock.start", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_flock_len,
{ "Length", "glusterfs.flock.len", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_flock_pid,
{ "PID", "glusterfs.flock.pid", FT_INT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_flock_owner,
{ "Owner", "glusterfs.flock.owner", FT_BYTES,
BASE_NONE, NULL, 0, NULL, HFILL }
},
/* statvfs descriptions from 'man 2 statvfs' on Linix */
{ &hf_glusterfs_bsize,
{ "File system block size", "glusterfs.statfs.bsize",
FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_frsize,
{ "Fragment size", "glusterfs.statfs.frsize",
FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_blocks,
{ "Size of fs in f_frsize units",
"glusterfs.statfs.blocks", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_bfree,
{ "# free blocks", "glusterfs.statfs.bfree", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_bavail,
{ "# free blocks for non-root",
"glusterfs.statfs.bavail", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_files,
{ "# inodes", "glusterfs.statfs.files", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_ffree,
{ "# free inodes", "glusterfs.statfs.ffree", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_favail,
{ "# free inodes for non-root",
"glusterfs.statfs.favail", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_id,
{ "File system ID", "glusterfs.statfs.fsid", FT_UINT64,
BASE_HEX, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_mnt_flags,
{ "Mount flags", "glusterfs.statfs.flags", FT_UINT64,
BASE_HEX, NULL, 0, NULL, HFILL }
},
/* ST_* flags from /usr/include/bits/statvfs.h */
{ &hf_glusterfs_mnt_flag_rdonly,
{ "ST_RDONLY", "glusterfs.statfs.flag.rdonly",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 1, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_nosuid,
{ "ST_NOSUID", "glusterfs.statfs.flag.nosuid",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 2, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_nodev,
{ "ST_NODEV", "glusterfs.statfs.flag.nodev",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 4, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_noexec,
{ "ST_EXEC", "glusterfs.statfs.flag.noexec",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 8, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_synchronous,
{ "ST_SYNCHRONOUS",
"glusterfs.statfs.flag.synchronous",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 16, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_mandlock,
{ "ST_MANDLOCK", "glusterfs.statfs.flag.mandlock",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 64, NULL,
HFILL }
},
{ &hf_glusterfs_mnt_flag_write,
{ "ST_WRITE", "glusterfs.statfs.flag.write",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 128,
NULL, HFILL }
},
{ &hf_glusterfs_mnt_flag_append,
{ "ST_APPEND", "glusterfs.statfs.flag.append",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 256,
NULL, HFILL }
},
{ &hf_glusterfs_mnt_flag_immutable,
{ "ST_IMMUTABLE", "glusterfs.statfs.flag.immutable",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 512,
NULL, HFILL }
},
{ &hf_glusterfs_mnt_flag_noatime,
{ "ST_NOATIME", "glusterfs.statfs.flag.noatime",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 1024,
NULL, HFILL }
},
{ &hf_glusterfs_mnt_flag_nodiratime,
{ "ST_NODIRATIME", "glusterfs.statfs.flag.nodiratime",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 2048,
NULL, HFILL }
},
{ &hf_glusterfs_mnt_flag_relatime,
{ "ST_RELATIME", "glusterfs.statfs.flag.relatime",
FT_BOOLEAN, 64, TFS(&tfs_set_notset), 4096,
NULL, HFILL }
},
{ &hf_glusterfs_namemax,
{ "Maximum filename length",
"glusterfs.statfs.namemax", FT_UINT64,
BASE_DEC, NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_setattr_valid,
{ "Set attributes", "glusterfs.setattr.valid",
FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
},
/* setattr.valid flags from libglusterfs/src/xlator.h */
{ &hf_glusterfs_setattr_set_mode,
{ "SET_ATTR_MODE", "glusterfs.setattr.set_mode",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x1,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_uid,
{ "SET_ATTR_UID", "glusterfs.setattr.set_uid",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x2,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_gid,
{ "SET_ATTR_GID", "glusterfs.setattr.set_gid",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x4,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_size,
{ "SET_ATTR_SIZE", "glusterfs.setattr.set_size",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x8,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_atime,
{ "SET_ATTR_ATIME", "glusterfs.setattr.set_atime",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x10,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_mtime,
{ "SET_ATTR_MTIME", "glusterfs.setattr.set_mtime",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x20,
NULL, HFILL }
},
{ &hf_glusterfs_setattr_set_reserved,
{ "Reserved", "glusterfs.setattr.set_reserved",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), ~0x3f,
NULL, HFILL }
},
{ &hf_glusterfs_xflags,
{ "XFlags", "glusterfs.xflags", FT_UINT32, BASE_OCT,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_oldbname,
{ "OldBasename", "glusterfs.oldbname", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_newbname,
{ "NewBasename", "glusterfs.newbname", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_name,
{ "Name", "glusterfs.name", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_fsync_flags,
{ "Flags", "glusterfs.fsync.flags", FT_UINT32, BASE_HEX,
NULL, 0, NULL, HFILL }
},
{ &hf_glusterfs_fsync_flag_datasync,
{ "DATASYNC", "glusterfs.fsync.datasync",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x1,
NULL, HFILL }
},
{ &hf_glusterfs_fsync_flag_unknown,
{ "Unknown", "glusterfs.fsync.unknown",
FT_BOOLEAN, 32, TFS(&tfs_set_notset), ~0x1,
NULL, HFILL }
},
/* For entry an fentry lk */
{ &hf_glusterfs_entrylk_namelen,
{ "File Descriptor", "glusterfs.entrylk.namelen", FT_UINT64, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_dict_size,
{ "Size", "glusterfs.dict_size", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_num_dict_items,
{ "Items", "glusterfs.num_dict_items", FT_UINT32, BASE_DEC,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_rpc_roundup_bytes,
{ "RPC-roundup bytes", "glusterfs.rpc_roundup_bytes", FT_BYTES, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_trusted_afr_key,
{ "Key", "glusterfs.trusted_afr_key", FT_BYTES, BASE_NONE,
NULL, 0, NULL, HFILL }
},
{ &hf_gluster_dict_value,
{ "Value", "glusterfs.dict_value", FT_STRING, BASE_NONE,
NULL, 0, NULL, HFILL }
},
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_glusterfs,
&ett_glusterfs_flags,
&ett_glusterfs_mnt_flags,
&ett_glusterfs_mode,
&ett_glusterfs_entry,
&ett_glusterfs_setattr_valid,
&ett_glusterfs_parent_iatt,
&ett_glusterfs_iatt,
&ett_glusterfs_flock,
&ett_glusterfs_fsync_flags,
&ett_gluster_dict,
&ett_gluster_dict_items
};
/* Register the protocol name and description */
proto_glusterfs = proto_register_protocol("GlusterFS", "GlusterFS",
"glusterfs");
proto_register_subtree_array(ett, array_length(ett));
proto_register_field_array(proto_glusterfs, hf, array_length(hf));
}
void
proto_reg_handoff_glusterfs(void)
{
rpc_init_prog(proto_glusterfs, GLUSTER3_1_FOP_PROGRAM, ett_glusterfs,
G_N_ELEMENTS(glusterfs_vers_info), glusterfs_vers_info);
}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 8
* tab-width: 8
* indent-tabs-mode: t
* End:
*
* vi: set shiftwidth=8 tabstop=8 noexpandtab:
* :indentSize=8:tabSize=8:noTabs=false:
*/