/* packet-pvfs2.c

 * Routines for pvfs2 packet dissection

 * By Mike Frisch <mfrisch@platform.com>

 * Joint and Several Copyright 2005, Mike Frisch and Platform Computing Inc.

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * Dissector for Parallel Virtual File System (PVFS) version 2.

 * https://web.archive.org/web/20160701052501/http://www.pvfs.org/

 *

 * Copied from packet-smb.c and others

 *

 * TODO

 *

 *    - Add filename snooping (match file handles with file names),

 *      similar to how packet-rpc.c/packet-nfs.c implements it

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/prefs.h>

#include <epan/strutil.h>

#include <epan/expert.h>

#include <epan/charsets.h>

#include <wsutil/ws_roundup.h>

#include "packet-tcp.h"

#define TCP_PORT_PVFS2 3334 /* Not IANA registered */

#define PVFS2_FH_LENGTH 8

/* Header incl. magic number, mode, tag, size */

#define BMI_HEADER_SIZE 24

/* desegmentation of PVFS over TCP */

static bool pvfs_desegment = true;

/* Forward declaration we need below */

void proto_register_pvfs(void);

void proto_reg_handoff_pvfs(void);

static dissector_handle_t pvfs_handle;

/* Initialize the protocol and registered fields */

static int proto_pvfs;

static int hf_pvfs_magic_nr;

static int hf_pvfs_uid;

static int hf_pvfs_gid;

static int hf_pvfs_mode;

static int hf_pvfs_tag;

static int hf_pvfs_size;

static int hf_pvfs_release_number;

static int hf_pvfs_encoding;

static int hf_pvfs_server_op;

/* static int hf_pvfs_handle; */

static int hf_pvfs_fs_id;

static int hf_pvfs_attrmask;

static int hf_pvfs_attr;

static int hf_pvfs_ds_type;

static int hf_pvfs_error;

static int hf_pvfs_atime;

static int hf_pvfs_atime_sec;

static int hf_pvfs_atime_nsec;

static int hf_pvfs_mtime;

static int hf_pvfs_mtime_sec;

static int hf_pvfs_mtime_nsec;

static int hf_pvfs_ctime;

static int hf_pvfs_ctime_sec;

static int hf_pvfs_ctime_nsec;

static int hf_pvfs_parent_atime;

static int hf_pvfs_parent_atime_sec;

static int hf_pvfs_parent_atime_nsec;

static int hf_pvfs_parent_mtime;

static int hf_pvfs_parent_mtime_sec;

static int hf_pvfs_parent_mtime_nsec;

static int hf_pvfs_parent_ctime;

static int hf_pvfs_parent_ctime_sec;

static int hf_pvfs_parent_ctime_nsec;

static int hf_pvfs_distribution;

static int hf_pvfs_dfile_count;

static int hf_pvfs_dirent_count;

static int hf_pvfs_directory_version;

static int hf_pvfs_path;

static int hf_pvfs_total_completed;

static int hf_pvfs_io_dist;

static int hf_pvfs_aggregate_size;

static int hf_pvfs_io_type;

static int hf_pvfs_flowproto_type;

static int hf_pvfs_server_param;

static int hf_pvfs_prev_value;

/* static int hf_pvfs_ram_free_bytes; */

static int hf_pvfs_bytes_available;

static int hf_pvfs_bytes_total;

static int hf_pvfs_ram_bytes_total;

static int hf_pvfs_ram_bytes_free;

static int hf_pvfs_load_average_1s;

static int hf_pvfs_load_average_5s;

static int hf_pvfs_load_average_15s;

static int hf_pvfs_uptime_seconds;

static int hf_pvfs_handles_available;

static int hf_pvfs_handles_total;

static int hf_pvfs_unused;

static int hf_pvfs_context_id;

static int hf_pvfs_offset;

static int hf_pvfs_stride;

static int hf_pvfs_lb;

static int hf_pvfs_ub;

static int hf_pvfs_end_time_ms;

static int hf_pvfs_cur_time_ms;

static int hf_pvfs_start_time_ms;

static int hf_pvfs_bytes_written;

static int hf_pvfs_bytes_read;

static int hf_pvfs_metadata_write;

static int hf_pvfs_metadata_read;

static int hf_pvfs_b_size;

static int hf_pvfs_k_size;

static int hf_pvfs_id_gen_t;

static int hf_pvfs_attribute_key;

static int hf_pvfs_attribute_value;

static int hf_pvfs_strip_size;

static int hf_pvfs_ereg;

static int hf_pvfs_sreg;

static int hf_pvfs_num_eregs;

static int hf_pvfs_num_blocks;

static int hf_pvfs_num_contig_chunks;

static int hf_pvfs_server_nr;

static int hf_pvfs_server_count;

static int hf_pvfs_fh_length;

static int hf_pvfs_fh_hash;

static int hf_pvfs_permissions;

static int hf_pvfs_server_mode;

static int hf_pvfs_depth;

static int hf_pvfs_num_nested_req;

static int hf_pvfs_committed;

static int hf_pvfs_refcount;

static int hf_pvfs_numreq;

static int hf_pvfs_truncate_request_flags;

static int hf_pvfs_ds_position;

static int hf_pvfs_dirent_limit;

static int hf_pvfs_flush_request_flags;

static int hf_pvfs_next_id;

static int hf_pvfs_mgmt_perf_mon_request_count;

static int hf_pvfs_mgmt_perf_mon_request_event_count;

static int hf_pvfs_lookup_path_response_handle_count;

static int hf_pvfs_getconfig_response_total_bytes;

static int hf_pvfs_getconfig_response_lines;

static int hf_pvfs_getconfig_response_config_bytes;

static int hf_pvfs_mgmt_perf_mon_response_suggested_next_id;

static int hf_pvfs_mgmt_perf_stat_valid_flag;

static int hf_pvfs_mgmt_perf_stat_id;

static int hf_pvfs_mgmt_perf_mon_response_perf_array_count;

static int hf_pvfs_mgmt_iterate_handles_response_ds_position;

static int hf_pvfs_mgmt_iterate_handles_response_handle_count;

static int hf_pvfs_mgmt_dspace_info_list_response_dspace_info_count;

static int hf_pvfs_mgmt_event_mon_response_api;

static int hf_pvfs_mgmt_event_mon_response_operation;

static int hf_pvfs_mgmt_event_mon_response_value;

static int hf_pvfs_mgmt_event_mon_response_flags;

static int hf_pvfs_mgmt_event_mon_response_tv_sec;

static int hf_pvfs_mgmt_event_mon_response_tv_usec;

static int hf_pvfs_fill_bytes;

static int hf_pvfs_target_path_len;

static int hf_pvfs_version2;

static int hf_pvfs_flow_data;

static int hf_pvfs_getconfig_response_entry;

static int hf_fhandle_data;

static int hf_pvfs_opaque_length;

/* Initialize the subtree pointers */

static int ett_pvfs;

static int ett_pvfs_hdr;

static int ett_pvfs_credentials;

static int ett_pvfs_server_config;

static int ett_pvfs_server_config_branch;

static int ett_pvfs_attrmask;

static int ett_pvfs_time;

static int ett_pvfs_extent_array_tree;

static int ett_pvfs_extent_item;

static int ett_pvfs_string;

static int ett_pvfs_attr_tree;

static int ett_pvfs_distribution;

static int ett_pvfs_mgmt_perf_stat;

static int ett_pvfs_mgmt_dspace_info;

static int ett_pvfs_attr;

static int ett_pvfs_fh;

static expert_field ei_pvfs_malformed;

#define BMI_MAGIC_NR 51903

static const value_string names_pvfs_mode[] =

{

#define TCP_MODE_IMMED 1

  { TCP_MODE_IMMED, "TCP_MODE_IMMED" },

#define TCP_MODE_UNEXP 2

  { TCP_MODE_UNEXP, "TCP_MODE_UNEXP" },

#define TCP_MODE_EAGER 4

  { TCP_MODE_EAGER, "TCP_MODE_EAGER" },

#define TCP_MODE_REND 8

  { TCP_MODE_REND,  "TCP_MODE_REND" },

  { 0, NULL }

};

static const value_string names_pvfs_encoding[] =

{

#define PVFS_ENCODING_DIRECT 1

  { PVFS_ENCODING_DIRECT, "ENCODING_DIRECT" },

#define PVFS_ENCODING_LE_BFIELD 2

  { PVFS_ENCODING_LE_BFIELD, "ENCODING_LE_BFIELD" },

#define PVFS_ENCODING_XDR 3

  { PVFS_ENCODING_XDR, "ENCODING_XDR" },

  { 0, NULL }

};

static const value_string names_pvfs_io_type[] =

{

#define PVFS_IO_READ 1

  { PVFS_IO_READ, "PVFS_IO_READ" },

#define PVFS_IO_WRITE 2

  { PVFS_IO_WRITE, "PVFS_IO_WRITE" },

  { 0, NULL }

};

static const value_string names_pvfs_flowproto_type[] =

{

#define FLOWPROTO_DUMP_OFFSETS 1

  { FLOWPROTO_DUMP_OFFSETS, "FLOWPROTO_DUMP_OFFSETS" },

#define FLOWPROTO_BMI_CACHE 2

  { FLOWPROTO_BMI_CACHE, "FLOWPROTO_BMI_CACHE" },

#define FLOWPROTO_MULTIQUEUE 3

  { FLOWPROTO_MULTIQUEUE, "FLOWPROTO_MULTIQUEUE" },

  { 0, NULL }

};

static const value_string names_pvfs_server_param[] =

{

#define PVFS_SERV_PARAM_INVALID 0

  { PVFS_SERV_PARAM_INVALID, "PVFS_SERV_PARAM_INVALID" },

#define PVFS_SERV_PARAM_GOSSIP_MASK 1

  { PVFS_SERV_PARAM_GOSSIP_MASK, "PVFS_SERV_PARAM_GOSSIP_MASK" },

#define PVFS_SERV_PARAM_FSID_CHECK 2

  { PVFS_SERV_PARAM_FSID_CHECK, "PVFS_SERV_PARAM_FSID_CHECK" },

#define PVFS_SERV_PARAM_ROOT_CHECK 3

  { PVFS_SERV_PARAM_ROOT_CHECK, "PVFS_SERV_PARAM_ROOT_CHECK" },

#define PVFS_SERV_PARAM_MODE 4

  { PVFS_SERV_PARAM_MODE, "PVFS_SERV_PARAM_MODE" },

#define PVFS_SERV_PARAM_EVENT_ON 5

  { PVFS_SERV_PARAM_EVENT_ON, "PVFS_SERV_PARAM_EVENT_ON" },

#define PVFS_SERV_PARAM_EVENT_MASKS 6

  { PVFS_SERV_PARAM_EVENT_MASKS, "PVFS_SERV_PARAM_EVENT_MASKS" },

  { 0, NULL }

};

static const value_string names_pvfs_server_mode[] =

{

#define PVFS_SERVER_NORMAL_MODE 1

  { PVFS_SERVER_NORMAL_MODE, "PVFS_SERVER_NORMAL_MODE" },

#define PVFS_SERVER_ADMIN_MODE 2

  { PVFS_SERVER_ADMIN_MODE, "PVFS_SERVER_ADMIN_MODE" },

  { 0, NULL }

};

/* Forward declaration */

static bool

dissect_pvfs_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

    bool dissect_other_as_continuation);

static int dissect_pvfs_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)

{

  dissect_pvfs_common(tvb, pinfo, tree, false);

  return tvb_reported_length(tvb);

}

static unsigned get_pvfs_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb,

                              int offset, void *data _U_)

{

  uint32_t plen;

  /*

   * Get the length of the PVFS-over-TCP packet. Ignore top 32 bits

   */

  plen = tvb_get_letohl(tvb, offset + 16);

  return plen+24;

}

static int

dissect_pvfs(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)

{

  uint32_t magic_nr, mode;

  uint64_t size;

  /* verify that this is indeed PVFS and that it looks sane */

  if(tvb_reported_length(tvb)<24){

    /* too few bytes remaining to verify the header */

    return 0;

  }

  /* validate the magic number */

  magic_nr = tvb_get_letohl(tvb, 0);

  if(magic_nr!=BMI_MAGIC_NR){

    return 0;

  }

  /* Validate the TCP message mode (32-bit) */

  mode = tvb_get_letohl(tvb, 4);

  switch(mode){

  case TCP_MODE_IMMED:

  case TCP_MODE_UNEXP:

  case TCP_MODE_EAGER:

  case TCP_MODE_REND:

    break;

  default:

    /* invalid mode, not a PVFS packet */

    return 0;

  }

  /* validate the size : assume size must be >0 and less than 1000000 */

  size=tvb_get_letohl(tvb, 20);

  size<<=32;

  size|=tvb_get_letohl(tvb, 16);

  if((size>1000000)||(size==0)){

    return 0;

  }

  tcp_dissect_pdus(tvb, pinfo, tree, pvfs_desegment, 24, get_pvfs_pdu_len,

    dissect_pvfs_pdu, data);

  return tvb_reported_length(tvb);

}

static bool

dissect_pvfs_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)

{

    return dissect_pvfs(tvb, pinfo, tree, data) > 0;

}

static const value_string names_pvfs_server_op[] =

{

#define PVFS_SERV_INVALID 0

  { PVFS_SERV_INVALID, "PVFS_SERV_INVALID" },

#define PVFS_SERV_CREATE 1

  { PVFS_SERV_CREATE, "PVFS_SERV_CREATE" },

#define PVFS_SERV_REMOVE 2

  { PVFS_SERV_REMOVE, "PVFS_SERV_REMOVE" },

#define PVFS_SERV_IO 3

  { PVFS_SERV_IO, "PVFS_SERV_IO" },

#define PVFS_SERV_GETATTR 4

  { PVFS_SERV_GETATTR, "PVFS_SERV_GETATTR" },

#define PVFS_SERV_SETATTR 5

  { PVFS_SERV_SETATTR, "PVFS_SERV_SETATTR" },

#define PVFS_SERV_LOOKUP_PATH 6

  { PVFS_SERV_LOOKUP_PATH, "PVFS_SERV_LOOKUP_PATH" },

#define PVFS_SERV_CRDIRENT 7

  { PVFS_SERV_CRDIRENT, "PVFS_SERV_CRDIRENT" },

#define PVFS_SERV_RMDIRENT 8

  { PVFS_SERV_RMDIRENT, "PVFS_SERV_RMDIRENT" },

#define PVFS_SERV_CHDIRENT 9

  { PVFS_SERV_CHDIRENT, "PVFS_SERV_CHDIRENT" },

#define PVFS_SERV_TRUNCATE 10

  { PVFS_SERV_TRUNCATE, "PVFS_SERV_TRUNCATE" },

#define PVFS_SERV_MKDIR 11

  { PVFS_SERV_MKDIR, "PVFS_SERV_MKDIR" },

#define PVFS_SERV_READDIR 12

  { PVFS_SERV_READDIR, "PVFS_SERV_READDIR" },

#define PVFS_SERV_GETCONFIG 13

  { PVFS_SERV_GETCONFIG, "PVFS_SERV_GETCONFIG" },

#define PVFS_SERV_WRITE_COMPLETION 14

  { PVFS_SERV_WRITE_COMPLETION, "PVFS_SERV_WRITE_COMPLETION" },

#define PVFS_SERV_FLUSH 15

  { PVFS_SERV_FLUSH, "PVFS_SERV_FLUSH" },

#define PVFS_SERV_MGMT_SETPARAM 16

  { PVFS_SERV_MGMT_SETPARAM, "PVFS_SERV_MGMT_SETPARAM" },

#define PVFS_SERV_MGMT_NOOP 17

  { PVFS_SERV_MGMT_NOOP, "PVFS_SERV_MGMT_NOOP" },

#define PVFS_SERV_STATFS 18

  { PVFS_SERV_STATFS, "PVFS_SERV_STATFS" },

#define PVFS_SERV_PERF_UPDATE 19  /* not a real protocol request */

  { PVFS_SERV_PERF_UPDATE, "PVFS_SERV_PERF_UPDATE" },

#define PVFS_SERV_MGMT_PERF_MON 20

  { PVFS_SERV_MGMT_PERF_MON, "PVFS_SERV_MGMT_PERF_MON" },

#define PVFS_SERV_MGMT_ITERATE_HANDLES 21

  { PVFS_SERV_MGMT_ITERATE_HANDLES, "PVFS_SERV_MGMT_ITERATE_HANDLES" },

#define PVFS_SERV_MGMT_DSPACE_INFO_LIST 22

  { PVFS_SERV_MGMT_DSPACE_INFO_LIST, "PVFS_SERV_MGMT_DSPACE_INFO_LIST" },

#define PVFS_SERV_MGMT_EVENT_MON 23

  { PVFS_SERV_MGMT_EVENT_MON, "PVFS_SERV_MGMT_EVENT_MON" },

#define PVFS_SERV_MGMT_REMOVE_OBJECT 24

  { PVFS_SERV_MGMT_REMOVE_OBJECT, "PVFS_SERV_MGMT_REMOVE_OBJECT" },

#define PVFS_SERV_MGMT_REMOVE_DIRENT 25

  { PVFS_SERV_MGMT_REMOVE_DIRENT, "PVFS_SERV_MGMT_REMOVE_DIRENT" },

#define PVFS_SERV_MGMT_GET_DIRDATA_HANDLE 26

  { PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, "PVFS_SERV_MGMT_GET_DIRDATA_HANDLE" },

#define PVFS_SERV_JOB_TIMER 27    /* not a real protocol request */

  { PVFS_SERV_JOB_TIMER, "PVFS_SERV_JOB_TIMER" },

#define PVFS_SERV_PROTO_ERROR 28

  { PVFS_SERV_PROTO_ERROR, "PVFS_SERV_PROTO_ERROR" },

#define PVFS_SERV_GETEATTR 29

  { PVFS_SERV_GETEATTR, "PVFS_SERV_GETEATTR" },

#define PVFS_SERV_SETEATTR 30

  { PVFS_SERV_SETEATTR, "PVFS_SERV_SETEATTR" },

#define PVFS_SERV_DELEATTR 31

  { PVFS_SERV_DELEATTR, "PVFS_SERV_DELEATTR" },

  { 0, NULL }

};

/* special bits used to differentiate PVFS error codes from system

 *  * errno values

 *   */

#define PVFS_ERROR_BIT           (1 << 30)

/* a shorthand to make the error code definitions more readable */

#define E(num) (num|PVFS_ERROR_BIT)

static const value_string names_pvfs_error[] = {

  { 0, "Success" },

#define PVFS_EPERM            E(1) /* Operation not permitted */

  { PVFS_EPERM, "PVFS_EPERM" },

#define PVFS_ENOENT           E(2) /* No such file or directory */

  { PVFS_ENOENT, "PVFS_ENOENT" },

#define PVFS_EINTR            E(3) /* Interrupted system call */

  { PVFS_EINTR, "PVFS_EINTR" },

#define PVFS_EIO              E(4) /* I/O error */

  { PVFS_EIO, "PVFS_EIO" },

#define PVFS_ENXIO            E(5) /* No such device or address */

  { PVFS_ENXIO, "PVFS_ENXIO" },

#define PVFS_EBADF            E(6) /* Bad file number */

  { PVFS_EBADF, "PVFS_EBADF" },

#define PVFS_EAGAIN           E(7) /* Try again */

  { PVFS_EAGAIN, "PVFS_EAGAIN" },

#define PVFS_ENOMEM           E(8) /* Out of memory */

  { PVFS_ENOMEM, "PVFS_ENOMEM" },

#define PVFS_EFAULT           E(9) /* Bad address */

  { PVFS_EFAULT, "PVFS_EFAULT" },

#define PVFS_EBUSY           E(10) /* Device or resource busy */

  { PVFS_EBUSY, "PVFS_EBUSY" },

#define PVFS_EEXIST          E(11) /* File exists */

  { PVFS_EEXIST, "PVFS_EEXIST" },

#define PVFS_ENODEV          E(12) /* No such device */

  { PVFS_ENODEV, "PVFS_ENODEV" },

#define PVFS_ENOTDIR         E(13) /* Not a directory */

  { PVFS_ENOTDIR, "PVFS_ENOTDIR" },

#define PVFS_EISDIR          E(14) /* Is a directory */

  { PVFS_EISDIR, "PVFS_EISDIR" },

#define PVFS_EINVAL          E(15) /* Invalid argument */

  { PVFS_EINVAL, "PVFS_EINVAL" },

#define PVFS_EMFILE          E(16) /* Too many open files */

  { PVFS_EMFILE, "PVFS_EMFILE" },

#define PVFS_EFBIG           E(17) /* File too large */

  { PVFS_EFBIG, "PVFS_EFBIG" },

#define PVFS_ENOSPC          E(18) /* No space left on device */

  { PVFS_ENOSPC, "PVFS_ENOSPC" },

#define PVFS_EROFS           E(19) /* Read-only file system */

  { PVFS_EROFS, "PVFS_EROFS" },

#define PVFS_EMLINK          E(20) /* Too many links */

  { PVFS_EMLINK, "PVFS_EMLINK" },

#define PVFS_EPIPE           E(21) /* Broken pipe */

  { PVFS_EPIPE, "PVFS_EPIPE" },

#define PVFS_EDEADLK         E(22) /* Resource deadlock would occur */

  { PVFS_EDEADLK, "PVFS_EDEADLK" },

#define PVFS_ENAMETOOLONG    E(23) /* File name too long */

  { PVFS_ENAMETOOLONG, "PVFS_ENAMETOOLONG" },

#define PVFS_ENOLCK          E(24) /* No record locks available */

  { PVFS_ENOLCK, "PVFS_ENOLCK" },

#define PVFS_ENOSYS          E(25) /* Function not implemented */

  { PVFS_ENOSYS, "PVFS_ENOSYS" },

#define PVFS_ENOTEMPTY       E(26) /* Directory not empty */

  { PVFS_ENOTEMPTY, "PVFS_ENOTEMPTY" },

#define PVFS_ELOOP           E(27) /* Too many symbolic links encountered */

  { PVFS_ELOOP, "PVFS_ELOOP" },

#define PVFS_EWOULDBLOCK     E(28) /* Operation would block */

  { PVFS_EWOULDBLOCK, "PVFS_EWOULDBLOCK" },

#define PVFS_ENOMSG          E(29) /* No message of desired type */

  { PVFS_ENOMSG, "PVFS_ENOMSG" },

#define PVFS_EUNATCH         E(30) /* Protocol driver not attached */

  { PVFS_EUNATCH, "PVFS_EUNATCH" },

#define PVFS_EBADR           E(31) /* Invalid request descriptor */

  { PVFS_EBADR, "PVFS_EBADR" },

#define PVFS_EDEADLOCK       E(32)

  { PVFS_EDEADLOCK, "PVFS_EDEADLOCK" },

#define PVFS_ENODATA         E(33) /* No data available */

  { PVFS_ENODATA, "PVFS_ENODATA" },

#define PVFS_ETIME           E(34) /* Timer expired */

  { PVFS_ETIME, "PVFS_ETIME" },

#define PVFS_ENONET          E(35) /* Machine is not on the network */

  { PVFS_ENONET, "PVFS_ENONET" },

#define PVFS_EREMOTE         E(36) /* Object is remote */

  { PVFS_EREMOTE, "PVFS_EREMOTE" },

#define PVFS_ECOMM           E(37) /* Communication error on send */

  { PVFS_ECOMM, "PVFS_ECOMM" },

#define PVFS_EPROTO          E(38) /* Protocol error */

  { PVFS_EPROTO, "PVFS_EPROTO" },

#define PVFS_EBADMSG         E(39) /* Not a data message */

  { PVFS_EBADMSG, "PVFS_EBADMSG" },

#define PVFS_EOVERFLOW       E(40) /* Value too large for defined data type */

  { PVFS_EOVERFLOW, "PVFS_EOVERFLOW" },

#define PVFS_ERESTART        E(41) /* Interrupted system call should be restarted */

  { PVFS_ERESTART, "PVFS_ERESTART" },

#define PVFS_EMSGSIZE        E(42) /* Message too long */

  { PVFS_EMSGSIZE, "PVFS_EMSGSIZE" },

#define PVFS_EPROTOTYPE      E(43) /* Protocol wrong type for socket */

  { PVFS_EPROTOTYPE, "PVFS_EPROTOTYPE" },

#define PVFS_ENOPROTOOPT     E(44) /* Protocol not available */

  { PVFS_ENOPROTOOPT, "PVFS_ENOPROTOOPT" },

#define PVFS_EPROTONOSUPPORT E(45) /* Protocol not supported */

  { PVFS_EPROTONOSUPPORT, "PVFS_EPROTONOSUPPORT" },

#define PVFS_EOPNOTSUPP      E(46) /* Operation not supported on transport endpoint */

  { PVFS_EOPNOTSUPP, "PVFS_EOPNOTSUPP" },

#define PVFS_EADDRINUSE      E(47) /* Address already in use */

  { PVFS_EADDRINUSE, "PVFS_EADDRINUSE" },

#define PVFS_EADDRNOTAVAIL   E(48) /* Cannot assign requested address */

  { PVFS_EADDRNOTAVAIL, "PVFS_EADDRNOTAVAIL" },

#define PVFS_ENETDOWN        E(49) /* Network is down */

  { PVFS_ENETDOWN, "PVFS_ENETDOWN" },

#define PVFS_ENETUNREACH     E(50) /* Network is unreachable */

  { PVFS_ENETUNREACH, "PVFS_ENETUNREACH" },

#define PVFS_ENETRESET       E(51) /* Network dropped connection because of reset */

  { PVFS_ENETRESET, "PVFS_ENETRESET" },

#define PVFS_ENOBUFS         E(52) /* No buffer space available */

  { PVFS_ENOBUFS, "PVFS_ENOBUFS" },

#define PVFS_ETIMEDOUT       E(53) /* Connection timed out */

  { PVFS_ETIMEDOUT, "PVFS_ETIMEDOUT" },

#define PVFS_ECONNREFUSED    E(54) /* Connection refused */

  { PVFS_ECONNREFUSED, "PVFS_ECONNREFUSED" },

#define PVFS_EHOSTDOWN       E(55) /* Host is down */

  { PVFS_EHOSTDOWN, "PVFS_EHOSTDOWN" },

#define PVFS_EHOSTUNREACH    E(56) /* No route to host */

  { PVFS_EHOSTUNREACH, "PVFS_EHOSTUNREACH" },

#define PVFS_EALREADY        E(57) /* Operation already in progress */

  { PVFS_EALREADY, "PVFS_EALREADY" },

#define PVFS_EACCES          E(58) /* Operation already in progress */

  { PVFS_EACCES, "PVFS_EACCES" },

  { 0, NULL }

};

static unsigned

dissect_pvfs2_error(tvbuff_t *tvb, proto_tree *tree, unsigned offset,

    packet_info *pinfo)

{

  int32_t err;

  const char *errmsg = NULL;

  err = tvb_get_letohl(tvb, offset);

  proto_tree_add_uint(tree, hf_pvfs_error, tvb, offset, 4, -err);

  offset += 4;

  if (err != 0)

  {

    errmsg = val_to_str(pinfo->pool, -err, names_pvfs_error, "Unknown error: %u");

    col_append_fstr(pinfo->cinfo, COL_INFO, " Error: %s", errmsg);

  }

  return offset;

}

static unsigned

dissect_pvfs_credentials(tvbuff_t *tvb, proto_tree *parent_tree,

    unsigned offset)

{

  proto_tree *hcred_tree;

  uint32_t uid, gid;

  uid = tvb_get_letohl(tvb, offset);

  gid = tvb_get_letohl(tvb, offset + 4);

  hcred_tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, 8,

      ett_pvfs_credentials, NULL, "Credentials (UID: %d, GID: %d)", uid, gid);

  /* UID */

  proto_tree_add_item(hcred_tree, hf_pvfs_uid, tvb, offset, 4, ENC_LITTLE_ENDIAN);

  offset += 4;

  /* GID */

  proto_tree_add_item(hcred_tree, hf_pvfs_gid, tvb, offset, 4, ENC_LITTLE_ENDIAN);

  offset += 4;

  return offset;

}

static const value_string names_pvfs_attr[] =

{

#define PVFS_ATTR_COMMON_UID   (1 << 0)

#define PVFS_ATTR_BIT_COMMON_UID 0

  { PVFS_ATTR_BIT_COMMON_UID, "PVFS_ATTR_COMMON_UID" },

#define PVFS_ATTR_COMMON_GID   (1 << 1)

#define PVFS_ATTR_BIT_COMMON_GID 1

  { PVFS_ATTR_BIT_COMMON_GID, "PVFS_ATTR_COMMON_GID" },

#define PVFS_ATTR_COMMON_PERM  (1 << 2)

#define PVFS_ATTR_BIT_COMMON_PERM 2

  { PVFS_ATTR_BIT_COMMON_PERM, "PVFS_ATTR_COMMON_PERM" },

#define PVFS_ATTR_COMMON_ATIME (1 << 3)

#define PVFS_ATTR_BIT_COMMON_ATIME 3

  { PVFS_ATTR_BIT_COMMON_ATIME, "PVFS_ATTR_COMMON_ATIME" },

#define PVFS_ATTR_COMMON_CTIME (1 << 4)

#define PVFS_ATTR_BIT_COMMON_CTIME 4

  { PVFS_ATTR_BIT_COMMON_CTIME, "PVFS_ATTR_COMMON_CTIME" },

#define PVFS_ATTR_COMMON_MTIME (1 << 5)

#define PVFS_ATTR_BIT_COMMON_MTIME 5

  { PVFS_ATTR_BIT_COMMON_MTIME, "PVFS_ATTR_COMMON_MTIME" },

#define PVFS_ATTR_COMMON_TYPE  (1 << 6)

#define PVFS_ATTR_BIT_COMMON_TYPE 6

  { PVFS_ATTR_BIT_COMMON_TYPE, "PVFS_ATTR_COMMON_TYPE" },

#if 0

#define PVFS_ATTR_COMMON_ALL                       \

  (PVFS_ATTR_COMMON_UID   | PVFS_ATTR_COMMON_GID   | \

    PVFS_ATTR_COMMON_PERM  | PVFS_ATTR_COMMON_ATIME | \

    PVFS_ATTR_COMMON_CTIME | PVFS_ATTR_COMMON_MTIME | \

    PVFS_ATTR_COMMON_TYPE)

#endif

/* internal attribute masks for metadata objects */

#define PVFS_ATTR_META_DIST    (1 << 10)

#define PVFS_ATTR_BIT_META_DIST 10

  { PVFS_ATTR_BIT_META_DIST, "PVFS_ATTR_META_DIST" },

#define PVFS_ATTR_META_DFILES  (1 << 11)

#define PVFS_ATTR_BIT_META_DFILES 11

  { PVFS_ATTR_BIT_META_DFILES, "PVFS_ATTR_META_DFILES" },

#if 0

#define PVFS_ATTR_META_ALL \

  (PVFS_ATTR_META_DIST | PVFS_ATTR_META_DFILES)

#endif

/* internal attribute masks for datafile objects */

#define PVFS_ATTR_DATA_SIZE            (1 << 15)

#define PVFS_ATTR_BIT_DATA_SIZE 15

  { PVFS_ATTR_BIT_DATA_SIZE, "PVFS_ATTR_DATA_SIZE" },

#if 0

#define PVFS_ATTR_DATA_ALL   PVFS_ATTR_DATA_SIZE

#endif

/* internal attribute masks for symlink objects */

#define PVFS_ATTR_SYMLNK_TARGET            (1 << 18)

#define PVFS_ATTR_BIT_SYMLINK_TARGET 18

  { PVFS_ATTR_BIT_SYMLINK_TARGET, "PVFS_ATTR_SYMLNK_TARGET" },

#if 0

#define PVFS_ATTR_SYMLNK_ALL PVFS_ATTR_SYMLNK_TARGET

#endif

/* internal attribute masks for directory objects */

#define PVFS_ATTR_DIR_DIRENT_COUNT         (1 << 19)

#define PVFS_ATTR_BIT_DIR_DIRENT_COUNT 19

  { PVFS_ATTR_BIT_DIR_DIRENT_COUNT, "PVFS_ATTR_DIR_DIRENT_COUNT" },

#if 0

#define PVFS_ATTR_DIR_ALL PVFS_ATTR_DIR_DIRENT_COUNT

#endif

/* attribute masks used by system interface callers */

#define PVFS_ATTR_SYS_SIZE                  (1 << 20)

#define PVFS_ATTR_BIT_SYS_SIZE 20

  { PVFS_ATTR_BIT_SYS_SIZE, "PVFS_ATTR_SYS_SIZE" },

#define PVFS_ATTR_SYS_LNK_TARGET            (1 << 24)

#define PVFS_ATTR_BIT_SYS_LNK_TARGET 24

  { PVFS_ATTR_BIT_SYS_LNK_TARGET, "PVFS_ATTR_SYS_LNK_TARGET" },

#define PVFS_ATTR_SYS_DFILE_COUNT           (1 << 25)

#define PVFS_ATTR_BIT_SYS_DFILE_COUNT 25

  { PVFS_ATTR_BIT_SYS_DFILE_COUNT, "PVFS_ATTR_SYS_DFILE_COUNT" },

#define PVFS_ATTR_SYS_DIRENT_COUNT          (1 << 26)

#define PVFS_ATTR_BIT_SYS_DIRENT_COUNT 26

  { PVFS_ATTR_BIT_SYS_DIRENT_COUNT, "PVFS_ATTR_SYS_DIRENT_COUNT" },

#if 0

#define PVFS_ATTR_SYS_UID        PVFS_ATTR_COMMON_UID

#define PVFS_ATTR_SYS_GID        PVFS_ATTR_COMMON_GID

#define PVFS_ATTR_SYS_PERM       PVFS_ATTR_COMMON_PERM

#define PVFS_ATTR_SYS_ATIME      PVFS_ATTR_COMMON_ATIME

#define PVFS_ATTR_SYS_CTIME      PVFS_ATTR_COMMON_CTIME

#define PVFS_ATTR_SYS_MTIME      PVFS_ATTR_COMMON_MTIME

#define PVFS_ATTR_SYS_TYPE       PVFS_ATTR_COMMON_TYPE

#endif

  { 0, NULL }

};

#if 0

#define PVFS_ATTR_SYS_ALL                    \

  (PVFS_ATTR_COMMON_ALL | PVFS_ATTR_SYS_SIZE | \

    PVFS_ATTR_SYS_LNK_TARGET | PVFS_ATTR_SYS_DFILE_COUNT | \

    PVFS_ATTR_SYS_DIRENT_COUNT)

#define PVFS_ATTR_SYS_ALL_NOSIZE                   \

  (PVFS_ATTR_COMMON_ALL | PVFS_ATTR_SYS_LNK_TARGET | \

    PVFS_ATTR_SYS_DFILE_COUNT | PVFS_ATTR_SYS_DIRENT_COUNT)

#define PVFS_ATTR_SYS_ALL_SETABLE \

  (PVFS_ATTR_COMMON_ALL-PVFS_ATTR_COMMON_TYPE)

#endif

static unsigned

dissect_pvfs2_attrmask(tvbuff_t *tvb, proto_tree *tree, unsigned offset,

    uint32_t *pattrmask)

{

  uint32_t attrmask, i;

  proto_item *attritem;

  proto_tree *attrtree;

  attrmask = tvb_get_letohl(tvb, offset);

  attritem = proto_tree_add_uint(tree, hf_pvfs_attrmask, tvb, offset, 4, attrmask);

  attrtree = proto_item_add_subtree(attritem, ett_pvfs_attrmask);

  for (i = 0; i < 32; i++)

  {

    if (attrmask & (1u << i))

      proto_tree_add_uint(attrtree, hf_pvfs_attr, tvb, offset, 4, i);

  }

  offset += 4;

  if (pattrmask)

    *pattrmask = attrmask;

  return offset;

}

static const value_string names_pvfs_ds_type[] = {

#define PVFS_TYPE_NONE 0

  { PVFS_TYPE_NONE, "PVFS_TYPE_NONE" },

#define PVFS_TYPE_METAFILE (1 << 0)

  { PVFS_TYPE_METAFILE, "PVFS_TYPE_METAFILE" },

#define PVFS_TYPE_DATAFILE (1 << 1)

  { PVFS_TYPE_DATAFILE, "PVFS_TYPE_DATAFILE" },

#define PVFS_TYPE_DIRECTORY (1 << 2)

  { PVFS_TYPE_DIRECTORY, "PVFS_TYPE_DIRECTORY" },

#define PVFS_TYPE_SYMLINK (1 << 3)

  { PVFS_TYPE_SYMLINK, "PVFS_TYPE_SYMLINK" },

#define PVFS_TYPE_DIRDATA (1 << 4)

  { PVFS_TYPE_DIRDATA, "PVFS_TYPE_DIRDATA" },

  { 0, NULL }

};

static unsigned

dissect_pvfs2_ds_type(tvbuff_t *tvb, proto_tree *tree, unsigned offset,

    int *pds_type)

{

  uint32_t ds_type;

  ds_type = tvb_get_letohl(tvb, offset);

  proto_tree_add_uint(tree, hf_pvfs_ds_type, tvb, offset, 4, ds_type);

  offset += 4;

  if (pds_type)

    *pds_type = ds_type;

  return offset;

}

static unsigned

dissect_pvfs_opaque_data(tvbuff_t *tvb, unsigned offset,

  proto_tree *tree,

  packet_info *pinfo,

  int hfindex,

  bool fixed_length, uint32_t length,

  bool string_data, const char **string_buffer_ret)

{

  int data_offset;

  proto_item *string_item = NULL;

  proto_tree *string_tree = NULL;

  uint32_t string_length;

  uint32_t string_length_full;

  uint32_t string_length_packet;

  uint32_t string_length_captured;

  uint32_t string_length_copy;

  int fill_truncated;

  uint32_t fill_length;

  uint32_t fill_length_packet;

  uint32_t fill_length_captured;

  uint32_t fill_length_copy;

  int exception = 0;

  char *string_buffer = NULL;

  const char *string_buffer_print = NULL;

  if (fixed_length) {

    string_length = length;

    data_offset = offset;

  } else {

    string_length = tvb_get_letohl(tvb,offset+0);

    data_offset = offset + 4;

    /*

     * Variable-length strings include NULL terminator on-the-wire but

     * NULL terminator is not included in string length.

     */

    if (string_data)

      string_length += 1;

  }

  string_length_captured = tvb_captured_length_remaining(tvb, data_offset);

  string_length_packet = tvb_reported_length_remaining(tvb, data_offset);

  /*

   * Strangeness...  the protocol basically says that the length plus

   * the string must be padded out to an 8-byte boundary.

   */

  if (!string_data)

    string_length_full = WS_ROUNDUP_4(string_length);

  else

    string_length_full = WS_ROUNDUP_8(4 + string_length);

  if (string_length_captured < string_length) {

    /* truncated string */

    string_length_copy = string_length_captured;

    fill_truncated = 2;

    fill_length = 0;

    fill_length_copy = 0;

    if (string_length_packet < string_length)

      exception = ReportedBoundsError;

    else

      exception = BoundsError;

  }

  else {

    /* full string data */

    string_length_copy = string_length;

    if (!string_data)

      fill_length = string_length_full - string_length;

    else

      fill_length = string_length_full - string_length - 4;

    fill_length_captured = tvb_captured_length_remaining(tvb,

        data_offset + string_length);

    fill_length_packet = tvb_reported_length_remaining(tvb,

        data_offset + string_length);

    if (fill_length_captured < fill_length) {

      /* truncated fill bytes */

      fill_length_copy = fill_length_packet;

      fill_truncated = 1;

      if (fill_length_packet < fill_length)

        exception = ReportedBoundsError;

      else

        exception = BoundsError;

    }

    else {

      /* full fill bytes */

      fill_length_copy = fill_length;

      fill_truncated = 0;

    }

  }

  if (string_data) {

    string_buffer = (char*)tvb_get_string_enc(pinfo->pool, tvb, data_offset, string_length_copy, ENC_ASCII);

  } else {

    string_buffer = (char *) tvb_memcpy(tvb,

        wmem_alloc(pinfo->pool, string_length_copy+1), data_offset, string_length_copy);

    string_buffer[string_length_copy] = '\0';

  }

  /* calculate a nice printable string */

  if (string_length) {

    if (string_length != strlen(string_buffer)) {

      if (string_data) {

        char *formatted;

        size_t string_buffer_size = 0;

        char *string_buffer_temp;

        formatted = format_text(pinfo->pool, string_buffer,

            (int)strlen(string_buffer));

        string_buffer_size = strlen(formatted) + 12 + 1;

        /* alloc maximum data area */

        string_buffer_temp = (char*) wmem_alloc(pinfo->pool, string_buffer_size);

        /* copy over the data */

        snprintf(string_buffer_temp, string_buffer_size,

            "%s<TRUNCATED>", formatted);

        /* append <TRUNCATED> */

        /* This way, we get the TRUNCATED even

           in the case of totally wrong packets,

           where \0 are inside the string.

           TRUNCATED will appear at the

           first \0 or at the end (where we

           put the securing \0).

        */

        string_buffer_print = string_buffer_temp;

      } else {

        string_buffer_print="<DATA><TRUNCATED>";

      }

    } else {

      if (string_data) {

        string_buffer_print = format_text(pinfo->pool, string_buffer,

                 (int)strlen(string_buffer));

      } else {

        string_buffer_print="<DATA>";

      }

    }

  } else {

    string_buffer_print="<EMPTY>";

  }

  string_item = proto_tree_add_string(tree, hfindex, tvb, offset+0, -1,

        string_buffer_print);

  string_tree = proto_item_add_subtree(string_item,

          ett_pvfs_string);

  if (!fixed_length) {

    proto_tree_add_uint_format_value(string_tree, hf_pvfs_opaque_length, tvb, offset, 4,

        string_length - 1, "%u (excl. NULL terminator)", string_length - 1);

    offset += 4;

  }

  if (string_data) {

    proto_tree_add_string_format(string_tree,

      hfindex, tvb, offset, string_length_copy,

      string_buffer,

      "contents: %s", string_buffer_print);

  } else {

    proto_tree_add_bytes_format(string_tree,

      hfindex, tvb, offset, string_length_copy,

      (uint8_t *) string_buffer,

      "contents: %s", string_buffer_print);

  }

  offset += string_length_copy;

  if (fill_length) {

    if (string_tree) {

      if (fill_truncated) {

        proto_tree_add_bytes_format_value(string_tree, hf_pvfs_fill_bytes, tvb,

        offset, fill_length_copy, NULL,

        "opaque data <TRUNCATED>");

      }

      else {

        proto_tree_add_bytes_format_value(string_tree, hf_pvfs_fill_bytes, tvb,

        offset, fill_length_copy, NULL,

        "opaque data");

      }

    }

    offset += fill_length_copy;

  }

  if (string_item)

    proto_item_set_end(string_item, tvb, offset);

  if (string_buffer_ret != NULL)

    *string_buffer_ret = string_buffer_print;

  /*

   * If the data was truncated, throw the appropriate exception,

   * so that dissection stops and the frame is properly marked.

   */

  if (exception != 0)

    THROW(exception);

  return offset;

}

static unsigned

dissect_pvfs_string(tvbuff_t *tvb, proto_tree *tree, int hfindex,

    unsigned offset, packet_info *pinfo, const char **string_buffer_ret)

{

  return dissect_pvfs_opaque_data(tvb, offset, tree, pinfo, hfindex,

      false, 0, true, string_buffer_ret);

}

static void

dissect_fhandle_data_unknown(tvbuff_t *tvb, unsigned offset, proto_tree *tree)

{

  unsigned bytes_left  = PVFS2_FH_LENGTH;

  proto_tree_add_item(tree, hf_fhandle_data, tvb, offset, bytes_left, ENC_NA);

}

static void

dissect_fhandle_data(tvbuff_t *tvb, unsigned offset, packet_info *pinfo _U_,

         proto_tree *tree, uint32_t *hash)

{

  uint32_t fhhash;

  uint32_t i;

  /* Not all bytes there. Any attempt to deduce the type would be

    senseless. */

  if (!tvb_bytes_exist(tvb, offset, PVFS2_FH_LENGTH))

    goto type_ready;

  /* create a semiunique hash value for the filehandle */

  for(fhhash=0,i=0;i<(PVFS2_FH_LENGTH-3);i+=4){

    uint32_t val;

    val = tvb_get_ntohl(tvb, offset+i);

    fhhash ^= val;

    fhhash += val;

  }

  proto_tree_add_uint(tree, hf_pvfs_fh_hash, tvb, offset, PVFS2_FH_LENGTH,

      fhhash);

  if (hash)

    *hash = fhhash;