Added Nathan's patch for AFS and RX dissection.

svn path=/trunk/; revision=894

1 files changed, 2502 insertions, 0 deletions

diff --git a/packet-afs.c b/packet-afs.c
new file mode 100644
index 0000000000..b3f9240bb9
--- /dev/null
+++ b/packet-afs.c
@@ -0,0 +1,2502 @@
+/* packet-rx.c
+ * Routines for RX packet dissection
+ * Copyright 1999, Nathan Neulinger <nneul@umr.edu>
+ * Based on routines from tcpdump patches by
+ *   Ken Hornstein <kenh@cmf.nrl.navy.mil>
+ * Portions based on information retrieved from the RX definitions
+ *   in Arla, the free AFS client at http://www.stacken.kth.se/project/arla/
+ *
+ * $Id: packet-afs.c,v 1.1 1999/10/20 16:41:17 gram Exp $
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@unicom.net>
+ * Copyright 1998 Gerald Combs
+ *
+ * Copied from packet-tftp.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif
+
+#include <string.h>
+#include <glib.h>
+#include "packet.h"
+#include "packet-rx.h"
+#include "packet-afs.h"
+#include "resolv.h"
+
+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,		"oldsetlock" },
+	{ 144,		"oldextlock" },
+	{ 145,		"oldrellock" },
+	{ 146,		"get-stats" },
+	{ 147,		"give-cbs" },
+	{ 148,		"get-vlinfo" },
+	{ 149,		"get-vlstats" },
+	{ 150,		"set-vlstats" },
+	{ 151,		"get-rootvl" },
+	{ 152,		"check-token" },
+	{ 153,		"get-time" },
+	{ 154,		"nget-vlinfo" },
+	{ 155,		"bulk-stat" },
+	{ 156,		"setlock" },
+	{ 157,		"extlock" },
+	{ 158,		"rellock" },
+	{ 159,		"xstat-ver" },
+	{ 160,		"get-xstat" },
+	{ 161,		"dfs-lookup" },
+	{ 162,		"dfs-flushcps" },
+	{ 163,		"dfs-symlink" },
+	{ 0,		NULL },
+};
+
+static const value_string cb_req[] = {
+	{ 204,		"callback" },
+	{ 205,		"initcb" },
+	{ 206,		"probe" },
+	{ 207,		"getlock" },
+	{ 208,		"getce" },
+	{ 209,		"xstatver" },
+	{ 210,		"getxstat" },
+	{ 211,		"initcb2" },
+	{ 212,		"whoareyou" },
+	{ 213,		"initcb3" },
+	{ 214,		"probeuuid" },
+	{ 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,		"same-mbr-of" },
+	{ 516,		"set-fld-sentry" },
+	{ 517,		"list-owned" },
+	{ 518,		"get-cps2" },
+	{ 519,		"get-host-cps" },
+	{ 520,		"update-entry" },
+	{ 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,		"setlock" },
+	{ 509,		"releaselock" },
+	{ 510,		"list-entry" },
+	{ 511,		"list-attrib" },
+	{ 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" },
+	{ 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" },
+	{ 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,		"start-bozo-install" },
+	{ 106,		"uninstall" },
+	{ 107,		"get-dates" },
+	{ 108,		"exec" },
+	{ 109,		"prune" },
+	{ 110,		"set-restart-time" },
+	{ 111,		"get-restart-time" },
+	{ 112,		"start-bozo-log" },
+	{ 113,		"wait-all" },
+	{ 114,		"get-instance-strings" },
+	{ 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" },
+	{ 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, "VL_IDALREADHASED"},
+	{ 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 */
+	{ 180488, "No Authentication"},
+	{ 180490, "Bad Request"},
+
+	/* someone please 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 volume_types[] = {
+	{ 0,		"read-write" },
+	{ 1,		"read-only" },
+	{ 2,		"backup" },
+	{ 0,		NULL },
+};
+
+int afs_packet_init_count = 100;
+
+struct afs_request_key {
+  guint32 ip_src, ip_dst, callnumber;
+  guint16 port_src, port_dst, service;
+};
+
+struct afs_request_val {
+  guint32 opcode;
+};
+
+GHashTable *afs_request_hash = NULL;
+GMemChunk *afs_request_keys = NULL;
+GMemChunk *afs_request_vals = NULL;
+
+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_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_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_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_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_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_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_syncsite = -1;
+static int hf_afs_ubik_site = -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;
+
+/*
+ * Dissector prototypes
+ */
+static void dissect_fs_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_fs_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_cb_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_cb_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_bos_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_bos_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_vol_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_vol_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_ubik_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_ubik_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_kauth_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_kauth_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_prot_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_prot_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_vldb_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_vldb_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_backup_request(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+static void dissect_backup_reply(const u_char *pd,
+	int offset, frame_data *fd, proto_tree *tree, int opcode);
+
+
+/*
+ * Hash Functions - copied from packet-afs.c
+ */
+gint
+afs_equal(gconstpointer v, gconstpointer w)
+{
+  struct afs_request_key *v1 = (struct afs_request_key *)v;
+  struct afs_request_key *v2 = (struct afs_request_key *)w;
+
+  if (v1 -> ip_src   == v2 -> ip_src &&
+      v1 -> ip_dst   == v2 -> ip_dst &&
+      v1 -> port_src == v2 -> port_src &&
+      v1 -> port_dst == v2 -> port_dst &&
+      v1 -> service  == v2 -> service &&
+      v1 -> callnumber == v2 -> callnumber ) {
+
+    return 1;
+  }
+
+  return 0;
+}
+
+guint
+afs_hash (gconstpointer v)
+{
+	struct afs_request_key *key = (struct afs_request_key *)v;
+	guint val;
+
+	val = key -> ip_src + key -> ip_dst +
+		key -> port_src + key -> port_dst +
+		key -> service + key -> callnumber;
+
+	return val;
+}
+
+/*
+ * Protocol initialization
+ */
+void
+afs_init_protocol(void)
+{
+	if (afs_request_hash)
+		g_hash_table_destroy(afs_request_hash);
+	if (afs_request_keys)
+		g_mem_chunk_destroy(afs_request_keys);
+	if (afs_request_vals)
+		g_mem_chunk_destroy(afs_request_vals);
+
+	afs_request_hash = g_hash_table_new(afs_hash, afs_equal);
+	afs_request_keys = g_mem_chunk_new("afs_request_keys",
+		sizeof(struct afs_request_key),
+		afs_packet_init_count * sizeof(struct afs_request_key),
+		G_ALLOC_AND_FREE);
+	afs_request_vals = g_mem_chunk_new("afs_request_vals",
+		sizeof(struct afs_request_val),
+		afs_packet_init_count * sizeof(struct afs_request_val),
+		G_ALLOC_AND_FREE);
+}
+
+
+
+/*
+ * Dissection routines
+ */
+
+void
+dissect_afs(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
+{
+	proto_tree      *afs_tree, *afs_op_tree, *ti;
+	struct rx_header *rxh;
+	struct afs_header *afsh;
+	int port, node, typenode, opcode;
+	value_string const *vals;
+	int reply = 0;
+	int doffset = 0;
+	struct afs_request_key request_key, *new_request_key;
+	struct afs_request_val *request_val;
+	void (*dissector)(const u_char *pd, int offset,
+		frame_data *fd, proto_tree *tree, int opcode);
+
+	rxh = (struct rx_header *) &pd[offset];
+	doffset = offset + sizeof(struct rx_header);
+	afsh = (struct afs_header *) &pd[doffset];
+
+	/* get at least a full packet structure */
+	if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header)) )
+		return;
+
+	if (check_col(fd, COL_PROTOCOL))
+		col_add_str(fd, COL_PROTOCOL, "AFS (RX)");
+
+	reply = (rxh->flags & RX_CLIENT_INITIATED) == 0;
+	port = ((reply == 0) ? pi.destport : pi.srcport );
+
+	request_key.ip_src   = ((reply == 0) ? pi.ip_src : pi.ip_dst);
+	request_key.ip_dst   = ((reply == 0) ? pi.ip_dst : pi.ip_src);
+	request_key.port_src = ((reply == 0) ? pi.srcport : pi.destport);
+	request_key.port_dst = ((reply == 0) ? pi.destport : pi.srcport);
+	request_key.service = ntohs(rxh->serviceId);
+	request_key.callnumber = ntohl(rxh->callNumber);
+
+	request_val = (struct afs_request_val *) g_hash_table_lookup(
+		afs_request_hash, &request_key);
+
+	/* only allocate a new hash element when it's a request */
+	opcode = 0;
+	if ( !request_val && !reply)
+	{
+		new_request_key = g_mem_chunk_alloc(afs_request_keys);
+		*new_request_key = request_key;
+
+		request_val = g_mem_chunk_alloc(afs_request_vals);
+		request_val -> opcode = ntohl(afsh->opcode);
+		opcode = request_val->opcode;
+
+		g_hash_table_insert(afs_request_hash, new_request_key,
+			request_val);
+	}
+
+	if ( request_val )
+	{
+		opcode = request_val->opcode;
+	}
+
+	node = 0;
+	typenode = 0;
+	vals = NULL;
+	dissector = NULL;
+	switch (port)
+	{
+		case AFS_PORT_FS:
+			typenode = hf_afs_fs;
+			node = hf_afs_fs_opcode;
+			vals = fs_req;
+			dissector = reply ? dissect_fs_reply : dissect_fs_request;
+			break;
+		case AFS_PORT_CB:
+			typenode = hf_afs_cb;
+			node = hf_afs_cb_opcode;
+			vals = cb_req;
+			dissector = reply ? dissect_cb_reply : dissect_cb_request;
+			break;
+		case AFS_PORT_PROT:
+			typenode = hf_afs_prot;
+			node = hf_afs_prot_opcode;
+			vals = prot_req;
+			dissector = reply ? dissect_prot_reply : dissect_prot_request;
+			break;
+		case AFS_PORT_VLDB:
+			typenode = hf_afs_vldb;
+			node = hf_afs_vldb_opcode;
+			vals = vldb_req;
+			dissector = reply ? dissect_vldb_reply : dissect_vldb_request;
+			break;
+		case AFS_PORT_KAUTH:
+			typenode = hf_afs_kauth;
+			node = hf_afs_kauth_opcode;
+			vals = kauth_req;
+			dissector = reply ? dissect_kauth_reply : dissect_kauth_request;
+			break;
+		case AFS_PORT_VOL:
+			typenode = hf_afs_vol;
+			node = hf_afs_vol_opcode;
+			vals = vol_req;
+			dissector = reply ? dissect_vol_reply : dissect_vol_request;
+			break;
+		case AFS_PORT_ERROR:
+			typenode = hf_afs_error;
+			node = hf_afs_error_opcode;
+//			dissector = reply ? dissect_error_reply : dissect_error_request;
+			break;
+		case AFS_PORT_BOS:
+			typenode = hf_afs_bos;
+			node = hf_afs_bos_opcode;
+			vals = bos_req;
+			dissector = reply ? dissect_bos_reply : dissect_bos_request;
+			break;
+		case AFS_PORT_UPDATE:
+			typenode = hf_afs_update;
+			node = hf_afs_update_opcode;
+//			dissector = reply ? dissect_update_reply : dissect_update_request;
+			break;
+		case AFS_PORT_RMTSYS:
+			typenode = hf_afs_rmtsys;
+			node = hf_afs_rmtsys_opcode;
+//			dissector = reply ? dissect_rmtsys_reply : dissect_rmtsys_request;
+			break;
+		case AFS_PORT_BACKUP:
+			typenode = hf_afs_backup;
+			node = hf_afs_backup_opcode;
+			dissector = reply ? dissect_backup_reply : dissect_backup_request;
+			break;
+	}
+	if ( (opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
+		(opcode >= DISK_LOW && opcode <= DISK_HIGH) )
+	{
+		typenode = hf_afs_ubik;
+		node = hf_afs_ubik_opcode;
+		vals = ubik_req;
+		dissector = reply ? dissect_ubik_reply : dissect_ubik_request;
+	}
+
+	if ( vals )
+	{
+		if (check_col(fd, COL_INFO))
+			col_add_fstr(fd, COL_INFO, "%s %s: %s (%d)",
+			val_to_str(port, port_types_short, "Unknown(%d)"),
+			reply ? "Reply" : "Request",
+			val_to_str(opcode, vals, "Unknown(%d)"), opcode);
+	}
+	else
+	{
+		if (check_col(fd, COL_INFO))
+			col_add_fstr(fd, COL_INFO, "%s %s: Unknown(%d)",
+			val_to_str(port, port_types_short, "Unknown(%d)"),
+			reply ? "Reply" : "Request",
+			opcode);
+	}
+
+	if (tree) {
+		ti = proto_tree_add_item(tree, proto_afs, doffset, END_OF_FRAME);
+		afs_tree = proto_item_add_subtree(ti, ETT_AFS);
+
+		if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header) +
+			sizeof(struct afs_header)) )
+		{
+			proto_tree_add_text(afs_tree, doffset, END_OF_FRAME,
+				"Service: %s %s (Truncated)",
+				val_to_str(port, port_types, "Unknown(%d)"),
+				reply ? "Reply" : "Request");
+				return;
+		}
+		else
+		{
+			proto_tree_add_text(afs_tree, doffset, END_OF_FRAME,
+				"Service: %s %s",
+				val_to_str(port, port_types, "Unknown(%d)"),
+				reply ? "Reply" : "Request");
+		}
+
+		/* until we do cache, can't handle replies */
+		ti = NULL;
+		if ( !reply && node != 0 )
+		{
+			ti = proto_tree_add_item(afs_tree,
+				node, doffset, 4, opcode);
+		}
+		else if ( reply && node != 0 )
+		{
+			/* the opcode isn't in this packet */
+			ti = proto_tree_add_item(afs_tree,
+				node, doffset, 0, opcode);
+		}
+		else
+		{
+			ti = proto_tree_add_text(afs_tree,
+				doffset, 0, "Operation: Unknown");
+		}
+
+		/* Add the subtree for this particular service */
+		afs_op_tree = proto_item_add_subtree(ti, ETT_AFS_OP);
+
+		if ( typenode != 0 )
+		{
+			/* indicate the type of request */
+			proto_tree_add_item_hidden(afs_tree, typenode, doffset, 0, 1);
+		}
+
+		/* Process the packet according to what service it is */
+		if ( dissector )
+		{
+			(*dissector)(pd,offset,fd,afs_op_tree,opcode);
+		}
+	}
+
+	/* if it's the last packet, and it's a reply, remove opcode
+		from hash */
+	/* ignoring for now, I'm not sure how the chunk deallocation works */
+	if ( rxh->flags & RX_LAST_PACKET && reply )
+	{
+
+	}
+}
+
+/*
+ * Macros for helper dissection routines
+ *
+ * The macros are here to save on coding. They assume that
+ * the current offset is in 'curoffset', and that the offset
+ * should be incremented after performing the macro's operation.
+ */
+
+// Get the next available integer, be sure and call TRUNC beforehand
+#define GETINT() (ntohl( *((int*)&pd[curoffset]) ))
+
+// Check if enough bytes are present, if not, return to caller
+// after adding a 'Truncated' message to tree
+#define TRUNC(bytes) \
+	if(!BYTES_ARE_IN_FRAME(curoffset,(bytes))) \
+	{ proto_tree_add_text(tree,curoffset,END_OF_FRAME,"Truncated"); \
+	return; }
+
+// Output a unsigned integer, stored into field 'field'
+// Assumes it is in network byte order, converts to host before using
+#define UINTOUT(field) \
+	TRUNC(sizeof(guint32)) \
+	proto_tree_add_item(tree,field,curoffset,sizeof(guint32), GETINT()); \
+	curoffset += 4;
+
+// Output a unsigned integer, stored into field 'field'
+// Assumes it is in network byte order, converts to host before using
+#define IPOUT(field) \
+	TRUNC(sizeof(gint32)) \
+	proto_tree_add_item(tree,field,curoffset,sizeof(gint32),\
+		*((int*)&pd[curoffset]));\
+	curoffset += 4;
+
+// Output a unix timestamp, after converting to a timeval
+#define BIGDATEOUT(field) \
+	{ struct timeval tv; \
+	TRUNC(2*sizeof(guint32)); \
+	tv.tv_sec = GETINT(); \
+	tv.tv_usec = GETINT(); \
+	proto_tree_add_item(tree,field,curoffset,2*sizeof(guint32),&tv); \
+	curoffset += 8; \
+	}
+
+// Output a unix timestamp, after converting to a timeval
+#define DATEOUT(field) \
+	{ struct timeval tv; \
+	TRUNC(sizeof(guint32)); \
+	tv.tv_sec = GETINT(); \
+	tv.tv_usec = 0; \
+	proto_tree_add_item(tree,field,curoffset,sizeof(guint32),&tv); \
+	curoffset += 4; \
+	}
+
+
+// Output a callback
+#define FS_CALLBACKOUT() \
+	{ 	proto_tree *save, *ti; \
+		ti = proto_tree_add_text(tree, curoffset, 3*4, "Callback"); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_CALLBACK); \
+		TRUNC(3*sizeof(guint32)); \
+		UINTOUT(hf_afs_fs_callback_version); \
+		BIGDATEOUT(hf_afs_fs_callback_expires); \
+		UINTOUT(hf_afs_fs_callback_type); \
+		tree = save; \
+	}
+
+// Output a callback
+#define CB_CALLBACKOUT() \
+	{ 	proto_tree *save, *ti; \
+		ti = proto_tree_add_text(tree, curoffset, 3*4, "Callback"); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_CALLBACK); \
+		TRUNC(3*sizeof(guint32)); \
+		UINTOUT(hf_afs_cb_callback_version); \
+		DATEOUT(hf_afs_cb_callback_expires); \
+		UINTOUT(hf_afs_cb_callback_type); \
+		tree = save; \
+	}
+
+
+// Output a File ID
+#define FS_FIDOUT(label) \
+	{ 	proto_tree *save, *ti; \
+		ti = proto_tree_add_text(tree, curoffset, 3*4, \
+			"FileID (%s)", label); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_FID); \
+		UINTOUT(hf_afs_fs_fid_volume); \
+		UINTOUT(hf_afs_fs_fid_vnode); \
+		UINTOUT(hf_afs_fs_fid_uniqifier); \
+		tree = save; \
+	}
+
+// Output a File ID
+#define CB_FIDOUT(label) \
+	{ 	proto_tree *save, *ti; \
+		ti = proto_tree_add_text(tree, curoffset, 3*4, \
+			"FileID (%s)", label); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_FID); \
+		UINTOUT(hf_afs_cb_fid_volume); \
+		UINTOUT(hf_afs_cb_fid_vnode); \
+		UINTOUT(hf_afs_cb_fid_uniqifier); \
+		tree = save; \
+	}
+
+// 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, curoffset, bytes, \
+			"ACL:  %s %s%s", \
+			who, tmp, positive ? "" : " (negative)"); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_ACL); \
+		proto_tree_add_item(tree,hf_afs_fs_acl_entity,curoffset,strlen(who), who);\
+		tmpoffset = curoffset + strlen(who) + 1; \
+		acllen = bytes - strlen(who) - 1; \
+		proto_tree_add_item(tree,hf_afs_fs_acl_r,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_l,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_i,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_d,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_w,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_k,tmpoffset,acllen,acl);\
+		proto_tree_add_item(tree,hf_afs_fs_acl_a,tmpoffset,acllen,acl);\
+		tree = save; \
+	}
+
+// Skip a certain number of bytes
+#define SKIP(bytes) \
+	TRUNC(bytes) \
+	curoffset += bytes;
+
+// Raw data - to end of frame
+#define RAWOUT(field) BYTESOUT(field, offset+END_OF_FRAME-curoffset)
+
+// Raw data
+#define BYTESOUT(field, bytes) \
+	TRUNC(bytes); \
+	proto_tree_add_item(tree,field,curoffset,bytes,\
+		(void *)&pd[curoffset]); \
+	curoffset += bytes;
+
+// Output a rx style string, up to a maximum length
+// first 4 bytes - length, then char data
+#define STROUT(field) \
+	{	int i; \
+		TRUNC(4); \
+		i = ntohl(*((int *) &pd[curoffset])); \
+		curoffset += 4; \
+		TRUNC(i); \
+		if ( i > 0 ) { \
+			proto_tree_add_item(tree, field, curoffset-4, i+4, \
+			(void *)&pd[curoffset]); \
+		} else { \
+			proto_tree_add_item(tree, field, curoffset-4, 4, \
+			""); \
+		} \
+		curoffset += i; \
+	}
+
+// Output a fixed length vectorized string (each char is a 32 bit int)
+#define VECOUT(field, length) \
+	{ 	char tmp[length+1]; \
+		int i,soff; \
+		soff = curoffset;\
+		TRUNC(length * sizeof(guint32));\
+		for (i=0; i<length; i++)\
+		{\
+			tmp[i] = (char) GETINT();\
+			curoffset += sizeof(guint32);\
+		}\
+		tmp[length] = '\0';\
+		proto_tree_add_item(tree, field, soff, length, tmp);\
+	}
+
+// Output a UBIK version code
+#define UBIK_VERSIONOUT(label) \
+	{ 	proto_tree *save, *ti; \
+		unsigned int epoch,counter; \
+		struct timeval tv; \
+		TRUNC(8); \
+		epoch = GETINT(); \
+		curoffset += 4; \
+		counter = GETINT(); \
+		curoffset += 4; \
+		tv.tv_sec = epoch; \
+		tv.tv_usec = 0; \
+		ti = proto_tree_add_text(tree, curoffset, 3*4, \
+			"UBIK Version (%s): %u.%u", label, epoch, counter ); \
+		save = tree; \
+		tree = proto_item_add_subtree(ti, ETT_AFS_UBIKVER); \
+		proto_tree_add_item(tree,hf_afs_ubik_version_epoch,curoffset-8, \
+			sizeof(guint32),&tv); \
+		proto_tree_add_item(tree,hf_afs_ubik_version_counter,curoffset-4, \
+			sizeof(guint32),counter); \
+		tree = save; \
+	}
+
+/*
+ * Here is a helper routine for adding an AFS acl to the proto tree
+ * This is to be used with FS packets only
+ *
+ * An AFS ACL is a string that has the following format:
+ *
+ * <positive> <negative>
+ * <uid1> <aclbits1>
+ * ....
+ *
+ * "positive" and "negative" are integers which contain the number of
+ * positive and negative ACL's in the string.  The uid/aclbits pair are
+ * ASCII strings containing the UID/PTS record and and a ascii number
+ * representing a logical OR of all the ACL permission bits
+ */
+
+static void dissect_acl(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
+{
+	int pos, neg, acl;
+	int n, i, bytes;
+	u_char const *s;
+	u_char const *end;
+	char user[128];
+	int curoffset;
+	int soff,eoff;
+
+	curoffset = offset;
+
+	TRUNC(sizeof(guint32));
+	bytes = ntohl(*((int *) &pd[curoffset]));
+	UINTOUT(hf_afs_fs_acl_datasize);
+
+	TRUNC(bytes);
+
+	soff = curoffset;
+	eoff = curoffset+bytes;
+
+	s = &pd[soff];
+	end = &pd[eoff];
+
+	if (sscanf((char *) s, "%d %n", &pos, &n) != 1)
+		return;
+	s += n;
+	TRUNC(1);
+	proto_tree_add_item(tree, hf_afs_fs_acl_count_positive, curoffset, n, pos);
+	curoffset += n;
+
+	if (sscanf((char *) s, "%d %n", &neg, &n) != 1)
+		return;
+	s += n;
+	TRUNC(1);
+	proto_tree_add_item(tree, hf_afs_fs_acl_count_negative, curoffset, n, neg);
+	curoffset += n;
+
+
+	/*
+	 * This wacky order preserves the order used by the "fs" command
+	 */
+
+	for (i = 0; i < pos; i++) {
+		if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
+			return;
+		s += n;
+		ACLOUT(user,1,acl,n);
+		curoffset += n;
+		TRUNC(1);
+	}
+
+	for (i = 0; i < neg; i++) {
+		if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
+			return;
+		s += n;
+		ACLOUT(user,0,acl,n);
+		curoffset += n;
+		if (s > end)
+			return;
+	}
+}
+
+/*
+ * Here are the helper dissection routines
+ */
+
+static void
+dissect_fs_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 130: /* fetch data */
+				RAWOUT(hf_afs_fs_data);
+				break;
+			case 131: /* fetch acl */
+				dissect_acl(pd,curoffset,fd,tree);
+				break;
+			case 137: /* create file */
+				FS_FIDOUT("New File");
+				break;
+			case 141: /* make dir */
+				FS_FIDOUT("New Directory");
+				break;
+			case 151: /* root volume */
+				STROUT(hf_afs_fs_volname);
+				break;
+			case 153: /* get time */
+				BIGDATEOUT(hf_afs_fs_timestamp);
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_fs_errcode);
+	}
+}
+
+static void
+dissect_fs_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 130: /* Fetch data */
+			FS_FIDOUT("Source");
+			UINTOUT(hf_afs_fs_offset);
+			UINTOUT(hf_afs_fs_length);
+			break;
+		case 131: /* Fetch ACL */
+		case 132: /* Fetch Status */
+		case 135: /* Store Status */
+		case 143: /* Old Set Lock */
+		case 144: /* Old Extend Lock */
+		case 145: /* Old Release Lock */
+		case 156: /* Set Lock */
+		case 157: /* Extend Lock */
+		case 158: /* Release Lock */
+			FS_FIDOUT("Target");
+			break;
+		case 133: /* Store Data */
+			FS_FIDOUT("Destination");
+			SKIP(6*sizeof(guint32));
+			UINTOUT(hf_afs_fs_offset);
+			UINTOUT(hf_afs_fs_length);
+			UINTOUT(hf_afs_fs_flength);
+			break;
+		case 134: /* Store ACL */
+			FS_FIDOUT("Target");
+			dissect_acl(pd,curoffset,fd,tree);
+			/* print acl */
+			break;
+		case 136: /* Remove File */
+		case 137: /* Create File */
+		case 141: /* Make dir */
+		case 142: /* Remove dir */
+			FS_FIDOUT("Target");
+			STROUT(hf_afs_fs_name);
+			break;
+		case 138: /* Rename file */
+			FS_FIDOUT("Old");
+			STROUT(hf_afs_fs_oldname);
+			FS_FIDOUT("New");
+			STROUT(hf_afs_fs_newname);
+			break;
+		case 139: /* Symlink */
+			FS_FIDOUT("File");
+			STROUT(hf_afs_fs_symlink_name);
+			STROUT(hf_afs_fs_symlink_content);
+			break;
+		case 140: /* Link */
+			FS_FIDOUT("Link From (Old File)");
+			STROUT(hf_afs_fs_name);
+			FS_FIDOUT("Link To (New File)");
+			break;
+		case 148: /* Get vol info */
+			STROUT(hf_afs_fs_volname);
+			break;
+		case 149: /* Get vol stats */
+		case 150: /* Set vol stats */
+			UINTOUT(hf_afs_fs_volid);
+			break;
+		case 154: /* new get vol info */
+			STROUT(hf_afs_fs_volname);
+			break;
+		case 155: /* bulk stat */
+		{
+			unsigned int j,i;
+			TRUNC(1);
+
+			j = ntohl( *((int*)&pd[curoffset]) );
+			curoffset += 1;
+			for (i=0; i<j; i++)
+			{
+				FS_FIDOUT("Target");
+			}
+			break;
+		}
+	}
+}
+
+/*
+ * BOS Helpers
+ */
+static void
+dissect_bos_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 85: /* get instance info */
+				STROUT(hf_afs_bos_type);
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_bos_errcode);
+	}
+}
+
+static void
+dissect_bos_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 80: /* create b node */
+			STROUT(hf_afs_bos_type);
+			STROUT(hf_afs_bos_instance);
+			break;
+		case 81: /* delete b node */
+		case 83: /* get status */
+		case 85: /* get instance info */
+		case 87: /* add super user */
+		case 88: /* delete super user */
+		case 93: /* set cell name */
+		case 96: /* add cell host */
+		case 97: /* delete cell host */
+		case 104: /* restart */
+		case 106: /* uninstall */
+		case 108: /* exec */
+		case 112: /* get log */
+		case 114: /* get instance strings */
+			STROUT(hf_afs_bos_content);
+			break;
+		case 82: /* set status */
+		case 98: /* set t status */
+			STROUT(hf_afs_bos_content);
+			UINTOUT(hf_afs_bos_status);
+			break;
+		case 86: /* get instance parm */
+			STROUT(hf_afs_bos_instance);
+			UINTOUT(hf_afs_bos_num);
+			break;
+		case 84: /* enumerate instance */
+		case 89: /* list super users */
+		case 90: /* list keys */
+		case 91: /* add key */
+		case 92: /* delete key */
+		case 95: /* set cell host */
+			UINTOUT(hf_afs_bos_num);
+			break;
+		case 105: /* install */
+			STROUT(hf_afs_bos_content);
+			UINTOUT(hf_afs_bos_size);
+			UINTOUT(hf_afs_bos_flags);
+			UINTOUT(hf_afs_bos_date);
+			break;
+	}
+}
+
+/*
+ * VOL Helpers
+ */
+static void
+dissect_vol_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 121:
+				/* should loop here maybe */
+				UINTOUT(hf_afs_vol_count);
+				VECOUT(hf_afs_vol_name, 32); /* not sure on  */
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_vol_errcode);
+	}
+}
+
+static void
+dissect_vol_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 121: /* list one vol */
+			UINTOUT(hf_afs_vol_count);
+			UINTOUT(hf_afs_vol_id);
+			break;
+	}
+}
+
+/*
+ * KAUTH Helpers
+ */
+static void
+dissect_kauth_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_kauth_errcode);
+	}
+}
+
+static void
+dissect_kauth_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 1: /* authenticate old */
+		case 21: /* authenticate */
+		case 22: /* authenticate v2 */
+		case 2: /* change pw */
+		case 5: /* set fields */
+		case 6: /* create user */
+		case 7: /* delete user */
+		case 8: /* get entry */
+		case 14: /* unlock */
+		case 15: /* lock status */
+			STROUT(hf_afs_kauth_princ);
+			STROUT(hf_afs_kauth_realm);
+			RAWOUT(hf_afs_kauth_data);
+			break;
+		case 3: /* getticket-old */
+		case 23: /* getticket */
+			UINTOUT(hf_afs_kauth_kvno);
+			STROUT(hf_afs_kauth_domain);
+			STROUT(hf_afs_kauth_data);
+			STROUT(hf_afs_kauth_princ);
+			STROUT(hf_afs_kauth_realm);
+			break;
+		case 4: /* set pass */
+			STROUT(hf_afs_kauth_princ);
+			STROUT(hf_afs_kauth_realm);
+			UINTOUT(hf_afs_kauth_kvno);
+			break;
+		case 12: /* get pass */
+			STROUT(hf_afs_kauth_name);
+			break;
+	}
+}
+
+/*
+ * CB Helpers
+ */
+static void
+dissect_cb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_cb_errcode);
+	}
+}
+
+static void
+dissect_cb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 204: /* callback */
+		{
+			unsigned int i,j;
+
+			TRUNC(4);
+			j = GETINT();
+
+			for (i=0; i<j; i++)
+			{
+				CB_FIDOUT("Target");
+			}
+
+			TRUNC(4);
+			j = GETINT();
+			for (i=0; i<j; i++)
+			{
+				CB_CALLBACKOUT();
+			}
+		}
+	}
+}
+
+/*
+ * PROT Helpers
+ */
+static void
+dissect_prot_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 504: /* name to id */
+				{
+					unsigned int i, j;
+
+					TRUNC(4);
+					j = GETINT();
+					UINTOUT(hf_afs_prot_count);
+
+					for (i=0; i<j; i++)
+					{
+						UINTOUT(hf_afs_prot_id);
+					}
+				}
+				break;
+			case 505: /* id to name */
+				{
+					unsigned int i, j;
+
+					TRUNC(4);
+					j = GETINT();
+					UINTOUT(hf_afs_prot_count);
+
+					for (i=0; i<j; i++)
+					{
+						VECOUT(hf_afs_prot_name, PRNAMEMAX);
+					}
+				}
+				break;
+			case 508: /* get cps */
+			case 514: /* list elements */
+			case 517: /* list owned */
+			case 518: /* get cps2 */
+			case 519: /* get host cps */
+				{
+					unsigned int i, j;
+
+					TRUNC(4);
+					j = GETINT();
+					UINTOUT(hf_afs_prot_count);
+
+					for (i=0; i<j; i++)
+					{
+						UINTOUT(hf_afs_prot_id);
+					}
+				}
+				break;
+			case 510: /* list max */
+				UINTOUT(hf_afs_prot_maxuid);
+				UINTOUT(hf_afs_prot_maxgid);
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_prot_errcode);
+	}
+}
+
+static void
+dissect_prot_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 500: /* new user */
+			STROUT(hf_afs_prot_name);
+			UINTOUT(hf_afs_prot_id);
+			UINTOUT(hf_afs_prot_oldid);
+			break;
+		case 501: /* where is it */
+		case 506: /* delete */
+		case 508: /* get cps */
+		case 512: /* list entry */
+		case 514: /* list elements */
+		case 517: /* list owned */
+		case 519: /* get host cps */
+			UINTOUT(hf_afs_prot_id);
+			break;
+		case 502: /* dump entry */
+			UINTOUT(hf_afs_prot_pos);
+			break;
+		case 503: /* add to group */
+		case 507: /* remove from group */
+		case 515: /* is a member of? */
+			UINTOUT(hf_afs_prot_uid);
+			UINTOUT(hf_afs_prot_gid);
+			break;
+		case 504: /* name to id */
+			{
+				unsigned int i, j;
+
+				TRUNC(4);
+				j = GETINT();
+				UINTOUT(hf_afs_prot_count);
+
+				for (i=0; i<j; i++)
+				{
+					VECOUT(hf_afs_prot_name,PRNAMEMAX);
+				}
+			}
+			break;
+		case 505: /* id to name */
+			{
+				unsigned int i, j;
+
+				TRUNC(4);
+				j = GETINT();
+				UINTOUT(hf_afs_prot_count);
+
+				for (i=0; i<j; i++)
+				{
+					UINTOUT(hf_afs_prot_id);
+				}
+			}
+			break;
+		case 509: /* new entry */
+			STROUT(hf_afs_prot_name);
+			UINTOUT(hf_afs_prot_flag);
+			UINTOUT(hf_afs_prot_oldid);
+			break;
+		case 511: /* set max */
+			UINTOUT(hf_afs_prot_id);
+			UINTOUT(hf_afs_prot_flag);
+			break;
+		case 513: /* change entry */
+			UINTOUT(hf_afs_prot_id);
+			STROUT(hf_afs_prot_name);
+			UINTOUT(hf_afs_prot_oldid);
+			UINTOUT(hf_afs_prot_newid);
+			break;
+		case 520: /* update entry */
+			UINTOUT(hf_afs_prot_id);
+			STROUT(hf_afs_prot_name);
+			break;
+	}
+}
+
+/*
+ * VLDB Helpers
+ */
+static void
+dissect_vldb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 510: /* list entry */
+				UINTOUT(hf_afs_vldb_count);
+				UINTOUT(hf_afs_vldb_nextindex);
+				break;
+			case 503: /* get entry by id */
+			case 504: /* get entry by name */
+				{
+					int nservers,i,j;
+					VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+					TRUNC(4);
+					nservers = GETINT();
+					UINTOUT(hf_afs_vldb_numservers);
+					for (i=0; i<8; i++)
+					{
+						if ( i<nservers )
+						{
+							IPOUT(hf_afs_vldb_server);
+						}
+						else
+						{
+							SKIP(4);
+						}
+					}
+					for (i=0; i<8; i++)
+					{
+						char part[8];
+						TRUNC(4);
+						j = GETINT();
+						strcpy(part, "/vicepa");
+						if ( i<nservers && j<=26 )
+						{
+							part[6] = (char) j;
+							proto_tree_add_item(tree, hf_afs_vldb_partition,
+								curoffset, 4, part);
+						}
+						SKIP(4);
+					}
+					SKIP(8 * sizeof(guint32));
+					UINTOUT(hf_afs_vldb_rwvol);
+					UINTOUT(hf_afs_vldb_rovol);
+					UINTOUT(hf_afs_vldb_bkvol);
+				}
+				break;
+			case 505: /* get new volume id */
+				UINTOUT(hf_afs_vldb_id);
+				break;
+			case 521: /* list entry */
+			case 529: /* list entry U */
+				UINTOUT(hf_afs_vldb_count);
+				UINTOUT(hf_afs_vldb_nextindex);
+				break;
+			case 518: /* get entry by id n */
+			case 519: /* get entry by name N */
+				{
+					int nservers,i,j;
+					VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+					TRUNC(4);
+					nservers = GETINT();
+					UINTOUT(hf_afs_vldb_numservers);
+					for (i=0; i<13; i++)
+					{
+						if ( i<nservers )
+						{
+							IPOUT(hf_afs_vldb_server);
+						}
+						else
+						{
+							SKIP(4);
+						}
+					}
+					for (i=0; i<13; i++)
+					{
+						char part[8];
+						TRUNC(4);
+						j = GETINT();
+						strcpy(part, "/vicepa");
+						if ( i<nservers && j<=26 )
+						{
+							part[6] = (char) j;
+							proto_tree_add_item(tree, hf_afs_vldb_partition,
+								curoffset, 4, part);
+						}
+						SKIP(4);
+					}
+					SKIP(13 * sizeof(guint32));
+					UINTOUT(hf_afs_vldb_rwvol);
+					UINTOUT(hf_afs_vldb_rovol);
+					UINTOUT(hf_afs_vldb_bkvol);
+				}
+				break;
+			case 526: /* get entry by id u */
+			case 527: /* get entry by name u */
+				{
+					int nservers,i,j;
+					VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+					TRUNC(4);
+					nservers = GETINT();
+					UINTOUT(hf_afs_vldb_numservers);
+					for (i=0; i<13; i++)
+					{
+						if ( i<nservers )
+						{
+							BYTESOUT(hf_afs_vldb_serveruuid, 11*sizeof(guint32));
+						}
+						else
+						{
+							SKIP(11*sizeof(guint32));
+						}
+					}
+					for (i=0; i<13; i++)
+					{
+						char part[8];
+						TRUNC(4);
+						j = GETINT();
+						strcpy(part, "/vicepa");
+						if ( i<nservers && j<=26 )
+						{
+							part[6] = (char) j;
+							proto_tree_add_item(tree, hf_afs_vldb_partition,
+								curoffset, 4, part);
+						}
+						SKIP(4);
+					}
+					SKIP(13 * sizeof(guint32));
+					UINTOUT(hf_afs_vldb_rwvol);
+					UINTOUT(hf_afs_vldb_rovol);
+					UINTOUT(hf_afs_vldb_bkvol);
+				}
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_vldb_errcode);
+	}
+}
+
+static void
+dissect_vldb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 501: /* create new volume */
+		case 517: /* create entry N */
+			VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+			break;
+		case 502: /* delete entry */
+		case 503: /* get entry by id */
+		case 507: /* update entry */
+		case 508: /* set lock */
+		case 509: /* release lock */
+		case 518: /* get entry by id */
+			UINTOUT(hf_afs_vldb_id);
+			UINTOUT(hf_afs_vldb_type);
+			break;
+		case 504: /* get entry by name */
+		case 519: /* get entry by name N */
+		case 524: /* update entry by name */
+		case 527: /* get entry by name U */
+			STROUT(hf_afs_vldb_name);
+			break;
+		case 505: /* get new vol id */
+			UINTOUT(hf_afs_vldb_bump);
+			break;
+		case 506: /* replace entry */
+		case 520: /* replace entry N */
+			UINTOUT(hf_afs_vldb_id);
+			UINTOUT(hf_afs_vldb_type);
+			VECOUT(hf_afs_vldb_name, VLNAMEMAX);
+			break;
+		case 510: /* list entry */
+		case 521: /* list entry N */
+			UINTOUT(hf_afs_vldb_index);
+			break;
+	}
+}
+
+/*
+ * UBIK Helpers
+ */
+static void
+dissect_ubik_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+			case 10000: /* beacon */
+				proto_tree_add_item(tree,hf_afs_ubik_votetype,0,0,0);
+				break;
+			case 20004: /* get version */
+				UBIK_VERSIONOUT("DB Version");
+				break;
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		switch ( opcode )
+		{
+			case 10000:
+				proto_tree_add_item(tree,hf_afs_ubik_votetype,0,0,1);
+				DATEOUT(hf_afs_ubik_voteend);
+				break;
+			default:
+				UINTOUT(hf_afs_ubik_errcode);
+				break;
+		}
+	}
+}
+
+static void
+dissect_ubik_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+		case 10000: /* beacon */
+			UINTOUT(hf_afs_ubik_syncsite);
+			DATEOUT(hf_afs_ubik_votestart);
+			UBIK_VERSIONOUT("DB Version");
+			UBIK_VERSIONOUT("TID");
+			break;
+		case 10003: /* get sync site */
+			IPOUT(hf_afs_ubik_site);
+			break;
+		case 20000: /* begin */
+		case 20001: /* commit */
+		case 20007: /* abort */
+		case 20008: /* release locks */
+		case 20010: /* writev */
+			UBIK_VERSIONOUT("TID");
+			break;
+		case 20002: /* lock */
+			UBIK_VERSIONOUT("TID");
+			UINTOUT(hf_afs_ubik_file);
+			UINTOUT(hf_afs_ubik_pos);
+			UINTOUT(hf_afs_ubik_length);
+			UINTOUT(hf_afs_ubik_locktype);
+			break;
+		case 20003: /* write */
+			UBIK_VERSIONOUT("TID");
+			UINTOUT(hf_afs_ubik_file);
+			UINTOUT(hf_afs_ubik_pos);
+			break;
+		case 20005: /* get file */
+			UINTOUT(hf_afs_ubik_file);
+			break;
+		case 20006: /* send file */
+			UINTOUT(hf_afs_ubik_file);
+			UINTOUT(hf_afs_ubik_length);
+			UBIK_VERSIONOUT("DB Version");
+			break;
+		case 20009: /* truncate */
+			UBIK_VERSIONOUT("TID");
+			UINTOUT(hf_afs_ubik_file);
+			UINTOUT(hf_afs_ubik_length);
+			break;
+		case 20012: /* set version */
+			UBIK_VERSIONOUT("TID");
+			UBIK_VERSIONOUT("Old DB Version");
+			UBIK_VERSIONOUT("New DB Version");
+			break;
+	}
+}
+
+/*
+ * BACKUP Helpers
+ */
+static void
+dissect_backup_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	if ( rxh->type == RX_PACKET_TYPE_DATA )
+	{
+		switch ( opcode )
+		{
+		}
+	}
+	else if ( rxh->type == RX_PACKET_TYPE_ABORT )
+	{
+		UINTOUT(hf_afs_backup_errcode);
+	}
+}
+
+static void
+dissect_backup_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
+{
+	struct rx_header *rxh;
+	unsigned char *data;
+	int doffset, curoffset;
+
+	rxh = (struct rx_header *) &pd[offset];
+	data = (char *)rxh + sizeof(struct rx_header);
+	doffset = offset + sizeof(struct rx_header);
+	curoffset = doffset;
+
+	/* skip opcode */
+	SKIP(sizeof(guint32));
+
+	switch ( opcode )
+	{
+	}
+}
+
+/*
+ * Registration code for registering the protocol and fields
+ */
+
+void
+proto_register_afs(void)
+{
+	static hf_register_info hf[] = {
+
+		{ &hf_afs_fs, {
+			"File Server", "afs.fs", FT_BOOLEAN, BASE_NONE,
+			0, 0, "File Server" }},
+		{ &hf_afs_cb, {
+			"Callback", "afs.cb", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Callback" }},
+		{ &hf_afs_prot, {
+			"Protection", "afs.prot", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Protection" }},
+		{ &hf_afs_vldb, {
+			"VLDB", "afs.vldb", FT_BOOLEAN, BASE_NONE,
+			0, 0, "VLDB" }},
+		{ &hf_afs_kauth, {
+			"Kauth", "afs.kauth", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Kauth" }},
+		{ &hf_afs_vol, {
+			"Volume Server", "afs.vol", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Volume Server" }},
+		{ &hf_afs_error, {
+			"Error", "afs.error", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Error" }},
+		{ &hf_afs_bos, {
+			"BOS", "afs.bos", FT_BOOLEAN, BASE_NONE,
+			0, 0, "BOS" }},
+		{ &hf_afs_update, {
+			"Update", "afs.update", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Update" }},
+		{ &hf_afs_rmtsys, {
+			"Rmtsys", "afs.rmtsys", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Rmtsys" }},
+		{ &hf_afs_ubik, {
+			"Ubik", "afs.ubik", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Ubik" }},
+		{ &hf_afs_backup, {
+			"Backup", "afs.backup", FT_BOOLEAN, BASE_NONE,
+			0, 0, "Backup" }},
+
+		{ &hf_afs_fs_opcode, {
+			"Operation", "afs.fs.opcode", FT_UINT32, BASE_DEC,
+			VALS(fs_req), 0, "Operation" }},
+		{ &hf_afs_cb_opcode, {
+			"Operation", "afs.cb.opcode", FT_UINT32, BASE_DEC,
+			VALS(cb_req), 0, "Operation" }},
+		{ &hf_afs_prot_opcode, {
+			"Operation", "afs.prot.opcode", FT_UINT32, BASE_DEC,
+			VALS(prot_req), 0, "Operation" }},
+		{ &hf_afs_vldb_opcode, {
+			"Operation", "afs.vldb.opcode", FT_UINT32, BASE_DEC,
+			VALS(vldb_req), 0, "Operation" }},
+		{ &hf_afs_kauth_opcode, {
+			"Operation", "afs.kauth.opcode", FT_UINT32, BASE_DEC,
+			VALS(kauth_req), 0, "Operation" }},
+		{ &hf_afs_vol_opcode, {
+			"Operation", "afs.vol.opcode", FT_UINT32, BASE_DEC,
+			VALS(vol_req), 0, "Operation" }},
+		{ &hf_afs_bos_opcode, {
+			"Operation", "afs.bos.opcode", FT_UINT32, BASE_DEC,
+			VALS(bos_req), 0, "Operation" }},
+		{ &hf_afs_update_opcode, {
+			"Operation", "afs.update.opcode", FT_UINT32, BASE_DEC,
+			0, 0, "Operation" }},
+		{ &hf_afs_rmtsys_opcode, {
+			"Operation", "afs.rmtsys.opcode", FT_UINT32, BASE_DEC,
+			0, 0, "Operation" }},
+		{ &hf_afs_error_opcode, {
+			"Operation", "afs.error.opcode", FT_UINT32, BASE_DEC,
+			0, 0, "Operation" }},
+		{ &hf_afs_backup_opcode, {
+			"Operation", "afs.backup.opcode", FT_UINT32, BASE_DEC,
+			0, 0, "Operation" }},
+		{ &hf_afs_ubik_opcode, {
+			"Operation", "afs.ubik.opcode", FT_UINT32, BASE_DEC,
+			VALS(ubik_req), 0, "Operation" }},
+
+
+		/* File Server Fields */
+		{ &hf_afs_fs_fid_volume, {
+			"FileID (Volume)", "afs.fs.fid.volume", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (Volume)" }},
+		{ &hf_afs_fs_fid_vnode, {
+			"FileID (VNode)", "afs.fs.fid.vnode", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (VNode)" }},
+		{ &hf_afs_fs_fid_uniqifier, {
+			"FileID (Uniqifier)", "afs.fs.fid.uniq", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (Uniqifier)" }},
+		{ &hf_afs_fs_offset, {
+			"Offset", "afs.fs.offset", FT_UINT32, BASE_DEC,
+			0, 0, "Offset" }},
+		{ &hf_afs_fs_length, {
+			"Length", "afs.fs.length", FT_UINT32, BASE_DEC,
+			0, 0, "Length" }},
+		{ &hf_afs_fs_flength, {
+			"FLength", "afs.fs.flength", FT_UINT32, BASE_DEC,
+			0, 0, "FLength" }},
+		{ &hf_afs_fs_errcode, {
+			"Error Code", "afs.fs.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_fs_data, {
+			"Data", "afs.fs.data", FT_BYTES, BASE_HEX,
+			0, 0, "Data" }},
+		{ &hf_afs_fs_oldname, {
+			"Old Name", "afs.fs.oldname", FT_STRING, BASE_HEX,
+			0, 0, "Old Name" }},
+		{ &hf_afs_fs_newname, {
+			"New Name", "afs.fs.newname", FT_STRING, BASE_HEX,
+			0, 0, "New Name" }},
+		{ &hf_afs_fs_name, {
+			"Name", "afs.fs.name", FT_STRING, BASE_HEX,
+			0, 0, "Name" }},
+		{ &hf_afs_fs_symlink_name, {
+			"Symlink Name", "afs.fs.symlink.name", FT_STRING, BASE_HEX,
+			0, 0, "Symlink Name" }},
+		{ &hf_afs_fs_symlink_content, {
+			"Symlink Content", "afs.fs.symlink.content", FT_STRING, BASE_HEX,
+			0, 0, "Symlink Content" }},
+		{ &hf_afs_fs_volid, {
+			"Volume ID", "afs.fs.volid", FT_UINT32, BASE_DEC,
+			0, 0, "Volume ID" }},
+		{ &hf_afs_fs_volname, {
+			"Volume Name", "afs.fs.volname", FT_STRING, BASE_HEX,
+			0, 0, "Volume Name" }},
+		{ &hf_afs_fs_timestamp, {
+			"Timestamp", "afs.fs.timestamp", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Timestamp" }},
+
+		{ &hf_afs_fs_acl_count_positive, {
+			"ACL Count (Positive)", "afs.fs.acl.count.positive", FT_UINT32, BASE_DEC,
+			0, 0, "Number of Positive ACLs" }},
+		{ &hf_afs_fs_acl_count_negative, {
+			"ACL Count (Negative)", "afs.fs.acl.count.negative", FT_UINT32, BASE_DEC,
+			0, 0, "Number of Negative ACLs" }},
+		{ &hf_afs_fs_acl_datasize, {
+			"ACL Size", "afs.fs.acl.datasize", FT_UINT32, BASE_DEC,
+			0, 0, "ACL Data Size" }},
+		{ &hf_afs_fs_acl_entity, {
+			"Entity (User/Group)", "afs.fs.acl.entity", FT_STRING, BASE_HEX,
+			0, 0, "ACL Entity (User/Group)" }},
+		{ &hf_afs_fs_acl_r, {
+			"_R_ead", "afs.fs.acl.r", FT_UINT8, BASE_BIN,
+			0, PRSFS_READ, "Read" }},
+		{ &hf_afs_fs_acl_l, {
+			"_L_ookup", "afs.fs.acl.l", FT_UINT8, BASE_BIN,
+			0, PRSFS_LOOKUP, "Lookup" }},
+		{ &hf_afs_fs_acl_i, {
+			"_I_nsert", "afs.fs.acl.i", FT_UINT8, BASE_BIN,
+			0, PRSFS_INSERT, "Insert" }},
+		{ &hf_afs_fs_acl_d, {
+			"_D_elete", "afs.fs.acl.d", FT_UINT8, BASE_BIN,
+			0, PRSFS_DELETE, "Delete" }},
+		{ &hf_afs_fs_acl_w, {
+			"_W_rite", "afs.fs.acl.w", FT_UINT8, BASE_BIN,
+			0, PRSFS_WRITE, "Write" }},
+		{ &hf_afs_fs_acl_k, {
+			"_L_ock", "afs.fs.acl.k", FT_UINT8, BASE_BIN,
+			0, PRSFS_LOCK, "Lock" }},
+		{ &hf_afs_fs_acl_a, {
+			"_A_dminister", "afs.fs.acl.a", FT_UINT8, BASE_BIN,
+			0, PRSFS_ADMINISTER, "Administer" }},
+
+		{ &hf_afs_fs_callback_version, {
+			"Version", "afs.fs.callback.version", FT_UINT32, BASE_DEC,
+			0, 0, "Version" }},
+		{ &hf_afs_fs_callback_expires, {
+			"Expires", "afs.fs.callback.expires", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Expires" }},
+		{ &hf_afs_fs_callback_type, {
+			"Type", "afs.fs.callback.type", FT_UINT32, BASE_DEC,
+			VALS(cb_types), 0, "Type" }},
+
+		/* BOS Server Fields */
+		{ &hf_afs_bos_errcode, {
+			"Error Code", "afs.bos.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_bos_type, {
+			"Type", "afs.bos.type", FT_STRING, BASE_HEX,
+			0, 0, "Type" }},
+		{ &hf_afs_bos_content, {
+			"Content", "afs.bos.content", FT_STRING, BASE_HEX,
+			0, 0, "Content" }},
+		{ &hf_afs_bos_instance, {
+			"Instance", "afs.bos.instance", FT_STRING, BASE_HEX,
+			0, 0, "Instance" }},
+		{ &hf_afs_bos_status, {
+			"Status", "afs.bos.status", FT_INT32, BASE_DEC,
+			0, 0, "Status" }},
+		{ &hf_afs_bos_num, {
+			"Number", "afs.bos.number", FT_UINT32, BASE_DEC,
+			0, 0, "Number" }},
+		{ &hf_afs_bos_size, {
+			"Size", "afs.bos.size", FT_UINT32, BASE_DEC,
+			0, 0, "Size" }},
+		{ &hf_afs_bos_flags, {
+			"Flags", "afs.bos.flags", FT_UINT32, BASE_DEC,
+			0, 0, "Flags" }},
+		{ &hf_afs_bos_date, {
+			"Date", "afs.bos.date", FT_UINT32, BASE_DEC,
+			0, 0, "Date" }},
+
+		/* KAUTH Server Fields */
+		{ &hf_afs_kauth_errcode, {
+			"Error Code", "afs.kauth.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_kauth_princ, {
+			"Principal", "afs.kauth.princ", FT_STRING, BASE_HEX,
+			0, 0, "Principal" }},
+		{ &hf_afs_kauth_realm, {
+			"Realm", "afs.kauth.realm", FT_STRING, BASE_HEX,
+			0, 0, "Realm" }},
+		{ &hf_afs_kauth_domain, {
+			"Domain", "afs.kauth.domain", FT_STRING, BASE_HEX,
+			0, 0, "Domain" }},
+		{ &hf_afs_kauth_name, {
+			"Name", "afs.kauth.name", FT_STRING, BASE_HEX,
+			0, 0, "Name" }},
+		{ &hf_afs_kauth_data, {
+			"Data", "afs.kauth.data", FT_BYTES, BASE_HEX,
+			0, 0, "Data" }},
+		{ &hf_afs_kauth_kvno, {
+			"Key Version Number", "afs.kauth.kvno", FT_UINT32, BASE_DEC,
+			0, 0, "Key Version Number" }},
+
+		/* VOL Server Fields */
+		{ &hf_afs_vol_errcode, {
+			"Error Code", "afs.vol.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_vol_id, {
+			"Volume ID", "afs.vol.id", FT_UINT32, BASE_DEC,
+			0, 0, "Volume ID" }},
+		{ &hf_afs_vol_count, {
+			"Volume Count", "afs.vol.count", FT_UINT32, BASE_DEC,
+			0, 0, "Volume Count" }},
+		{ &hf_afs_vol_name, {
+			"Volume Name", "afs.vol.name", FT_STRING, BASE_HEX,
+			0, 0, "Volume Name" }},
+
+		/* VLDB Server Fields */
+		{ &hf_afs_vldb_errcode, {
+			"Error Code", "afs.vldb.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_vldb_type, {
+			"Volume Type", "afs.vldb.type", FT_UINT32, BASE_DEC,
+			VALS(volume_types), 0, "Volume Type" }},
+		{ &hf_afs_vldb_id, {
+			"Volume ID", "afs.vldb.id", FT_UINT32, BASE_DEC,
+			0, 0, "Volume ID" }},
+		{ &hf_afs_vldb_bump, {
+			"Bumped Volume ID", "afs.vldb.bump", FT_UINT32, BASE_DEC,
+			0, 0, "Bumped Volume ID" }},
+		{ &hf_afs_vldb_index, {
+			"Volume Index", "afs.vldb.index", FT_UINT32, BASE_DEC,
+			0, 0, "Volume Index" }},
+		{ &hf_afs_vldb_count, {
+			"Volume Count", "afs.vldb.count", FT_UINT32, BASE_DEC,
+			0, 0, "Volume Count" }},
+		{ &hf_afs_vldb_numservers, {
+			"Number of Servers", "afs.vldb.numservers", FT_UINT32, BASE_DEC,
+			0, 0, "Number of Servers" }},
+		{ &hf_afs_vldb_nextindex, {
+			"Next Volume Index", "afs.vldb.nextindex", FT_UINT32, BASE_DEC,
+			0, 0, "Next Volume Index" }},
+		{ &hf_afs_vldb_rovol, {
+			"Read-Only Volume ID", "afs.vldb.rovol", FT_UINT32, BASE_DEC,
+			0, 0, "Read-Only Volume ID" }},
+		{ &hf_afs_vldb_rwvol, {
+			"Read-Write Volume ID", "afs.vldb.rwvol", FT_UINT32, BASE_DEC,
+			0, 0, "Read-Only Volume ID" }},
+		{ &hf_afs_vldb_bkvol, {
+			"Backup Volume ID", "afs.vldb.bkvol", FT_UINT32, BASE_DEC,
+			0, 0, "Read-Only Volume ID" }},
+		{ &hf_afs_vldb_name, {
+			"Volume Name", "afs.vldb.name", FT_STRING, BASE_HEX,
+			0, 0, "Volume Name" }},
+		{ &hf_afs_vldb_partition, {
+			"Partition", "afs.vldb.partition", FT_STRING, BASE_HEX,
+			0, 0, "Partition" }},
+		{ &hf_afs_vldb_server, {
+			"Server", "afs.vldb.server", FT_IPv4, BASE_HEX,
+			0, 0, "Server" }},
+		{ &hf_afs_vldb_serveruuid, {
+			"Server UUID", "afs.vldb.serveruuid", FT_BYTES, BASE_HEX,
+			0, 0, "Server UUID" }},
+
+		/* BACKUP Server Fields */
+		{ &hf_afs_backup_errcode, {
+			"Error Code", "afs.backup.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+
+		/* CB Server Fields */
+		{ &hf_afs_cb_errcode, {
+			"Error Code", "afs.cb.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_cb_callback_version, {
+			"Version", "afs.cb.callback.version", FT_UINT32, BASE_DEC,
+			0, 0, "Version" }},
+		{ &hf_afs_cb_callback_expires, {
+			"Expires", "afs.cb.callback.expires", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Expires" }},
+		{ &hf_afs_cb_callback_type, {
+			"Type", "afs.cb.callback.type", FT_UINT32, BASE_DEC,
+			VALS(cb_types), 0, "Type" }},
+		{ &hf_afs_cb_fid_volume, {
+			"FileID (Volume)", "afs.cb.fid.volume", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (Volume)" }},
+		{ &hf_afs_cb_fid_vnode, {
+			"FileID (VNode)", "afs.cb.fid.vnode", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (VNode)" }},
+		{ &hf_afs_cb_fid_uniqifier, {
+			"FileID (Uniqifier)", "afs.cb.fid.uniq", FT_UINT32, BASE_DEC,
+			0, 0, "File ID (Uniqifier)" }},
+
+		/* PROT Server Fields */
+		{ &hf_afs_prot_errcode, {
+			"Error Code", "afs.prot.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_prot_name, {
+			"Name", "afs.prot.name", FT_STRING, BASE_HEX,
+			0, 0, "Name" }},
+		{ &hf_afs_prot_id, {
+			"ID", "afs.prot.id", FT_UINT32, BASE_DEC,
+			0, 0, "ID" }},
+		{ &hf_afs_prot_oldid, {
+			"Old ID", "afs.prot.oldid", FT_UINT32, BASE_DEC,
+			0, 0, "Old ID" }},
+		{ &hf_afs_prot_newid, {
+			"New ID", "afs.prot.newid", FT_UINT32, BASE_DEC,
+			0, 0, "New ID" }},
+		{ &hf_afs_prot_gid, {
+			"Group ID", "afs.prot.gid", FT_UINT32, BASE_DEC,
+			0, 0, "Group ID" }},
+		{ &hf_afs_prot_uid, {
+			"User ID", "afs.prot.uid", FT_UINT32, BASE_DEC,
+			0, 0, "User ID" }},
+		{ &hf_afs_prot_count, {
+			"Count", "afs.prot.count", FT_UINT32, BASE_DEC,
+			0, 0, "Count" }},
+		{ &hf_afs_prot_maxgid, {
+			"Maximum Group ID", "afs.prot.maxgid", FT_UINT32, BASE_DEC,
+			0, 0, "Maximum Group ID" }},
+		{ &hf_afs_prot_maxuid, {
+			"Maximum User ID", "afs.prot.maxuid", FT_UINT32, BASE_DEC,
+			0, 0, "Maximum User ID" }},
+		{ &hf_afs_prot_pos, {
+			"Position", "afs.prot.pos", FT_UINT32, BASE_DEC,
+			0, 0, "Position" }},
+		{ &hf_afs_prot_flag, {
+			"Flag", "afs.prot.flag", FT_UINT32, BASE_HEX,
+			0, 0, "Flag" }},
+
+		/* UBIK Fields */
+		{ &hf_afs_ubik_errcode, {
+			"Error Code", "afs.ubik.errcode", FT_UINT32, BASE_DEC,
+			VALS(afs_errors), 0, "Error Code" }},
+		{ &hf_afs_ubik_version_epoch, {
+			"Epoch", "afs.ubik.version.epoch", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Epoch" }},
+		{ &hf_afs_ubik_votestart, {
+			"Vote Started", "afs.ubik.votestart", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Vote Started" }},
+		{ &hf_afs_ubik_voteend, {
+			"Vote Ends", "afs.ubik.voteend", FT_ABSOLUTE_TIME, BASE_DEC,
+			0, 0, "Vote Ends" }},
+		{ &hf_afs_ubik_version_counter, {
+			"Counter", "afs.ubik.version.counter", FT_UINT32, BASE_DEC,
+			0, 0, "Counter" }},
+		{ &hf_afs_ubik_file, {
+			"File", "afs.ubik.file", FT_UINT32, BASE_DEC,
+			0, 0, "File" }},
+		{ &hf_afs_ubik_pos, {
+			"Position", "afs.ubik.position", FT_UINT32, BASE_DEC,
+			0, 0, "Position" }},
+		{ &hf_afs_ubik_length, {
+			"Length", "afs.ubik.length", FT_UINT32, BASE_DEC,
+			0, 0, "Length" }},
+		{ &hf_afs_ubik_locktype, {
+			"Lock Type", "afs.ubik.locktype", FT_UINT32, BASE_DEC,
+			VALS(ubik_lock_types), 0, "Lock Type" }},
+		{ &hf_afs_ubik_votetype, {
+			"Vote Type", "afs.ubik.votetype", FT_BOOLEAN, BASE_HEX,
+			0, 0, "Vote Type" }},
+		{ &hf_afs_ubik_syncsite, {
+			"Syncsite", "afs.ubik.syncsite", FT_BOOLEAN, BASE_HEX,
+			0, 0, "Syncsite" }},
+		{ &hf_afs_ubik_site, {
+			"Site", "afs.ubik.site", FT_IPv4, BASE_HEX,
+			0, 0, "Site" }},
+
+	};
+
+	proto_afs = proto_register_protocol("Andrew File System (AFS)", "afs");
+	proto_register_field_array(proto_afs, hf, array_length(hf));
+}