packet-afs-register-info.h

   1 /* packet-afs-register-info.h
   2  * Routines for AFS packet dissection
   3  * Copyright 1999, Nathan Neulinger <nneul@umr.edu>
   4  * Based on routines from tcpdump patches by
   5  *   Ken Hornstein <kenh@cmf.nrl.navy.mil>
   6  * Portions based on information retrieved from the RX definitions
   7  *   in Arla, the free AFS client at http://www.stacken.kth.se/project/arla/
   8  * Portions based on information/specs retrieved from the OpenAFS sources at
   9  *   www.openafs.org, Copyright IBM.
  10  *
  11  * $Id: packet-afs-register-info.h,v 1.3 2000/11/03 19:27:11 nneul Exp $
  12  *
  13  * Ethereal - Network traffic analyzer
  14  * By Gerald Combs <gerald@zing.org>
  15  * Copyright 1998 Gerald Combs
  16  *
  17  * Copied from packet-tftp.c
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License
  21  * as published by the Free Software Foundation; either version 2
  22  * of the License, or (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU General Public License
  30  * along with this program; if not, write to the Free Software
  31  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  32  */
  33
  34 { &hf_afs_fs, { "File Server", "afs.fs",
  35         FT_BOOLEAN, BASE_NONE, 0, 0, "File Server" }},
  36 { &hf_afs_cb, { "Callback", "afs.cb",
  37         FT_BOOLEAN, BASE_NONE, 0, 0, "Callback" }},
  38 { &hf_afs_prot, { "Protection", "afs.prot",
  39         FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server" }},
  40 { &hf_afs_vldb, { "VLDB", "afs.vldb",
  41         FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server" }},
  42 { &hf_afs_kauth, { "KAuth", "afs.kauth",
  43         FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server" }},
  44 { &hf_afs_vol, { "Volume Server", "afs.vol",
  45         FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server" }},
  46 { &hf_afs_error, { "Error", "afs.error",
  47         FT_BOOLEAN, BASE_NONE, 0, 0, "Error" }},
  48 { &hf_afs_bos, { "BOS", "afs.bos",
  49         FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server" }},
  50 { &hf_afs_update, { "Update", "afs.update",
  51         FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server" }},
  52 { &hf_afs_rmtsys, { "Rmtsys", "afs.rmtsys",
  53         FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys" }},
  54 { &hf_afs_ubik, { "Ubik", "afs.ubik",
  55         FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik" }},
  56 { &hf_afs_backup, { "Backup", "afs.backup",
  57         FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server" }},
  58
  59 { &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode",
  60         FT_UINT32, BASE_DEC,
  61         VALS(fs_req), 0, "Operation" }},
  62 { &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode",
  63         FT_UINT32, BASE_DEC,
  64         VALS(cb_req), 0, "Operation" }},
  65 { &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode",
  66         FT_UINT32, BASE_DEC,
  67         VALS(prot_req), 0, "Operation" }},
  68 { &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode",
  69         FT_UINT32, BASE_DEC,
  70         VALS(vldb_req), 0, "Operation" }},
  71 { &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode",
  72         FT_UINT32, BASE_DEC,
  73         VALS(kauth_req), 0, "Operation" }},
  74 { &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode",
  75         FT_UINT32, BASE_DEC,
  76         VALS(vol_req), 0, "Operation" }},
  77 { &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode",
  78         FT_UINT32, BASE_DEC,
  79         VALS(bos_req), 0, "Operation" }},
  80 { &hf_afs_update_opcode, { "Operation", "afs.update.opcode",
  81         FT_UINT32, BASE_DEC,
  82         VALS(update_req), 0, "Operation" }},
  83 { &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode",
  84         FT_UINT32, BASE_DEC,
  85         VALS(rmtsys_req), 0, "Operation" }},
  86 { &hf_afs_error_opcode, { "Operation", "afs.error.opcode",
  87         FT_UINT32, BASE_DEC,
  88         0, 0, "Operation" }},
  89 { &hf_afs_backup_opcode, {
  90         "Operation", "afs.backup.opcode",
  91         FT_UINT32, BASE_DEC,
  92         VALS(backup_req), 0, "Operation" }},
  93 { &hf_afs_ubik_opcode, {
  94         "Operation", "afs.ubik.opcode",
  95         FT_UINT32, BASE_DEC,
  96         VALS(ubik_req), 0, "Operation" }},
  97
  98
  99 /* File Server Fields */
 100 { &hf_afs_fs_fid_volume, { "FileID (Volume)", "afs.fs.fid.volume",
 101         FT_UINT32, BASE_DEC,
 102         0, 0, "File ID (Volume)" }},
 103 { &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode",
 104         FT_UINT32, BASE_DEC,
 105         0, 0, "File ID (VNode)" }},
 106 { &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq",
 107         FT_UINT32, BASE_DEC,
 108         0, 0, "File ID (Uniqifier)" }},
 109 { &hf_afs_fs_offset, { "Offset", "afs.fs.offset",
 110         FT_UINT32, BASE_DEC,
 111         0, 0, "Offset" }},
 112 { &hf_afs_fs_length, { "Length", "afs.fs.length",
 113         FT_UINT32, BASE_DEC, 0, 0, "Length" }},
 114 { &hf_afs_fs_flength, { "FLength", "afs.fs.flength",
 115         FT_UINT32, BASE_DEC, 0, 0, "FLength" }},
 116 { &hf_afs_fs_errcode, { "Error Code", "afs.fs.errcode",
 117         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
 118 { &hf_afs_fs_data, { "Data", "afs.fs.data",
 119         FT_BYTES, BASE_HEX, 0, 0, "Data" }},
 120 { &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname",
 121         FT_STRING, BASE_HEX, 0, 0, "Old Name" }},
 122 { &hf_afs_fs_newname, { "New Name", "afs.fs.newname",
 123         FT_STRING, BASE_HEX, 0, 0, "New Name" }},
 124 { &hf_afs_fs_name, { "Name", "afs.fs.name",
 125         FT_STRING, BASE_HEX, 0, 0, "Name" }},
 126 { &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name",
 127         FT_STRING, BASE_HEX, 0, 0, "Symlink Name" }},
 128 { &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content",
 129         FT_STRING, BASE_HEX, 0, 0, "Symlink Content" }},
 130 { &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid",
 131         FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
 132 { &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname",
 133         FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
 134 { &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp",
 135         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp" }},
 136 { &hf_afs_fs_offlinemsg, { "Offline Message", "afs.fs.offlinemsg",
 137         FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
 138 { &hf_afs_fs_motd, { "Message of the Day", "afs.fs.motd",
 139         FT_STRING, BASE_HEX, 0, 0, "Message of the Day" }},
 140 { &hf_afs_fs_xstats_version, { "XStats Version", "afs.fs.xstats.version",
 141         FT_UINT32, BASE_DEC, 0, 0, "XStats Version" }},
 142 { &hf_afs_fs_xstats_clientversion, { "Client Version", "afs.fs.xstats.clientversion",
 143         FT_UINT32, BASE_DEC, 0, 0, "Client Version" }},
 144 { &hf_afs_fs_xstats_version, { "Collection Number", "afs.fs.xstats.collnumber",
 145         FT_UINT32, BASE_DEC, 0, 0, "Collection Number" }},
 146 { &hf_afs_fs_xstats_timestamp, { "XStats Timestamp", "afs.fs.xstats.timestamp",
 147         FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp" }},
 148 { &hf_afs_fs_cps_spare1, { "CPS Spare1", "afs.fs.cps.spare1",
 149         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1" }},
 150 { &hf_afs_fs_cps_spare2, { "CPS Spare2", "afs.fs.cps.spare2",
 151         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2" }},
 152 { &hf_afs_fs_cps_spare3, { "CPS Spare3", "afs.fs.cps.spare3",
 153         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3" }},
 154 { &hf_afs_fs_vicelocktype, { "Vice Lock Type", "afs.fs.vicelocktype",
 155         FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type" }},
 156 { &hf_afs_fs_viceid, { "Vice ID", "afs.fs.viceid",
 157         FT_UINT32, BASE_DEC, 0, 0, "Vice ID" }},
 158 { &hf_afs_fs_viceid, { "IP Address", "afs.fs.ipaddr",
 159         FT_IPv4, BASE_HEX, 0, 0, "IP Address" }},
 160
 161 { &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask",
 162         FT_UINT32, BASE_HEX, 0, 0, "Mask" }},
 163 { &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime",
 164         FT_UINT32, BASE_BIN, 0, 1, "Set Modification Time" }},
 165 { &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner",
 166         FT_UINT32, BASE_BIN, 0, 2, "Set Owner" }},
 167 { &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup",
 168         FT_UINT32, BASE_BIN, 0, 4, "Set Group" }},
 169 { &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode",
 170         FT_UINT32, BASE_BIN, 0, 8, "Set Mode" }},
 171 { &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize",
 172         FT_UINT32, BASE_BIN, 0, 16, "Set Segment Size" }},
 173 { &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync",
 174         FT_UINT32, BASE_BIN, 0, 1024, "FSync" }},
 175 { &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime",
 176         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time" }},
 177 { &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime",
 178         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time" }},
 179 { &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner",
 180         FT_UINT32, BASE_DEC, 0, 0, "Owner" }},
 181 { &hf_afs_fs_status_group, { "Group", "afs.fs.status.group",
 182         FT_UINT32, BASE_DEC, 0, 0, "Group" }},
 183 { &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode",
 184         FT_UINT32, BASE_OCT, 0, 0, "Unix Mode" }},
 185 { &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize",
 186         FT_UINT32, BASE_DEC, 0, 0, "Segment Size" }},
 187 { &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion",
 188         FT_UINT32, BASE_DEC, 0, 0, "Interface Version" }},
 189 { &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype",
 190         FT_UINT32, BASE_DEC, 0, 0, "File Type" }},
 191 { &hf_afs_fs_status_author, { "Author", "afs.fs.status.author",
 192         FT_UINT32, BASE_DEC, 0, 0, "Author" }},
 193 { &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess",
 194         FT_UINT32, BASE_DEC, 0, 0, "Caller Access" }},
 195 { &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess",
 196         FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access" }},
 197 { &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode",
 198         FT_UINT32, BASE_DEC, 0, 0, "Parent VNode" }},
 199 { &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique",
 200         FT_UINT32, BASE_DEC, 0, 0, "Parent Unique" }},
 201 { &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion",
 202         FT_UINT32, BASE_DEC, 0, 0, "Data Version" }},
 203 { &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh",
 204         FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)" }},
 205 { &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount",
 206         FT_UINT32, BASE_DEC, 0, 0, "Link Count" }},
 207 { &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2",
 208         FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
 209 { &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3",
 210         FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
 211 { &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4",
 212         FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
 213 { &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter",
 214         FT_UINT32, BASE_DEC, 0, 0, "Sync Counter" }},
 215 { &hf_afs_fs_status_length, { "Length", "afs.fs.status.length",
 216         FT_UINT32, BASE_DEC, 0, 0, "Length" }},
 217
 218
 219 { &hf_afs_fs_volsync_spare1, { "Spare 1", "afs.fs.volsync.spare1",
 220         FT_UINT32, BASE_DEC, 0, 0, "Spare 1" }},
 221 { &hf_afs_fs_volsync_spare2, { "Spare 2", "afs.fs.volsync.spare2",
 222         FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
 223 { &hf_afs_fs_volsync_spare3, { "Spare 3", "afs.fs.volsync.spare3",
 224         FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
 225 { &hf_afs_fs_volsync_spare4, { "Spare 4", "afs.fs.volsync.spare4",
 226         FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
 227 { &hf_afs_fs_volsync_spare5, { "Spare 5", "afs.fs.volsync.spare5",
 228         FT_UINT32, BASE_DEC, 0, 0, "Spare 5" }},
 229 { &hf_afs_fs_volsync_spare6, { "Spare 6", "afs.fs.volsync.spare6",
 230         FT_UINT32, BASE_DEC, 0, 0, "Spare 6" }},
 231
 232
 233 { &hf_afs_fs_acl_count_positive, {
 234         "ACL Count (Positive)", "afs.fs.acl.count.positive",
 235         FT_UINT32, BASE_DEC,
 236         0, 0, "Number of Positive ACLs" }},
 237 { &hf_afs_fs_acl_count_negative, {
 238         "ACL Count (Negative)", "afs.fs.acl.count.negative",
 239         FT_UINT32, BASE_DEC,
 240         0, 0, "Number of Negative ACLs" }},
 241 { &hf_afs_fs_acl_datasize, {
 242         "ACL Size", "afs.fs.acl.datasize",
 243         FT_UINT32, BASE_DEC,
 244         0, 0, "ACL Data Size" }},
 245 { &hf_afs_fs_acl_entity, {
 246         "Entity (User/Group)", "afs.fs.acl.entity",
 247         FT_STRING, BASE_HEX,
 248         0, 0, "ACL Entity (User/Group)" }},
 249 { &hf_afs_fs_acl_r, {
 250         "_R_ead", "afs.fs.acl.r",
 251         FT_UINT8, BASE_BIN,
 252         0, PRSFS_READ, "Read" }},
 253 { &hf_afs_fs_acl_l, {
 254         "_L_ookup", "afs.fs.acl.l",
 255         FT_UINT8, BASE_BIN,
 256         0, PRSFS_LOOKUP, "Lookup" }},
 257 { &hf_afs_fs_acl_i, {
 258         "_I_nsert", "afs.fs.acl.i",
 259         FT_UINT8, BASE_BIN,
 260         0, PRSFS_INSERT, "Insert" }},
 261 { &hf_afs_fs_acl_d, {
 262         "_D_elete", "afs.fs.acl.d",
 263         FT_UINT8, BASE_BIN,
 264         0, PRSFS_DELETE, "Delete" }},
 265 { &hf_afs_fs_acl_w, {
 266         "_W_rite", "afs.fs.acl.w",
 267         FT_UINT8, BASE_BIN,
 268         0, PRSFS_WRITE, "Write" }},
 269 { &hf_afs_fs_acl_k, {
 270         "_L_ock", "afs.fs.acl.k",
 271         FT_UINT8, BASE_BIN,
 272         0, PRSFS_LOCK, "Lock" }},
 273 { &hf_afs_fs_acl_a, {
 274         "_A_dminister", "afs.fs.acl.a",
 275         FT_UINT8, BASE_BIN,
 276         0, PRSFS_ADMINISTER, "Administer" }},
 277
 278 { &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version",
 279         FT_UINT32, BASE_DEC,
 280         0, 0, "Version" }},
 281 { &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires",
 282         FT_ABSOLUTE_TIME, BASE_DEC,
 283         0, 0, "Expires" }},
 284 { &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type",
 285         FT_UINT32, BASE_DEC,
 286         VALS(cb_types), 0, "Type" }},
 287
 288 /* BOS Server Fields */
 289 { &hf_afs_bos_errcode, {
 290         "Error Code", "afs.bos.errcode",
 291         FT_UINT32, BASE_DEC,
 292         VALS(afs_errors), 0, "Error Code" }},
 293 { &hf_afs_bos_type, { "Type", "afs.bos.type",
 294         FT_STRING, BASE_HEX,
 295         0, 0, "Type" }},
 296 { &hf_afs_bos_content, { "Content", "afs.bos.content",
 297         FT_STRING, BASE_HEX,
 298         0, 0, "Content" }},
 299 { &hf_afs_bos_instance, { "Instance", "afs.bos.instance",
 300         FT_STRING, BASE_HEX,
 301         0, 0, "Instance" }},
 302 { &hf_afs_bos_status, { "Status", "afs.bos.status",
 303         FT_INT32, BASE_DEC,
 304         0, 0, "Status" }},
 305 { &hf_afs_bos_num, { "Number", "afs.bos.number",
 306         FT_UINT32, BASE_DEC,
 307         0, 0, "Number" }},
 308 { &hf_afs_bos_size, { "Size", "afs.bos.size",
 309         FT_UINT32, BASE_DEC,
 310         0, 0, "Size" }},
 311 { &hf_afs_bos_flags, { "Flags", "afs.bos.flags",
 312         FT_UINT32, BASE_DEC,
 313         0, 0, "Flags" }},
 314 { &hf_afs_bos_date, { "Date", "afs.bos.date",
 315         FT_UINT32, BASE_DEC,
 316         0, 0, "Date" }},
 317
 318 /* KAUTH Server Fields */
 319 { &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode",
 320         FT_UINT32, BASE_DEC,
 321         VALS(afs_errors), 0, "Error Code" }},
 322 { &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ",
 323         FT_STRING, BASE_HEX,
 324         0, 0, "Principal" }},
 325 { &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm",
 326         FT_STRING, BASE_HEX,
 327         0, 0, "Realm" }},
 328 { &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain",
 329         FT_STRING, BASE_HEX,
 330         0, 0, "Domain" }},
 331 { &hf_afs_kauth_name, { "Name", "afs.kauth.name",
 332         FT_STRING, BASE_HEX,
 333         0, 0, "Name" }},
 334 { &hf_afs_kauth_data, { "Data", "afs.kauth.data",
 335         FT_BYTES, BASE_HEX,
 336         0, 0, "Data" }},
 337 { &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno",
 338         FT_UINT32, BASE_DEC,
 339         0, 0, "Key Version Number" }},
 340
 341 /* VOL Server Fields */
 342 { &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode",
 343         FT_UINT32, BASE_DEC,
 344         VALS(afs_errors), 0, "Error Code" }},
 345 { &hf_afs_vol_id, { "Volume ID", "afs.vol.id",
 346         FT_UINT32, BASE_DEC,
 347         0, 0, "Volume ID" }},
 348 { &hf_afs_vol_count, { "Volume Count", "afs.vol.count",
 349         FT_UINT32, BASE_DEC,
 350         0, 0, "Volume Count" }},
 351 { &hf_afs_vol_name, { "Volume Name", "afs.vol.name",
 352         FT_STRING, BASE_HEX,
 353         0, 0, "Volume Name" }},
 354
 355 /* VLDB Server Fields */
 356 { &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode",
 357         FT_UINT32, BASE_DEC,
 358         VALS(afs_errors), 0, "Error Code" }},
 359 { &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type",
 360         FT_UINT32, BASE_DEC,
 361         VALS(volume_types), 0, "Volume Type" }},
 362 { &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id",
 363         FT_UINT32, BASE_DEC,
 364         0, 0, "Volume ID" }},
 365 { &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump",
 366         FT_UINT32, BASE_DEC,
 367         0, 0, "Bumped Volume ID" }},
 368 { &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index",
 369         FT_UINT32, BASE_DEC,
 370         0, 0, "Volume Index" }},
 371 { &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count",
 372         FT_UINT32, BASE_DEC,
 373         0, 0, "Volume Count" }},
 374 { &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers",
 375         FT_UINT32, BASE_DEC,
 376         0, 0, "Number of Servers" }},
 377 { &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex",
 378         FT_UINT32, BASE_DEC,
 379         0, 0, "Next Volume Index" }},
 380 { &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol",
 381         FT_UINT32, BASE_DEC,
 382         0, 0, "Read-Only Volume ID" }},
 383 { &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol",
 384         FT_UINT32, BASE_DEC,
 385         0, 0, "Read-Only Volume ID" }},
 386 { &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol",
 387         FT_UINT32, BASE_DEC,
 388         0, 0, "Read-Only Volume ID" }},
 389 { &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name",
 390         FT_STRING, BASE_HEX,
 391         0, 0, "Volume Name" }},
 392 { &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition",
 393         FT_STRING, BASE_HEX,
 394         0, 0, "Partition" }},
 395 { &hf_afs_vldb_server, { "Server", "afs.vldb.server",
 396         FT_IPv4, BASE_HEX,
 397         0, 0, "Server" }},
 398 { &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid",
 399         FT_BYTES, BASE_HEX,
 400         0, 0, "Server UUID" }},
 401
 402 /* BACKUP Server Fields */
 403 { &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode",
 404         FT_UINT32, BASE_DEC,
 405         VALS(afs_errors), 0, "Error Code" }},
 406
 407 /* CB Server Fields */
 408 { &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode",
 409         FT_UINT32, BASE_DEC,
 410         VALS(afs_errors), 0, "Error Code" }},
 411 { &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version",
 412         FT_UINT32, BASE_DEC,
 413         0, 0, "Version" }},
 414 { &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires",
 415         FT_ABSOLUTE_TIME, BASE_DEC,
 416         0, 0, "Expires" }},
 417 { &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type",
 418         FT_UINT32, BASE_DEC,
 419         VALS(cb_types), 0, "Type" }},
 420 { &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume",
 421         FT_UINT32, BASE_DEC,
 422         0, 0, "File ID (Volume)" }},
 423 { &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode",
 424         FT_UINT32, BASE_DEC,
 425         0, 0, "File ID (VNode)" }},
 426 { &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq",
 427         FT_UINT32, BASE_DEC,
 428         0, 0, "File ID (Uniqifier)" }},
 429
 430 /* PROT Server Fields */
 431 { &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode",
 432         FT_UINT32, BASE_DEC,
 433         VALS(afs_errors), 0, "Error Code" }},
 434 { &hf_afs_prot_name, { "Name", "afs.prot.name",
 435         FT_STRING, BASE_HEX,
 436         0, 0, "Name" }},
 437 { &hf_afs_prot_id, { "ID", "afs.prot.id",
 438         FT_UINT32, BASE_DEC,
 439         0, 0, "ID" }},
 440 { &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid",
 441         FT_UINT32, BASE_DEC,
 442         0, 0, "Old ID" }},
 443 { &hf_afs_prot_newid, { "New ID", "afs.prot.newid",
 444         FT_UINT32, BASE_DEC,
 445         0, 0, "New ID" }},
 446 { &hf_afs_prot_gid, { "Group ID", "afs.prot.gid",
 447         FT_UINT32, BASE_DEC,
 448         0, 0, "Group ID" }},
 449 { &hf_afs_prot_uid, { "User ID", "afs.prot.uid",
 450         FT_UINT32, BASE_DEC,
 451         0, 0, "User ID" }},
 452 { &hf_afs_prot_count, { "Count", "afs.prot.count",
 453         FT_UINT32, BASE_DEC,
 454         0, 0, "Count" }},
 455 { &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid",
 456         FT_UINT32, BASE_DEC,
 457         0, 0, "Maximum Group ID" }},
 458 { &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid",
 459         FT_UINT32, BASE_DEC,
 460         0, 0, "Maximum User ID" }},
 461 { &hf_afs_prot_pos, { "Position", "afs.prot.pos",
 462         FT_UINT32, BASE_DEC,
 463         0, 0, "Position" }},
 464 { &hf_afs_prot_flag, { "Flag", "afs.prot.flag",
 465         FT_UINT32, BASE_HEX,
 466         0, 0, "Flag" }},
 467
 468 /* UBIK Fields */
 469 { &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode",
 470         FT_UINT32, BASE_DEC,
 471         VALS(afs_errors), 0, "Error Code" }},
 472 { &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch",
 473         FT_ABSOLUTE_TIME, BASE_DEC,
 474         0, 0, "Epoch" }},
 475 { &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart",
 476         FT_ABSOLUTE_TIME, BASE_DEC,
 477         0, 0, "Vote Started" }},
 478 { &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend",
 479         FT_ABSOLUTE_TIME, BASE_DEC,
 480         0, 0, "Vote Ends" }},
 481 { &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter",
 482         FT_UINT32, BASE_DEC,
 483         0, 0, "Counter" }},
 484 { &hf_afs_ubik_file, { "File", "afs.ubik.file",
 485         FT_UINT32, BASE_DEC,
 486         0, 0, "File" }},
 487 { &hf_afs_ubik_pos, { "Position", "afs.ubik.position",
 488         FT_UINT32, BASE_DEC,
 489         0, 0, "Position" }},
 490 { &hf_afs_ubik_length, { "Length", "afs.ubik.length",
 491         FT_UINT32, BASE_DEC,
 492         0, 0, "Length" }},
 493 { &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype",
 494         FT_UINT32, BASE_DEC,
 495         VALS(ubik_lock_types), 0, "Lock Type" }},
 496 { &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype",
 497         FT_BOOLEAN, BASE_HEX,
 498         0, 0, "Vote Type" }},
 499 { &hf_afs_ubik_syncsite, { "Syncsite", "afs.ubik.syncsite",
 500         FT_BOOLEAN, BASE_HEX,
 501         0, 0, "Syncsite" }},
 502 { &hf_afs_ubik_site, { "Site", "afs.ubik.site",
 503         FT_IPv4, BASE_HEX, 0, 0, "Site" }},