Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / 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.13 2002/02/10 02:22:02 guy 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", HFILL }},
36 { &hf_afs_cb, { "Callback", "afs.cb", 
37         FT_BOOLEAN, BASE_NONE, 0, 0, "Callback", HFILL }},
38 { &hf_afs_prot, { "Protection", "afs.prot", 
39         FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server", HFILL }},
40 { &hf_afs_vldb, { "VLDB", "afs.vldb", 
41         FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server", HFILL }},
42 { &hf_afs_kauth, { "KAuth", "afs.kauth", 
43         FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server", HFILL }},
44 { &hf_afs_vol, { "Volume Server", "afs.vol", 
45         FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server", HFILL }},
46 { &hf_afs_error, { "Error", "afs.error", 
47         FT_BOOLEAN, BASE_NONE, 0, 0, "Error", HFILL }},
48 { &hf_afs_bos, { "BOS", "afs.bos", 
49         FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server", HFILL }},
50 { &hf_afs_update, { "Update", "afs.update", 
51         FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server", HFILL }},
52 { &hf_afs_rmtsys, { "Rmtsys", "afs.rmtsys", 
53         FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys", HFILL }},
54 { &hf_afs_ubik, { "Ubik", "afs.ubik", 
55         FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik", HFILL }},
56 { &hf_afs_backup, { "Backup", "afs.backup", 
57         FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server", HFILL }},
58
59 { &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode", 
60         FT_UINT32, BASE_DEC,
61         VALS(fs_req), 0, "Operation", HFILL }},
62 { &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode", 
63         FT_UINT32, BASE_DEC,
64         VALS(cb_req), 0, "Operation", HFILL }},
65 { &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode", 
66         FT_UINT32, BASE_DEC,
67         VALS(prot_req), 0, "Operation", HFILL }},
68 { &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode", 
69         FT_UINT32, BASE_DEC,
70         VALS(vldb_req), 0, "Operation", HFILL }},
71 { &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode", 
72         FT_UINT32, BASE_DEC,
73         VALS(kauth_req), 0, "Operation", HFILL }},
74 { &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode", 
75         FT_UINT32, BASE_DEC,
76         VALS(vol_req), 0, "Operation", HFILL }},
77 { &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode", 
78         FT_UINT32, BASE_DEC,
79         VALS(bos_req), 0, "Operation", HFILL }},
80 { &hf_afs_update_opcode, { "Operation", "afs.update.opcode", 
81         FT_UINT32, BASE_DEC,
82         VALS(update_req), 0, "Operation", HFILL }},
83 { &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode", 
84         FT_UINT32, BASE_DEC,
85         VALS(rmtsys_req), 0, "Operation", HFILL }},
86 { &hf_afs_error_opcode, { "Operation", "afs.error.opcode", 
87         FT_UINT32, BASE_DEC,
88         0, 0, "Operation", HFILL }},
89 { &hf_afs_backup_opcode, {
90         "Operation", "afs.backup.opcode", 
91         FT_UINT32, BASE_DEC,
92         VALS(backup_req), 0, "Operation", HFILL }},
93 { &hf_afs_ubik_opcode, {
94         "Operation", "afs.ubik.opcode", 
95         FT_UINT32, BASE_DEC,
96         VALS(ubik_req), 0, "Operation", HFILL }},
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)", HFILL }},
103 { &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode", 
104         FT_UINT32, BASE_DEC,
105         0, 0, "File ID (VNode)", HFILL }},
106 { &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq", 
107         FT_UINT32, BASE_DEC,
108         0, 0, "File ID (Uniqifier)", HFILL }},
109 { &hf_afs_fs_offset, { "Offset", "afs.fs.offset", 
110         FT_UINT32, BASE_DEC,
111         0, 0, "Offset", HFILL }},
112 { &hf_afs_fs_length, { "Length", "afs.fs.length", 
113         FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
114 { &hf_afs_fs_flength, { "FLength", "afs.fs.flength", 
115         FT_UINT32, BASE_DEC, 0, 0, "FLength", HFILL }},
116 { &hf_afs_fs_errcode, { "Error Code", "afs.fs.errcode", 
117         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
118 { &hf_afs_fs_data, { "Data", "afs.fs.data", 
119         FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
120 { &hf_afs_fs_token, { "Token", "afs.fs.token", 
121         FT_BYTES, BASE_HEX, 0, 0, "Token", HFILL }},
122 { &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname", 
123         FT_STRING, BASE_HEX, 0, 0, "Old Name", HFILL }},
124 { &hf_afs_fs_newname, { "New Name", "afs.fs.newname", 
125         FT_STRING, BASE_HEX, 0, 0, "New Name", HFILL }},
126 { &hf_afs_fs_name, { "Name", "afs.fs.name", 
127         FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
128 { &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name", 
129         FT_STRING, BASE_HEX, 0, 0, "Symlink Name", HFILL }},
130 { &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content", 
131         FT_STRING, BASE_HEX, 0, 0, "Symlink Content", HFILL }},
132 { &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid", 
133         FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
134 { &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname", 
135         FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
136 { &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp", 
137         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp", HFILL }},
138 { &hf_afs_fs_offlinemsg, { "Offline Message", "afs.fs.offlinemsg", 
139         FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
140 { &hf_afs_fs_motd, { "Message of the Day", "afs.fs.motd", 
141         FT_STRING, BASE_HEX, 0, 0, "Message of the Day", HFILL }},
142 { &hf_afs_fs_xstats_version, { "XStats Version", "afs.fs.xstats.version", 
143         FT_UINT32, BASE_DEC, 0, 0, "XStats Version", HFILL }},
144 { &hf_afs_fs_xstats_clientversion, { "Client Version", "afs.fs.xstats.clientversion", 
145         FT_UINT32, BASE_DEC, 0, 0, "Client Version", HFILL }},
146 { &hf_afs_fs_xstats_version, { "Collection Number", "afs.fs.xstats.collnumber", 
147         FT_UINT32, BASE_DEC, VALS(xstat_collections), 0, "Collection Number", HFILL }},
148 { &hf_afs_fs_xstats_timestamp, { "XStats Timestamp", "afs.fs.xstats.timestamp", 
149         FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp", HFILL }},
150 { &hf_afs_fs_cps_spare1, { "CPS Spare1", "afs.fs.cps.spare1", 
151         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1", HFILL }},
152 { &hf_afs_fs_cps_spare2, { "CPS Spare2", "afs.fs.cps.spare2", 
153         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2", HFILL }},
154 { &hf_afs_fs_cps_spare3, { "CPS Spare3", "afs.fs.cps.spare3", 
155         FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3", HFILL }},
156 { &hf_afs_fs_vicelocktype, { "Vice Lock Type", "afs.fs.vicelocktype", 
157         FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type", HFILL }},
158 { &hf_afs_fs_viceid, { "Vice ID", "afs.fs.viceid", 
159         FT_UINT32, BASE_DEC, 0, 0, "Vice ID", HFILL }},
160 { &hf_afs_fs_viceid, { "IP Address", "afs.fs.ipaddr", 
161         FT_IPv4, BASE_HEX, 0, 0, "IP Address", HFILL }},
162                         
163 { &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask", 
164         FT_UINT32, BASE_HEX, 0, 0, "Mask", HFILL }},
165 { &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime", 
166         FT_BOOLEAN, 32, 0, 0x00000001, "Set Modification Time", HFILL }},
167 { &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner", 
168         FT_BOOLEAN, 32, 0, 0x00000002, "Set Owner", HFILL }},
169 { &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup", 
170         FT_BOOLEAN, 32, 0, 0x00000004, "Set Group", HFILL }},
171 { &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode", 
172         FT_BOOLEAN, 32, 0, 0x00000008, "Set Mode", HFILL }},
173 { &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize", 
174         FT_BOOLEAN, 32, 0, 0x00000010, "Set Segment Size", HFILL }},
175 { &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync", 
176         FT_BOOLEAN, 32, 0, 0x00000400, "FSync", HFILL }},
177
178 { &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime", 
179         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time", HFILL }},
180 { &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime", 
181         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time", HFILL }},
182 { &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner", 
183         FT_UINT32, BASE_DEC, 0, 0, "Owner", HFILL }},
184 { &hf_afs_fs_status_group, { "Group", "afs.fs.status.group", 
185         FT_UINT32, BASE_DEC, 0, 0, "Group", HFILL }},
186 { &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode", 
187         FT_UINT32, BASE_OCT, 0, 0, "Unix Mode", HFILL }},
188 { &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize", 
189         FT_UINT32, BASE_DEC, 0, 0, "Segment Size", HFILL }},
190 { &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion", 
191         FT_UINT32, BASE_DEC, 0, 0, "Interface Version", HFILL }},
192 { &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype", 
193         FT_UINT32, BASE_DEC, 0, 0, "File Type", HFILL }},
194 { &hf_afs_fs_status_author, { "Author", "afs.fs.status.author", 
195         FT_UINT32, BASE_DEC, 0, 0, "Author", HFILL }},
196 { &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess", 
197         FT_UINT32, BASE_DEC, 0, 0, "Caller Access", HFILL }},
198 { &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess", 
199         FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access", HFILL }},
200 { &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode", 
201         FT_UINT32, BASE_DEC, 0, 0, "Parent VNode", HFILL }},
202 { &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique", 
203         FT_UINT32, BASE_DEC, 0, 0, "Parent Unique", HFILL }},
204 { &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion", 
205         FT_UINT32, BASE_DEC, 0, 0, "Data Version", HFILL }},
206 { &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh", 
207         FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)", HFILL }},
208 { &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount", 
209         FT_UINT32, BASE_DEC, 0, 0, "Link Count", HFILL }},
210 { &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2", 
211         FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }},
212 { &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3", 
213         FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }},
214 { &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4", 
215         FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }},
216 { &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter", 
217         FT_UINT32, BASE_DEC, 0, 0, "Sync Counter", HFILL }},
218 { &hf_afs_fs_status_length, { "Length", "afs.fs.status.length", 
219         FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
220
221
222 { &hf_afs_fs_volsync_spare1, { "Volume Creation Timestamp", "afs.fs.volsync.spare1", 
223         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Volume Creation Timestamp", HFILL }},
224 { &hf_afs_fs_volsync_spare2, { "Spare 2", "afs.fs.volsync.spare2", 
225         FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }},
226 { &hf_afs_fs_volsync_spare3, { "Spare 3", "afs.fs.volsync.spare3", 
227         FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }},
228 { &hf_afs_fs_volsync_spare4, { "Spare 4", "afs.fs.volsync.spare4", 
229         FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }},
230 { &hf_afs_fs_volsync_spare5, { "Spare 5", "afs.fs.volsync.spare5", 
231         FT_UINT32, BASE_DEC, 0, 0, "Spare 5", HFILL }},
232 { &hf_afs_fs_volsync_spare6, { "Spare 6", "afs.fs.volsync.spare6", 
233         FT_UINT32, BASE_DEC, 0, 0, "Spare 6", HFILL }},
234
235
236 { &hf_afs_fs_acl_count_positive, {
237         "ACL Count (Positive)", "afs.fs.acl.count.positive", 
238         FT_UINT32, BASE_DEC, 0, 0, "Number of Positive ACLs", HFILL }},
239 { &hf_afs_fs_acl_count_negative, {
240         "ACL Count (Negative)", "afs.fs.acl.count.negative", 
241         FT_UINT32, BASE_DEC, 0, 0, "Number of Negative ACLs", HFILL }},
242 { &hf_afs_fs_acl_datasize, {
243         "ACL Size", "afs.fs.acl.datasize", 
244         FT_UINT32, BASE_DEC, 0, 0, "ACL Data Size", HFILL }},
245 { &hf_afs_fs_acl_entity, {
246         "Entity (User/Group)", "afs.fs.acl.entity", 
247         FT_STRING, BASE_HEX, 0, 0, "ACL Entity (User/Group)", HFILL }},
248 { &hf_afs_fs_acl_r, {
249         "_R_ead", "afs.fs.acl.r", 
250         FT_BOOLEAN, 8, 0, PRSFS_READ, "Read", HFILL }},
251 { &hf_afs_fs_acl_l, {
252         "_L_ookup", "afs.fs.acl.l", 
253         FT_BOOLEAN, 8, 0, PRSFS_LOOKUP, "Lookup", HFILL }},
254 { &hf_afs_fs_acl_i, {
255         "_I_nsert", "afs.fs.acl.i", 
256         FT_BOOLEAN, 8, 0, PRSFS_INSERT, "Insert", HFILL }},
257 { &hf_afs_fs_acl_d, { "_D_elete", "afs.fs.acl.d", 
258         FT_BOOLEAN, 8, 0, PRSFS_DELETE, "Delete", HFILL }},
259 { &hf_afs_fs_acl_w, { "_W_rite", "afs.fs.acl.w", 
260         FT_BOOLEAN, 8, 0, PRSFS_WRITE, "Write", HFILL }},
261 { &hf_afs_fs_acl_k, { "_L_ock", "afs.fs.acl.k", 
262         FT_BOOLEAN, 8, 0, PRSFS_LOCK, "Lock", HFILL }},
263 { &hf_afs_fs_acl_a, { "_A_dminister", "afs.fs.acl.a", 
264         FT_BOOLEAN, 8, 0, PRSFS_ADMINISTER, "Administer", HFILL }},
265
266 { &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version", 
267         FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }},
268 { &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires", 
269         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires", HFILL }},
270 { &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type", 
271         FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }},
272
273 /* BOS Server Fields */
274 { &hf_afs_bos_errcode, { "Error Code", "afs.bos.errcode", 
275         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
276 { &hf_afs_bos_type, { "Type", "afs.bos.type", 
277         FT_STRING, BASE_HEX, 0, 0, "Type", HFILL }},
278 { &hf_afs_bos_content, { "Content", "afs.bos.content", 
279         FT_STRING, BASE_HEX, 0, 0, "Content", HFILL }},
280 { &hf_afs_bos_data, { "Data", "afs.bos.data", 
281         FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
282 { &hf_afs_bos_path, { "Path", "afs.bos.path", 
283         FT_STRING, BASE_HEX, 0, 0, "Path", HFILL }},
284 { &hf_afs_bos_parm, { "Parm", "afs.bos.parm", 
285         FT_STRING, BASE_HEX, 0, 0, "Parm", HFILL }},
286 { &hf_afs_bos_error, { "Error", "afs.bos.error", 
287         FT_STRING, BASE_HEX, 0, 0, "Error", HFILL }},
288 { &hf_afs_bos_spare1, { "Spare1", "afs.bos.spare1", 
289         FT_STRING, BASE_HEX, 0, 0, "Spare1", HFILL }},
290 { &hf_afs_bos_spare2, { "Spare2", "afs.bos.spare2", 
291         FT_STRING, BASE_HEX, 0, 0, "Spare2", HFILL }},
292 { &hf_afs_bos_spare3, { "Spare3", "afs.bos.spare3", 
293         FT_STRING, BASE_HEX, 0, 0, "Spare3", HFILL }},
294 { &hf_afs_bos_file, { "File", "afs.bos.file", 
295         FT_STRING, BASE_HEX, 0, 0, "File", HFILL }},
296 { &hf_afs_bos_cmd, { "Command", "afs.bos.cmd", 
297         FT_STRING, BASE_HEX, 0, 0, "Command", HFILL }},
298 { &hf_afs_bos_key, { "Key", "afs.bos.key", 
299         FT_BYTES, BASE_HEX, 0, 0, "key", HFILL }},
300 { &hf_afs_bos_user, { "User", "afs.bos.user", 
301         FT_STRING, BASE_HEX, 0, 0, "User", HFILL }},
302 { &hf_afs_bos_instance, { "Instance", "afs.bos.instance", 
303         FT_STRING, BASE_HEX, 0, 0, "Instance", HFILL }},
304 { &hf_afs_bos_status, { "Status", "afs.bos.status", 
305         FT_INT32, BASE_DEC, 0, 0, "Status", HFILL }},
306 { &hf_afs_bos_statusdesc, { "Status Description", "afs.bos.statusdesc", 
307         FT_STRING, BASE_DEC, 0, 0, "Status Description", HFILL }},
308 { &hf_afs_bos_num, { "Number", "afs.bos.number", 
309         FT_UINT32, BASE_DEC, 0, 0, "Number", HFILL }},
310 { &hf_afs_bos_size, { "Size", "afs.bos.size", 
311         FT_UINT32, BASE_DEC, 0, 0, "Size", HFILL }},
312 { &hf_afs_bos_flags, { "Flags", "afs.bos.flags", 
313         FT_UINT32, BASE_DEC, 0, 0, "Flags", HFILL }},
314 { &hf_afs_bos_date, { "Date", "afs.bos.date", 
315         FT_UINT32, BASE_DEC, 0, 0, "Date", HFILL }},
316 { &hf_afs_bos_kvno, { "Key Version Number", "afs.bos.kvno", 
317         FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }},
318 { &hf_afs_bos_cell, { "Cell", "afs.bos.cell", 
319         FT_STRING, BASE_HEX, 0, 0, "Cell", HFILL }},
320 { &hf_afs_bos_host, { "Host", "afs.bos.host", 
321         FT_STRING, BASE_HEX, 0, 0, "Host", HFILL }},
322 { &hf_afs_bos_newtime, { "New Time", "afs.bos.newtime", 
323         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "New Time", HFILL }},
324 { &hf_afs_bos_baktime, { "Backup Time", "afs.bos.baktime", 
325         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Backup Time", HFILL }},
326 { &hf_afs_bos_oldtime, { "Old Time", "afs.bos.oldtime", 
327         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Old Time", HFILL }},
328 { &hf_afs_bos_keymodtime, { "Key Modification Time", "afs.bos.keymodtime", 
329         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Key Modification Time", HFILL }},
330 { &hf_afs_bos_keychecksum, { "Key Checksum", "afs.bos.keychecksum", 
331         FT_UINT32, BASE_DEC, 0, 0, "Key Checksum", HFILL }},
332 { &hf_afs_bos_keyspare2, { "Key Spare 2", "afs.bos.keyspare2", 
333         FT_UINT32, BASE_DEC, 0, 0, "Key Spare 2", HFILL }},
334
335
336 /* KAUTH Server Fields */
337 { &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode", 
338         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
339 { &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ", 
340         FT_STRING, BASE_HEX, 0, 0, "Principal", HFILL }},
341 { &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm", 
342         FT_STRING, BASE_HEX, 0, 0, "Realm", HFILL }},
343 { &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain", 
344         FT_STRING, BASE_HEX, 0, 0, "Domain", HFILL }},
345 { &hf_afs_kauth_name, { "Name", "afs.kauth.name", 
346         FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
347 { &hf_afs_kauth_data, { "Data", "afs.kauth.data", 
348         FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
349 { &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno", 
350         FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }},
351
352 /* VOL Server Fields */
353 { &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode", 
354         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
355 { &hf_afs_vol_id, { "Volume ID", "afs.vol.id", 
356         FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
357 { &hf_afs_vol_count, { "Volume Count", "afs.vol.count", 
358         FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }},
359 { &hf_afs_vol_name, { "Volume Name", "afs.vol.name", 
360         FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
361
362 /* VLDB Server Fields */
363 { &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode", 
364         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
365 { &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type", 
366         FT_UINT32, BASE_HEX, VALS(volume_types), 0, "Volume Type", HFILL }},
367 { &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id", 
368         FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
369 { &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump", 
370         FT_UINT32, BASE_DEC, 0, 0, "Bumped Volume ID", HFILL }},
371 { &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index", 
372         FT_UINT32, BASE_DEC, 0, 0, "Volume Index", HFILL }},
373 { &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count", 
374         FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }},
375 { &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers", 
376         FT_UINT32, BASE_DEC, 0, 0, "Number of Servers", HFILL }},
377 { &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex", 
378         FT_UINT32, BASE_DEC, 0, 0, "Next Volume Index", HFILL }},
379 { &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol", 
380         FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
381 { &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol", 
382         FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
383 { &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol", 
384         FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
385 { &hf_afs_vldb_clonevol, { "Clone Volume ID", "afs.vldb.clonevol", 
386         FT_UINT32, BASE_DEC, 0, 0, "Clone Volume ID", HFILL }},
387 { &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name", 
388         FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
389 { &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition", 
390         FT_STRING, BASE_HEX, 0, 0, "Partition", HFILL }},
391 { &hf_afs_vldb_server, { "Server", "afs.vldb.server", 
392         FT_IPv4, BASE_HEX, 0, 0, "Server", HFILL }},
393 { &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid", 
394         FT_BYTES, BASE_HEX, 0, 0, "Server UUID", HFILL }},
395 { &hf_afs_vldb_serveruniq, { "Server Unique Address", "afs.vldb.serveruniq", 
396         FT_UINT32, BASE_HEX, 0, 0, "Server Unique Address", HFILL }},
397 { &hf_afs_vldb_serverflags, { "Server Flags", "afs.vldb.serverflags", 
398         FT_UINT32, BASE_HEX, 0, 0, "Server Flags", HFILL }},
399 { &hf_afs_vldb_serverip, { "Server IP", "afs.vldb.serverip", 
400         FT_IPv4, BASE_HEX, 0, 0, "Server IP", HFILL }},
401 { &hf_afs_vldb_flags, { "Flags", "afs.vldb.flags", 
402         FT_UINT32, BASE_HEX, 0, 0, "Flags", HFILL }},
403         
404 { &hf_afs_vldb_flags_rwexists, { "Read/Write Exists", "afs.vldb.flags.rwexists", 
405         FT_BOOLEAN, 32, 0, 0x1000, "Read/Write Exists", HFILL }},
406 { &hf_afs_vldb_flags_roexists, { "Read-Only Exists", "afs.vldb.flags.roexists", 
407         FT_BOOLEAN, 32, 0, 0x2000, "Read-Only Exists", HFILL }},
408 { &hf_afs_vldb_flags_bkexists, { "Backup Exists", "afs.vldb.flags.bkexists", 
409         FT_BOOLEAN, 32, 0, 0x4000, "Backup Exists", HFILL }},
410 { &hf_afs_vldb_flags_dfsfileset, { "DFS Fileset", "afs.vldb.flags.dfsfileset", 
411         FT_BOOLEAN, 32, 0, 0x8000, "DFS Fileset", HFILL }},
412         
413 { &hf_afs_vldb_spare1, { "Spare 1", "afs.vldb.spare1", 
414         FT_UINT32, BASE_DEC, 0, 0, "Spare 1", HFILL }},
415 { &hf_afs_vldb_spare2, { "Spare 2", "afs.vldb.spare2", 
416         FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }},
417 { &hf_afs_vldb_spare3, { "Spare 3", "afs.vldb.spare3", 
418         FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }},
419 { &hf_afs_vldb_spare4, { "Spare 4", "afs.vldb.spare4", 
420         FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }},
421 { &hf_afs_vldb_spare5, { "Spare 5", "afs.vldb.spare5", 
422         FT_UINT32, BASE_DEC, 0, 0, "Spare 5", HFILL }},
423 { &hf_afs_vldb_spare6, { "Spare 6", "afs.vldb.spare6", 
424         FT_UINT32, BASE_DEC, 0, 0, "Spare 6", HFILL }},
425 { &hf_afs_vldb_spare7, { "Spare 7", "afs.vldb.spare7", 
426         FT_UINT32, BASE_DEC, 0, 0, "Spare 7", HFILL }},
427 { &hf_afs_vldb_spare8, { "Spare 8", "afs.vldb.spare8", 
428         FT_UINT32, BASE_DEC, 0, 0, "Spare 8", HFILL }},
429 { &hf_afs_vldb_spare9, { "Spare 9", "afs.vldb.spare9", 
430         FT_UINT32, BASE_DEC, 0, 0, "Spare 9", HFILL }},
431
432 /* BACKUP Server Fields */
433 { &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode", 
434         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
435
436 /* CB Server Fields */
437 { &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode", 
438         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
439 { &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version", 
440         FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }},
441 { &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires", 
442         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires", HFILL }},
443 { &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type", 
444         FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }},
445 { &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume", 
446         FT_UINT32, BASE_DEC, 0, 0, "File ID (Volume)", HFILL }},
447 { &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode", 
448         FT_UINT32, BASE_DEC, 0, 0, "File ID (VNode)", HFILL }},
449 { &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq", 
450         FT_UINT32, BASE_DEC, 0, 0, "File ID (Uniqifier)", HFILL }},
451
452 /* PROT Server Fields */
453 { &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode", 
454         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
455 { &hf_afs_prot_name, { "Name", "afs.prot.name", 
456         FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
457 { &hf_afs_prot_id, { "ID", "afs.prot.id", 
458         FT_UINT32, BASE_DEC, 0, 0, "ID", HFILL }},
459 { &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid", 
460         FT_UINT32, BASE_DEC, 0, 0, "Old ID", HFILL }},
461 { &hf_afs_prot_newid, { "New ID", "afs.prot.newid", 
462         FT_UINT32, BASE_DEC, 0, 0, "New ID", HFILL }},
463 { &hf_afs_prot_gid, { "Group ID", "afs.prot.gid", 
464         FT_UINT32, BASE_DEC, 0, 0, "Group ID", HFILL }},
465 { &hf_afs_prot_uid, { "User ID", "afs.prot.uid", 
466         FT_UINT32, BASE_DEC, 0, 0, "User ID", HFILL }},
467 { &hf_afs_prot_count, { "Count", "afs.prot.count", 
468         FT_UINT32, BASE_DEC, 0, 0, "Count", HFILL }},
469 { &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid", 
470         FT_UINT32, BASE_DEC, 0, 0, "Maximum Group ID", HFILL }},
471 { &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid", 
472         FT_UINT32, BASE_DEC, 0, 0, "Maximum User ID", HFILL }},
473 { &hf_afs_prot_pos, { "Position", "afs.prot.pos", 
474         FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }},
475 { &hf_afs_prot_flag, { "Flag", "afs.prot.flag", 
476         FT_UINT32, BASE_HEX, 0, 0, "Flag", HFILL }},
477
478 /* UBIK Fields */
479 { &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode", 
480         FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
481 { &hf_afs_ubik_state, { "State", "afs.ubik.state", 
482         FT_UINT32, BASE_HEX, 0, 0, "State", HFILL }},
483 { &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch", 
484         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Epoch", HFILL }},
485 { &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter", 
486         FT_UINT32, BASE_DEC, 0, 0, "Counter", HFILL }},
487 { &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart", 
488         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Started", HFILL }},
489 { &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend", 
490         FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Ends", HFILL }},
491 { &hf_afs_ubik_file, { "File", "afs.ubik.file", 
492         FT_UINT32, BASE_DEC, 0, 0, "File", HFILL }},
493 { &hf_afs_ubik_pos, { "Position", "afs.ubik.position", 
494         FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }},
495 { &hf_afs_ubik_length, { "Length", "afs.ubik.length", 
496         FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
497 { &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype", 
498         FT_UINT32, BASE_DEC, VALS(ubik_lock_types), 0, "Lock Type", HFILL }},
499 { &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype", 
500         FT_UINT32, BASE_HEX, 0, 0, "Vote Type", HFILL }},
501 { &hf_afs_ubik_site, { "Site", "afs.ubik.site", 
502         FT_IPv4, BASE_HEX, 0, 0, "Site", HFILL }},
503 { &hf_afs_ubik_interface, { "Interface Address", "afs.ubik.interface", 
504         FT_IPv4, BASE_HEX, 0, 0, "Interface Address", HFILL }},
505
506 { &hf_afs_ubik_now, { "Now", "afs.ubik.now", 
507         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Now", HFILL }},
508 { &hf_afs_ubik_lastyestime, { "Last Yes Time", "afs.ubik.lastyesttime", 
509         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Time", HFILL }},
510 { &hf_afs_ubik_lastyeshost, { "Last Yes Host", "afs.ubik.lastyeshost", 
511         FT_IPv4, BASE_HEX, 0, 0, "Last Yes Host", HFILL }},
512 { &hf_afs_ubik_lastyesstate, { "Last Yes State", "afs.ubik.lastyesstate", 
513         FT_UINT32, BASE_HEX, 0, 0, "Last Yes State", HFILL }},
514 { &hf_afs_ubik_lastyesclaim, { "Last Yes Claim", "afs.ubik.lastyesclaim", 
515         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Claim", HFILL }},
516 { &hf_afs_ubik_lowesthost, { "Lowest Host", "afs.ubik.lowesthost", 
517         FT_IPv4, BASE_HEX, 0, 0, "Lowest Host", HFILL }},
518 { &hf_afs_ubik_lowesttime, { "Lowest Time", "afs.ubik.lowesttime", 
519         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Lowest Time", HFILL }},
520 { &hf_afs_ubik_synchost, { "Sync Host", "afs.ubik.synchost", 
521         FT_IPv4, BASE_HEX, 0, 0, "Sync Host", HFILL }},
522 { &hf_afs_ubik_addr, { "Address", "afs.ubik.addr", 
523         FT_IPv4, BASE_HEX, 0, 0, "Address", HFILL }},
524 { &hf_afs_ubik_synctime, { "Sync Time", "afs.ubik.synctime", 
525         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Time", HFILL }},
526 { &hf_afs_ubik_lastvotetime, { "Last Vote Time", "afs.ubik.lastvotetime", 
527         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Vote Time", HFILL }},
528 { &hf_afs_ubik_lastbeaconsent, { "Last Beacon Sent", "afs.ubik.lastbeaconsent", 
529         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Beacon Sent", HFILL }},
530 { &hf_afs_ubik_lastvote, { "Last Vote", "afs.ubik.lastvote", 
531         FT_UINT32, BASE_HEX, 0, 0, "Last Vote", HFILL }},
532 { &hf_afs_ubik_currentdb, { "Current DB", "afs.ubik.currentdb", 
533         FT_UINT32, BASE_HEX, 0, 0, "Current DB", HFILL }},
534 { &hf_afs_ubik_up, { "Up", "afs.ubik.up", 
535         FT_UINT32, BASE_HEX, 0, 0, "Up", HFILL }},
536 { &hf_afs_ubik_beaconsincedown, { "Beacon Since Down", "afs.ubik.beaconsincedown", 
537         FT_UINT32, BASE_HEX, 0, 0, "Beacon Since Down", HFILL }},
538 { &hf_afs_ubik_amsyncsite, { "Am Sync Site", "afs.ubik.amsyncsite", 
539         FT_UINT32, BASE_HEX, 0, 0, "Am Sync Site", HFILL }},
540 { &hf_afs_ubik_syncsiteuntil, { "Sync Site Until", "afs.ubik.syncsiteuntil", 
541         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Site Until", HFILL }},
542 { &hf_afs_ubik_nservers, { "Number of Servers", "afs.ubik.nservers", 
543         FT_UINT32, BASE_HEX, 0, 0, "Number of Servers", HFILL }},
544 { &hf_afs_ubik_lockedpages, { "Locked Pages", "afs.ubik.lockedpages", 
545         FT_UINT32, BASE_HEX, 0, 0, "Locked Pages", HFILL }},
546 { &hf_afs_ubik_writelockedpages, { "Write Locked Pages", "afs.ubik.writelockedpages", 
547         FT_UINT32, BASE_HEX, 0, 0, "Write Locked Pages", HFILL }},
548 { &hf_afs_ubik_activewrite, { "Active Write", "afs.ubik.activewrite", 
549         FT_UINT32, BASE_HEX, 0, 0, "Active Write", HFILL }},
550 { &hf_afs_ubik_tidcounter, { "TID Counter", "afs.ubik.tidcounter", 
551         FT_UINT32, BASE_HEX, 0, 0, "TID Counter", HFILL }},
552 { &hf_afs_ubik_anyreadlocks, { "Any Read Locks", "afs.ubik.anyreadlocks", 
553         FT_UINT32, BASE_HEX, 0, 0, "Any Read Locks", HFILL }},
554 { &hf_afs_ubik_anywritelocks, { "Any Write Locks", "afs.ubik.anywritelocks", 
555         FT_UINT32, BASE_HEX, 0, 0, "Any Write Locks", HFILL }},
556 { &hf_afs_ubik_recoverystate, { "Recovery State", "afs.ubik.recoverystate", 
557         FT_UINT32, BASE_HEX, 0, 0, "Recovery State", HFILL }},
558 { &hf_afs_ubik_currenttrans, { "Current Transaction", "afs.ubik.currenttran", 
559         FT_UINT32, BASE_HEX, 0, 0, "Current Transaction", HFILL }},
560 { &hf_afs_ubik_writetrans, { "Write Transaction", "afs.ubik.writetran", 
561         FT_UINT32, BASE_HEX, 0, 0, "Write Transaction", HFILL }},
562 { &hf_afs_ubik_epochtime, { "Epoch Time", "afs.ubik.epochtime", 
563         FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Epoch Time", HFILL }},
564 { &hf_afs_ubik_isclone, { "Is Clone", "afs.ubik.isclone", 
565         FT_UINT32, BASE_HEX, 0, 0, "Is Clone", HFILL }},
566
567
568
569
570
571
572