diff options
author | Jörg Mayer <jmayer@loplof.de> | 2005-08-29 00:02:50 +0000 |
---|---|---|
committer | Jörg Mayer <jmayer@loplof.de> | 2005-08-29 00:02:50 +0000 |
commit | 0de532170de23f487fc0b13e9e07ef54ebc67dce (patch) | |
tree | 8e172f7dcfd184bfc5f8731564078478f12e1263 /epan/dissectors/packet-afs.c | |
parent | 95d06eb4e18e34a682c2b7fd5dc6f50a1374067c (diff) |
Merge packet-afs-register-info.h, packet-afs-defs.h and packet-afs-macros.h
into packet-afs.c
svn path=/trunk/; revision=15605
Diffstat (limited to 'epan/dissectors/packet-afs.c')
-rw-r--r-- | epan/dissectors/packet-afs.c | 1800 |
1 files changed, 1797 insertions, 3 deletions
diff --git a/epan/dissectors/packet-afs.c b/epan/dissectors/packet-afs.c index 7d62b45ab8..7396f68182 100644 --- a/epan/dissectors/packet-afs.c +++ b/epan/dissectors/packet-afs.c @@ -46,8 +46,784 @@ #include "packet-rx.h" #include "packet-afs.h" -#include "packet-afs-defs.h" -#include "packet-afs-macros.h" + +static int proto_afs = -1; +static int hf_afs_fs = -1; +static int hf_afs_cb = -1; +static int hf_afs_prot = -1; +static int hf_afs_vldb = -1; +static int hf_afs_kauth = -1; +static int hf_afs_vol = -1; +static int hf_afs_error = -1; +static int hf_afs_bos = -1; +static int hf_afs_update = -1; +static int hf_afs_rmtsys = -1; +static int hf_afs_ubik = -1; +static int hf_afs_backup = -1; + +static int hf_afs_fs_opcode = -1; +static int hf_afs_cb_opcode = -1; +static int hf_afs_prot_opcode = -1; +static int hf_afs_vldb_opcode = -1; +static int hf_afs_kauth_opcode = -1; +static int hf_afs_vol_opcode = -1; +static int hf_afs_error_opcode = -1; +static int hf_afs_bos_opcode = -1; +static int hf_afs_update_opcode = -1; +static int hf_afs_rmtsys_opcode = -1; +static int hf_afs_ubik_opcode = -1; +static int hf_afs_backup_opcode = -1; + +static int hf_afs_fs_fid_volume = -1; +static int hf_afs_fs_fid_vnode = -1; +static int hf_afs_fs_fid_uniqifier = -1; +static int hf_afs_fs_offset = -1; +static int hf_afs_fs_length = -1; +static int hf_afs_fs_flength = -1; +static int hf_afs_fs_offset64 = -1; +static int hf_afs_fs_length64 = -1; +static int hf_afs_fs_flength64 = -1; +static int hf_afs_fs_errcode = -1; +static int hf_afs_fs_data = -1; +static int hf_afs_fs_name = -1; +static int hf_afs_fs_oldname = -1; +static int hf_afs_fs_newname = -1; +static int hf_afs_fs_symlink_name = -1; +static int hf_afs_fs_symlink_content = -1; +static int hf_afs_fs_volid = -1; +static int hf_afs_fs_volname = -1; +static int hf_afs_fs_timestamp = -1; +static int hf_afs_fs_offlinemsg = -1; +static int hf_afs_fs_motd = -1; +static int hf_afs_fs_xstats_version = -1; +static int hf_afs_fs_xstats_timestamp = -1; +static int hf_afs_fs_xstats_clientversion = -1; +static int hf_afs_fs_xstats_collnumber = -1; +static int hf_afs_fs_cps_spare1 = -1; +static int hf_afs_fs_cps_spare2 = -1; +static int hf_afs_fs_cps_spare3 = -1; +static int hf_afs_fs_vicelocktype = -1; +static int hf_afs_fs_viceid = -1; +static int hf_afs_fs_ipaddr = -1; +static int hf_afs_fs_token = -1; + +static int hf_afs_fs_status_anonymousaccess = -1; +static int hf_afs_fs_status_author = -1; +static int hf_afs_fs_status_calleraccess = -1; +static int hf_afs_fs_status_clientmodtime = -1; +static int hf_afs_fs_status_dataversion = -1; +static int hf_afs_fs_status_dataversionhigh = -1; +static int hf_afs_fs_status_filetype = -1; +static int hf_afs_fs_status_group = -1; +static int hf_afs_fs_status_interfaceversion = -1; +static int hf_afs_fs_status_length = -1; +static int hf_afs_fs_status_linkcount = -1; +static int hf_afs_fs_status_mask = -1; +static int hf_afs_fs_status_mask_fsync = -1; +static int hf_afs_fs_status_mask_setgroup = -1; +static int hf_afs_fs_status_mask_setmode = -1; +static int hf_afs_fs_status_mask_setmodtime = -1; +static int hf_afs_fs_status_mask_setowner = -1; +static int hf_afs_fs_status_mask_setsegsize = -1; +static int hf_afs_fs_status_mode = -1; +static int hf_afs_fs_status_owner = -1; +static int hf_afs_fs_status_parentunique = -1; +static int hf_afs_fs_status_parentvnode = -1; +static int hf_afs_fs_status_segsize = -1; +static int hf_afs_fs_status_servermodtime = -1; +static int hf_afs_fs_status_spare2 = -1; +static int hf_afs_fs_status_spare3 = -1; +static int hf_afs_fs_status_spare4 = -1; +static int hf_afs_fs_status_synccounter = -1; + +static int hf_afs_fs_volsync_spare1 = -1; +static int hf_afs_fs_volsync_spare2 = -1; +static int hf_afs_fs_volsync_spare3 = -1; +static int hf_afs_fs_volsync_spare4 = -1; +static int hf_afs_fs_volsync_spare5 = -1; +static int hf_afs_fs_volsync_spare6 = -1; + +static int hf_afs_fs_acl_datasize = -1; +static int hf_afs_fs_acl_count_negative = -1; +static int hf_afs_fs_acl_count_positive = -1; +static int hf_afs_fs_acl_entity = -1; +static int hf_afs_fs_acl_r = -1; +static int hf_afs_fs_acl_l = -1; +static int hf_afs_fs_acl_i = -1; +static int hf_afs_fs_acl_d = -1; +static int hf_afs_fs_acl_w = -1; +static int hf_afs_fs_acl_k = -1; +static int hf_afs_fs_acl_a = -1; + +static int hf_afs_fs_callback_version = -1; +static int hf_afs_fs_callback_expires = -1; +static int hf_afs_fs_callback_type = -1; + +static int hf_afs_bos_errcode = -1; +static int hf_afs_bos_type = -1; +static int hf_afs_bos_instance = -1; +static int hf_afs_bos_status = -1; +static int hf_afs_bos_statusdesc = -1; +static int hf_afs_bos_num = -1; +static int hf_afs_bos_size = -1; +static int hf_afs_bos_flags = -1; +static int hf_afs_bos_date = -1; +static int hf_afs_bos_content = -1; +static int hf_afs_bos_user = -1; +static int hf_afs_bos_key = -1; +static int hf_afs_bos_path = -1; +static int hf_afs_bos_file = -1; +static int hf_afs_bos_cmd = -1; +static int hf_afs_bos_error = -1; +static int hf_afs_bos_spare1 = -1; +static int hf_afs_bos_spare2 = -1; +static int hf_afs_bos_spare3 = -1; +static int hf_afs_bos_parm = -1; +static int hf_afs_bos_kvno = -1; +static int hf_afs_bos_cell = -1; +static int hf_afs_bos_host = -1; +static int hf_afs_bos_newtime = -1; +static int hf_afs_bos_baktime = -1; +static int hf_afs_bos_oldtime = -1; +static int hf_afs_bos_data = -1; +static int hf_afs_bos_keymodtime = -1; +static int hf_afs_bos_keychecksum = -1; +static int hf_afs_bos_keyspare2 = -1; + +static int hf_afs_vldb_errcode = -1; +static int hf_afs_vldb_name = -1; +static int hf_afs_vldb_id = -1; +static int hf_afs_vldb_type = -1; +static int hf_afs_vldb_bump = -1; +static int hf_afs_vldb_index = -1; +static int hf_afs_vldb_nextindex = -1; +static int hf_afs_vldb_count = -1; +static int hf_afs_vldb_numservers = -1; +static int hf_afs_vldb_server = -1; +static int hf_afs_vldb_serveruuid = -1; +static int hf_afs_vldb_serveruniq = -1; +static int hf_afs_vldb_serverflags = -1; +static int hf_afs_vldb_serverip = -1; +static int hf_afs_vldb_partition = -1; +static int hf_afs_vldb_rovol = -1; +static int hf_afs_vldb_rwvol = -1; +static int hf_afs_vldb_bkvol = -1; +static int hf_afs_vldb_clonevol = -1; +static int hf_afs_vldb_flags = -1; +static int hf_afs_vldb_flags_rwexists = -1; +static int hf_afs_vldb_flags_roexists = -1; +static int hf_afs_vldb_flags_bkexists = -1; +static int hf_afs_vldb_flags_dfsfileset = -1; + +static int hf_afs_vldb_spare1 = -1; +static int hf_afs_vldb_spare2 = -1; +static int hf_afs_vldb_spare3 = -1; +static int hf_afs_vldb_spare4 = -1; +static int hf_afs_vldb_spare5 = -1; +static int hf_afs_vldb_spare6 = -1; +static int hf_afs_vldb_spare7 = -1; +static int hf_afs_vldb_spare8 = -1; +static int hf_afs_vldb_spare9 = -1; + +static int hf_afs_kauth_errcode = -1; +static int hf_afs_kauth_princ = -1; +static int hf_afs_kauth_realm = -1; +static int hf_afs_kauth_domain = -1; +static int hf_afs_kauth_kvno = -1; +static int hf_afs_kauth_name = -1; +static int hf_afs_kauth_data = -1; + +static int hf_afs_vol_errcode = -1; +static int hf_afs_vol_count = -1; +static int hf_afs_vol_id = -1; +static int hf_afs_vol_name = -1; + +static int hf_afs_cb_errcode = -1; +static int hf_afs_cb_callback_version = -1; +static int hf_afs_cb_callback_type = -1; +static int hf_afs_cb_callback_expires = -1; +static int hf_afs_cb_fid_volume = -1; +static int hf_afs_cb_fid_vnode = -1; +static int hf_afs_cb_fid_uniqifier = -1; + +static int hf_afs_prot_errcode = -1; +static int hf_afs_prot_name = -1; +static int hf_afs_prot_id = -1; +static int hf_afs_prot_count = -1; +static int hf_afs_prot_oldid = -1; +static int hf_afs_prot_newid = -1; +static int hf_afs_prot_pos = -1; +static int hf_afs_prot_flag = -1; +static int hf_afs_prot_uid = -1; +static int hf_afs_prot_gid = -1; +static int hf_afs_prot_maxuid = -1; +static int hf_afs_prot_maxgid = -1; + +static int hf_afs_backup_errcode = -1; + +static int hf_afs_ubik_errcode = -1; +static int hf_afs_ubik_version_epoch = -1; +static int hf_afs_ubik_version_counter = -1; +static int hf_afs_ubik_votestart = -1; +static int hf_afs_ubik_state = -1; +static int hf_afs_ubik_site = -1; +static int hf_afs_ubik_interface = -1; +static int hf_afs_ubik_file = -1; +static int hf_afs_ubik_pos = -1; +static int hf_afs_ubik_length = -1; +static int hf_afs_ubik_locktype = -1; +static int hf_afs_ubik_voteend = -1; +static int hf_afs_ubik_votetype = -1; + +static int hf_afs_ubik_now = -1; +static int hf_afs_ubik_lastyestime = -1; +static int hf_afs_ubik_lastyeshost = -1; +static int hf_afs_ubik_lastyesstate = -1; +static int hf_afs_ubik_lastyesclaim = -1; +static int hf_afs_ubik_lowesthost = -1; +static int hf_afs_ubik_lowesttime = -1; +static int hf_afs_ubik_synchost = -1; +static int hf_afs_ubik_synctime = -1; +static int hf_afs_ubik_amsyncsite = -1; +static int hf_afs_ubik_syncsiteuntil = -1; +static int hf_afs_ubik_nservers = -1; +static int hf_afs_ubik_lockedpages = -1; +static int hf_afs_ubik_writelockedpages = -1; +static int hf_afs_ubik_activewrite = -1; +static int hf_afs_ubik_tidcounter = -1; +static int hf_afs_ubik_anyreadlocks = -1; +static int hf_afs_ubik_anywritelocks = -1; +static int hf_afs_ubik_recoverystate = -1; +static int hf_afs_ubik_currenttrans = -1; +static int hf_afs_ubik_writetrans = -1; +static int hf_afs_ubik_epochtime = -1; +static int hf_afs_ubik_isclone = -1; +static int hf_afs_ubik_addr = -1; +static int hf_afs_ubik_lastvotetime = -1; +static int hf_afs_ubik_lastbeaconsent = -1; +static int hf_afs_ubik_lastvote = -1; +static int hf_afs_ubik_currentdb = -1; +static int hf_afs_ubik_beaconsincedown = -1; +static int hf_afs_ubik_up = -1; +static int hf_afs_repframe = -1; +static int hf_afs_reqframe = -1; +static int hf_afs_time = -1; + +static gint ett_afs = -1; +static gint ett_afs_op = -1; +static gint ett_afs_acl = -1; +static gint ett_afs_fid = -1; +static gint ett_afs_callback = -1; +static gint ett_afs_ubikver = -1; +static gint ett_afs_status = -1; +static gint ett_afs_status_mask = -1; +static gint ett_afs_volsync = -1; +static gint ett_afs_volumeinfo = -1; +static gint ett_afs_vicestat = -1; +static gint ett_afs_vldb_flags = -1; + +/* + * Macros for helper dissection routines + * + * The macros are here to save on coding. They assume that + * the current offset is in 'offset', and that the offset + * should be incremented after performing the macro's operation. + */ + + +/* Output a unsigned integer, stored into field 'field' + Assumes it is in network byte order, converts to host before using */ +#define OUT_UINT(field) \ + proto_tree_add_uint(tree, field, tvb, offset, sizeof(guint32), tvb_get_ntohl(tvb, offset)); \ + offset += 4; + +/* Output a unsigned integer, stored into field 'field' + Assumes it is in network byte order, converts to host before using */ +#define OUT_INT(field) \ + proto_tree_add_int(tree, field, tvb, offset, sizeof(gint32), tvb_get_ntohl(tvb, offset)); \ + offset += 4; + +/* Output a unsigned integer, stored into field 'field' + Assumes it is in network byte order, converts to host before using */ +#define OUT_UINT64(field) \ + proto_tree_add_item(tree, field, tvb, offset, 8, FALSE); \ + offset += 8; + +/* Output a unsigned integer, stored into field 'field' + Assumes it is in network byte order, converts to host before using */ +#define OUT_INT64(field) \ + proto_tree_add_item(tree, field, tvb, offset, 8, FALSE); \ + offset += 8; + +/* Output a unsigned integer, stored into field 'field' + Assumes it is in network byte order, converts to host before using, + Note - does not increment offset, so can be used repeatedly for bitfields */ +#define DISP_UINT(field) \ + proto_tree_add_uint(tree,field,tvb,offset,sizeof(guint32),tvb_get_ntohl(tvb, offset)); + +/* Output an IPv4 address, stored into field 'field' */ +#define OUT_IP(field) \ + proto_tree_add_ipv4(tree,field,tvb,offset,sizeof(gint32),\ + tvb_get_letohl(tvb, offset));\ + offset += 4; + +/* Output a simple rx array */ +#define OUT_RXArray8(func) \ + { \ + unsigned int j,i; \ + j = tvb_get_guint8(tvb, offset); \ + offset += 1; \ + for (i=0; i<j; i++) { \ + func; \ + } \ + } + +/* Output a simple rx array */ +#define OUT_RXArray32(func) \ + { \ + unsigned int j,i; \ + j = tvb_get_ntohl(tvb, offset); \ + offset += sizeof(guint32); \ + for (i=0; i<j; i++) { \ + func; \ + } \ + } + +/* Output a UNIX seconds/microseconds timestamp, after converting to an + nstime_t */ +#define OUT_TIMESTAMP(field) \ + { nstime_t ts; \ + ts.secs = tvb_get_ntohl(tvb, offset); \ + ts.nsecs = tvb_get_ntohl(tvb, offset)*1000; \ + proto_tree_add_time(tree,field, tvb,offset,2*sizeof(guint32),&ts); \ + offset += 8; \ + } + +/* Output a seconds-only time value, after converting to an nstime_t; + this can be an absolute time as a UNIX time-since-epoch, or a + relative time in seconds */ +#define OUT_TIMESECS(field) \ + { nstime_t ts; \ + ts.secs = tvb_get_ntohl(tvb, offset); \ + ts.nsecs = 0; \ + proto_tree_add_time(tree,field, tvb,offset,sizeof(guint32),&ts); \ + offset += 4; \ + } + +/* Output a rx style string, up to a maximum length first + 4 bytes - length, then char data */ +#define OUT_RXString(field) \ + { guint32 i,len; \ + char *tmp; \ + const guint8 *p; \ + i = tvb_get_ntohl(tvb, offset); \ + offset += 4; \ + p = tvb_get_ptr(tvb,offset,i); \ + len = ((i+4-1)/4)*4; \ + tmp = g_malloc(i+1); \ + memcpy(tmp, p, i); \ + tmp[i] = '\0'; \ + proto_tree_add_string(tree, field, tvb, offset-4, len+4, \ + (void *)tmp); \ + g_free(tmp); \ + offset += len; \ + } + +/* Output a fixed length vectorized string (each char is a 32 bit int) */ +#define OUT_RXStringV(field, length) \ + { char tmp[length+1]; \ + int i,soff; \ + soff = offset;\ + for (i=0; i<length; i++)\ + {\ + tmp[i] = (char) tvb_get_ntohl(tvb, offset);\ + offset += sizeof(guint32);\ + }\ + tmp[length] = '\0';\ + proto_tree_add_string(tree, field, tvb, soff, length*sizeof(guint32), tmp);\ + } + + +/* Output a callback */ +#define OUT_FS_AFSCallBack() \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_callback); \ + OUT_UINT(hf_afs_fs_callback_version); \ + OUT_TIMESECS(hf_afs_fs_callback_expires); \ + OUT_UINT(hf_afs_fs_callback_type); \ + tree = save; \ + } + +/* Output a callback */ +#define OUT_CB_AFSCallBack() \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_callback); \ + OUT_UINT(hf_afs_cb_callback_version); \ + OUT_TIMESECS(hf_afs_cb_callback_expires); \ + OUT_UINT(hf_afs_cb_callback_type); \ + tree = save; \ + } + +/* Output a File ID */ +#define OUT_FS_AFSFid(label) \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 3*4, \ + "FileID (%s)", label); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_fid); \ + OUT_UINT(hf_afs_fs_fid_volume); \ + OUT_UINT(hf_afs_fs_fid_vnode); \ + OUT_UINT(hf_afs_fs_fid_uniqifier); \ + tree = save; \ + } + +/* Output a Status mask */ +#define OUT_FS_STATUSMASK() \ + { proto_tree *save, *ti; \ + guint32 mask; \ + mask = tvb_get_ntohl(tvb, offset); \ + ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, tvb, offset, \ + sizeof(guint32), mask); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_status_mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setmodtime, \ + tvb,offset,sizeof(guint32), mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setowner, \ + tvb,offset,sizeof(guint32), mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setgroup, \ + tvb,offset,sizeof(guint32), mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setmode, \ + tvb,offset,sizeof(guint32), mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setsegsize, \ + tvb,offset,sizeof(guint32), mask); \ + proto_tree_add_boolean(tree, hf_afs_fs_status_mask_fsync, \ + tvb,offset,sizeof(guint32), mask); \ + offset += 4; \ + tree = save; \ + } + +/* Output vldb flags */ +#define OUT_VLDB_Flags() \ + { proto_tree *save, *ti; \ + guint32 flags; \ + flags = tvb_get_ntohl(tvb, offset); \ + ti = proto_tree_add_uint(tree, hf_afs_vldb_flags, tvb, offset, \ + sizeof(guint32), flags); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_vldb_flags); \ + proto_tree_add_boolean(tree, hf_afs_vldb_flags_rwexists, \ + tvb,offset,sizeof(guint32), flags); \ + proto_tree_add_boolean(tree, hf_afs_vldb_flags_roexists, \ + tvb,offset,sizeof(guint32), flags); \ + proto_tree_add_boolean(tree, hf_afs_vldb_flags_bkexists, \ + tvb,offset,sizeof(guint32), flags); \ + proto_tree_add_boolean(tree, hf_afs_vldb_flags_dfsfileset, \ + tvb,offset,sizeof(guint32), flags); \ + offset += 4; \ + tree = save; \ + } + + + +/* Output a File ID */ +#define OUT_CB_AFSFid(label) \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 3*4, \ + "FileID (%s)", label); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_fid); \ + OUT_UINT(hf_afs_cb_fid_volume); \ + OUT_UINT(hf_afs_cb_fid_vnode); \ + OUT_UINT(hf_afs_cb_fid_uniqifier); \ + tree = save; \ + } + +/* Output a StoreStatus */ +#define OUT_FS_AFSStoreStatus(label) \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 6*4, \ + label); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_status); \ + OUT_FS_STATUSMASK(); \ + OUT_TIMESECS(hf_afs_fs_status_clientmodtime); \ + OUT_UINT(hf_afs_fs_status_owner); \ + OUT_UINT(hf_afs_fs_status_group); \ + OUT_UINT(hf_afs_fs_status_mode); \ + OUT_UINT(hf_afs_fs_status_segsize); \ + tree = save; \ + } + +/* Output a FetchStatus */ +#define OUT_FS_AFSFetchStatus(label) \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 21*4, \ + label); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_status); \ + OUT_UINT(hf_afs_fs_status_interfaceversion); \ + OUT_UINT(hf_afs_fs_status_filetype); \ + OUT_UINT(hf_afs_fs_status_linkcount); \ + OUT_UINT(hf_afs_fs_status_length); \ + OUT_UINT(hf_afs_fs_status_dataversion); \ + OUT_UINT(hf_afs_fs_status_author); \ + OUT_UINT(hf_afs_fs_status_owner); \ + OUT_UINT(hf_afs_fs_status_calleraccess); \ + OUT_UINT(hf_afs_fs_status_anonymousaccess); \ + OUT_UINT(hf_afs_fs_status_mode); \ + OUT_UINT(hf_afs_fs_status_parentvnode); \ + OUT_UINT(hf_afs_fs_status_parentunique); \ + OUT_UINT(hf_afs_fs_status_segsize); \ + OUT_TIMESECS(hf_afs_fs_status_clientmodtime); \ + OUT_TIMESECS(hf_afs_fs_status_servermodtime); \ + OUT_UINT(hf_afs_fs_status_group); \ + OUT_UINT(hf_afs_fs_status_synccounter); \ + OUT_UINT(hf_afs_fs_status_dataversionhigh); \ + OUT_UINT(hf_afs_fs_status_spare2); \ + OUT_UINT(hf_afs_fs_status_spare3); \ + OUT_UINT(hf_afs_fs_status_spare4); \ + tree = save; \ + } + +/* Output a VolSync */ +#define OUT_FS_AFSVolSync() \ + { proto_tree *save, *ti; \ + ti = proto_tree_add_text(tree, tvb, offset, 6*4, \ + "VolSync"); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_volsync); \ + OUT_TIMESECS(hf_afs_fs_volsync_spare1); \ + OUT_UINT(hf_afs_fs_volsync_spare2); \ + OUT_UINT(hf_afs_fs_volsync_spare3); \ + OUT_UINT(hf_afs_fs_volsync_spare4); \ + OUT_UINT(hf_afs_fs_volsync_spare5); \ + OUT_UINT(hf_afs_fs_volsync_spare6); \ + tree = save; \ + } + +/* Output a AFSCBFids */ +#define OUT_FS_AFSCBFids() \ + OUT_RXArray32(OUT_FS_AFSFid("Target")); + +/* Output a ViceIds */ +#define OUT_FS_ViceIds() \ + OUT_RXArray8(OUT_UINT(hf_afs_fs_viceid)); + +/* Output a IPAddrs */ +#define OUT_FS_IPAddrs() \ + OUT_RXArray8(OUT_IP(hf_afs_fs_ipaddr)); + +/* Output a AFSCBs */ +#define OUT_FS_AFSCBs() \ + OUT_RXArray32(OUT_FS_AFSCallBack()); + +/* Output a AFSBulkStats */ +#define OUT_FS_AFSBulkStats() \ + OUT_RXArray32(OUT_FS_AFSFetchStatus("Status")); + +/* Output a AFSFetchVolumeStatus */ +#define OUT_FS_AFSFetchVolumeStatus() + +/* Output a AFSStoreVolumeStatus */ +#define OUT_FS_AFSStoreVolumeStatus() + +/* Output a ViceStatistics structure */ +#define OUT_FS_ViceStatistics() + +/* Output a AFS_CollData structure */ +#define OUT_FS_AFS_CollData() + +/* Output a VolumeInfo structure */ +#define OUT_FS_VolumeInfo() + +/* Output an AFS Token - might just be bytes though */ +#define OUT_FS_AFSTOKEN() OUT_RXStringV(hf_afs_fs_token, 1024) + +/* Output a AFS acl */ +#define ACLOUT(who, positive, acl, bytes) \ + { proto_tree *save, *ti; \ + int tmpoffset; \ + int acllen; \ + char tmp[10]; \ + tmp[0] = 0; \ + if ( acl & PRSFS_READ ) strcat(tmp, "r"); \ + if ( acl & PRSFS_LOOKUP ) strcat(tmp, "l"); \ + if ( acl & PRSFS_INSERT ) strcat(tmp, "i"); \ + if ( acl & PRSFS_DELETE ) strcat(tmp, "d"); \ + if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \ + if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \ + if ( acl & PRSFS_ADMINISTER ) strcat(tmp, "a"); \ + ti = proto_tree_add_text(tree, tvb, offset, bytes, \ + "ACL: %s %s%s", \ + who, tmp, positive ? "" : " (negative)"); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_acl); \ + proto_tree_add_string(tree,hf_afs_fs_acl_entity, tvb,offset,strlen(who), who);\ + tmpoffset = offset + strlen(who) + 1; \ + acllen = bytes - strlen(who) - 1; \ + proto_tree_add_boolean(tree,hf_afs_fs_acl_r, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_l, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_i, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_d, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_w, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_k, tvb,tmpoffset,acllen,acl);\ + proto_tree_add_boolean(tree,hf_afs_fs_acl_a, tvb,tmpoffset,acllen,acl);\ + tree = save; \ + } + +/* Output a UUID */ +#define OUT_UUID(x) \ + OUT_BYTES(x, 11*sizeof(guint32)); +#define SKIP_UUID() \ + SKIP(11*sizeof(guint32)); + + +/* Output a bulkaddr */ +#define OUT_VLDB_BulkAddr() \ + OUT_RXArray32(OUT_IP(hf_afs_vldb_serverip)); + +/* output a bozo_key */ +#define OUT_BOS_KEY() \ + OUT_BYTES(hf_afs_bos_key, 8); + +/* output a bozo_key */ +#define OUT_BOS_KEYINFO() \ + OUT_TIMESTAMP(hf_afs_bos_keymodtime); \ + OUT_UINT(hf_afs_bos_keychecksum); \ + OUT_UINT(hf_afs_bos_keyspare2); + +/* output a bozo_netKTime */ +#define OUT_BOS_TIME() \ + SKIP(4); SKIP(2); SKIP(2); SKIP(2); SKIP(2); + +/* output a bozo_status */ +#define OUT_BOS_STATUS() \ + SKIP(10 * 4); + +/* output a ubik interface addr array */ +#define OUT_UBIK_InterfaceAddrs() \ + { \ + unsigned int i,j,seen_null=0; \ + for (i=0; i<255; i++) { \ + j = tvb_get_ntohl(tvb, offset); \ + if ( j != 0 ) { \ + OUT_IP(hf_afs_ubik_interface); \ + seen_null = 0; \ + } else { \ + if ( ! seen_null ) { \ + proto_tree_add_text(tree, tvb, offset, \ + tvb_length_remaining(tvb, offset), \ + "Null Interface Addresses"); \ + seen_null = 1; \ + } \ + offset += 4; \ + }\ + } \ + } + +#define OUT_UBIK_DebugOld() \ + { \ + OUT_TIMESECS(hf_afs_ubik_now); \ + OUT_TIMESECS(hf_afs_ubik_lastyestime); \ + OUT_IP(hf_afs_ubik_lastyeshost); \ + OUT_UINT(hf_afs_ubik_lastyesstate); \ + OUT_TIMESECS(hf_afs_ubik_lastyesclaim); \ + OUT_IP(hf_afs_ubik_lowesthost); \ + OUT_TIMESECS(hf_afs_ubik_lowesttime); \ + OUT_IP(hf_afs_ubik_synchost); \ + OUT_TIMESECS(hf_afs_ubik_synctime); \ + OUT_UBIKVERSION("Sync Version"); \ + OUT_UBIKVERSION("Sync TID"); \ + OUT_UINT(hf_afs_ubik_amsyncsite); \ + OUT_TIMESECS(hf_afs_ubik_syncsiteuntil); \ + OUT_UINT(hf_afs_ubik_nservers); \ + OUT_UINT(hf_afs_ubik_lockedpages); \ + OUT_UINT(hf_afs_ubik_writelockedpages); \ + OUT_UBIKVERSION("Local Version"); \ + OUT_UINT(hf_afs_ubik_activewrite); \ + OUT_UINT(hf_afs_ubik_tidcounter); \ + OUT_UINT(hf_afs_ubik_anyreadlocks); \ + OUT_UINT(hf_afs_ubik_anywritelocks); \ + OUT_UINT(hf_afs_ubik_recoverystate); \ + OUT_UINT(hf_afs_ubik_currenttrans); \ + OUT_UINT(hf_afs_ubik_writetrans); \ + OUT_TIMESECS(hf_afs_ubik_epochtime); \ + } + +#define OUT_UBIK_SDebugOld() \ + { \ + OUT_IP(hf_afs_ubik_addr); \ + OUT_TIMESECS(hf_afs_ubik_lastvotetime); \ + OUT_TIMESECS(hf_afs_ubik_lastbeaconsent); \ + OUT_UINT(hf_afs_ubik_lastvote); \ + OUT_UBIKVERSION("Remote Version"); \ + OUT_UINT(hf_afs_ubik_currentdb); \ + OUT_UINT(hf_afs_ubik_beaconsincedown); \ + OUT_UINT(hf_afs_ubik_up); \ + } + +/* Skip a certain number of bytes */ +#define SKIP(bytes) \ + offset += bytes; + +/* Raw data - to end of frame */ +#define OUT_BYTES_ALL(field) OUT_BYTES(field, tvb_length_remaining(tvb,offset)) + +/* Raw data */ +#define OUT_BYTES(field, bytes) \ + proto_tree_add_item(tree, field, tvb, offset, bytes, FALSE);\ + offset += bytes; + + + +/* Skip the opcode */ +#define SKIP_OPCODE() \ + { \ + SKIP(sizeof(guint32)); \ + } + +/* Output a UBIK version code */ +#define OUT_UBIKVERSION(label) \ + { proto_tree *save, *ti; \ + unsigned int epoch,counter; \ + nstime_t ts; \ + epoch = tvb_get_ntohl(tvb, offset); \ + offset += 4; \ + counter = tvb_get_ntohl(tvb, offset); \ + offset += 4; \ + ts.secs = epoch; \ + ts.nsecs = 0; \ + ti = proto_tree_add_text(tree, tvb, offset-8, 8, \ + "UBIK Version (%s): %u.%u", label, epoch, counter ); \ + save = tree; \ + tree = proto_item_add_subtree(ti, ett_afs_ubikver); \ + if ( epoch != 0 ) \ + proto_tree_add_time(tree,hf_afs_ubik_version_epoch, tvb,offset-8, \ + sizeof(guint32),&ts); \ + else \ + proto_tree_add_text(tree, tvb, offset-8, \ + sizeof(guint32),"Epoch: 0"); \ + proto_tree_add_uint(tree,hf_afs_ubik_version_counter, tvb,offset-4, \ + sizeof(guint32),counter); \ + tree = save; \ + } + +/* Output a kauth getticket request */ +#define OUT_KAUTH_GetTicket() \ + { \ + int len = 0; \ + OUT_UINT(hf_afs_kauth_kvno); \ + OUT_RXString(hf_afs_kauth_domain); \ + len = tvb_get_ntohl(tvb, offset); \ + offset += 4; \ + OUT_BYTES(hf_afs_kauth_data, len); \ + OUT_RXString(hf_afs_kauth_princ); \ + OUT_RXString(hf_afs_kauth_realm); \ + } #define GETSTR ((const char *)tvb_get_ptr(tvb,offset,tvb_ensure_length_remaining(tvb,offset))) @@ -55,6 +831,481 @@ (opcode >= VOTE_LOW && opcode <= VOTE_HIGH) || \ (opcode >= DISK_LOW && opcode <= DISK_HIGH)) +static const value_string fs_req[] = { + { 130, "fetch-data" }, + { 131, "fetch-acl" }, + { 132, "fetch-status" }, + { 133, "store-data" }, + { 134, "store-acl" }, + { 135, "store-status" }, + { 136, "remove-file" }, + { 137, "create-file" }, + { 138, "rename" }, + { 139, "symlink" }, + { 140, "link" }, + { 141, "makedir" }, + { 142, "rmdir" }, + { 143, "old-set-lock" }, + { 144, "old-extend-lock" }, + { 145, "old-release-lock" }, + { 146, "get-stats" }, + { 147, "give-up-callbacks" }, + { 148, "get-volume-info" }, + { 149, "get-volume-status" }, + { 150, "set-volume-status" }, + { 151, "get-root-volume" }, + { 152, "check-token" }, + { 153, "get-time" }, + { 154, "nget-volume-info" }, + { 155, "bulk-status" }, + { 156, "set-lock" }, + { 157, "extend-lock" }, + { 158, "release-lock" }, + { 159, "xstats-version" }, + { 160, "get-xstats" }, + { 161, "dfs-lookup" }, + { 162, "dfs-flushcps" }, + { 163, "dfs-symlink" }, + { 220, "residency" }, + { 65536, "inline-bulk-status" }, + { 65537, "fetch-data-64" }, + { 65538, "store-data-64" }, + { 65539, "give-up-all-callbacks" }, + { 65540, "get-capabilities" }, + { 0, NULL }, +}; + +static const value_string cb_req[] = { + { 204, "callback" }, + { 205, "init-callback-state" }, + { 206, "probe" }, + { 207, "get-lock" }, + { 208, "get-ce" }, + { 209, "xstats-version" }, + { 210, "get-xstats" }, + { 211, "init-callback-state2" }, + { 212, "who-are-you" }, + { 213, "init-callback-state3" }, + { 214, "probeuuid" }, + { 215, "get-server-prefs" }, + { 216, "get-cellservdb" }, + { 217, "get-local-cell" }, + { 218, "get-cache-config" }, + { 65536, "get-ce-64" }, + { 65537, "get-cell-by-num" }, + { 65538, "get-capabilities" }, + { 0, NULL }, +}; + +static const value_string prot_req[] = { + { 500, "new-user" }, + { 501, "where-is-it" }, + { 502, "dump-entry" }, + { 503, "add-to-group" }, + { 504, "name-to-id" }, + { 505, "id-to-name" }, + { 506, "delete" }, + { 507, "remove-from-group" }, + { 508, "get-cps" }, + { 509, "new-entry" }, + { 510, "list-max" }, + { 511, "set-max" }, + { 512, "list-entry" }, + { 513, "change-entry" }, + { 514, "list-elements" }, + { 515, "is-member-of" }, + { 516, "set-fld-sentry" }, + { 517, "list-owned" }, + { 518, "get-cps2" }, + { 519, "get-host-cps" }, + { 520, "update-entry" }, + { 521, "list-entries" }, + { 0, NULL }, +}; + +static const value_string vldb_req[] = { + { 501, "create-entry" }, + { 502, "delete-entry" }, + { 503, "get-entry-by-id" }, + { 504, "get-entry-by-name" }, + { 505, "get-new-volume-id" }, + { 506, "replace-entry" }, + { 507, "update-entry" }, + { 508, "set-lock" }, + { 509, "release-lock" }, + { 510, "list-entry" }, + { 511, "list-attributes" }, + { 512, "linked-list" }, + { 513, "get-stats" }, + { 514, "probe" }, + { 515, "get-addrs" }, + { 516, "change-addr" }, + { 517, "create-entry-n" }, + { 518, "get-entry-by-id-n" }, + { 519, "get-entry-by-name-n" }, + { 520, "replace-entry-n" }, + { 521, "list-entry-n" }, + { 522, "list-attrib-n" }, + { 523, "linked-list-n" }, + { 524, "update-entry-by-name" }, + { 525, "create-entry-u" }, + { 526, "get-entry-by-id-u" }, + { 527, "get-entry-by-name-u" }, + { 528, "replace-entry-u" }, + { 529, "list-entry-u" }, + { 530, "list-attrib-u" }, + { 531, "linked-list-u" }, + { 532, "regaddr" }, + { 533, "get-addrs-u" }, + { 534, "list-attrib-n2" }, + { 0, NULL }, +}; + +static const value_string kauth_req[] = { + { 1, "auth-old" }, + { 21, "authenticate" }, + { 22, "authenticate-v2" }, + { 2, "change-pw" }, + { 3, "get-ticket-old" }, + { 23, "get-ticket" }, + { 4, "set-pw" }, + { 5, "set-fields" }, + { 6, "create-user" }, + { 7, "delete-user" }, + { 8, "get-entry" }, + { 9, "list-entry" }, + { 10, "get-stats" }, + { 11, "debug" }, + { 12, "get-pw" }, + { 13, "get-random-key" }, + { 14, "unlock" }, + { 15, "lock-status" }, + { 0, NULL }, +}; + +static const value_string vol_req[] = { + { 100, "create-volume" }, + { 101, "delete-volume" }, + { 102, "restore" }, + { 103, "forward" }, + { 104, "end-trans" }, + { 105, "clone" }, + { 106, "set-flags" }, + { 107, "get-flags" }, + { 108, "trans-create" }, + { 109, "dump" }, + { 110, "get-nth-volume" }, + { 111, "set-forwarding" }, + { 112, "get-name" }, + { 113, "get-status" }, + { 114, "sig-restore" }, + { 115, "list-partitions" }, + { 116, "list-volumes" }, + { 117, "set-id-types" }, + { 118, "monitor" }, + { 119, "partition-info" }, + { 120, "reclone" }, + { 121, "list-one-volume" }, + { 122, "nuke" }, + { 123, "set-date" }, + { 124, "x-list-volumes" }, + { 125, "x-list-one-volume" }, + { 126, "set-info" }, + { 127, "x-list-partitions" }, + { 128, "forward-multiple" }, + { 65536, "convert-ro" }, + { 65537, "getsize" }, + { 0, NULL }, +}; + +static const value_string bos_req[] = { + { 80, "create-bnode" }, + { 81, "delete-bnode" }, + { 82, "set-status" }, + { 83, "get-status" }, + { 84, "enumerate-instance" }, + { 85, "get-instance-info" }, + { 86, "get-instance-parm" }, + { 87, "add-superuser" }, + { 88, "delete-superuser" }, + { 89, "list-superusers" }, + { 90, "list-keys" }, + { 91, "add-key" }, + { 92, "delete-key" }, + { 93, "set-cell-name" }, + { 94, "get-cell-name" }, + { 95, "get-cell-host" }, + { 96, "add-cell-host" }, + { 97, "delete-cell-host" }, + { 98, "set-t-status" }, + { 99, "shutdown-all" }, + { 100, "restart-all" }, + { 101, "startup-all" }, + { 102, "set-noauth-flag" }, + { 103, "re-bozo" }, + { 104, "restart" }, + { 105, "install" }, + { 106, "uninstall" }, + { 107, "get-dates" }, + { 108, "exec" }, + { 109, "prune" }, + { 110, "set-restart-time" }, + { 111, "get-restart-time" }, + { 112, "get-log" }, + { 113, "wait-all" }, + { 114, "get-instance-strings" }, + { 115, "get-restricted" }, + { 116, "set restricted" }, + { 0, NULL }, +}; + +static const value_string update_req[] = { + { 1, "fetch-file" }, + { 2, "fetch-info" }, + { 0, NULL }, +}; + +static const value_string rmtsys_req[] = { + { 1, "setpag" }, + { 2, "pioctl" }, + { 0, NULL }, +}; + +static const value_string backup_req[] = { + { 100, "perform-dump" }, + { 101, "perform-restore" }, + { 102, "check-dump" }, + { 103, "abort-dump" }, + { 104, "wait-for-dump" }, + { 105, "end-dump" }, + { 106, "get-tm-info" }, + { 107, "label-tape" }, + { 108, "scan-nodes" }, + { 109, "read-label" }, + { 110, "scan-dumps" }, + { 111, "get-tc-info" }, + { 112, "save-database" }, + { 113, "restore-database" }, + { 114, "get-status" }, + { 115, "request-abort" }, + { 116, "end-status" }, + { 117, "scan-status" }, + { 118, "delete-dump" }, + { 0, NULL }, +}; + +static const value_string ubik_req[] = { + { 10000, "vote-beacon" }, + { 10001, "vote-debug-old" }, + { 10002, "vote-sdebug-old" }, + { 10003, "vote-getsyncsite" }, + { 10004, "vote-debug" }, + { 10005, "vote-sdebug" }, + { 10006, "vote-xdebug" }, + { 10007, "vote-xsdebug" }, + { 20000, "disk-begin" }, + { 20001, "disk-commit" }, + { 20002, "disk-lock" }, + { 20003, "disk-write" }, + { 20004, "disk-getversion" }, + { 20005, "disk-getfile" }, + { 20006, "disk-sendfile" }, + { 20007, "disk-abort" }, + { 20008, "disk-releaselocks" }, + { 20009, "disk-truncate" }, + { 20010, "disk-probe" }, + { 20011, "disk-writev" }, + { 20012, "disk-interfaceaddr" }, + { 20013, "disk-setversion" }, + { 0, NULL }, +}; + +static const value_string cb_types[] = { + { CB_TYPE_EXCLUSIVE, "exclusive" }, + { CB_TYPE_SHARED, "shared" }, + { CB_TYPE_DROPPED, "dropped" }, + { 0, NULL }, +}; + +static const value_string afs_errors[] = { + /* VOL Errors */ + { 363520, "ID Exists"}, + { 363521, "IO Error"}, + { 363522, "Name Exists"}, + { 363523, "Create Failed"}, + { 363524, "Entry Not Found"}, + { 363525, "Empty"}, + { 363526, "Entry Deleted"}, + { 363527, "Bad Name"}, + { 363528, "Bad Index"}, + { 363529, "Bad Volume Type"}, + { 363530, "Bad Partition"}, + { 363531, "Bad Server"}, + { 363532, "Bad Replicate Server"}, + { 363533, "No Replicate Server"}, + { 363534, "Duplicate Replicate Server"}, + { 363535, "ReadWrite Volume Not Found"}, + { 363536, "Bad Reference Count"}, + { 363537, "Size Exceeded"}, + { 363538, "Bad Entry"}, + { 363539, "Bad Volume ID Bump"}, + { 363540, "Already has edit"}, + { 363541, "Entry Locked"}, + { 363542, "Bad Volume Operation"}, + { 363543, "Bad Rel Lock Type"}, + { 363544, "Rerelease"}, + { 363545, "Bad Server"}, + { 363546, "Permission Denied"}, + { 363547, "Out of Memory"}, + + /* KAUTH Errors */ + { 180480, "Database Inconsistent"}, + { 180481, "Exists"}, + { 180482, "IO"}, + { 180483, "Create Failed"}, + { 180484, "noent"}, + { 180485, "Empty"}, + { 180486, "Bad Name"}, + { 180487, "Bad Index"}, + { 180488, "No auth"}, + { 180489, "Answer too long"}, + { 180490, "Bad Request"}, + { 180491, "Old Interface"}, + { 180492, "Bad Argument"}, + { 180493, "Bad Command"}, + { 180494, "No keys"}, + { 180495, "Read PW"}, + { 180496, "Bad key"}, + { 180497, "Ubik Init"}, + { 180498, "Ubik Call"}, + { 180499, "Bad Protocol"}, + { 180500, "No cells"}, + { 180501, "No cell"}, + { 180502, "Too many ubiks"}, + { 180503, "Too many keys"}, + { 180504, "Bad ticket"}, + { 180505, "Unknown Key"}, + { 180506, "Key Cache Invalid"}, + { 180507, "Bad Server"}, + { 180508, "Bad User"}, + { 180509, "Bad CPW"}, + { 180510, "Bad Create"}, + { 180511, "No ticket"}, + { 180512, "Assoc user"}, + { 180513, "Not special"}, + { 180514, "Clock skew too great"}, + { 180515, "No recursion"}, + { 180516, "RX failed"}, + { 180517, "Null password"}, + { 180518, "Internal error"}, + { 180519, "Password expired"}, + { 180520, "Reused"}, + { 180521, "Too soon"}, + { 180522, "Locked"}, + + /* PT Errors */ + { 267264, "Exists"}, + { 267265, "ID Exists"}, + { 267266, "No IDs"}, + { 267267, "DB Failed"}, + { 267268, "No such entry"}, + { 267269, "Permission denied"}, + { 267270, "Not group"}, + { 267271, "Not user"}, + { 267272, "Bad name"}, + { 267273, "Bad argument"}, + { 267274, "No more"}, + { 267275, "Bad DB"}, + { 267276, "Group empty"}, + { 267277, "Inconsistent"}, + { 267278, "DB Address"}, + { 267279, "Too many"}, + { 267280, "No memory"}, + + /* Volume server errors */ + { 1492325120, "Release error"}, + { 1492325121, "No op"}, + { 1492325122, "Read dump error"}, + { 1492325123, "Dump error"}, + { 1492325124, "Attach error"}, + { 1492325125, "Illegal partition"}, + { 1492325126, "Detach error"}, + { 1492325127, "Bad access"}, + { 1492325128, "VLDB error"}, + { 1492325129, "Bad Name"}, + { 1492325130, "Volume moved"}, + { 1492325131, "Bad operation"}, + { 1492325132, "Bad release"}, + { 1492325133, "Volume busy"}, + { 1492325134, "No memory"}, + { 1492325135, "No volume"}, + { 1492325136, "Multiple RW volumes"}, + { 1492325137, "Failed operation"}, + + /* add more of these errors to decode the errcode responses */ + { 0, NULL }, +}; + +static const value_string port_types[] = { + { AFS_PORT_FS, "File Server" }, + { AFS_PORT_CB, "Callback Server" }, + { AFS_PORT_BOS, "BOS Server" }, + { AFS_PORT_PROT, "Protection Server" }, + { AFS_PORT_VLDB, "Volume Location Database Server" }, + { AFS_PORT_KAUTH, "Kerberos Authentication Server" }, + { AFS_PORT_ERROR, "Error Server" }, + { AFS_PORT_VOL, "Volume Server" }, + { AFS_PORT_RMTSYS, "Rmtsys? Server" }, + { AFS_PORT_UPDATE, "Update? Server" }, + { AFS_PORT_BACKUP, "Backup Server" }, + { 0, NULL } +}; + +static const value_string port_types_short[] = { + { AFS_PORT_FS, "FS" }, + { AFS_PORT_CB, "CB" }, + { AFS_PORT_BOS, "BOS" }, + { AFS_PORT_PROT, "PROT" }, + { AFS_PORT_VLDB, "VLDB" }, + { AFS_PORT_KAUTH, "KAUTH" }, + { AFS_PORT_ERROR, "ERR" }, + { AFS_PORT_VOL, "VOL" }, + { AFS_PORT_RMTSYS, "RMT" }, + { AFS_PORT_UPDATE, "UPD" }, + { AFS_PORT_BACKUP, "BKUP" }, + { 0, NULL } +}; + +static const value_string ubik_lock_types[] = { + { 1, "read" }, + { 2, "write" }, + { 3, "wait" }, + { 0, NULL }, +}; + +static const value_string xstat_collections[] = { + { 0, "call counting & info" }, + { 1, "performance info" }, + { 2, "full performance info" }, + { 0, NULL }, +}; + +static const value_string vice_lock_types[] = { + { 0, "read" }, + { 1, "write" }, + { 2, "extend" }, + { 3, "release" }, + { 0, NULL }, +}; + +static const value_string volume_types[] = { + { 0, "read-write" }, + { 1, "read-only" }, + { 2, "backup" }, + { 0xffffffff, "any" }, + { 0, NULL }, +}; + struct afs_request_key { guint32 conversation, callnumber; guint16 service; @@ -1730,7 +2981,550 @@ void proto_register_afs(void) { static hf_register_info hf[] = { -#include "packet-afs-register-info.h" + { &hf_afs_fs, { "File Server", "afs.fs", + FT_BOOLEAN, BASE_NONE, 0, 0, "File Server", HFILL }}, + { &hf_afs_cb, { "Callback", "afs.cb", + FT_BOOLEAN, BASE_NONE, 0, 0, "Callback", HFILL }}, + { &hf_afs_prot, { "Protection", "afs.prot", + FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server", HFILL }}, + { &hf_afs_vldb, { "VLDB", "afs.vldb", + FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server", HFILL }}, + { &hf_afs_kauth, { "KAuth", "afs.kauth", + FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server", HFILL }}, + { &hf_afs_vol, { "Volume Server", "afs.vol", + FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server", HFILL }}, + { &hf_afs_error, { "Error", "afs.error", + FT_BOOLEAN, BASE_NONE, 0, 0, "Error", HFILL }}, + { &hf_afs_bos, { "BOS", "afs.bos", + FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server", HFILL }}, + { &hf_afs_update, { "Update", "afs.update", + FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server", HFILL }}, + { &hf_afs_rmtsys, { "Rmtsys", "afs.rmtsys", + FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys", HFILL }}, + { &hf_afs_ubik, { "Ubik", "afs.ubik", + FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik", HFILL }}, + { &hf_afs_backup, { "Backup", "afs.backup", + FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server", HFILL }}, + + { &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode", + FT_UINT32, BASE_DEC, + VALS(fs_req), 0, "Operation", HFILL }}, + { &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode", + FT_UINT32, BASE_DEC, + VALS(cb_req), 0, "Operation", HFILL }}, + { &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode", + FT_UINT32, BASE_DEC, + VALS(prot_req), 0, "Operation", HFILL }}, + { &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode", + FT_UINT32, BASE_DEC, + VALS(vldb_req), 0, "Operation", HFILL }}, + { &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode", + FT_UINT32, BASE_DEC, + VALS(kauth_req), 0, "Operation", HFILL }}, + { &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode", + FT_UINT32, BASE_DEC, + VALS(vol_req), 0, "Operation", HFILL }}, + { &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode", + FT_UINT32, BASE_DEC, + VALS(bos_req), 0, "Operation", HFILL }}, + { &hf_afs_update_opcode, { "Operation", "afs.update.opcode", + FT_UINT32, BASE_DEC, + VALS(update_req), 0, "Operation", HFILL }}, + { &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode", + FT_UINT32, BASE_DEC, + VALS(rmtsys_req), 0, "Operation", HFILL }}, + { &hf_afs_error_opcode, { "Operation", "afs.error.opcode", + FT_UINT32, BASE_DEC, + 0, 0, "Operation", HFILL }}, + { &hf_afs_backup_opcode, { + "Operation", "afs.backup.opcode", + FT_UINT32, BASE_DEC, + VALS(backup_req), 0, "Operation", HFILL }}, + { &hf_afs_ubik_opcode, { + "Operation", "afs.ubik.opcode", + FT_UINT32, BASE_DEC, + VALS(ubik_req), 0, "Operation", HFILL }}, + + +/* File Server Fields */ + { &hf_afs_fs_fid_volume, { "FileID (Volume)", "afs.fs.fid.volume", + FT_UINT32, BASE_DEC, + 0, 0, "File ID (Volume)", HFILL }}, + { &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode", + FT_UINT32, BASE_DEC, + 0, 0, "File ID (VNode)", HFILL }}, + { &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq", + FT_UINT32, BASE_DEC, + 0, 0, "File ID (Uniqifier)", HFILL }}, + { &hf_afs_fs_offset, { "Offset", "afs.fs.offset", + FT_UINT32, BASE_DEC, + 0, 0, "Offset", HFILL }}, + { &hf_afs_fs_length, { "Length", "afs.fs.length", + FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }}, + { &hf_afs_fs_flength, { "FLength", "afs.fs.flength", + FT_UINT32, BASE_DEC, 0, 0, "FLength", HFILL }}, + { &hf_afs_fs_offset64, { "Offset64", "afs.fs.offset64", + FT_UINT64, BASE_DEC, + 0, 0, "Offset64", HFILL }}, + { &hf_afs_fs_length64, { "Length64", "afs.fs.length64", + FT_UINT64, BASE_DEC, 0, 0, "Length64", HFILL }}, + { &hf_afs_fs_flength64, { "FLength64", "afs.fs.flength64", + FT_UINT64, BASE_DEC, 0, 0, "FLength64", HFILL }}, + { &hf_afs_fs_errcode, { "Error Code", "afs.fs.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_fs_data, { "Data", "afs.fs.data", + FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }}, + { &hf_afs_fs_token, { "Token", "afs.fs.token", + FT_BYTES, BASE_HEX, 0, 0, "Token", HFILL }}, + { &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname", + FT_STRING, BASE_HEX, 0, 0, "Old Name", HFILL }}, + { &hf_afs_fs_newname, { "New Name", "afs.fs.newname", + FT_STRING, BASE_HEX, 0, 0, "New Name", HFILL }}, + { &hf_afs_fs_name, { "Name", "afs.fs.name", + FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }}, + { &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name", + FT_STRING, BASE_HEX, 0, 0, "Symlink Name", HFILL }}, + { &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content", + FT_STRING, BASE_HEX, 0, 0, "Symlink Content", HFILL }}, + { &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid", + FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }}, + { &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname", + FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }}, + { &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Timestamp", HFILL }}, + { &hf_afs_fs_offlinemsg, { "Offline Message", "afs.fs.offlinemsg", + FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }}, + { &hf_afs_fs_motd, { "Message of the Day", "afs.fs.motd", + FT_STRING, BASE_HEX, 0, 0, "Message of the Day", HFILL }}, + { &hf_afs_fs_xstats_version, { "XStats Version", "afs.fs.xstats.version", + FT_UINT32, BASE_DEC, 0, 0, "XStats Version", HFILL }}, + { &hf_afs_fs_xstats_clientversion, { "Client Version", "afs.fs.xstats.clientversion", + FT_UINT32, BASE_DEC, 0, 0, "Client Version", HFILL }}, + { &hf_afs_fs_xstats_collnumber, { "Collection Number", "afs.fs.xstats.collnumber", + FT_UINT32, BASE_DEC, VALS(xstat_collections), 0, "Collection Number", HFILL }}, + { &hf_afs_fs_xstats_timestamp, { "XStats Timestamp", "afs.fs.xstats.timestamp", + FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp", HFILL }}, + { &hf_afs_fs_cps_spare1, { "CPS Spare1", "afs.fs.cps.spare1", + FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1", HFILL }}, + { &hf_afs_fs_cps_spare2, { "CPS Spare2", "afs.fs.cps.spare2", + FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2", HFILL }}, + { &hf_afs_fs_cps_spare3, { "CPS Spare3", "afs.fs.cps.spare3", + FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3", HFILL }}, + { &hf_afs_fs_vicelocktype, { "Vice Lock Type", "afs.fs.vicelocktype", + FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type", HFILL }}, +/* XXX - is this an IP address? */ + { &hf_afs_fs_viceid, { "Vice ID", "afs.fs.viceid", + FT_UINT32, BASE_DEC, 0, 0, "Vice ID", HFILL }}, + + { &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask", + FT_UINT32, BASE_HEX, 0, 0, "Mask", HFILL }}, + { &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime", + FT_BOOLEAN, 32, 0, 0x00000001, "Set Modification Time", HFILL }}, + { &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner", + FT_BOOLEAN, 32, 0, 0x00000002, "Set Owner", HFILL }}, + { &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup", + FT_BOOLEAN, 32, 0, 0x00000004, "Set Group", HFILL }}, + { &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode", + FT_BOOLEAN, 32, 0, 0x00000008, "Set Mode", HFILL }}, + { &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize", + FT_BOOLEAN, 32, 0, 0x00000010, "Set Segment Size", HFILL }}, + { &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync", + FT_BOOLEAN, 32, 0, 0x00000400, "FSync", HFILL }}, + + { &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Client Modification Time", HFILL }}, + { &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Server Modification Time", HFILL }}, + { &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner", + FT_UINT32, BASE_DEC, 0, 0, "Owner", HFILL }}, + { &hf_afs_fs_status_group, { "Group", "afs.fs.status.group", + FT_UINT32, BASE_DEC, 0, 0, "Group", HFILL }}, + { &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode", + FT_UINT32, BASE_OCT, 0, 0, "Unix Mode", HFILL }}, + { &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize", + FT_UINT32, BASE_DEC, 0, 0, "Segment Size", HFILL }}, + { &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion", + FT_UINT32, BASE_DEC, 0, 0, "Interface Version", HFILL }}, + { &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype", + FT_UINT32, BASE_DEC, 0, 0, "File Type", HFILL }}, + { &hf_afs_fs_status_author, { "Author", "afs.fs.status.author", + FT_UINT32, BASE_DEC, 0, 0, "Author", HFILL }}, + { &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess", + FT_UINT32, BASE_DEC, 0, 0, "Caller Access", HFILL }}, + { &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess", + FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access", HFILL }}, + { &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode", + FT_UINT32, BASE_DEC, 0, 0, "Parent VNode", HFILL }}, + { &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique", + FT_UINT32, BASE_DEC, 0, 0, "Parent Unique", HFILL }}, + { &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion", + FT_UINT32, BASE_DEC, 0, 0, "Data Version", HFILL }}, + { &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh", + FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)", HFILL }}, + { &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount", + FT_UINT32, BASE_DEC, 0, 0, "Link Count", HFILL }}, + { &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2", + FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }}, + { &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3", + FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }}, + { &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4", + FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }}, + { &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter", + FT_UINT32, BASE_DEC, 0, 0, "Sync Counter", HFILL }}, + { &hf_afs_fs_status_length, { "Length", "afs.fs.status.length", + FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }}, + + + { &hf_afs_fs_volsync_spare1, { "Volume Creation Timestamp", "afs.fs.volsync.spare1", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Volume Creation Timestamp", HFILL }}, + { &hf_afs_fs_volsync_spare2, { "Spare 2", "afs.fs.volsync.spare2", + FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }}, + { &hf_afs_fs_volsync_spare3, { "Spare 3", "afs.fs.volsync.spare3", + FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }}, + { &hf_afs_fs_volsync_spare4, { "Spare 4", "afs.fs.volsync.spare4", + FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }}, + { &hf_afs_fs_volsync_spare5, { "Spare 5", "afs.fs.volsync.spare5", + FT_UINT32, BASE_DEC, 0, 0, "Spare 5", HFILL }}, + { &hf_afs_fs_volsync_spare6, { "Spare 6", "afs.fs.volsync.spare6", + FT_UINT32, BASE_DEC, 0, 0, "Spare 6", HFILL }}, + + + { &hf_afs_fs_acl_count_positive, { + "ACL Count (Positive)", "afs.fs.acl.count.positive", + FT_UINT32, BASE_DEC, 0, 0, "Number of Positive ACLs", HFILL }}, + { &hf_afs_fs_acl_count_negative, { + "ACL Count (Negative)", "afs.fs.acl.count.negative", + FT_UINT32, BASE_DEC, 0, 0, "Number of Negative ACLs", HFILL }}, + { &hf_afs_fs_acl_datasize, { + "ACL Size", "afs.fs.acl.datasize", + FT_UINT32, BASE_DEC, 0, 0, "ACL Data Size", HFILL }}, + { &hf_afs_fs_acl_entity, { + "Entity (User/Group)", "afs.fs.acl.entity", + FT_STRING, BASE_HEX, 0, 0, "ACL Entity (User/Group)", HFILL }}, + { &hf_afs_fs_acl_r, { + "_R_ead", "afs.fs.acl.r", + FT_BOOLEAN, 8, 0, PRSFS_READ, "Read", HFILL }}, + { &hf_afs_fs_acl_l, { + "_L_ookup", "afs.fs.acl.l", + FT_BOOLEAN, 8, 0, PRSFS_LOOKUP, "Lookup", HFILL }}, + { &hf_afs_fs_acl_i, { + "_I_nsert", "afs.fs.acl.i", + FT_BOOLEAN, 8, 0, PRSFS_INSERT, "Insert", HFILL }}, + { &hf_afs_fs_acl_d, { "_D_elete", "afs.fs.acl.d", + FT_BOOLEAN, 8, 0, PRSFS_DELETE, "Delete", HFILL }}, + { &hf_afs_fs_acl_w, { "_W_rite", "afs.fs.acl.w", + FT_BOOLEAN, 8, 0, PRSFS_WRITE, "Write", HFILL }}, + { &hf_afs_fs_acl_k, { "_L_ock", "afs.fs.acl.k", + FT_BOOLEAN, 8, 0, PRSFS_LOCK, "Lock", HFILL }}, + { &hf_afs_fs_acl_a, { "_A_dminister", "afs.fs.acl.a", + FT_BOOLEAN, 8, 0, PRSFS_ADMINISTER, "Administer", HFILL }}, + + { &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version", + FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }}, + { &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires", + FT_RELATIVE_TIME, BASE_NONE, 0, 0, "Expires", HFILL }}, + { &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type", + FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }}, + +/* BOS Server Fields */ + { &hf_afs_bos_errcode, { "Error Code", "afs.bos.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_bos_type, { "Type", "afs.bos.type", + FT_STRING, BASE_HEX, 0, 0, "Type", HFILL }}, + { &hf_afs_bos_content, { "Content", "afs.bos.content", + FT_STRING, BASE_HEX, 0, 0, "Content", HFILL }}, + { &hf_afs_bos_data, { "Data", "afs.bos.data", + FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }}, + { &hf_afs_bos_path, { "Path", "afs.bos.path", + FT_STRING, BASE_HEX, 0, 0, "Path", HFILL }}, + { &hf_afs_bos_parm, { "Parm", "afs.bos.parm", + FT_STRING, BASE_HEX, 0, 0, "Parm", HFILL }}, + { &hf_afs_bos_error, { "Error", "afs.bos.error", + FT_STRING, BASE_HEX, 0, 0, "Error", HFILL }}, + { &hf_afs_bos_spare1, { "Spare1", "afs.bos.spare1", + FT_STRING, BASE_HEX, 0, 0, "Spare1", HFILL }}, + { &hf_afs_bos_spare2, { "Spare2", "afs.bos.spare2", + FT_STRING, BASE_HEX, 0, 0, "Spare2", HFILL }}, + { &hf_afs_bos_spare3, { "Spare3", "afs.bos.spare3", + FT_STRING, BASE_HEX, 0, 0, "Spare3", HFILL }}, + { &hf_afs_bos_file, { "File", "afs.bos.file", + FT_STRING, BASE_HEX, 0, 0, "File", HFILL }}, + { &hf_afs_bos_cmd, { "Command", "afs.bos.cmd", + FT_STRING, BASE_HEX, 0, 0, "Command", HFILL }}, + { &hf_afs_bos_key, { "Key", "afs.bos.key", + FT_BYTES, BASE_HEX, 0, 0, "key", HFILL }}, + { &hf_afs_bos_user, { "User", "afs.bos.user", + FT_STRING, BASE_HEX, 0, 0, "User", HFILL }}, + { &hf_afs_bos_instance, { "Instance", "afs.bos.instance", + FT_STRING, BASE_HEX, 0, 0, "Instance", HFILL }}, + { &hf_afs_bos_status, { "Status", "afs.bos.status", + FT_INT32, BASE_DEC, 0, 0, "Status", HFILL }}, + { &hf_afs_bos_statusdesc, { "Status Description", "afs.bos.statusdesc", + FT_STRING, BASE_DEC, 0, 0, "Status Description", HFILL }}, + { &hf_afs_bos_num, { "Number", "afs.bos.number", + FT_UINT32, BASE_DEC, 0, 0, "Number", HFILL }}, + { &hf_afs_bos_size, { "Size", "afs.bos.size", + FT_UINT32, BASE_DEC, 0, 0, "Size", HFILL }}, + { &hf_afs_bos_flags, { "Flags", "afs.bos.flags", + FT_UINT32, BASE_DEC, 0, 0, "Flags", HFILL }}, + { &hf_afs_bos_date, { "Date", "afs.bos.date", + FT_UINT32, BASE_DEC, 0, 0, "Date", HFILL }}, + { &hf_afs_bos_kvno, { "Key Version Number", "afs.bos.kvno", + FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }}, + { &hf_afs_bos_cell, { "Cell", "afs.bos.cell", + FT_STRING, BASE_HEX, 0, 0, "Cell", HFILL }}, + { &hf_afs_bos_host, { "Host", "afs.bos.host", + FT_STRING, BASE_HEX, 0, 0, "Host", HFILL }}, + { &hf_afs_bos_newtime, { "New Time", "afs.bos.newtime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "New Time", HFILL }}, + { &hf_afs_bos_baktime, { "Backup Time", "afs.bos.baktime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Backup Time", HFILL }}, + { &hf_afs_bos_oldtime, { "Old Time", "afs.bos.oldtime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Old Time", HFILL }}, + { &hf_afs_bos_keymodtime, { "Key Modification Time", "afs.bos.keymodtime", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Key Modification Time", HFILL }}, + { &hf_afs_bos_keychecksum, { "Key Checksum", "afs.bos.keychecksum", + FT_UINT32, BASE_DEC, 0, 0, "Key Checksum", HFILL }}, + { &hf_afs_bos_keyspare2, { "Key Spare 2", "afs.bos.keyspare2", + FT_UINT32, BASE_DEC, 0, 0, "Key Spare 2", HFILL }}, + + +/* KAUTH Server Fields */ + { &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ", + FT_STRING, BASE_HEX, 0, 0, "Principal", HFILL }}, + { &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm", + FT_STRING, BASE_HEX, 0, 0, "Realm", HFILL }}, + { &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain", + FT_STRING, BASE_HEX, 0, 0, "Domain", HFILL }}, + { &hf_afs_kauth_name, { "Name", "afs.kauth.name", + FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }}, + { &hf_afs_kauth_data, { "Data", "afs.kauth.data", + FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }}, + { &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno", + FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }}, + +/* VOL Server Fields */ + { &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_vol_id, { "Volume ID", "afs.vol.id", + FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }}, + { &hf_afs_vol_count, { "Volume Count", "afs.vol.count", + FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }}, + { &hf_afs_vol_name, { "Volume Name", "afs.vol.name", + FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }}, + +/* VLDB Server Fields */ + { &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type", + FT_UINT32, BASE_HEX, VALS(volume_types), 0, "Volume Type", HFILL }}, + { &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id", + FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }}, + { &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump", + FT_UINT32, BASE_DEC, 0, 0, "Bumped Volume ID", HFILL }}, + { &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index", + FT_UINT32, BASE_DEC, 0, 0, "Volume Index", HFILL }}, + { &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count", + FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }}, + { &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers", + FT_UINT32, BASE_DEC, 0, 0, "Number of Servers", HFILL }}, + { &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex", + FT_UINT32, BASE_DEC, 0, 0, "Next Volume Index", HFILL }}, + { &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol", + FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }}, + { &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol", + FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }}, + { &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol", + FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }}, + { &hf_afs_vldb_clonevol, { "Clone Volume ID", "afs.vldb.clonevol", + FT_UINT32, BASE_DEC, 0, 0, "Clone Volume ID", HFILL }}, + { &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name", + FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }}, + { &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition", + FT_STRING, BASE_HEX, 0, 0, "Partition", HFILL }}, + { &hf_afs_vldb_server, { "Server", "afs.vldb.server", + FT_IPv4, BASE_HEX, 0, 0, "Server", HFILL }}, + { &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid", + FT_BYTES, BASE_HEX, 0, 0, "Server UUID", HFILL }}, + { &hf_afs_vldb_serveruniq, { "Server Unique Address", "afs.vldb.serveruniq", + FT_UINT32, BASE_HEX, 0, 0, "Server Unique Address", HFILL }}, + { &hf_afs_vldb_serverflags, { "Server Flags", "afs.vldb.serverflags", + FT_UINT32, BASE_HEX, 0, 0, "Server Flags", HFILL }}, + { &hf_afs_vldb_serverip, { "Server IP", "afs.vldb.serverip", + FT_IPv4, BASE_HEX, 0, 0, "Server IP", HFILL }}, + { &hf_afs_vldb_flags, { "Flags", "afs.vldb.flags", + FT_UINT32, BASE_HEX, 0, 0, "Flags", HFILL }}, + + { &hf_afs_vldb_flags_rwexists, { "Read/Write Exists", "afs.vldb.flags.rwexists", + FT_BOOLEAN, 32, 0, 0x1000, "Read/Write Exists", HFILL }}, + { &hf_afs_vldb_flags_roexists, { "Read-Only Exists", "afs.vldb.flags.roexists", + FT_BOOLEAN, 32, 0, 0x2000, "Read-Only Exists", HFILL }}, + { &hf_afs_vldb_flags_bkexists, { "Backup Exists", "afs.vldb.flags.bkexists", + FT_BOOLEAN, 32, 0, 0x4000, "Backup Exists", HFILL }}, + { &hf_afs_vldb_flags_dfsfileset, { "DFS Fileset", "afs.vldb.flags.dfsfileset", + FT_BOOLEAN, 32, 0, 0x8000, "DFS Fileset", HFILL }}, + + { &hf_afs_vldb_spare1, { "Spare 1", "afs.vldb.spare1", + FT_UINT32, BASE_DEC, 0, 0, "Spare 1", HFILL }}, + { &hf_afs_vldb_spare2, { "Spare 2", "afs.vldb.spare2", + FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }}, + { &hf_afs_vldb_spare3, { "Spare 3", "afs.vldb.spare3", + FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }}, + { &hf_afs_vldb_spare4, { "Spare 4", "afs.vldb.spare4", + FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }}, + { &hf_afs_vldb_spare5, { "Spare 5", "afs.vldb.spare5", + FT_UINT32, BASE_DEC, 0, 0, "Spare 5", HFILL }}, + { &hf_afs_vldb_spare6, { "Spare 6", "afs.vldb.spare6", + FT_UINT32, BASE_DEC, 0, 0, "Spare 6", HFILL }}, + { &hf_afs_vldb_spare7, { "Spare 7", "afs.vldb.spare7", + FT_UINT32, BASE_DEC, 0, 0, "Spare 7", HFILL }}, + { &hf_afs_vldb_spare8, { "Spare 8", "afs.vldb.spare8", + FT_UINT32, BASE_DEC, 0, 0, "Spare 8", HFILL }}, + { &hf_afs_vldb_spare9, { "Spare 9", "afs.vldb.spare9", + FT_UINT32, BASE_DEC, 0, 0, "Spare 9", HFILL }}, + +/* BACKUP Server Fields */ + { &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + +/* CB Server Fields */ + { &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version", + FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }}, + { &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Expires", HFILL }}, + { &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type", + FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }}, + { &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume", + FT_UINT32, BASE_DEC, 0, 0, "File ID (Volume)", HFILL }}, + { &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode", + FT_UINT32, BASE_DEC, 0, 0, "File ID (VNode)", HFILL }}, + { &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq", + FT_UINT32, BASE_DEC, 0, 0, "File ID (Uniqifier)", HFILL }}, + +/* PROT Server Fields */ + { &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_prot_name, { "Name", "afs.prot.name", + FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }}, + { &hf_afs_prot_id, { "ID", "afs.prot.id", + FT_UINT32, BASE_DEC, 0, 0, "ID", HFILL }}, + { &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid", + FT_UINT32, BASE_DEC, 0, 0, "Old ID", HFILL }}, + { &hf_afs_prot_newid, { "New ID", "afs.prot.newid", + FT_UINT32, BASE_DEC, 0, 0, "New ID", HFILL }}, + { &hf_afs_prot_gid, { "Group ID", "afs.prot.gid", + FT_UINT32, BASE_DEC, 0, 0, "Group ID", HFILL }}, + { &hf_afs_prot_uid, { "User ID", "afs.prot.uid", + FT_UINT32, BASE_DEC, 0, 0, "User ID", HFILL }}, + { &hf_afs_prot_count, { "Count", "afs.prot.count", + FT_UINT32, BASE_DEC, 0, 0, "Count", HFILL }}, + { &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid", + FT_UINT32, BASE_DEC, 0, 0, "Maximum Group ID", HFILL }}, + { &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid", + FT_UINT32, BASE_DEC, 0, 0, "Maximum User ID", HFILL }}, + { &hf_afs_prot_pos, { "Position", "afs.prot.pos", + FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }}, + { &hf_afs_prot_flag, { "Flag", "afs.prot.flag", + FT_UINT32, BASE_HEX, 0, 0, "Flag", HFILL }}, + +/* UBIK Fields */ + { &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode", + FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }}, + { &hf_afs_ubik_state, { "State", "afs.ubik.state", + FT_UINT32, BASE_HEX, 0, 0, "State", HFILL }}, + { &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Epoch", HFILL }}, + { &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter", + FT_UINT32, BASE_DEC, 0, 0, "Counter", HFILL }}, + { &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Vote Started", HFILL }}, + { &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend", + FT_ABSOLUTE_TIME, BASE_NONE, 0, 0, "Vote Ends", HFILL }}, + { &hf_afs_ubik_file, { "File", "afs.ubik.file", + FT_UINT32, BASE_DEC, 0, 0, "File", HFILL }}, + { &hf_afs_ubik_pos, { "Position", "afs.ubik.position", + FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }}, + { &hf_afs_ubik_length, { "Length", "afs.ubik.length", + FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }}, + { &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype", + FT_UINT32, BASE_DEC, VALS(ubik_lock_types), 0, "Lock Type", HFILL }}, + { &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype", + FT_UINT32, BASE_HEX, 0, 0, "Vote Type", HFILL }}, + { &hf_afs_ubik_site, { "Site", "afs.ubik.site", + FT_IPv4, BASE_HEX, 0, 0, "Site", HFILL }}, + { &hf_afs_ubik_interface, { "Interface Address", "afs.ubik.interface", + FT_IPv4, BASE_HEX, 0, 0, "Interface Address", HFILL }}, + + { &hf_afs_ubik_now, { "Now", "afs.ubik.now", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Now", HFILL }}, + { &hf_afs_ubik_lastyestime, { "Last Yes Time", "afs.ubik.lastyesttime", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Time", HFILL }}, + { &hf_afs_ubik_lastyeshost, { "Last Yes Host", "afs.ubik.lastyeshost", + FT_IPv4, BASE_HEX, 0, 0, "Last Yes Host", HFILL }}, + { &hf_afs_ubik_lastyesstate, { "Last Yes State", "afs.ubik.lastyesstate", + FT_UINT32, BASE_HEX, 0, 0, "Last Yes State", HFILL }}, + { &hf_afs_ubik_lastyesclaim, { "Last Yes Claim", "afs.ubik.lastyesclaim", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Claim", HFILL }}, + { &hf_afs_ubik_lowesthost, { "Lowest Host", "afs.ubik.lowesthost", + FT_IPv4, BASE_HEX, 0, 0, "Lowest Host", HFILL }}, + { &hf_afs_ubik_lowesttime, { "Lowest Time", "afs.ubik.lowesttime", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Lowest Time", HFILL }}, + { &hf_afs_ubik_synchost, { "Sync Host", "afs.ubik.synchost", + FT_IPv4, BASE_HEX, 0, 0, "Sync Host", HFILL }}, + { &hf_afs_ubik_addr, { "Address", "afs.ubik.addr", + FT_IPv4, BASE_HEX, 0, 0, "Address", HFILL }}, + { &hf_afs_ubik_synctime, { "Sync Time", "afs.ubik.synctime", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Time", HFILL }}, + { &hf_afs_ubik_lastvotetime, { "Last Vote Time", "afs.ubik.lastvotetime", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Vote Time", HFILL }}, + { &hf_afs_ubik_lastbeaconsent, { "Last Beacon Sent", "afs.ubik.lastbeaconsent", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Beacon Sent", HFILL }}, + { &hf_afs_ubik_lastvote, { "Last Vote", "afs.ubik.lastvote", + FT_UINT32, BASE_HEX, 0, 0, "Last Vote", HFILL }}, + { &hf_afs_ubik_currentdb, { "Current DB", "afs.ubik.currentdb", + FT_UINT32, BASE_HEX, 0, 0, "Current DB", HFILL }}, + { &hf_afs_ubik_up, { "Up", "afs.ubik.up", + FT_UINT32, BASE_HEX, 0, 0, "Up", HFILL }}, + { &hf_afs_ubik_beaconsincedown, { "Beacon Since Down", "afs.ubik.beaconsincedown", + FT_UINT32, BASE_HEX, 0, 0, "Beacon Since Down", HFILL }}, + { &hf_afs_ubik_amsyncsite, { "Am Sync Site", "afs.ubik.amsyncsite", + FT_UINT32, BASE_HEX, 0, 0, "Am Sync Site", HFILL }}, + { &hf_afs_ubik_syncsiteuntil, { "Sync Site Until", "afs.ubik.syncsiteuntil", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Site Until", HFILL }}, + { &hf_afs_ubik_nservers, { "Number of Servers", "afs.ubik.nservers", + FT_UINT32, BASE_HEX, 0, 0, "Number of Servers", HFILL }}, + { &hf_afs_ubik_lockedpages, { "Locked Pages", "afs.ubik.lockedpages", + FT_UINT32, BASE_HEX, 0, 0, "Locked Pages", HFILL }}, + { &hf_afs_ubik_writelockedpages, { "Write Locked Pages", "afs.ubik.writelockedpages", + FT_UINT32, BASE_HEX, 0, 0, "Write Locked Pages", HFILL }}, + { &hf_afs_ubik_activewrite, { "Active Write", "afs.ubik.activewrite", + FT_UINT32, BASE_HEX, 0, 0, "Active Write", HFILL }}, + { &hf_afs_ubik_tidcounter, { "TID Counter", "afs.ubik.tidcounter", + FT_UINT32, BASE_HEX, 0, 0, "TID Counter", HFILL }}, + { &hf_afs_ubik_anyreadlocks, { "Any Read Locks", "afs.ubik.anyreadlocks", + FT_UINT32, BASE_HEX, 0, 0, "Any Read Locks", HFILL }}, + { &hf_afs_ubik_anywritelocks, { "Any Write Locks", "afs.ubik.anywritelocks", + FT_UINT32, BASE_HEX, 0, 0, "Any Write Locks", HFILL }}, + { &hf_afs_ubik_recoverystate, { "Recovery State", "afs.ubik.recoverystate", + FT_UINT32, BASE_HEX, 0, 0, "Recovery State", HFILL }}, + { &hf_afs_ubik_currenttrans, { "Current Transaction", "afs.ubik.currenttran", + FT_UINT32, BASE_HEX, 0, 0, "Current Transaction", HFILL }}, + { &hf_afs_ubik_writetrans, { "Write Transaction", "afs.ubik.writetran", + FT_UINT32, BASE_HEX, 0, 0, "Write Transaction", HFILL }}, + { &hf_afs_ubik_epochtime, { "Epoch Time", "afs.ubik.epochtime", + FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Epoch Time", HFILL }}, + { &hf_afs_ubik_isclone, { "Is Clone", "afs.ubik.isclone", + FT_UINT32, BASE_HEX, 0, 0, "Is Clone", HFILL }}, + { &hf_afs_reqframe, { "Request Frame", "afs.reqframe", + FT_FRAMENUM, BASE_NONE, NULL, 0, "Request Frame", HFILL }}, + { &hf_afs_repframe, { "Reply Frame", "afs.repframe", + FT_FRAMENUM, BASE_NONE, NULL, 0, "Reply Frame", HFILL }}, + { &hf_afs_time, { "Time from request", "afs.time", + FT_RELATIVE_TIME, BASE_NONE, NULL, 0, "Time between Request and Reply for AFS calls", HFILL }}, }; static gint *ett[] = { &ett_afs, |