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.
11 * $Id: packet-afs-register-info.h,v 1.5 2000/11/03 22:38:07 nneul Exp $
13 * Ethereal - Network traffic analyzer
14 * By Gerald Combs <gerald@zing.org>
15 * Copyright 1998 Gerald Combs
17 * Copied from packet-tftp.c
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.
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.
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.
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" }},
59 { &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode",
61 VALS(fs_req), 0, "Operation" }},
62 { &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode",
64 VALS(cb_req), 0, "Operation" }},
65 { &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode",
67 VALS(prot_req), 0, "Operation" }},
68 { &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode",
70 VALS(vldb_req), 0, "Operation" }},
71 { &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode",
73 VALS(kauth_req), 0, "Operation" }},
74 { &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode",
76 VALS(vol_req), 0, "Operation" }},
77 { &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode",
79 VALS(bos_req), 0, "Operation" }},
80 { &hf_afs_update_opcode, { "Operation", "afs.update.opcode",
82 VALS(update_req), 0, "Operation" }},
83 { &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode",
85 VALS(rmtsys_req), 0, "Operation" }},
86 { &hf_afs_error_opcode, { "Operation", "afs.error.opcode",
89 { &hf_afs_backup_opcode, {
90 "Operation", "afs.backup.opcode",
92 VALS(backup_req), 0, "Operation" }},
93 { &hf_afs_ubik_opcode, {
94 "Operation", "afs.ubik.opcode",
96 VALS(ubik_req), 0, "Operation" }},
99 /* File Server Fields */
100 { &hf_afs_fs_fid_volume, { "FileID (Volume)", "afs.fs.fid.volume",
102 0, 0, "File ID (Volume)" }},
103 { &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode",
105 0, 0, "File ID (VNode)" }},
106 { &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq",
108 0, 0, "File ID (Uniqifier)" }},
109 { &hf_afs_fs_offset, { "Offset", "afs.fs.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_token, { "Token", "afs.fs.token",
121 FT_BYTES, BASE_HEX, 0, 0, "Token" }},
122 { &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname",
123 FT_STRING, BASE_HEX, 0, 0, "Old Name" }},
124 { &hf_afs_fs_newname, { "New Name", "afs.fs.newname",
125 FT_STRING, BASE_HEX, 0, 0, "New Name" }},
126 { &hf_afs_fs_name, { "Name", "afs.fs.name",
127 FT_STRING, BASE_HEX, 0, 0, "Name" }},
128 { &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name",
129 FT_STRING, BASE_HEX, 0, 0, "Symlink Name" }},
130 { &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content",
131 FT_STRING, BASE_HEX, 0, 0, "Symlink Content" }},
132 { &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid",
133 FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
134 { &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname",
135 FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
136 { &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp",
137 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp" }},
138 { &hf_afs_fs_offlinemsg, { "Offline Message", "afs.fs.offlinemsg",
139 FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
140 { &hf_afs_fs_motd, { "Message of the Day", "afs.fs.motd",
141 FT_STRING, BASE_HEX, 0, 0, "Message of the Day" }},
142 { &hf_afs_fs_xstats_version, { "XStats Version", "afs.fs.xstats.version",
143 FT_UINT32, BASE_DEC, 0, 0, "XStats Version" }},
144 { &hf_afs_fs_xstats_clientversion, { "Client Version", "afs.fs.xstats.clientversion",
145 FT_UINT32, BASE_DEC, 0, 0, "Client Version" }},
146 { &hf_afs_fs_xstats_version, { "Collection Number", "afs.fs.xstats.collnumber",
147 FT_UINT32, BASE_DEC, VALS(xstat_collections), 0, "Collection Number" }},
148 { &hf_afs_fs_xstats_timestamp, { "XStats Timestamp", "afs.fs.xstats.timestamp",
149 FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp" }},
150 { &hf_afs_fs_cps_spare1, { "CPS Spare1", "afs.fs.cps.spare1",
151 FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1" }},
152 { &hf_afs_fs_cps_spare2, { "CPS Spare2", "afs.fs.cps.spare2",
153 FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2" }},
154 { &hf_afs_fs_cps_spare3, { "CPS Spare3", "afs.fs.cps.spare3",
155 FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3" }},
156 { &hf_afs_fs_vicelocktype, { "Vice Lock Type", "afs.fs.vicelocktype",
157 FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type" }},
158 { &hf_afs_fs_viceid, { "Vice ID", "afs.fs.viceid",
159 FT_UINT32, BASE_DEC, 0, 0, "Vice ID" }},
160 { &hf_afs_fs_viceid, { "IP Address", "afs.fs.ipaddr",
161 FT_IPv4, BASE_HEX, 0, 0, "IP Address" }},
163 { &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask",
164 FT_UINT32, BASE_HEX, 0, 0, "Mask" }},
165 { &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime",
166 FT_UINT32, BASE_BIN, 0, 1, "Set Modification Time" }},
167 { &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner",
168 FT_UINT32, BASE_BIN, 0, 2, "Set Owner" }},
169 { &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup",
170 FT_UINT32, BASE_BIN, 0, 4, "Set Group" }},
171 { &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode",
172 FT_UINT32, BASE_BIN, 0, 8, "Set Mode" }},
173 { &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize",
174 FT_UINT32, BASE_BIN, 0, 16, "Set Segment Size" }},
175 { &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync",
176 FT_UINT32, BASE_BIN, 0, 1024, "FSync" }},
177 { &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime",
178 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time" }},
179 { &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime",
180 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time" }},
181 { &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner",
182 FT_UINT32, BASE_DEC, 0, 0, "Owner" }},
183 { &hf_afs_fs_status_group, { "Group", "afs.fs.status.group",
184 FT_UINT32, BASE_DEC, 0, 0, "Group" }},
185 { &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode",
186 FT_UINT32, BASE_OCT, 0, 0, "Unix Mode" }},
187 { &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize",
188 FT_UINT32, BASE_DEC, 0, 0, "Segment Size" }},
189 { &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion",
190 FT_UINT32, BASE_DEC, 0, 0, "Interface Version" }},
191 { &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype",
192 FT_UINT32, BASE_DEC, 0, 0, "File Type" }},
193 { &hf_afs_fs_status_author, { "Author", "afs.fs.status.author",
194 FT_UINT32, BASE_DEC, 0, 0, "Author" }},
195 { &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess",
196 FT_UINT32, BASE_DEC, 0, 0, "Caller Access" }},
197 { &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess",
198 FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access" }},
199 { &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode",
200 FT_UINT32, BASE_DEC, 0, 0, "Parent VNode" }},
201 { &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique",
202 FT_UINT32, BASE_DEC, 0, 0, "Parent Unique" }},
203 { &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion",
204 FT_UINT32, BASE_DEC, 0, 0, "Data Version" }},
205 { &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh",
206 FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)" }},
207 { &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount",
208 FT_UINT32, BASE_DEC, 0, 0, "Link Count" }},
209 { &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2",
210 FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
211 { &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3",
212 FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
213 { &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4",
214 FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
215 { &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter",
216 FT_UINT32, BASE_DEC, 0, 0, "Sync Counter" }},
217 { &hf_afs_fs_status_length, { "Length", "afs.fs.status.length",
218 FT_UINT32, BASE_DEC, 0, 0, "Length" }},
221 { &hf_afs_fs_volsync_spare1, { "Spare 1", "afs.fs.volsync.spare1",
222 FT_UINT32, BASE_DEC, 0, 0, "Spare 1" }},
223 { &hf_afs_fs_volsync_spare2, { "Spare 2", "afs.fs.volsync.spare2",
224 FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
225 { &hf_afs_fs_volsync_spare3, { "Spare 3", "afs.fs.volsync.spare3",
226 FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
227 { &hf_afs_fs_volsync_spare4, { "Spare 4", "afs.fs.volsync.spare4",
228 FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
229 { &hf_afs_fs_volsync_spare5, { "Spare 5", "afs.fs.volsync.spare5",
230 FT_UINT32, BASE_DEC, 0, 0, "Spare 5" }},
231 { &hf_afs_fs_volsync_spare6, { "Spare 6", "afs.fs.volsync.spare6",
232 FT_UINT32, BASE_DEC, 0, 0, "Spare 6" }},
235 { &hf_afs_fs_acl_count_positive, {
236 "ACL Count (Positive)", "afs.fs.acl.count.positive",
238 0, 0, "Number of Positive ACLs" }},
239 { &hf_afs_fs_acl_count_negative, {
240 "ACL Count (Negative)", "afs.fs.acl.count.negative",
242 0, 0, "Number of Negative ACLs" }},
243 { &hf_afs_fs_acl_datasize, {
244 "ACL Size", "afs.fs.acl.datasize",
246 0, 0, "ACL Data Size" }},
247 { &hf_afs_fs_acl_entity, {
248 "Entity (User/Group)", "afs.fs.acl.entity",
250 0, 0, "ACL Entity (User/Group)" }},
251 { &hf_afs_fs_acl_r, {
252 "_R_ead", "afs.fs.acl.r",
254 0, PRSFS_READ, "Read" }},
255 { &hf_afs_fs_acl_l, {
256 "_L_ookup", "afs.fs.acl.l",
258 0, PRSFS_LOOKUP, "Lookup" }},
259 { &hf_afs_fs_acl_i, {
260 "_I_nsert", "afs.fs.acl.i",
262 0, PRSFS_INSERT, "Insert" }},
263 { &hf_afs_fs_acl_d, { "_D_elete", "afs.fs.acl.d",
265 0, PRSFS_DELETE, "Delete" }},
266 { &hf_afs_fs_acl_w, { "_W_rite", "afs.fs.acl.w",
267 FT_UINT8, BASE_BIN, 0, PRSFS_WRITE, "Write" }},
268 { &hf_afs_fs_acl_k, { "_L_ock", "afs.fs.acl.k",
269 FT_UINT8, BASE_BIN, 0, PRSFS_LOCK, "Lock" }},
270 { &hf_afs_fs_acl_a, { "_A_dminister", "afs.fs.acl.a",
271 FT_UINT8, BASE_BIN, 0, PRSFS_ADMINISTER, "Administer" }},
273 { &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version",
274 FT_UINT32, BASE_DEC, 0, 0, "Version" }},
275 { &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires",
276 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires" }},
277 { &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type",
278 FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type" }},
280 /* BOS Server Fields */
281 { &hf_afs_bos_errcode, { "Error Code", "afs.bos.errcode",
282 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
283 { &hf_afs_bos_type, { "Type", "afs.bos.type",
284 FT_STRING, BASE_HEX, 0, 0, "Type" }},
285 { &hf_afs_bos_content, { "Content", "afs.bos.content",
286 FT_STRING, BASE_HEX, 0, 0, "Content" }},
287 { &hf_afs_bos_data, { "Data", "afs.bos.data",
288 FT_BYTES, BASE_HEX, 0, 0, "Data" }},
289 { &hf_afs_bos_path, { "Path", "afs.bos.path",
290 FT_STRING, BASE_HEX, 0, 0, "Path" }},
291 { &hf_afs_bos_parm, { "Parm", "afs.bos.parm",
292 FT_STRING, BASE_HEX, 0, 0, "Parm" }},
293 { &hf_afs_bos_error, { "Error", "afs.bos.error",
294 FT_STRING, BASE_HEX, 0, 0, "Error" }},
295 { &hf_afs_bos_spare1, { "Spare1", "afs.bos.spare1",
296 FT_STRING, BASE_HEX, 0, 0, "Spare1" }},
297 { &hf_afs_bos_spare2, { "Spare2", "afs.bos.spare2",
298 FT_STRING, BASE_HEX, 0, 0, "Spare2" }},
299 { &hf_afs_bos_spare3, { "Spare3", "afs.bos.spare3",
300 FT_STRING, BASE_HEX, 0, 0, "Spare3" }},
301 { &hf_afs_bos_file, { "File", "afs.bos.file",
302 FT_STRING, BASE_HEX, 0, 0, "File" }},
303 { &hf_afs_bos_cmd, { "Command", "afs.bos.cmd",
304 FT_STRING, BASE_HEX, 0, 0, "Command" }},
305 { &hf_afs_bos_key, { "Key", "afs.bos.key",
306 FT_BYTES, BASE_HEX, 0, 0, "key" }},
307 { &hf_afs_bos_user, { "User", "afs.bos.user",
308 FT_STRING, BASE_HEX, 0, 0, "User" }},
309 { &hf_afs_bos_instance, { "Instance", "afs.bos.instance",
310 FT_STRING, BASE_HEX, 0, 0, "Instance" }},
311 { &hf_afs_bos_status, { "Status", "afs.bos.status",
312 FT_INT32, BASE_DEC, 0, 0, "Status" }},
313 { &hf_afs_bos_statusdesc, { "Status Description", "afs.bos.statusdesc",
314 FT_STRING, BASE_DEC, 0, 0, "Status Description" }},
315 { &hf_afs_bos_num, { "Number", "afs.bos.number",
316 FT_UINT32, BASE_DEC, 0, 0, "Number" }},
317 { &hf_afs_bos_size, { "Size", "afs.bos.size",
318 FT_UINT32, BASE_DEC, 0, 0, "Size" }},
319 { &hf_afs_bos_flags, { "Flags", "afs.bos.flags",
320 FT_UINT32, BASE_DEC, 0, 0, "Flags" }},
321 { &hf_afs_bos_date, { "Date", "afs.bos.date",
322 FT_UINT32, BASE_DEC, 0, 0, "Date" }},
323 { &hf_afs_bos_kvno, { "Key Version Number", "afs.bos.kvno",
324 FT_UINT32, BASE_DEC, 0, 0, "Key Version Number" }},
325 { &hf_afs_bos_cell, { "Cell", "afs.bos.cell",
326 FT_STRING, BASE_HEX, 0, 0, "Cell" }},
327 { &hf_afs_bos_host, { "Host", "afs.bos.host",
328 FT_STRING, BASE_HEX, 0, 0, "Host" }},
329 { &hf_afs_bos_newtime, { "New Time", "afs.bos.newtime",
330 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "New Time" }},
331 { &hf_afs_bos_baktime, { "Backup Time", "afs.bos.baktime",
332 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Backup Time" }},
333 { &hf_afs_bos_oldtime, { "Old Time", "afs.bos.oldtime",
334 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Old Time" }},
335 { &hf_afs_bos_keymodtime, { "Key Modification Time", "afs.bos.keymodtime",
336 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Key Modification Time" }},
337 { &hf_afs_bos_keychecksum, { "Key Checksum", "afs.bos.keychecksum",
338 FT_UINT32, BASE_DEC, 0, 0, "Key Checksum" }},
339 { &hf_afs_bos_keyspare2, { "Key Spare 2", "afs.bos.keyspare2",
340 FT_UINT32, BASE_DEC, 0, 0, "Key Spare 2" }},
343 /* KAUTH Server Fields */
344 { &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode",
345 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
346 { &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ",
347 FT_STRING, BASE_HEX, 0, 0, "Principal" }},
348 { &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm",
349 FT_STRING, BASE_HEX, 0, 0, "Realm" }},
350 { &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain",
351 FT_STRING, BASE_HEX, 0, 0, "Domain" }},
352 { &hf_afs_kauth_name, { "Name", "afs.kauth.name",
353 FT_STRING, BASE_HEX, 0, 0, "Name" }},
354 { &hf_afs_kauth_data, { "Data", "afs.kauth.data",
355 FT_BYTES, BASE_HEX, 0, 0, "Data" }},
356 { &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno",
357 FT_UINT32, BASE_DEC, 0, 0, "Key Version Number" }},
359 /* VOL Server Fields */
360 { &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode",
361 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
362 { &hf_afs_vol_id, { "Volume ID", "afs.vol.id",
363 FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
364 { &hf_afs_vol_count, { "Volume Count", "afs.vol.count",
365 FT_UINT32, BASE_DEC, 0, 0, "Volume Count" }},
366 { &hf_afs_vol_name, { "Volume Name", "afs.vol.name",
367 FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
369 /* VLDB Server Fields */
370 { &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode",
371 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
372 { &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type",
373 FT_UINT32, BASE_DEC, VALS(volume_types), 0, "Volume Type" }},
374 { &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id",
375 FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
376 { &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump",
377 FT_UINT32, BASE_DEC, 0, 0, "Bumped Volume ID" }},
378 { &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index",
379 FT_UINT32, BASE_DEC, 0, 0, "Volume Index" }},
380 { &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count",
381 FT_UINT32, BASE_DEC, 0, 0, "Volume Count" }},
382 { &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers",
383 FT_UINT32, BASE_DEC, 0, 0, "Number of Servers" }},
384 { &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex",
385 FT_UINT32, BASE_DEC, 0, 0, "Next Volume Index" }},
386 { &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol",
387 FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
388 { &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol",
389 FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
390 { &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol",
391 FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
392 { &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name",
393 FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
394 { &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition",
395 FT_STRING, BASE_HEX, 0, 0, "Partition" }},
396 { &hf_afs_vldb_server, { "Server", "afs.vldb.server",
397 FT_IPv4, BASE_HEX, 0, 0, "Server" }},
398 { &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid",
399 FT_BYTES, BASE_HEX, 0, 0, "Server UUID" }},
401 /* BACKUP Server Fields */
402 { &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode",
403 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
405 /* CB Server Fields */
406 { &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode",
407 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
408 { &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version",
409 FT_UINT32, BASE_DEC, 0, 0, "Version" }},
410 { &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires",
411 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires" }},
412 { &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type",
413 FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type" }},
414 { &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume",
415 FT_UINT32, BASE_DEC, 0, 0, "File ID (Volume)" }},
416 { &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode",
417 FT_UINT32, BASE_DEC, 0, 0, "File ID (VNode)" }},
418 { &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq",
419 FT_UINT32, BASE_DEC, 0, 0, "File ID (Uniqifier)" }},
421 /* PROT Server Fields */
422 { &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode",
423 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
424 { &hf_afs_prot_name, { "Name", "afs.prot.name",
425 FT_STRING, BASE_HEX, 0, 0, "Name" }},
426 { &hf_afs_prot_id, { "ID", "afs.prot.id",
427 FT_UINT32, BASE_DEC, 0, 0, "ID" }},
428 { &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid",
429 FT_UINT32, BASE_DEC, 0, 0, "Old ID" }},
430 { &hf_afs_prot_newid, { "New ID", "afs.prot.newid",
431 FT_UINT32, BASE_DEC, 0, 0, "New ID" }},
432 { &hf_afs_prot_gid, { "Group ID", "afs.prot.gid",
433 FT_UINT32, BASE_DEC, 0, 0, "Group ID" }},
434 { &hf_afs_prot_uid, { "User ID", "afs.prot.uid",
435 FT_UINT32, BASE_DEC, 0, 0, "User ID" }},
436 { &hf_afs_prot_count, { "Count", "afs.prot.count",
437 FT_UINT32, BASE_DEC, 0, 0, "Count" }},
438 { &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid",
439 FT_UINT32, BASE_DEC, 0, 0, "Maximum Group ID" }},
440 { &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid",
441 FT_UINT32, BASE_DEC, 0, 0, "Maximum User ID" }},
442 { &hf_afs_prot_pos, { "Position", "afs.prot.pos",
443 FT_UINT32, BASE_DEC, 0, 0, "Position" }},
444 { &hf_afs_prot_flag, { "Flag", "afs.prot.flag",
445 FT_UINT32, BASE_HEX, 0, 0, "Flag" }},
448 { &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode",
449 FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
450 { &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch",
451 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Epoch" }},
452 { &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart",
453 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Started" }},
454 { &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend",
455 FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Ends" }},
456 { &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter",
457 FT_UINT32, BASE_DEC, 0, 0, "Counter" }},
458 { &hf_afs_ubik_file, { "File", "afs.ubik.file",
459 FT_UINT32, BASE_DEC, 0, 0, "File" }},
460 { &hf_afs_ubik_pos, { "Position", "afs.ubik.position",
461 FT_UINT32, BASE_DEC, 0, 0, "Position" }},
462 { &hf_afs_ubik_length, { "Length", "afs.ubik.length",
463 FT_UINT32, BASE_DEC, 0, 0, "Length" }},
464 { &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype",
465 FT_UINT32, BASE_DEC, VALS(ubik_lock_types), 0, "Lock Type" }},
466 { &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype",
467 FT_BOOLEAN, BASE_HEX, 0, 0, "Vote Type" }},
468 { &hf_afs_ubik_syncsite, { "Syncsite", "afs.ubik.syncsite",
469 FT_BOOLEAN, BASE_HEX, 0, 0, "Syncsite" }},
470 { &hf_afs_ubik_site, { "Site", "afs.ubik.site",
471 FT_IPv4, BASE_HEX, 0, 0, "Site" }},