Merge packet-afs-register-info.h, packet-afs-defs.h and packet-afs-macros.h

into packet-afs.c


svn path=/trunk/; revision=15605

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,