Include <time.h> to declare "gmtime()".
[obnox/wireshark/wip.git] / packet-afs.c
1 /* packet-rx.c
2  * Routines for RX 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  *
9  * $Id: packet-afs.c,v 1.7 1999/11/17 21:58:31 guy Exp $
10  *
11  * Ethereal - Network traffic analyzer
12  * By Gerald Combs <gerald@unicom.net>
13  * Copyright 1998 Gerald Combs
14  *
15  * Copied from packet-tftp.c
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License
19  * as published by the Free Software Foundation; either version 2
20  * of the License, or (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
30  */
31
32 #ifdef HAVE_CONFIG_H
33 # include "config.h"
34 #endif
35
36 #include <stdio.h>
37
38 #ifdef HAVE_SYS_TYPES_H
39 # include <sys/types.h>
40 #endif
41
42 #ifdef HAVE_NETINET_IN_H
43 # include <netinet/in.h>
44 #endif
45
46 #include <string.h>
47 #include <glib.h>
48 #include "packet.h"
49 #include "conversation.h"
50 #include "packet-rx.h"
51 #include "packet-afs.h"
52 #include "resolv.h"
53
54 static const value_string fs_req[] = {
55         { 130,          "fetch-data" },
56         { 131,          "fetch-acl" },
57         { 132,          "fetch-status" },
58         { 133,          "store-data" },
59         { 134,          "store-acl" },
60         { 135,          "store-status" },
61         { 136,          "remove-file" },
62         { 137,          "create-file" },
63         { 138,          "rename" },
64         { 139,          "symlink" },
65         { 140,          "link" },
66         { 141,          "makedir" },
67         { 142,          "rmdir" },
68         { 143,          "oldsetlock" },
69         { 144,          "oldextlock" },
70         { 145,          "oldrellock" },
71         { 146,          "get-stats" },
72         { 147,          "give-cbs" },
73         { 148,          "get-vlinfo" },
74         { 149,          "get-vlstats" },
75         { 150,          "set-vlstats" },
76         { 151,          "get-rootvl" },
77         { 152,          "check-token" },
78         { 153,          "get-time" },
79         { 154,          "nget-vlinfo" },
80         { 155,          "bulk-stat" },
81         { 156,          "setlock" },
82         { 157,          "extlock" },
83         { 158,          "rellock" },
84         { 159,          "xstat-ver" },
85         { 160,          "get-xstat" },
86         { 161,          "dfs-lookup" },
87         { 162,          "dfs-flushcps" },
88         { 163,          "dfs-symlink" },
89         { 0,            NULL },
90 };
91
92 static const value_string cb_req[] = {
93         { 204,          "callback" },
94         { 205,          "initcb" },
95         { 206,          "probe" },
96         { 207,          "getlock" },
97         { 208,          "getce" },
98         { 209,          "xstatver" },
99         { 210,          "getxstat" },
100         { 211,          "initcb2" },
101         { 212,          "whoareyou" },
102         { 213,          "initcb3" },
103         { 214,          "probeuuid" },
104         { 0,            NULL },
105 };
106
107 static const value_string prot_req[] = {
108         { 500,          "new-user" },
109         { 501,          "where-is-it" },
110         { 502,          "dump-entry" },
111         { 503,          "add-to-group" },
112         { 504,          "name-to-id" },
113         { 505,          "id-to-name" },
114         { 506,          "delete" },
115         { 507,          "remove-from-group" },
116         { 508,          "get-cps" },
117         { 509,          "new-entry" },
118         { 510,          "list-max" },
119         { 511,          "set-max" },
120         { 512,          "list-entry" },
121         { 513,          "change-entry" },
122         { 514,          "list-elements" },
123         { 515,          "same-mbr-of" },
124         { 516,          "set-fld-sentry" },
125         { 517,          "list-owned" },
126         { 518,          "get-cps2" },
127         { 519,          "get-host-cps" },
128         { 520,          "update-entry" },
129         { 0,            NULL },
130 };
131
132 static const value_string vldb_req[] = {
133         { 501,          "create-entry" },
134         { 502,          "delete-entry" },
135         { 503,          "get-entry-by-id" },
136         { 504,          "get-entry-by-name" },
137         { 505,          "get-new-volume-id" },
138         { 506,          "replace-entry" },
139         { 507,          "update-entry" },
140         { 508,          "setlock" },
141         { 509,          "releaselock" },
142         { 510,          "list-entry" },
143         { 511,          "list-attrib" },
144         { 512,          "linked-list" },
145         { 513,          "get-stats" },
146         { 514,          "probe" },
147         { 515,          "get-addrs" },
148         { 516,          "change-addr" },
149         { 517,          "create-entry-n" },
150         { 518,          "get-entry-by-id-n" },
151         { 519,          "get-entry-by-name-n" },
152         { 520,          "replace-entry-n" },
153         { 521,          "list-entry-n" },
154         { 522,          "list-attrib-n" },
155         { 523,          "linked-list-n" },
156         { 524,          "update-entry-by-name" },
157         { 525,          "create-entry-u" },
158         { 526,          "get-entry-by-id-u" },
159         { 527,          "get-entry-by-name-u" },
160         { 528,          "replace-entry-u" },
161         { 529,          "list-entry-u" },
162         { 530,          "list-attrib-u" },
163         { 531,          "linked-list-u" },
164         { 532,          "regaddr" },
165         { 533,          "get-addrs-u" },
166         { 0,            NULL },
167 };
168
169 static const value_string kauth_req[] = {
170         { 1,            "auth-old" },
171         { 21,           "authenticate" },
172         { 22,           "authenticate-v2" },
173         { 2,            "change-pw" },
174         { 3,            "get-ticket-old" },
175         { 23,           "get-ticket" },
176         { 4,            "set-pw" },
177         { 5,            "set-fields" },
178         { 6,            "create-user" },
179         { 7,            "delete-user" },
180         { 8,            "get-entry" },
181         { 9,            "list-entry" },
182         { 10,           "get-stats" },
183         { 11,           "debug" },
184         { 12,           "get-pw" },
185         { 13,           "get-random-key" },
186         { 14,           "unlock" },
187         { 15,           "lock-status" },
188         { 0,            NULL },
189 };
190
191 static const value_string vol_req[] = {
192         { 100,          "create-volume" },
193         { 101,          "delete-volume" },
194         { 102,          "restore" },
195         { 103,          "forward" },
196         { 104,          "end-trans" },
197         { 105,          "clone" },
198         { 106,          "set-flags" },
199         { 107,          "get-flags" },
200         { 108,          "trans-create" },
201         { 109,          "dump" },
202         { 110,          "get-nth-volume" },
203         { 111,          "set-forwarding" },
204         { 112,          "get-name" },
205         { 113,          "get-status" },
206         { 114,          "sig-restore" },
207         { 115,          "list-partitions" },
208         { 116,          "list-volumes" },
209         { 117,          "set-id-types" },
210         { 118,          "monitor" },
211         { 119,          "partition-info" },
212         { 120,          "reclone" },
213         { 121,          "list-one-volume" },
214         { 122,          "nuke" },
215         { 123,          "set-date" },
216         { 124,          "x-list-volumes" },
217         { 125,          "x-list-one-volume" },
218         { 126,          "set-info" },
219         { 127,          "x-list-partitions" },
220         { 128,          "forward-multiple" },
221         { 0,            NULL },
222 };
223
224 static const value_string bos_req[] = {
225         { 80,           "create-bnode" },
226         { 81,           "delete-bnode" },
227         { 82,           "set-status" },
228         { 83,           "get-status" },
229         { 84,           "enumerate-instance" },
230         { 85,           "get-instance-info" },
231         { 86,           "get-instance-parm" },
232         { 87,           "add-superuser" },
233         { 88,           "delete-superuser" },
234         { 89,           "list-superusers" },
235         { 90,           "list-keys" },
236         { 91,           "add-key" },
237         { 92,           "delete-key" },
238         { 93,           "set-cell-name" },
239         { 94,           "get-cell-name" },
240         { 95,           "get-cell-host" },
241         { 96,           "add-cell-host" },
242         { 97,           "delete-cell-host" },
243         { 98,           "set-t-status" },
244         { 99,           "shutdown-all" },
245         { 100,          "restart-all" },
246         { 101,          "startup-all" },
247         { 102,          "set-noauth-flag" },
248         { 103,          "re-bozo" },
249         { 104,          "restart" },
250         { 105,          "start-bozo-install" },
251         { 106,          "uninstall" },
252         { 107,          "get-dates" },
253         { 108,          "exec" },
254         { 109,          "prune" },
255         { 110,          "set-restart-time" },
256         { 111,          "get-restart-time" },
257         { 112,          "start-bozo-log" },
258         { 113,          "wait-all" },
259         { 114,          "get-instance-strings" },
260         { 0,            NULL },
261 };
262
263 static const value_string ubik_req[] = {
264         { 10000,        "vote-beacon" },
265         { 10001,        "vote-debug-old" },
266         { 10002,        "vote-sdebug-old" },
267         { 10003,        "vote-getsyncsite" },
268         { 10004,        "vote-debug" },
269         { 10005,        "vote-sdebug" },
270         { 20000,        "disk-begin" },
271         { 20001,        "disk-commit" },
272         { 20002,        "disk-lock" },
273         { 20003,        "disk-write" },
274         { 20004,        "disk-getversion" },
275         { 20005,        "disk-getfile" },
276         { 20006,        "disk-sendfile" },
277         { 20007,        "disk-abort" },
278         { 20008,        "disk-releaselocks" },
279         { 20009,        "disk-truncate" },
280         { 20010,        "disk-probe" },
281         { 20011,        "disk-writev" },
282         { 20012,        "disk-interfaceaddr" },
283         { 20013,        "disk-setversion" },
284         { 0,            NULL },
285 };
286
287 static const value_string cb_types[] = {
288         { CB_TYPE_EXCLUSIVE, "exclusive" },
289         { CB_TYPE_SHARED, "shared" },
290         { CB_TYPE_DROPPED, "dropped" },
291         { 0, NULL },
292 };
293
294 static const value_string afs_errors[] = {
295         /* VOL Errors */
296         { 363520, "ID Exists"},
297         { 363521, "IO Error"},
298         { 363522, "Name Exists"},
299         { 363523, "Create Failed"},
300         { 363524, "Entry Not Found"},
301         { 363525, "Empty"},
302         { 363526, "Entry Deleted"},
303         { 363527, "Bad Name"},
304         { 363528, "Bad Index"},
305         { 363529, "Bad Volume Type"},
306         { 363530, "Bad Partition"},
307         { 363531, "Bad Server"},
308         { 363532, "Bad Replicate Server"},
309         { 363533, "No Replicate Server"},
310         { 363534, "Duplicate Replicate Server"},
311         { 363535, "ReadWrite Volume Not Found"},
312         { 363536, "Bad Reference Count"},
313         { 363537, "Size Exceeded"},
314         { 363538, "Bad Entry"},
315         { 363539, "Bad Volume ID Bump"},
316         { 363540, "Already has edit"},
317         { 363541, "Entry Locked"},
318         { 363542, "Bad Volume Operation"},
319         { 363543, "Bad Rel Lock Type"},
320         { 363544, "Rerelease"},
321         { 363545, "Bad Server"},
322         { 363546, "Permission Denied"},
323         { 363547, "Out of Memory"},
324
325         /* KAUTH Errors */
326         { 180480, "Database Inconsistent"},
327         { 180481, "Exists"},
328         { 180482, "IO"},
329         { 180483, "Create Failed"},
330         { 180484, "noent"},
331         { 180485, "Empty"},
332         { 180486, "Bad Name"},
333         { 180487, "Bad Index"},
334         { 180488, "No auth"},
335         { 180489, "Answer too long"},
336         { 180490, "Bad Request"},
337         { 180491, "Old Interface"},
338         { 180492, "Bad Argument"},
339         { 180493, "Bad Command"},
340         { 180494, "No keys"},
341         { 180495, "Read PW"},
342         { 180496, "Bad key"},
343         { 180497, "Ubik Init"},
344         { 180498, "Ubik Call"},
345         { 180499, "Bad Protocol"},
346         { 180500, "No cells"},
347         { 180501, "No cell"},
348         { 180502, "Too many ubiks"},
349         { 180503, "Too many keys"},
350         { 180504, "Bad ticket"},
351         { 180505, "Unknown Key"},
352         { 180506, "Key Cache Invalid"},
353         { 180507, "Bad Server"},
354         { 180508, "Bad User"},
355         { 180509, "Bad CPW"},
356         { 180510, "Bad Create"},
357         { 180511, "No ticket"},
358         { 180512, "Assoc user"},
359         { 180513, "Not special"},
360         { 180514, "Clock skew too great"},
361         { 180515, "No recursion"},
362         { 180516, "RX failed"},
363         { 180517, "Null password"},
364         { 180518, "Internal error"},
365         { 180519, "Password expired"},
366         { 180520, "Reused"},
367         { 180521, "Too soon"},
368         { 180522, "Locked"},
369
370         /* PT Errors */
371         { 267264, "Exists"},
372         { 267265, "ID Exists"},
373         { 267266, "No IDs"},
374         { 267267, "DB Failed"},
375         { 267268, "No such entry"},
376         { 267269, "Permission denied"},
377         { 267270, "Not group"},
378         { 267271, "Not user"},
379         { 267272, "Bad name"},
380         { 267273, "Bad argument"},
381         { 267274, "No more"},
382         { 267275, "Bad DB"},
383         { 267276, "Group empty"},
384         { 267277, "Inconsistent"},
385         { 267278, "DB Address"},
386         { 267279, "Too many"},
387         { 267280, "No memory"},
388
389         /* Volume server errors */
390         { 1492325120, "Release error"},
391         { 1492325121, "No op"},
392         { 1492325122, "Read dump error"},
393         { 1492325123, "Dump error"},
394         { 1492325124, "Attach error"},
395         { 1492325125, "Illegal partition"},
396         { 1492325126, "Detach error"},
397         { 1492325127, "Bad access"},
398         { 1492325128, "VLDB error"},
399         { 1492325129, "Bad Name"},
400         { 1492325130, "Volume moved"},
401         { 1492325131, "Bad operation"},
402         { 1492325132, "Bad release"},
403         { 1492325133, "Volume busy"},
404         { 1492325134, "No memory"},
405         { 1492325135, "No volume"},
406         { 1492325136, "Multiple RW volumes"},
407         { 1492325137, "Failed operation"},
408         
409         /* add more of these errors to decode the errcode responses */
410         { 0, NULL },
411 };
412
413 static const value_string port_types[] = {
414         { AFS_PORT_FS, "File Server" },
415         { AFS_PORT_CB, "Callback Server" },
416         { AFS_PORT_BOS, "BOS Server" },
417         { AFS_PORT_PROT, "Protection Server" },
418         { AFS_PORT_VLDB, "Volume Location Database Server" },
419         { AFS_PORT_KAUTH, "Kerberos Authentication Server" },
420         { AFS_PORT_ERROR, "Error Server" },
421         { AFS_PORT_VOL, "Volume Server" },
422         { AFS_PORT_RMTSYS, "Rmtsys? Server" },
423         { AFS_PORT_UPDATE, "Update? Server" },
424         { AFS_PORT_BACKUP, "Backup Server" },
425         { 0, NULL }
426 };
427
428 static const value_string port_types_short[] = {
429         { AFS_PORT_FS, "FS" },
430         { AFS_PORT_CB, "CB" },
431         { AFS_PORT_BOS, "BOS" },
432         { AFS_PORT_PROT, "PROT" },
433         { AFS_PORT_VLDB, "VLDB" },
434         { AFS_PORT_KAUTH, "KAUTH" },
435         { AFS_PORT_ERROR, "ERR" },
436         { AFS_PORT_VOL, "VOL" },
437         { AFS_PORT_RMTSYS, "RMT" },
438         { AFS_PORT_UPDATE, "UPD" },
439         { AFS_PORT_BACKUP, "BKUP" },
440         { 0, NULL }
441 };
442
443 static const value_string ubik_lock_types[] = {
444         { 1,            "read" },
445         { 2,            "write" },
446         { 3,            "wait" },
447         { 0,            NULL },
448 };
449
450 static const value_string volume_types[] = {
451         { 0,            "read-write" },
452         { 1,            "read-only" },
453         { 2,            "backup" },
454         { 0,            NULL },
455 };
456
457 int afs_packet_init_count = 100;
458
459 struct afs_request_key {
460   guint32 conversation, callnumber;
461   guint16 service;
462 };
463
464 struct afs_request_val {
465   guint32 opcode;
466 };
467
468 GHashTable *afs_request_hash = NULL;
469 GMemChunk *afs_request_keys = NULL;
470 GMemChunk *afs_request_vals = NULL;
471
472 static int proto_afs = -1;
473 static int hf_afs_fs = -1;
474 static int hf_afs_cb = -1;
475 static int hf_afs_prot = -1;
476 static int hf_afs_vldb = -1;
477 static int hf_afs_kauth = -1;
478 static int hf_afs_vol = -1;
479 static int hf_afs_error = -1;
480 static int hf_afs_bos = -1;
481 static int hf_afs_update = -1;
482 static int hf_afs_rmtsys = -1;
483 static int hf_afs_ubik = -1;
484 static int hf_afs_backup = -1;
485
486 static int hf_afs_fs_opcode = -1;
487 static int hf_afs_cb_opcode = -1;
488 static int hf_afs_prot_opcode = -1;
489 static int hf_afs_vldb_opcode = -1;
490 static int hf_afs_kauth_opcode = -1;
491 static int hf_afs_vol_opcode = -1;
492 static int hf_afs_error_opcode = -1;
493 static int hf_afs_bos_opcode = -1;
494 static int hf_afs_update_opcode = -1;
495 static int hf_afs_rmtsys_opcode = -1;
496 static int hf_afs_ubik_opcode = -1;
497 static int hf_afs_backup_opcode = -1;
498
499 static int hf_afs_fs_fid_volume = -1;
500 static int hf_afs_fs_fid_vnode = -1;
501 static int hf_afs_fs_fid_uniqifier = -1;
502 static int hf_afs_fs_offset = -1;
503 static int hf_afs_fs_length = -1;
504 static int hf_afs_fs_flength = -1;
505 static int hf_afs_fs_errcode = -1;
506 static int hf_afs_fs_data = -1;
507 static int hf_afs_fs_name = -1;
508 static int hf_afs_fs_oldname = -1;
509 static int hf_afs_fs_newname = -1;
510 static int hf_afs_fs_symlink_name = -1;
511 static int hf_afs_fs_symlink_content = -1;
512 static int hf_afs_fs_volid = -1;
513 static int hf_afs_fs_volname = -1;
514 static int hf_afs_fs_timestamp = -1;
515
516 static int hf_afs_fs_acl_datasize = -1;
517 static int hf_afs_fs_acl_count_negative = -1;
518 static int hf_afs_fs_acl_count_positive = -1;
519 static int hf_afs_fs_acl_entity = -1;
520 static int hf_afs_fs_acl_r = -1;
521 static int hf_afs_fs_acl_l = -1;
522 static int hf_afs_fs_acl_i = -1;
523 static int hf_afs_fs_acl_d = -1;
524 static int hf_afs_fs_acl_w = -1;
525 static int hf_afs_fs_acl_k = -1;
526 static int hf_afs_fs_acl_a = -1;
527
528 static int hf_afs_fs_callback_version = -1;
529 static int hf_afs_fs_callback_expires = -1;
530 static int hf_afs_fs_callback_type = -1;
531
532 static int hf_afs_bos_errcode = -1;
533 static int hf_afs_bos_type = -1;
534 static int hf_afs_bos_instance = -1;
535 static int hf_afs_bos_status = -1;
536 static int hf_afs_bos_num = -1;
537 static int hf_afs_bos_size = -1;
538 static int hf_afs_bos_flags = -1;
539 static int hf_afs_bos_date = -1;
540 static int hf_afs_bos_content = -1;
541
542 static int hf_afs_vldb_errcode = -1;
543 static int hf_afs_vldb_name = -1;
544 static int hf_afs_vldb_id = -1;
545 static int hf_afs_vldb_type = -1;
546 static int hf_afs_vldb_bump = -1;
547 static int hf_afs_vldb_index = -1;
548 static int hf_afs_vldb_nextindex = -1;
549 static int hf_afs_vldb_count = -1;
550 static int hf_afs_vldb_numservers = -1;
551 static int hf_afs_vldb_server = -1;
552 static int hf_afs_vldb_serveruuid = -1;
553 static int hf_afs_vldb_partition = -1;
554 static int hf_afs_vldb_rovol = -1;
555 static int hf_afs_vldb_rwvol = -1;
556 static int hf_afs_vldb_bkvol = -1;
557
558 static int hf_afs_kauth_errcode = -1;
559 static int hf_afs_kauth_princ = -1;
560 static int hf_afs_kauth_realm = -1;
561 static int hf_afs_kauth_domain = -1;
562 static int hf_afs_kauth_kvno = -1;
563 static int hf_afs_kauth_name = -1;
564 static int hf_afs_kauth_data = -1;
565
566 static int hf_afs_vol_errcode = -1;
567 static int hf_afs_vol_count = -1;
568 static int hf_afs_vol_id = -1;
569 static int hf_afs_vol_name = -1;
570
571 static int hf_afs_cb_errcode = -1;
572 static int hf_afs_cb_callback_version = -1;
573 static int hf_afs_cb_callback_type = -1;
574 static int hf_afs_cb_callback_expires = -1;
575 static int hf_afs_cb_fid_volume = -1;
576 static int hf_afs_cb_fid_vnode = -1;
577 static int hf_afs_cb_fid_uniqifier = -1;
578
579 static int hf_afs_prot_errcode = -1;
580 static int hf_afs_prot_name = -1;
581 static int hf_afs_prot_id = -1;
582 static int hf_afs_prot_count = -1;
583 static int hf_afs_prot_oldid = -1;
584 static int hf_afs_prot_newid = -1;
585 static int hf_afs_prot_pos = -1;
586 static int hf_afs_prot_flag = -1;
587 static int hf_afs_prot_uid = -1;
588 static int hf_afs_prot_gid = -1;
589 static int hf_afs_prot_maxuid = -1;
590 static int hf_afs_prot_maxgid = -1;
591
592 static int hf_afs_backup_errcode = -1;
593
594 static int hf_afs_ubik_errcode = -1;
595 static int hf_afs_ubik_version_epoch = -1;
596 static int hf_afs_ubik_version_counter = -1;
597 static int hf_afs_ubik_votestart = -1;
598 static int hf_afs_ubik_syncsite = -1;
599 static int hf_afs_ubik_site = -1;
600 static int hf_afs_ubik_file = -1;
601 static int hf_afs_ubik_pos = -1;
602 static int hf_afs_ubik_length = -1;
603 static int hf_afs_ubik_locktype = -1;
604 static int hf_afs_ubik_voteend = -1;
605 static int hf_afs_ubik_votetype = -1;
606
607 static gint ett_afs = -1;
608 static gint ett_afs_op = -1;
609 static gint ett_afs_acl = -1;
610 static gint ett_afs_fid = -1;
611 static gint ett_afs_callback = -1;
612 static gint ett_afs_ubikver = -1;
613
614 /*
615  * Dissector prototypes
616  */
617 static void dissect_fs_request(const u_char *pd,
618         int offset, frame_data *fd, proto_tree *tree, int opcode);
619 static void dissect_fs_reply(const u_char *pd,
620         int offset, frame_data *fd, proto_tree *tree, int opcode);
621 static void dissect_cb_request(const u_char *pd,
622         int offset, frame_data *fd, proto_tree *tree, int opcode);
623 static void dissect_cb_reply(const u_char *pd,
624         int offset, frame_data *fd, proto_tree *tree, int opcode);
625 static void dissect_bos_request(const u_char *pd,
626         int offset, frame_data *fd, proto_tree *tree, int opcode);
627 static void dissect_bos_reply(const u_char *pd,
628         int offset, frame_data *fd, proto_tree *tree, int opcode);
629 static void dissect_vol_request(const u_char *pd,
630         int offset, frame_data *fd, proto_tree *tree, int opcode);
631 static void dissect_vol_reply(const u_char *pd,
632         int offset, frame_data *fd, proto_tree *tree, int opcode);
633 static void dissect_ubik_request(const u_char *pd,
634         int offset, frame_data *fd, proto_tree *tree, int opcode);
635 static void dissect_ubik_reply(const u_char *pd,
636         int offset, frame_data *fd, proto_tree *tree, int opcode);
637 static void dissect_kauth_request(const u_char *pd,
638         int offset, frame_data *fd, proto_tree *tree, int opcode);
639 static void dissect_kauth_reply(const u_char *pd,
640         int offset, frame_data *fd, proto_tree *tree, int opcode);
641 static void dissect_prot_request(const u_char *pd,
642         int offset, frame_data *fd, proto_tree *tree, int opcode);
643 static void dissect_prot_reply(const u_char *pd,
644         int offset, frame_data *fd, proto_tree *tree, int opcode);
645 static void dissect_vldb_request(const u_char *pd,
646         int offset, frame_data *fd, proto_tree *tree, int opcode);
647 static void dissect_vldb_reply(const u_char *pd,
648         int offset, frame_data *fd, proto_tree *tree, int opcode);
649 static void dissect_backup_request(const u_char *pd,
650         int offset, frame_data *fd, proto_tree *tree, int opcode);
651 static void dissect_backup_reply(const u_char *pd,
652         int offset, frame_data *fd, proto_tree *tree, int opcode);
653
654
655 /*
656  * Hash Functions - copied from packet-afs.c
657  */
658 gint
659 afs_equal(gconstpointer v, gconstpointer w)
660 {
661   struct afs_request_key *v1 = (struct afs_request_key *)v;
662   struct afs_request_key *v2 = (struct afs_request_key *)w;
663
664   if (v1 -> conversation == v2 -> conversation &&
665       v1 -> service == v2 -> service &&
666       v1 -> callnumber == v2 -> callnumber ) {
667
668     return 1;
669   }
670
671   return 0;
672 }
673
674 guint
675 afs_hash (gconstpointer v)
676 {
677         struct afs_request_key *key = (struct afs_request_key *)v;
678         guint val;
679
680         val = key -> conversation + key -> service + key -> callnumber;
681
682         return val;
683 }
684
685 /*
686  * Protocol initialization
687  */
688 static void
689 afs_init_protocol(void)
690 {
691         if (afs_request_hash)
692                 g_hash_table_destroy(afs_request_hash);
693         if (afs_request_keys)
694                 g_mem_chunk_destroy(afs_request_keys);
695         if (afs_request_vals)
696                 g_mem_chunk_destroy(afs_request_vals);
697
698         afs_request_hash = g_hash_table_new(afs_hash, afs_equal);
699         afs_request_keys = g_mem_chunk_new("afs_request_keys",
700                 sizeof(struct afs_request_key),
701                 afs_packet_init_count * sizeof(struct afs_request_key),
702                 G_ALLOC_AND_FREE);
703         afs_request_vals = g_mem_chunk_new("afs_request_vals",
704                 sizeof(struct afs_request_val),
705                 afs_packet_init_count * sizeof(struct afs_request_val),
706                 G_ALLOC_AND_FREE);
707 }
708
709
710
711 /*
712  * Dissection routines
713  */
714
715 void
716 dissect_afs(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
717 {
718         proto_tree      *afs_tree, *afs_op_tree, *ti;
719         struct rx_header *rxh;
720         struct afs_header *afsh;
721         int port, node, typenode, opcode;
722         value_string const *vals;
723         int reply = 0;
724         int doffset = 0;
725         conversation_t *conversation;
726         struct afs_request_key request_key, *new_request_key;
727         struct afs_request_val *request_val;
728         void (*dissector)(const u_char *pd, int offset,
729                 frame_data *fd, proto_tree *tree, int opcode);
730
731         rxh = (struct rx_header *) &pd[offset];
732         doffset = offset + sizeof(struct rx_header);
733         afsh = (struct afs_header *) &pd[doffset];
734
735         /* get at least a full packet structure */
736         if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header)) )
737                 return;
738
739         if (check_col(fd, COL_PROTOCOL))
740                 col_add_str(fd, COL_PROTOCOL, "AFS (RX)");
741
742         reply = (rxh->flags & RX_CLIENT_INITIATED) == 0;
743         port = ((reply == 0) ? pi.destport : pi.srcport );
744
745         /*
746          * Find out what conversation this packet is part of.
747          * XXX - this should really be done by the transport-layer protocol,
748          * although for connectionless transports, we may not want to do that
749          * unless we know some higher-level protocol will want it - or we
750          * may want to do it, so you can say e.g. "show only the packets in
751          * this UDP 'connection'".
752          *
753          * Note that we don't have to worry about the direction this packet
754          * was going - the conversation code handles that for us, treating
755          * packets from A:X to B:Y as being part of the same conversation as
756          * packets from B:Y to A:X.
757          */
758         conversation = find_conversation(&pi.src, &pi.dst, pi.ptype,
759             pi.srcport, pi.destport);
760         if (conversation == NULL) {
761                 /* It's not part of any conversation - create a new one. */
762                 conversation = conversation_new(&pi.src, &pi.dst, pi.ptype,
763                     pi.srcport, pi.destport, NULL);
764         }
765
766         request_key.conversation = conversation->index; 
767         request_key.service = ntohs(rxh->serviceId);
768         request_key.callnumber = ntohl(rxh->callNumber);
769
770         request_val = (struct afs_request_val *) g_hash_table_lookup(
771                 afs_request_hash, &request_key);
772
773         /* only allocate a new hash element when it's a request */
774         opcode = 0;
775         if ( !request_val && !reply)
776         {
777                 new_request_key = g_mem_chunk_alloc(afs_request_keys);
778                 *new_request_key = request_key;
779
780                 request_val = g_mem_chunk_alloc(afs_request_vals);
781                 request_val -> opcode = ntohl(afsh->opcode);
782                 opcode = request_val->opcode;
783
784                 g_hash_table_insert(afs_request_hash, new_request_key,
785                         request_val);
786         }
787
788         if ( request_val )
789         {
790                 opcode = request_val->opcode;
791         }
792
793         node = 0;
794         typenode = 0;
795         vals = NULL;
796         dissector = NULL;
797         switch (port)
798         {
799                 case AFS_PORT_FS:
800                         typenode = hf_afs_fs;
801                         node = hf_afs_fs_opcode;
802                         vals = fs_req;
803                         dissector = reply ? dissect_fs_reply : dissect_fs_request;
804                         break;
805                 case AFS_PORT_CB:
806                         typenode = hf_afs_cb;
807                         node = hf_afs_cb_opcode;
808                         vals = cb_req;
809                         dissector = reply ? dissect_cb_reply : dissect_cb_request;
810                         break;
811                 case AFS_PORT_PROT:
812                         typenode = hf_afs_prot;
813                         node = hf_afs_prot_opcode;
814                         vals = prot_req;
815                         dissector = reply ? dissect_prot_reply : dissect_prot_request;
816                         break;
817                 case AFS_PORT_VLDB:
818                         typenode = hf_afs_vldb;
819                         node = hf_afs_vldb_opcode;
820                         vals = vldb_req;
821                         dissector = reply ? dissect_vldb_reply : dissect_vldb_request;
822                         break;
823                 case AFS_PORT_KAUTH:
824                         typenode = hf_afs_kauth;
825                         node = hf_afs_kauth_opcode;
826                         vals = kauth_req;
827                         dissector = reply ? dissect_kauth_reply : dissect_kauth_request;
828                         break;
829                 case AFS_PORT_VOL:
830                         typenode = hf_afs_vol;
831                         node = hf_afs_vol_opcode;
832                         vals = vol_req;
833                         dissector = reply ? dissect_vol_reply : dissect_vol_request;
834                         break;
835                 case AFS_PORT_ERROR:
836                         typenode = hf_afs_error;
837                         node = hf_afs_error_opcode;
838                         /* dissector = reply ? dissect_error_reply : dissect_error_request; */
839                         break;
840                 case AFS_PORT_BOS:
841                         typenode = hf_afs_bos;
842                         node = hf_afs_bos_opcode;
843                         vals = bos_req;
844                         dissector = reply ? dissect_bos_reply : dissect_bos_request;
845                         break;
846                 case AFS_PORT_UPDATE:
847                         typenode = hf_afs_update;
848                         node = hf_afs_update_opcode;
849                         /* dissector = reply ? dissect_update_reply : dissect_update_request; */
850                         break;
851                 case AFS_PORT_RMTSYS:
852                         typenode = hf_afs_rmtsys;
853                         node = hf_afs_rmtsys_opcode;
854                         /* dissector = reply ? dissect_rmtsys_reply : dissect_rmtsys_request; */
855                         break;
856                 case AFS_PORT_BACKUP:
857                         typenode = hf_afs_backup;
858                         node = hf_afs_backup_opcode;
859                         dissector = reply ? dissect_backup_reply : dissect_backup_request;
860                         break;
861         }
862         if ( (opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
863                 (opcode >= DISK_LOW && opcode <= DISK_HIGH) )
864         {
865                 typenode = hf_afs_ubik;
866                 node = hf_afs_ubik_opcode;
867                 vals = ubik_req;
868                 dissector = reply ? dissect_ubik_reply : dissect_ubik_request;
869         }
870
871         if ( vals )
872         {
873                 if (check_col(fd, COL_INFO))
874                         col_add_fstr(fd, COL_INFO, "%s %s: %s (%d)",
875                         val_to_str(port, port_types_short, "Unknown(%d)"),
876                         reply ? "Reply" : "Request",
877                         val_to_str(opcode, vals, "Unknown(%d)"), opcode);
878         }
879         else
880         {
881                 if (check_col(fd, COL_INFO))
882                         col_add_fstr(fd, COL_INFO, "%s %s: Unknown(%d)",
883                         val_to_str(port, port_types_short, "Unknown(%d)"),
884                         reply ? "Reply" : "Request",
885                         opcode);
886         }
887
888         if (tree) {
889                 ti = proto_tree_add_item(tree, proto_afs, doffset, END_OF_FRAME);
890                 afs_tree = proto_item_add_subtree(ti, ett_afs);
891
892                 if ( !BYTES_ARE_IN_FRAME(offset, sizeof(struct rx_header) +
893                         sizeof(struct afs_header)) )
894                 {
895                         proto_tree_add_text(afs_tree, doffset, END_OF_FRAME,
896                                 "Service: %s %s (Truncated)",
897                                 val_to_str(port, port_types, "Unknown(%d)"),
898                                 reply ? "Reply" : "Request");
899                                 return;
900                 }
901                 else
902                 {
903                         proto_tree_add_text(afs_tree, doffset, END_OF_FRAME,
904                                 "Service: %s %s",
905                                 val_to_str(port, port_types, "Unknown(%d)"),
906                                 reply ? "Reply" : "Request");
907                 }
908
909                 /* until we do cache, can't handle replies */
910                 ti = NULL;
911                 if ( !reply && node != 0 )
912                 {
913                         ti = proto_tree_add_item(afs_tree,
914                                 node, doffset, 4, opcode);
915                 }
916                 else if ( reply && node != 0 )
917                 {
918                         /* the opcode isn't in this packet */
919                         ti = proto_tree_add_item(afs_tree,
920                                 node, doffset, 0, opcode);
921                 }
922                 else
923                 {
924                         ti = proto_tree_add_text(afs_tree,
925                                 doffset, 0, "Operation: Unknown");
926                 }
927
928                 /* Add the subtree for this particular service */
929                 afs_op_tree = proto_item_add_subtree(ti, ett_afs_op);
930
931                 if ( typenode != 0 )
932                 {
933                         /* indicate the type of request */
934                         proto_tree_add_item_hidden(afs_tree, typenode, doffset, 0, 1);
935                 }
936
937                 /* Process the packet according to what service it is */
938                 if ( dissector )
939                 {
940                         (*dissector)(pd,offset,fd,afs_op_tree,opcode);
941                 }
942         }
943
944         /* if it's the last packet, and it's a reply, remove opcode
945                 from hash */
946         /* ignoring for now, I'm not sure how the chunk deallocation works */
947         if ( rxh->flags & RX_LAST_PACKET && reply )
948         {
949
950         }
951 }
952
953 /*
954  * Macros for helper dissection routines
955  *
956  * The macros are here to save on coding. They assume that
957  * the current offset is in 'curoffset', and that the offset
958  * should be incremented after performing the macro's operation.
959  */
960
961 /* Get the next available integer, be sure and call TRUNC beforehand */
962 #define GETINT() (ntohl( *((int*)&pd[curoffset]) ))
963
964 /* Check if enough bytes are present, if not, return to caller
965    after adding a 'Truncated' message to tree */
966 #define TRUNC(bytes) \
967         if(!BYTES_ARE_IN_FRAME(curoffset,(bytes))) \
968         { proto_tree_add_text(tree,curoffset,END_OF_FRAME,"Truncated"); \
969         return; }
970
971 /* Output a unsigned integer, stored into field 'field'
972    Assumes it is in network byte order, converts to host before using */
973 #define UINTOUT(field) \
974         TRUNC(sizeof(guint32)) \
975         proto_tree_add_item(tree,field,curoffset,sizeof(guint32), GETINT()); \
976         curoffset += 4;
977
978 /* Output a unsigned integer, stored into field 'field'
979    Assumes it is in network byte order, converts to host before using */
980 #define IPOUT(field) \
981         TRUNC(sizeof(gint32)) \
982         proto_tree_add_item(tree,field,curoffset,sizeof(gint32),\
983                 *((int*)&pd[curoffset]));\
984         curoffset += 4;
985
986 /* Output a unix timestamp, after converting to a timeval */
987 #define BIGDATEOUT(field) \
988         { struct timeval tv; \
989         TRUNC(2*sizeof(guint32)); \
990         tv.tv_sec = GETINT(); \
991         tv.tv_usec = GETINT(); \
992         proto_tree_add_item(tree,field,curoffset,2*sizeof(guint32),&tv); \
993         curoffset += 8; \
994         }
995
996 /* Output a unix timestamp, after converting to a timeval */
997 #define DATEOUT(field) \
998         { struct timeval tv; \
999         TRUNC(sizeof(guint32)); \
1000         tv.tv_sec = GETINT(); \
1001         tv.tv_usec = 0; \
1002         proto_tree_add_item(tree,field,curoffset,sizeof(guint32),&tv); \
1003         curoffset += 4; \
1004         }
1005
1006 /* Output a callback */
1007 #define FS_CALLBACKOUT() \
1008         {       proto_tree *save, *ti; \
1009                 ti = proto_tree_add_text(tree, curoffset, 3*4, "Callback"); \
1010                 save = tree; \
1011                 tree = proto_item_add_subtree(ti, ett_afs_callback); \
1012                 TRUNC(3*sizeof(guint32)); \
1013                 UINTOUT(hf_afs_fs_callback_version); \
1014                 BIGDATEOUT(hf_afs_fs_callback_expires); \
1015                 UINTOUT(hf_afs_fs_callback_type); \
1016                 tree = save; \
1017         }
1018
1019 /* Output a callback */
1020 #define CB_CALLBACKOUT() \
1021         {       proto_tree *save, *ti; \
1022                 ti = proto_tree_add_text(tree, curoffset, 3*4, "Callback"); \
1023                 save = tree; \
1024                 tree = proto_item_add_subtree(ti, ett_afs_callback); \
1025                 TRUNC(3*sizeof(guint32)); \
1026                 UINTOUT(hf_afs_cb_callback_version); \
1027                 DATEOUT(hf_afs_cb_callback_expires); \
1028                 UINTOUT(hf_afs_cb_callback_type); \
1029                 tree = save; \
1030         }
1031
1032
1033 /* Output a File ID */
1034 #define FS_FIDOUT(label) \
1035         {       proto_tree *save, *ti; \
1036                 ti = proto_tree_add_text(tree, curoffset, 3*4, \
1037                         "FileID (%s)", label); \
1038                 save = tree; \
1039                 tree = proto_item_add_subtree(ti, ett_afs_fid); \
1040                 UINTOUT(hf_afs_fs_fid_volume); \
1041                 UINTOUT(hf_afs_fs_fid_vnode); \
1042                 UINTOUT(hf_afs_fs_fid_uniqifier); \
1043                 tree = save; \
1044         }
1045
1046 /* Output a File ID */
1047 #define CB_FIDOUT(label) \
1048         {       proto_tree *save, *ti; \
1049                 ti = proto_tree_add_text(tree, curoffset, 3*4, \
1050                         "FileID (%s)", label); \
1051                 save = tree; \
1052                 tree = proto_item_add_subtree(ti, ett_afs_fid); \
1053                 UINTOUT(hf_afs_cb_fid_volume); \
1054                 UINTOUT(hf_afs_cb_fid_vnode); \
1055                 UINTOUT(hf_afs_cb_fid_uniqifier); \
1056                 tree = save; \
1057         }
1058
1059 /* Output a AFS acl */
1060 #define ACLOUT(who, positive, acl, bytes) \
1061         {       proto_tree *save, *ti; \
1062                 int tmpoffset; \
1063                 int acllen; \
1064                 char tmp[10]; \
1065                 tmp[0] = 0; \
1066                 if ( acl & PRSFS_READ ) strcat(tmp, "r"); \
1067                 if ( acl & PRSFS_LOOKUP ) strcat(tmp, "l"); \
1068                 if ( acl & PRSFS_INSERT ) strcat(tmp, "i"); \
1069                 if ( acl & PRSFS_DELETE ) strcat(tmp, "d"); \
1070                 if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \
1071                 if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \
1072                 if ( acl & PRSFS_ADMINISTER ) strcat(tmp, "a"); \
1073                 ti = proto_tree_add_text(tree, curoffset, bytes, \
1074                         "ACL:  %s %s%s", \
1075                         who, tmp, positive ? "" : " (negative)"); \
1076                 save = tree; \
1077                 tree = proto_item_add_subtree(ti, ett_afs_acl); \
1078                 proto_tree_add_item(tree,hf_afs_fs_acl_entity,curoffset,strlen(who), who);\
1079                 tmpoffset = curoffset + strlen(who) + 1; \
1080                 acllen = bytes - strlen(who) - 1; \
1081                 proto_tree_add_item(tree,hf_afs_fs_acl_r,tmpoffset,acllen,acl);\
1082                 proto_tree_add_item(tree,hf_afs_fs_acl_l,tmpoffset,acllen,acl);\
1083                 proto_tree_add_item(tree,hf_afs_fs_acl_i,tmpoffset,acllen,acl);\
1084                 proto_tree_add_item(tree,hf_afs_fs_acl_d,tmpoffset,acllen,acl);\
1085                 proto_tree_add_item(tree,hf_afs_fs_acl_w,tmpoffset,acllen,acl);\
1086                 proto_tree_add_item(tree,hf_afs_fs_acl_k,tmpoffset,acllen,acl);\
1087                 proto_tree_add_item(tree,hf_afs_fs_acl_a,tmpoffset,acllen,acl);\
1088                 tree = save; \
1089         }
1090
1091 /* Skip a certain number of bytes */
1092 #define SKIP(bytes) \
1093         TRUNC(bytes) \
1094         curoffset += bytes;
1095
1096 /* Raw data - to end of frame */
1097 #define RAWOUT(field) BYTESOUT(field, offset+END_OF_FRAME-curoffset)
1098
1099 /* Raw data */
1100 #define BYTESOUT(field, bytes) \
1101         TRUNC(bytes); \
1102         proto_tree_add_item(tree,field,curoffset,bytes,\
1103                 (void *)&pd[curoffset]); \
1104         curoffset += bytes;
1105
1106 /* Output a rx style string, up to a maximum length first 
1107    4 bytes - length, then char data */
1108 #define STROUT(field) \
1109         {       int i; \
1110                 TRUNC(4); \
1111                 i = ntohl(*((int *) &pd[curoffset])); \
1112                 curoffset += 4; \
1113                 TRUNC(i); \
1114                 if ( i > 0 ) { \
1115                         proto_tree_add_item(tree, field, curoffset-4, i+4, \
1116                         (void *)&pd[curoffset]); \
1117                 } else { \
1118                         proto_tree_add_item(tree, field, curoffset-4, 4, \
1119                         ""); \
1120                 } \
1121                 curoffset += i; \
1122         }
1123
1124 /* Output a fixed length vectorized string (each char is a 32 bit int) */
1125 #define VECOUT(field, length) \
1126         {       char tmp[length+1]; \
1127                 int i,soff; \
1128                 soff = curoffset;\
1129                 TRUNC(length * sizeof(guint32));\
1130                 for (i=0; i<length; i++)\
1131                 {\
1132                         tmp[i] = (char) GETINT();\
1133                         curoffset += sizeof(guint32);\
1134                 }\
1135                 tmp[length] = '\0';\
1136                 proto_tree_add_item(tree, field, soff, length, tmp);\
1137         }
1138
1139 /* Output a UBIK version code */
1140 #define UBIK_VERSIONOUT(label) \
1141         {       proto_tree *save, *ti; \
1142                 unsigned int epoch,counter; \
1143                 struct timeval tv; \
1144                 TRUNC(8); \
1145                 epoch = GETINT(); \
1146                 curoffset += 4; \
1147                 counter = GETINT(); \
1148                 curoffset += 4; \
1149                 tv.tv_sec = epoch; \
1150                 tv.tv_usec = 0; \
1151                 ti = proto_tree_add_text(tree, curoffset, 3*4, \
1152                         "UBIK Version (%s): %u.%u", label, epoch, counter ); \
1153                 save = tree; \
1154                 tree = proto_item_add_subtree(ti, ett_afs_ubikver); \
1155                 proto_tree_add_item(tree,hf_afs_ubik_version_epoch,curoffset-8, \
1156                         sizeof(guint32),&tv); \
1157                 proto_tree_add_item(tree,hf_afs_ubik_version_counter,curoffset-4, \
1158                         sizeof(guint32),counter); \
1159                 tree = save; \
1160         }
1161
1162 /*
1163  * Here is a helper routine for adding an AFS acl to the proto tree
1164  * This is to be used with FS packets only
1165  *
1166  * An AFS ACL is a string that has the following format:
1167  *
1168  * <positive> <negative>
1169  * <uid1> <aclbits1>
1170  * ....
1171  *
1172  * "positive" and "negative" are integers which contain the number of
1173  * positive and negative ACL's in the string.  The uid/aclbits pair are
1174  * ASCII strings containing the UID/PTS record and and a ascii number
1175  * representing a logical OR of all the ACL permission bits
1176  */
1177
1178 static void dissect_acl(const u_char *pd, int offset, frame_data *fd, proto_tree *tree)
1179 {
1180         int pos, neg, acl;
1181         int n, i, bytes;
1182         u_char const *s;
1183         u_char const *end;
1184         char user[128];
1185         int curoffset;
1186         int soff,eoff;
1187
1188         curoffset = offset;
1189
1190         TRUNC(sizeof(guint32));
1191         bytes = ntohl(*((int *) &pd[curoffset]));
1192         UINTOUT(hf_afs_fs_acl_datasize);
1193
1194         TRUNC(bytes);
1195
1196         soff = curoffset;
1197         eoff = curoffset+bytes;
1198
1199         s = &pd[soff];
1200         end = &pd[eoff];
1201
1202         if (sscanf((char *) s, "%d %n", &pos, &n) != 1)
1203                 return;
1204         s += n;
1205         TRUNC(1);
1206         proto_tree_add_item(tree, hf_afs_fs_acl_count_positive, curoffset, n, pos);
1207         curoffset += n;
1208
1209         if (sscanf((char *) s, "%d %n", &neg, &n) != 1)
1210                 return;
1211         s += n;
1212         TRUNC(1);
1213         proto_tree_add_item(tree, hf_afs_fs_acl_count_negative, curoffset, n, neg);
1214         curoffset += n;
1215
1216
1217         /*
1218          * This wacky order preserves the order used by the "fs" command
1219          */
1220
1221         for (i = 0; i < pos; i++) {
1222                 if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
1223                         return;
1224                 s += n;
1225                 ACLOUT(user,1,acl,n);
1226                 curoffset += n;
1227                 TRUNC(1);
1228         }
1229
1230         for (i = 0; i < neg; i++) {
1231                 if (sscanf((char *) s, "%s %d %n", user, &acl, &n) != 2)
1232                         return;
1233                 s += n;
1234                 ACLOUT(user,0,acl,n);
1235                 curoffset += n;
1236                 if (s > end)
1237                         return;
1238         }
1239 }
1240
1241 /*
1242  * Here are the helper dissection routines
1243  */
1244
1245 static void
1246 dissect_fs_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1247 {
1248         struct rx_header *rxh;
1249         unsigned char *data;
1250         int doffset, curoffset;
1251
1252         rxh = (struct rx_header *) &pd[offset];
1253         data = (char *)rxh + sizeof(struct rx_header);
1254         doffset = offset + sizeof(struct rx_header);
1255         curoffset = doffset;
1256
1257         if ( rxh->type == RX_PACKET_TYPE_DATA )
1258         {
1259                 switch ( opcode )
1260                 {
1261                         case 130: /* fetch data */
1262                                 RAWOUT(hf_afs_fs_data);
1263                                 break;
1264                         case 131: /* fetch acl */
1265                                 dissect_acl(pd,curoffset,fd,tree);
1266                                 break;
1267                         case 137: /* create file */
1268                                 FS_FIDOUT("New File");
1269                                 break;
1270                         case 141: /* make dir */
1271                                 FS_FIDOUT("New Directory");
1272                                 break;
1273                         case 151: /* root volume */
1274                                 STROUT(hf_afs_fs_volname);
1275                                 break;
1276                         case 153: /* get time */
1277                                 BIGDATEOUT(hf_afs_fs_timestamp);
1278                                 break;
1279                 }
1280         }
1281         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1282         {
1283                 UINTOUT(hf_afs_fs_errcode);
1284         }
1285 }
1286
1287 static void
1288 dissect_fs_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1289 {
1290         struct rx_header *rxh;
1291         unsigned char *data;
1292         int doffset, curoffset;
1293
1294         rxh = (struct rx_header *) &pd[offset];
1295         data = (char *)rxh + sizeof(struct rx_header);
1296         doffset = offset + sizeof(struct rx_header);
1297         curoffset = doffset;
1298
1299         /* skip opcode */
1300         SKIP(sizeof(guint32));
1301
1302         switch ( opcode )
1303         {
1304                 case 130: /* Fetch data */
1305                         FS_FIDOUT("Source");
1306                         UINTOUT(hf_afs_fs_offset);
1307                         UINTOUT(hf_afs_fs_length);
1308                         break;
1309                 case 131: /* Fetch ACL */
1310                 case 132: /* Fetch Status */
1311                 case 135: /* Store Status */
1312                 case 143: /* Old Set Lock */
1313                 case 144: /* Old Extend Lock */
1314                 case 145: /* Old Release Lock */
1315                 case 156: /* Set Lock */
1316                 case 157: /* Extend Lock */
1317                 case 158: /* Release Lock */
1318                         FS_FIDOUT("Target");
1319                         break;
1320                 case 133: /* Store Data */
1321                         FS_FIDOUT("Destination");
1322                         SKIP(6*sizeof(guint32));
1323                         UINTOUT(hf_afs_fs_offset);
1324                         UINTOUT(hf_afs_fs_length);
1325                         UINTOUT(hf_afs_fs_flength);
1326                         break;
1327                 case 134: /* Store ACL */
1328                         FS_FIDOUT("Target");
1329                         dissect_acl(pd,curoffset,fd,tree);
1330                         /* print acl */
1331                         break;
1332                 case 136: /* Remove File */
1333                 case 137: /* Create File */
1334                 case 141: /* Make dir */
1335                 case 142: /* Remove dir */
1336                         FS_FIDOUT("Target");
1337                         STROUT(hf_afs_fs_name);
1338                         break;
1339                 case 138: /* Rename file */
1340                         FS_FIDOUT("Old");
1341                         STROUT(hf_afs_fs_oldname);
1342                         FS_FIDOUT("New");
1343                         STROUT(hf_afs_fs_newname);
1344                         break;
1345                 case 139: /* Symlink */
1346                         FS_FIDOUT("File");
1347                         STROUT(hf_afs_fs_symlink_name);
1348                         STROUT(hf_afs_fs_symlink_content);
1349                         break;
1350                 case 140: /* Link */
1351                         FS_FIDOUT("Link From (Old File)");
1352                         STROUT(hf_afs_fs_name);
1353                         FS_FIDOUT("Link To (New File)");
1354                         break;
1355                 case 148: /* Get vol info */
1356                         STROUT(hf_afs_fs_volname);
1357                         break;
1358                 case 149: /* Get vol stats */
1359                 case 150: /* Set vol stats */
1360                         UINTOUT(hf_afs_fs_volid);
1361                         break;
1362                 case 154: /* new get vol info */
1363                         STROUT(hf_afs_fs_volname);
1364                         break;
1365                 case 155: /* bulk stat */
1366                 {
1367                         unsigned int j,i;
1368                         TRUNC(1);
1369
1370                         j = ntohl( *((int*)&pd[curoffset]) );
1371                         curoffset += 1;
1372                         for (i=0; i<j; i++)
1373                         {
1374                                 FS_FIDOUT("Target");
1375                         }
1376                         break;
1377                 }
1378         }
1379 }
1380
1381 /*
1382  * BOS Helpers
1383  */
1384 static void
1385 dissect_bos_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1386 {
1387         struct rx_header *rxh;
1388         unsigned char *data;
1389         int doffset, curoffset;
1390
1391         rxh = (struct rx_header *) &pd[offset];
1392         data = (char *)rxh + sizeof(struct rx_header);
1393         doffset = offset + sizeof(struct rx_header);
1394         curoffset = doffset;
1395
1396         if ( rxh->type == RX_PACKET_TYPE_DATA )
1397         {
1398                 switch ( opcode )
1399                 {
1400                         case 85: /* get instance info */
1401                                 STROUT(hf_afs_bos_type);
1402                                 break;
1403                 }
1404         }
1405         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1406         {
1407                 UINTOUT(hf_afs_bos_errcode);
1408         }
1409 }
1410
1411 static void
1412 dissect_bos_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1413 {
1414         struct rx_header *rxh;
1415         unsigned char *data;
1416         int doffset, curoffset;
1417
1418         rxh = (struct rx_header *) &pd[offset];
1419         data = (char *)rxh + sizeof(struct rx_header);
1420         doffset = offset + sizeof(struct rx_header);
1421         curoffset = doffset;
1422
1423         /* skip opcode */
1424         SKIP(sizeof(guint32));
1425
1426         switch ( opcode )
1427         {
1428                 case 80: /* create b node */
1429                         STROUT(hf_afs_bos_type);
1430                         STROUT(hf_afs_bos_instance);
1431                         break;
1432                 case 81: /* delete b node */
1433                 case 83: /* get status */
1434                 case 85: /* get instance info */
1435                 case 87: /* add super user */
1436                 case 88: /* delete super user */
1437                 case 93: /* set cell name */
1438                 case 96: /* add cell host */
1439                 case 97: /* delete cell host */
1440                 case 104: /* restart */
1441                 case 106: /* uninstall */
1442                 case 108: /* exec */
1443                 case 112: /* get log */
1444                 case 114: /* get instance strings */
1445                         STROUT(hf_afs_bos_content);
1446                         break;
1447                 case 82: /* set status */
1448                 case 98: /* set t status */
1449                         STROUT(hf_afs_bos_content);
1450                         UINTOUT(hf_afs_bos_status);
1451                         break;
1452                 case 86: /* get instance parm */
1453                         STROUT(hf_afs_bos_instance);
1454                         UINTOUT(hf_afs_bos_num);
1455                         break;
1456                 case 84: /* enumerate instance */
1457                 case 89: /* list super users */
1458                 case 90: /* list keys */
1459                 case 91: /* add key */
1460                 case 92: /* delete key */
1461                 case 95: /* set cell host */
1462                         UINTOUT(hf_afs_bos_num);
1463                         break;
1464                 case 105: /* install */
1465                         STROUT(hf_afs_bos_content);
1466                         UINTOUT(hf_afs_bos_size);
1467                         UINTOUT(hf_afs_bos_flags);
1468                         UINTOUT(hf_afs_bos_date);
1469                         break;
1470         }
1471 }
1472
1473 /*
1474  * VOL Helpers
1475  */
1476 static void
1477 dissect_vol_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1478 {
1479         struct rx_header *rxh;
1480         unsigned char *data;
1481         int doffset, curoffset;
1482
1483         rxh = (struct rx_header *) &pd[offset];
1484         data = (char *)rxh + sizeof(struct rx_header);
1485         doffset = offset + sizeof(struct rx_header);
1486         curoffset = doffset;
1487
1488         if ( rxh->type == RX_PACKET_TYPE_DATA )
1489         {
1490                 switch ( opcode )
1491                 {
1492                         case 121:
1493                                 /* should loop here maybe */
1494                                 UINTOUT(hf_afs_vol_count);
1495                                 VECOUT(hf_afs_vol_name, 32); /* not sure on  */
1496                                 break;
1497                 }
1498         }
1499         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1500         {
1501                 UINTOUT(hf_afs_vol_errcode);
1502         }
1503 }
1504
1505 static void
1506 dissect_vol_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1507 {
1508         struct rx_header *rxh;
1509         unsigned char *data;
1510         int doffset, curoffset;
1511
1512         rxh = (struct rx_header *) &pd[offset];
1513         data = (char *)rxh + sizeof(struct rx_header);
1514         doffset = offset + sizeof(struct rx_header);
1515         curoffset = doffset;
1516
1517         /* skip opcode */
1518         SKIP(sizeof(guint32));
1519
1520         switch ( opcode )
1521         {
1522                 case 121: /* list one vol */
1523                         UINTOUT(hf_afs_vol_count);
1524                         UINTOUT(hf_afs_vol_id);
1525                         break;
1526         }
1527 }
1528
1529 /*
1530  * KAUTH Helpers
1531  */
1532 static void
1533 dissect_kauth_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1534 {
1535         struct rx_header *rxh;
1536         unsigned char *data;
1537         int doffset, curoffset;
1538
1539         rxh = (struct rx_header *) &pd[offset];
1540         data = (char *)rxh + sizeof(struct rx_header);
1541         doffset = offset + sizeof(struct rx_header);
1542         curoffset = doffset;
1543
1544         if ( rxh->type == RX_PACKET_TYPE_DATA )
1545         {
1546                 switch ( opcode )
1547                 {
1548                 }
1549         }
1550         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1551         {
1552                 UINTOUT(hf_afs_kauth_errcode);
1553         }
1554 }
1555
1556 static void
1557 dissect_kauth_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1558 {
1559         struct rx_header *rxh;
1560         unsigned char *data;
1561         int doffset, curoffset;
1562
1563         rxh = (struct rx_header *) &pd[offset];
1564         data = (char *)rxh + sizeof(struct rx_header);
1565         doffset = offset + sizeof(struct rx_header);
1566         curoffset = doffset;
1567
1568         /* skip opcode */
1569         SKIP(sizeof(guint32));
1570
1571         switch ( opcode )
1572         {
1573                 case 1: /* authenticate old */
1574                 case 21: /* authenticate */
1575                 case 22: /* authenticate v2 */
1576                 case 2: /* change pw */
1577                 case 5: /* set fields */
1578                 case 6: /* create user */
1579                 case 7: /* delete user */
1580                 case 8: /* get entry */
1581                 case 14: /* unlock */
1582                 case 15: /* lock status */
1583                         STROUT(hf_afs_kauth_princ);
1584                         STROUT(hf_afs_kauth_realm);
1585                         RAWOUT(hf_afs_kauth_data);
1586                         break;
1587                 case 3: /* getticket-old */
1588                 case 23: /* getticket */
1589                         UINTOUT(hf_afs_kauth_kvno);
1590                         STROUT(hf_afs_kauth_domain);
1591                         STROUT(hf_afs_kauth_data);
1592                         STROUT(hf_afs_kauth_princ);
1593                         STROUT(hf_afs_kauth_realm);
1594                         break;
1595                 case 4: /* set pass */
1596                         STROUT(hf_afs_kauth_princ);
1597                         STROUT(hf_afs_kauth_realm);
1598                         UINTOUT(hf_afs_kauth_kvno);
1599                         break;
1600                 case 12: /* get pass */
1601                         STROUT(hf_afs_kauth_name);
1602                         break;
1603         }
1604 }
1605
1606 /*
1607  * CB Helpers
1608  */
1609 static void
1610 dissect_cb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1611 {
1612         struct rx_header *rxh;
1613         unsigned char *data;
1614         int doffset, curoffset;
1615
1616         rxh = (struct rx_header *) &pd[offset];
1617         data = (char *)rxh + sizeof(struct rx_header);
1618         doffset = offset + sizeof(struct rx_header);
1619         curoffset = doffset;
1620
1621         if ( rxh->type == RX_PACKET_TYPE_DATA )
1622         {
1623                 switch ( opcode )
1624                 {
1625                 }
1626         }
1627         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1628         {
1629                 UINTOUT(hf_afs_cb_errcode);
1630         }
1631 }
1632
1633 static void
1634 dissect_cb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1635 {
1636         struct rx_header *rxh;
1637         unsigned char *data;
1638         int doffset, curoffset;
1639
1640         rxh = (struct rx_header *) &pd[offset];
1641         data = (char *)rxh + sizeof(struct rx_header);
1642         doffset = offset + sizeof(struct rx_header);
1643         curoffset = doffset;
1644
1645         /* skip opcode */
1646         SKIP(sizeof(guint32));
1647
1648         switch ( opcode )
1649         {
1650                 case 204: /* callback */
1651                 {
1652                         unsigned int i,j;
1653
1654                         TRUNC(4);
1655                         j = GETINT();
1656
1657                         for (i=0; i<j; i++)
1658                         {
1659                                 CB_FIDOUT("Target");
1660                         }
1661
1662                         TRUNC(4);
1663                         j = GETINT();
1664                         for (i=0; i<j; i++)
1665                         {
1666                                 CB_CALLBACKOUT();
1667                         }
1668                 }
1669         }
1670 }
1671
1672 /*
1673  * PROT Helpers
1674  */
1675 static void
1676 dissect_prot_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1677 {
1678         struct rx_header *rxh;
1679         unsigned char *data;
1680         int doffset, curoffset;
1681
1682         rxh = (struct rx_header *) &pd[offset];
1683         data = (char *)rxh + sizeof(struct rx_header);
1684         doffset = offset + sizeof(struct rx_header);
1685         curoffset = doffset;
1686
1687         if ( rxh->type == RX_PACKET_TYPE_DATA )
1688         {
1689                 switch ( opcode )
1690                 {
1691                         case 504: /* name to id */
1692                                 {
1693                                         unsigned int i, j;
1694
1695                                         TRUNC(4);
1696                                         j = GETINT();
1697                                         UINTOUT(hf_afs_prot_count);
1698
1699                                         for (i=0; i<j; i++)
1700                                         {
1701                                                 UINTOUT(hf_afs_prot_id);
1702                                         }
1703                                 }
1704                                 break;
1705                         case 505: /* id to name */
1706                                 {
1707                                         unsigned int i, j;
1708
1709                                         TRUNC(4);
1710                                         j = GETINT();
1711                                         UINTOUT(hf_afs_prot_count);
1712
1713                                         for (i=0; i<j; i++)
1714                                         {
1715                                                 VECOUT(hf_afs_prot_name, PRNAMEMAX);
1716                                         }
1717                                 }
1718                                 break;
1719                         case 508: /* get cps */
1720                         case 514: /* list elements */
1721                         case 517: /* list owned */
1722                         case 518: /* get cps2 */
1723                         case 519: /* get host cps */
1724                                 {
1725                                         unsigned int i, j;
1726
1727                                         TRUNC(4);
1728                                         j = GETINT();
1729                                         UINTOUT(hf_afs_prot_count);
1730
1731                                         for (i=0; i<j; i++)
1732                                         {
1733                                                 UINTOUT(hf_afs_prot_id);
1734                                         }
1735                                 }
1736                                 break;
1737                         case 510: /* list max */
1738                                 UINTOUT(hf_afs_prot_maxuid);
1739                                 UINTOUT(hf_afs_prot_maxgid);
1740                                 break;
1741                 }
1742         }
1743         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1744         {
1745                 UINTOUT(hf_afs_prot_errcode);
1746         }
1747 }
1748
1749 static void
1750 dissect_prot_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1751 {
1752         struct rx_header *rxh;
1753         unsigned char *data;
1754         int doffset, curoffset;
1755
1756         rxh = (struct rx_header *) &pd[offset];
1757         data = (char *)rxh + sizeof(struct rx_header);
1758         doffset = offset + sizeof(struct rx_header);
1759         curoffset = doffset;
1760
1761         /* skip opcode */
1762         SKIP(sizeof(guint32));
1763
1764         switch ( opcode )
1765         {
1766                 case 500: /* new user */
1767                         STROUT(hf_afs_prot_name);
1768                         UINTOUT(hf_afs_prot_id);
1769                         UINTOUT(hf_afs_prot_oldid);
1770                         break;
1771                 case 501: /* where is it */
1772                 case 506: /* delete */
1773                 case 508: /* get cps */
1774                 case 512: /* list entry */
1775                 case 514: /* list elements */
1776                 case 517: /* list owned */
1777                 case 519: /* get host cps */
1778                         UINTOUT(hf_afs_prot_id);
1779                         break;
1780                 case 502: /* dump entry */
1781                         UINTOUT(hf_afs_prot_pos);
1782                         break;
1783                 case 503: /* add to group */
1784                 case 507: /* remove from group */
1785                 case 515: /* is a member of? */
1786                         UINTOUT(hf_afs_prot_uid);
1787                         UINTOUT(hf_afs_prot_gid);
1788                         break;
1789                 case 504: /* name to id */
1790                         {
1791                                 unsigned int i, j;
1792
1793                                 TRUNC(4);
1794                                 j = GETINT();
1795                                 UINTOUT(hf_afs_prot_count);
1796
1797                                 for (i=0; i<j; i++)
1798                                 {
1799                                         VECOUT(hf_afs_prot_name,PRNAMEMAX);
1800                                 }
1801                         }
1802                         break;
1803                 case 505: /* id to name */
1804                         {
1805                                 unsigned int i, j;
1806
1807                                 TRUNC(4);
1808                                 j = GETINT();
1809                                 UINTOUT(hf_afs_prot_count);
1810
1811                                 for (i=0; i<j; i++)
1812                                 {
1813                                         UINTOUT(hf_afs_prot_id);
1814                                 }
1815                         }
1816                         break;
1817                 case 509: /* new entry */
1818                         STROUT(hf_afs_prot_name);
1819                         UINTOUT(hf_afs_prot_flag);
1820                         UINTOUT(hf_afs_prot_oldid);
1821                         break;
1822                 case 511: /* set max */
1823                         UINTOUT(hf_afs_prot_id);
1824                         UINTOUT(hf_afs_prot_flag);
1825                         break;
1826                 case 513: /* change entry */
1827                         UINTOUT(hf_afs_prot_id);
1828                         STROUT(hf_afs_prot_name);
1829                         UINTOUT(hf_afs_prot_oldid);
1830                         UINTOUT(hf_afs_prot_newid);
1831                         break;
1832                 case 520: /* update entry */
1833                         UINTOUT(hf_afs_prot_id);
1834                         STROUT(hf_afs_prot_name);
1835                         break;
1836         }
1837 }
1838
1839 /*
1840  * VLDB Helpers
1841  */
1842 static void
1843 dissect_vldb_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1844 {
1845         struct rx_header *rxh;
1846         unsigned char *data;
1847         int doffset, curoffset;
1848
1849         rxh = (struct rx_header *) &pd[offset];
1850         data = (char *)rxh + sizeof(struct rx_header);
1851         doffset = offset + sizeof(struct rx_header);
1852         curoffset = doffset;
1853
1854         if ( rxh->type == RX_PACKET_TYPE_DATA )
1855         {
1856                 switch ( opcode )
1857                 {
1858                         case 510: /* list entry */
1859                                 UINTOUT(hf_afs_vldb_count);
1860                                 UINTOUT(hf_afs_vldb_nextindex);
1861                                 break;
1862                         case 503: /* get entry by id */
1863                         case 504: /* get entry by name */
1864                                 {
1865                                         int nservers,i,j;
1866                                         VECOUT(hf_afs_vldb_name, VLNAMEMAX);
1867                                         TRUNC(4);
1868                                         nservers = GETINT();
1869                                         UINTOUT(hf_afs_vldb_numservers);
1870                                         for (i=0; i<8; i++)
1871                                         {
1872                                                 if ( i<nservers )
1873                                                 {
1874                                                         IPOUT(hf_afs_vldb_server);
1875                                                 }
1876                                                 else
1877                                                 {
1878                                                         SKIP(4);
1879                                                 }
1880                                         }
1881                                         for (i=0; i<8; i++)
1882                                         {
1883                                                 char part[8];
1884                                                 TRUNC(4);
1885                                                 j = GETINT();
1886                                                 strcpy(part, "/vicepa");
1887                                                 if ( i<nservers && j<=26 )
1888                                                 {
1889                                                         part[6] = (char) j;
1890                                                         proto_tree_add_item(tree, hf_afs_vldb_partition,
1891                                                                 curoffset, 4, part);
1892                                                 }
1893                                                 SKIP(4);
1894                                         }
1895                                         SKIP(8 * sizeof(guint32));
1896                                         UINTOUT(hf_afs_vldb_rwvol);
1897                                         UINTOUT(hf_afs_vldb_rovol);
1898                                         UINTOUT(hf_afs_vldb_bkvol);
1899                                 }
1900                                 break;
1901                         case 505: /* get new volume id */
1902                                 UINTOUT(hf_afs_vldb_id);
1903                                 break;
1904                         case 521: /* list entry */
1905                         case 529: /* list entry U */
1906                                 UINTOUT(hf_afs_vldb_count);
1907                                 UINTOUT(hf_afs_vldb_nextindex);
1908                                 break;
1909                         case 518: /* get entry by id n */
1910                         case 519: /* get entry by name N */
1911                                 {
1912                                         int nservers,i,j;
1913                                         VECOUT(hf_afs_vldb_name, VLNAMEMAX);
1914                                         TRUNC(4);
1915                                         nservers = GETINT();
1916                                         UINTOUT(hf_afs_vldb_numservers);
1917                                         for (i=0; i<13; i++)
1918                                         {
1919                                                 if ( i<nservers )
1920                                                 {
1921                                                         IPOUT(hf_afs_vldb_server);
1922                                                 }
1923                                                 else
1924                                                 {
1925                                                         SKIP(4);
1926                                                 }
1927                                         }
1928                                         for (i=0; i<13; i++)
1929                                         {
1930                                                 char part[8];
1931                                                 TRUNC(4);
1932                                                 j = GETINT();
1933                                                 strcpy(part, "/vicepa");
1934                                                 if ( i<nservers && j<=26 )
1935                                                 {
1936                                                         part[6] = (char) j;
1937                                                         proto_tree_add_item(tree, hf_afs_vldb_partition,
1938                                                                 curoffset, 4, part);
1939                                                 }
1940                                                 SKIP(4);
1941                                         }
1942                                         SKIP(13 * sizeof(guint32));
1943                                         UINTOUT(hf_afs_vldb_rwvol);
1944                                         UINTOUT(hf_afs_vldb_rovol);
1945                                         UINTOUT(hf_afs_vldb_bkvol);
1946                                 }
1947                                 break;
1948                         case 526: /* get entry by id u */
1949                         case 527: /* get entry by name u */
1950                                 {
1951                                         int nservers,i,j;
1952                                         VECOUT(hf_afs_vldb_name, VLNAMEMAX);
1953                                         TRUNC(4);
1954                                         nservers = GETINT();
1955                                         UINTOUT(hf_afs_vldb_numservers);
1956                                         for (i=0; i<13; i++)
1957                                         {
1958                                                 if ( i<nservers )
1959                                                 {
1960                                                         BYTESOUT(hf_afs_vldb_serveruuid, 11*sizeof(guint32));
1961                                                 }
1962                                                 else
1963                                                 {
1964                                                         SKIP(11*sizeof(guint32));
1965                                                 }
1966                                         }
1967                                         for (i=0; i<13; i++)
1968                                         {
1969                                                 char part[8];
1970                                                 TRUNC(4);
1971                                                 j = GETINT();
1972                                                 strcpy(part, "/vicepa");
1973                                                 if ( i<nservers && j<=26 )
1974                                                 {
1975                                                         part[6] = (char) j;
1976                                                         proto_tree_add_item(tree, hf_afs_vldb_partition,
1977                                                                 curoffset, 4, part);
1978                                                 }
1979                                                 SKIP(4);
1980                                         }
1981                                         SKIP(13 * sizeof(guint32));
1982                                         UINTOUT(hf_afs_vldb_rwvol);
1983                                         UINTOUT(hf_afs_vldb_rovol);
1984                                         UINTOUT(hf_afs_vldb_bkvol);
1985                                 }
1986                                 break;
1987                 }
1988         }
1989         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
1990         {
1991                 UINTOUT(hf_afs_vldb_errcode);
1992         }
1993 }
1994
1995 static void
1996 dissect_vldb_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
1997 {
1998         struct rx_header *rxh;
1999         unsigned char *data;
2000         int doffset, curoffset;
2001
2002         rxh = (struct rx_header *) &pd[offset];
2003         data = (char *)rxh + sizeof(struct rx_header);
2004         doffset = offset + sizeof(struct rx_header);
2005         curoffset = doffset;
2006
2007         /* skip opcode */
2008         SKIP(sizeof(guint32));
2009
2010         switch ( opcode )
2011         {
2012                 case 501: /* create new volume */
2013                 case 517: /* create entry N */
2014                         VECOUT(hf_afs_vldb_name, VLNAMEMAX);
2015                         break;
2016                 case 502: /* delete entry */
2017                 case 503: /* get entry by id */
2018                 case 507: /* update entry */
2019                 case 508: /* set lock */
2020                 case 509: /* release lock */
2021                 case 518: /* get entry by id */
2022                         UINTOUT(hf_afs_vldb_id);
2023                         UINTOUT(hf_afs_vldb_type);
2024                         break;
2025                 case 504: /* get entry by name */
2026                 case 519: /* get entry by name N */
2027                 case 524: /* update entry by name */
2028                 case 527: /* get entry by name U */
2029                         STROUT(hf_afs_vldb_name);
2030                         break;
2031                 case 505: /* get new vol id */
2032                         UINTOUT(hf_afs_vldb_bump);
2033                         break;
2034                 case 506: /* replace entry */
2035                 case 520: /* replace entry N */
2036                         UINTOUT(hf_afs_vldb_id);
2037                         UINTOUT(hf_afs_vldb_type);
2038                         VECOUT(hf_afs_vldb_name, VLNAMEMAX);
2039                         break;
2040                 case 510: /* list entry */
2041                 case 521: /* list entry N */
2042                         UINTOUT(hf_afs_vldb_index);
2043                         break;
2044         }
2045 }
2046
2047 /*
2048  * UBIK Helpers
2049  */
2050 static void
2051 dissect_ubik_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
2052 {
2053         struct rx_header *rxh;
2054         unsigned char *data;
2055         int doffset, curoffset;
2056
2057         rxh = (struct rx_header *) &pd[offset];
2058         data = (char *)rxh + sizeof(struct rx_header);
2059         doffset = offset + sizeof(struct rx_header);
2060         curoffset = doffset;
2061
2062         if ( rxh->type == RX_PACKET_TYPE_DATA )
2063         {
2064                 switch ( opcode )
2065                 {
2066                         case 10000: /* beacon */
2067                                 proto_tree_add_item(tree,hf_afs_ubik_votetype,0,0,0);
2068                                 break;
2069                         case 20004: /* get version */
2070                                 UBIK_VERSIONOUT("DB Version");
2071                                 break;
2072                 }
2073         }
2074         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
2075         {
2076                 switch ( opcode )
2077                 {
2078                         case 10000:
2079                                 proto_tree_add_item(tree,hf_afs_ubik_votetype,0,0,1);
2080                                 DATEOUT(hf_afs_ubik_voteend);
2081                                 break;
2082                         default:
2083                                 UINTOUT(hf_afs_ubik_errcode);
2084                                 break;
2085                 }
2086         }
2087 }
2088
2089 static void
2090 dissect_ubik_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
2091 {
2092         struct rx_header *rxh;
2093         unsigned char *data;
2094         int doffset, curoffset;
2095
2096         rxh = (struct rx_header *) &pd[offset];
2097         data = (char *)rxh + sizeof(struct rx_header);
2098         doffset = offset + sizeof(struct rx_header);
2099         curoffset = doffset;
2100
2101         /* skip opcode */
2102         SKIP(sizeof(guint32));
2103
2104         switch ( opcode )
2105         {
2106                 case 10000: /* beacon */
2107                         UINTOUT(hf_afs_ubik_syncsite);
2108                         DATEOUT(hf_afs_ubik_votestart);
2109                         UBIK_VERSIONOUT("DB Version");
2110                         UBIK_VERSIONOUT("TID");
2111                         break;
2112                 case 10003: /* get sync site */
2113                         IPOUT(hf_afs_ubik_site);
2114                         break;
2115                 case 20000: /* begin */
2116                 case 20001: /* commit */
2117                 case 20007: /* abort */
2118                 case 20008: /* release locks */
2119                 case 20010: /* writev */
2120                         UBIK_VERSIONOUT("TID");
2121                         break;
2122                 case 20002: /* lock */
2123                         UBIK_VERSIONOUT("TID");
2124                         UINTOUT(hf_afs_ubik_file);
2125                         UINTOUT(hf_afs_ubik_pos);
2126                         UINTOUT(hf_afs_ubik_length);
2127                         UINTOUT(hf_afs_ubik_locktype);
2128                         break;
2129                 case 20003: /* write */
2130                         UBIK_VERSIONOUT("TID");
2131                         UINTOUT(hf_afs_ubik_file);
2132                         UINTOUT(hf_afs_ubik_pos);
2133                         break;
2134                 case 20005: /* get file */
2135                         UINTOUT(hf_afs_ubik_file);
2136                         break;
2137                 case 20006: /* send file */
2138                         UINTOUT(hf_afs_ubik_file);
2139                         UINTOUT(hf_afs_ubik_length);
2140                         UBIK_VERSIONOUT("DB Version");
2141                         break;
2142                 case 20009: /* truncate */
2143                         UBIK_VERSIONOUT("TID");
2144                         UINTOUT(hf_afs_ubik_file);
2145                         UINTOUT(hf_afs_ubik_length);
2146                         break;
2147                 case 20012: /* set version */
2148                         UBIK_VERSIONOUT("TID");
2149                         UBIK_VERSIONOUT("Old DB Version");
2150                         UBIK_VERSIONOUT("New DB Version");
2151                         break;
2152         }
2153 }
2154
2155 /*
2156  * BACKUP Helpers
2157  */
2158 static void
2159 dissect_backup_reply(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
2160 {
2161         struct rx_header *rxh;
2162         unsigned char *data;
2163         int doffset, curoffset;
2164
2165         rxh = (struct rx_header *) &pd[offset];
2166         data = (char *)rxh + sizeof(struct rx_header);
2167         doffset = offset + sizeof(struct rx_header);
2168         curoffset = doffset;
2169
2170         if ( rxh->type == RX_PACKET_TYPE_DATA )
2171         {
2172                 switch ( opcode )
2173                 {
2174                 }
2175         }
2176         else if ( rxh->type == RX_PACKET_TYPE_ABORT )
2177         {
2178                 UINTOUT(hf_afs_backup_errcode);
2179         }
2180 }
2181
2182 static void
2183 dissect_backup_request(const u_char *pd, int offset, frame_data *fd, proto_tree *tree, int opcode)
2184 {
2185         struct rx_header *rxh;
2186         unsigned char *data;
2187         int doffset, curoffset;
2188
2189         rxh = (struct rx_header *) &pd[offset];
2190         data = (char *)rxh + sizeof(struct rx_header);
2191         doffset = offset + sizeof(struct rx_header);
2192         curoffset = doffset;
2193
2194         /* skip opcode */
2195         SKIP(sizeof(guint32));
2196
2197         switch ( opcode )
2198         {
2199         }
2200 }
2201
2202 /*
2203  * Registration code for registering the protocol and fields
2204  */
2205
2206 void
2207 proto_register_afs(void)
2208 {
2209         static hf_register_info hf[] = {
2210
2211                 { &hf_afs_fs, {
2212                         "File Server", "afs.fs", FT_BOOLEAN, BASE_NONE,
2213                         0, 0, "File Server" }},
2214                 { &hf_afs_cb, {
2215                         "Callback", "afs.cb", FT_BOOLEAN, BASE_NONE,
2216                         0, 0, "Callback" }},
2217                 { &hf_afs_prot, {
2218                         "Protection", "afs.prot", FT_BOOLEAN, BASE_NONE,
2219                         0, 0, "Protection" }},
2220                 { &hf_afs_vldb, {
2221                         "VLDB", "afs.vldb", FT_BOOLEAN, BASE_NONE,
2222                         0, 0, "VLDB" }},
2223                 { &hf_afs_kauth, {
2224                         "Kauth", "afs.kauth", FT_BOOLEAN, BASE_NONE,
2225                         0, 0, "Kauth" }},
2226                 { &hf_afs_vol, {
2227                         "Volume Server", "afs.vol", FT_BOOLEAN, BASE_NONE,
2228                         0, 0, "Volume Server" }},
2229                 { &hf_afs_error, {
2230                         "Error", "afs.error", FT_BOOLEAN, BASE_NONE,
2231                         0, 0, "Error" }},
2232                 { &hf_afs_bos, {
2233                         "BOS", "afs.bos", FT_BOOLEAN, BASE_NONE,
2234                         0, 0, "BOS" }},
2235                 { &hf_afs_update, {
2236                         "Update", "afs.update", FT_BOOLEAN, BASE_NONE,
2237                         0, 0, "Update" }},
2238                 { &hf_afs_rmtsys, {
2239                         "Rmtsys", "afs.rmtsys", FT_BOOLEAN, BASE_NONE,
2240                         0, 0, "Rmtsys" }},
2241                 { &hf_afs_ubik, {
2242                         "Ubik", "afs.ubik", FT_BOOLEAN, BASE_NONE,
2243                         0, 0, "Ubik" }},
2244                 { &hf_afs_backup, {
2245                         "Backup", "afs.backup", FT_BOOLEAN, BASE_NONE,
2246                         0, 0, "Backup" }},
2247
2248                 { &hf_afs_fs_opcode, {
2249                         "Operation", "afs.fs.opcode", FT_UINT32, BASE_DEC,
2250                         VALS(fs_req), 0, "Operation" }},
2251                 { &hf_afs_cb_opcode, {
2252                         "Operation", "afs.cb.opcode", FT_UINT32, BASE_DEC,
2253                         VALS(cb_req), 0, "Operation" }},
2254                 { &hf_afs_prot_opcode, {
2255                         "Operation", "afs.prot.opcode", FT_UINT32, BASE_DEC,
2256                         VALS(prot_req), 0, "Operation" }},
2257                 { &hf_afs_vldb_opcode, {
2258                         "Operation", "afs.vldb.opcode", FT_UINT32, BASE_DEC,
2259                         VALS(vldb_req), 0, "Operation" }},
2260                 { &hf_afs_kauth_opcode, {
2261                         "Operation", "afs.kauth.opcode", FT_UINT32, BASE_DEC,
2262                         VALS(kauth_req), 0, "Operation" }},
2263                 { &hf_afs_vol_opcode, {
2264                         "Operation", "afs.vol.opcode", FT_UINT32, BASE_DEC,
2265                         VALS(vol_req), 0, "Operation" }},
2266                 { &hf_afs_bos_opcode, {
2267                         "Operation", "afs.bos.opcode", FT_UINT32, BASE_DEC,
2268                         VALS(bos_req), 0, "Operation" }},
2269                 { &hf_afs_update_opcode, {
2270                         "Operation", "afs.update.opcode", FT_UINT32, BASE_DEC,
2271                         0, 0, "Operation" }},
2272                 { &hf_afs_rmtsys_opcode, {
2273                         "Operation", "afs.rmtsys.opcode", FT_UINT32, BASE_DEC,
2274                         0, 0, "Operation" }},
2275                 { &hf_afs_error_opcode, {
2276                         "Operation", "afs.error.opcode", FT_UINT32, BASE_DEC,
2277                         0, 0, "Operation" }},
2278                 { &hf_afs_backup_opcode, {
2279                         "Operation", "afs.backup.opcode", FT_UINT32, BASE_DEC,
2280                         0, 0, "Operation" }},
2281                 { &hf_afs_ubik_opcode, {
2282                         "Operation", "afs.ubik.opcode", FT_UINT32, BASE_DEC,
2283                         VALS(ubik_req), 0, "Operation" }},
2284
2285
2286                 /* File Server Fields */
2287                 { &hf_afs_fs_fid_volume, {
2288                         "FileID (Volume)", "afs.fs.fid.volume", FT_UINT32, BASE_DEC,
2289                         0, 0, "File ID (Volume)" }},
2290                 { &hf_afs_fs_fid_vnode, {
2291                         "FileID (VNode)", "afs.fs.fid.vnode", FT_UINT32, BASE_DEC,
2292                         0, 0, "File ID (VNode)" }},
2293                 { &hf_afs_fs_fid_uniqifier, {
2294                         "FileID (Uniqifier)", "afs.fs.fid.uniq", FT_UINT32, BASE_DEC,
2295                         0, 0, "File ID (Uniqifier)" }},
2296                 { &hf_afs_fs_offset, {
2297                         "Offset", "afs.fs.offset", FT_UINT32, BASE_DEC,
2298                         0, 0, "Offset" }},
2299                 { &hf_afs_fs_length, {
2300                         "Length", "afs.fs.length", FT_UINT32, BASE_DEC,
2301                         0, 0, "Length" }},
2302                 { &hf_afs_fs_flength, {
2303                         "FLength", "afs.fs.flength", FT_UINT32, BASE_DEC,
2304                         0, 0, "FLength" }},
2305                 { &hf_afs_fs_errcode, {
2306                         "Error Code", "afs.fs.errcode", FT_UINT32, BASE_DEC,
2307                         VALS(afs_errors), 0, "Error Code" }},
2308                 { &hf_afs_fs_data, {
2309                         "Data", "afs.fs.data", FT_BYTES, BASE_HEX,
2310                         0, 0, "Data" }},
2311                 { &hf_afs_fs_oldname, {
2312                         "Old Name", "afs.fs.oldname", FT_STRING, BASE_HEX,
2313                         0, 0, "Old Name" }},
2314                 { &hf_afs_fs_newname, {
2315                         "New Name", "afs.fs.newname", FT_STRING, BASE_HEX,
2316                         0, 0, "New Name" }},
2317                 { &hf_afs_fs_name, {
2318                         "Name", "afs.fs.name", FT_STRING, BASE_HEX,
2319                         0, 0, "Name" }},
2320                 { &hf_afs_fs_symlink_name, {
2321                         "Symlink Name", "afs.fs.symlink.name", FT_STRING, BASE_HEX,
2322                         0, 0, "Symlink Name" }},
2323                 { &hf_afs_fs_symlink_content, {
2324                         "Symlink Content", "afs.fs.symlink.content", FT_STRING, BASE_HEX,
2325                         0, 0, "Symlink Content" }},
2326                 { &hf_afs_fs_volid, {
2327                         "Volume ID", "afs.fs.volid", FT_UINT32, BASE_DEC,
2328                         0, 0, "Volume ID" }},
2329                 { &hf_afs_fs_volname, {
2330                         "Volume Name", "afs.fs.volname", FT_STRING, BASE_HEX,
2331                         0, 0, "Volume Name" }},
2332                 { &hf_afs_fs_timestamp, {
2333                         "Timestamp", "afs.fs.timestamp", FT_ABSOLUTE_TIME, BASE_DEC,
2334                         0, 0, "Timestamp" }},
2335
2336                 { &hf_afs_fs_acl_count_positive, {
2337                         "ACL Count (Positive)", "afs.fs.acl.count.positive", FT_UINT32, BASE_DEC,
2338                         0, 0, "Number of Positive ACLs" }},
2339                 { &hf_afs_fs_acl_count_negative, {
2340                         "ACL Count (Negative)", "afs.fs.acl.count.negative", FT_UINT32, BASE_DEC,
2341                         0, 0, "Number of Negative ACLs" }},
2342                 { &hf_afs_fs_acl_datasize, {
2343                         "ACL Size", "afs.fs.acl.datasize", FT_UINT32, BASE_DEC,
2344                         0, 0, "ACL Data Size" }},
2345                 { &hf_afs_fs_acl_entity, {
2346                         "Entity (User/Group)", "afs.fs.acl.entity", FT_STRING, BASE_HEX,
2347                         0, 0, "ACL Entity (User/Group)" }},
2348                 { &hf_afs_fs_acl_r, {
2349                         "_R_ead", "afs.fs.acl.r", FT_UINT8, BASE_BIN,
2350                         0, PRSFS_READ, "Read" }},
2351                 { &hf_afs_fs_acl_l, {
2352                         "_L_ookup", "afs.fs.acl.l", FT_UINT8, BASE_BIN,
2353                         0, PRSFS_LOOKUP, "Lookup" }},
2354                 { &hf_afs_fs_acl_i, {
2355                         "_I_nsert", "afs.fs.acl.i", FT_UINT8, BASE_BIN,
2356                         0, PRSFS_INSERT, "Insert" }},
2357                 { &hf_afs_fs_acl_d, {
2358                         "_D_elete", "afs.fs.acl.d", FT_UINT8, BASE_BIN,
2359                         0, PRSFS_DELETE, "Delete" }},
2360                 { &hf_afs_fs_acl_w, {
2361                         "_W_rite", "afs.fs.acl.w", FT_UINT8, BASE_BIN,
2362                         0, PRSFS_WRITE, "Write" }},
2363                 { &hf_afs_fs_acl_k, {
2364                         "_L_ock", "afs.fs.acl.k", FT_UINT8, BASE_BIN,
2365                         0, PRSFS_LOCK, "Lock" }},
2366                 { &hf_afs_fs_acl_a, {
2367                         "_A_dminister", "afs.fs.acl.a", FT_UINT8, BASE_BIN,
2368                         0, PRSFS_ADMINISTER, "Administer" }},
2369
2370                 { &hf_afs_fs_callback_version, {
2371                         "Version", "afs.fs.callback.version", FT_UINT32, BASE_DEC,
2372                         0, 0, "Version" }},
2373                 { &hf_afs_fs_callback_expires, {
2374                         "Expires", "afs.fs.callback.expires", FT_ABSOLUTE_TIME, BASE_DEC,
2375                         0, 0, "Expires" }},
2376                 { &hf_afs_fs_callback_type, {
2377                         "Type", "afs.fs.callback.type", FT_UINT32, BASE_DEC,
2378                         VALS(cb_types), 0, "Type" }},
2379
2380                 /* BOS Server Fields */
2381                 { &hf_afs_bos_errcode, {
2382                         "Error Code", "afs.bos.errcode", FT_UINT32, BASE_DEC,
2383                         VALS(afs_errors), 0, "Error Code" }},
2384                 { &hf_afs_bos_type, {
2385                         "Type", "afs.bos.type", FT_STRING, BASE_HEX,
2386                         0, 0, "Type" }},
2387                 { &hf_afs_bos_content, {
2388                         "Content", "afs.bos.content", FT_STRING, BASE_HEX,
2389                         0, 0, "Content" }},
2390                 { &hf_afs_bos_instance, {
2391                         "Instance", "afs.bos.instance", FT_STRING, BASE_HEX,
2392                         0, 0, "Instance" }},
2393                 { &hf_afs_bos_status, {
2394                         "Status", "afs.bos.status", FT_INT32, BASE_DEC,
2395                         0, 0, "Status" }},
2396                 { &hf_afs_bos_num, {
2397                         "Number", "afs.bos.number", FT_UINT32, BASE_DEC,
2398                         0, 0, "Number" }},
2399                 { &hf_afs_bos_size, {
2400                         "Size", "afs.bos.size", FT_UINT32, BASE_DEC,
2401                         0, 0, "Size" }},
2402                 { &hf_afs_bos_flags, {
2403                         "Flags", "afs.bos.flags", FT_UINT32, BASE_DEC,
2404                         0, 0, "Flags" }},
2405                 { &hf_afs_bos_date, {
2406                         "Date", "afs.bos.date", FT_UINT32, BASE_DEC,
2407                         0, 0, "Date" }},
2408
2409                 /* KAUTH Server Fields */
2410                 { &hf_afs_kauth_errcode, {
2411                         "Error Code", "afs.kauth.errcode", FT_UINT32, BASE_DEC,
2412                         VALS(afs_errors), 0, "Error Code" }},
2413                 { &hf_afs_kauth_princ, {
2414                         "Principal", "afs.kauth.princ", FT_STRING, BASE_HEX,
2415                         0, 0, "Principal" }},
2416                 { &hf_afs_kauth_realm, {
2417                         "Realm", "afs.kauth.realm", FT_STRING, BASE_HEX,
2418                         0, 0, "Realm" }},
2419                 { &hf_afs_kauth_domain, {
2420                         "Domain", "afs.kauth.domain", FT_STRING, BASE_HEX,
2421                         0, 0, "Domain" }},
2422                 { &hf_afs_kauth_name, {
2423                         "Name", "afs.kauth.name", FT_STRING, BASE_HEX,
2424                         0, 0, "Name" }},
2425                 { &hf_afs_kauth_data, {
2426                         "Data", "afs.kauth.data", FT_BYTES, BASE_HEX,
2427                         0, 0, "Data" }},
2428                 { &hf_afs_kauth_kvno, {
2429                         "Key Version Number", "afs.kauth.kvno", FT_UINT32, BASE_DEC,
2430                         0, 0, "Key Version Number" }},
2431
2432                 /* VOL Server Fields */
2433                 { &hf_afs_vol_errcode, {
2434                         "Error Code", "afs.vol.errcode", FT_UINT32, BASE_DEC,
2435                         VALS(afs_errors), 0, "Error Code" }},
2436                 { &hf_afs_vol_id, {
2437                         "Volume ID", "afs.vol.id", FT_UINT32, BASE_DEC,
2438                         0, 0, "Volume ID" }},
2439                 { &hf_afs_vol_count, {
2440                         "Volume Count", "afs.vol.count", FT_UINT32, BASE_DEC,
2441                         0, 0, "Volume Count" }},
2442                 { &hf_afs_vol_name, {
2443                         "Volume Name", "afs.vol.name", FT_STRING, BASE_HEX,
2444                         0, 0, "Volume Name" }},
2445
2446                 /* VLDB Server Fields */
2447                 { &hf_afs_vldb_errcode, {
2448                         "Error Code", "afs.vldb.errcode", FT_UINT32, BASE_DEC,
2449                         VALS(afs_errors), 0, "Error Code" }},
2450                 { &hf_afs_vldb_type, {
2451                         "Volume Type", "afs.vldb.type", FT_UINT32, BASE_DEC,
2452                         VALS(volume_types), 0, "Volume Type" }},
2453                 { &hf_afs_vldb_id, {
2454                         "Volume ID", "afs.vldb.id", FT_UINT32, BASE_DEC,
2455                         0, 0, "Volume ID" }},
2456                 { &hf_afs_vldb_bump, {
2457                         "Bumped Volume ID", "afs.vldb.bump", FT_UINT32, BASE_DEC,
2458                         0, 0, "Bumped Volume ID" }},
2459                 { &hf_afs_vldb_index, {
2460                         "Volume Index", "afs.vldb.index", FT_UINT32, BASE_DEC,
2461                         0, 0, "Volume Index" }},
2462                 { &hf_afs_vldb_count, {
2463                         "Volume Count", "afs.vldb.count", FT_UINT32, BASE_DEC,
2464                         0, 0, "Volume Count" }},
2465                 { &hf_afs_vldb_numservers, {
2466                         "Number of Servers", "afs.vldb.numservers", FT_UINT32, BASE_DEC,
2467                         0, 0, "Number of Servers" }},
2468                 { &hf_afs_vldb_nextindex, {
2469                         "Next Volume Index", "afs.vldb.nextindex", FT_UINT32, BASE_DEC,
2470                         0, 0, "Next Volume Index" }},
2471                 { &hf_afs_vldb_rovol, {
2472                         "Read-Only Volume ID", "afs.vldb.rovol", FT_UINT32, BASE_DEC,
2473                         0, 0, "Read-Only Volume ID" }},
2474                 { &hf_afs_vldb_rwvol, {
2475                         "Read-Write Volume ID", "afs.vldb.rwvol", FT_UINT32, BASE_DEC,
2476                         0, 0, "Read-Only Volume ID" }},
2477                 { &hf_afs_vldb_bkvol, {
2478                         "Backup Volume ID", "afs.vldb.bkvol", FT_UINT32, BASE_DEC,
2479                         0, 0, "Read-Only Volume ID" }},
2480                 { &hf_afs_vldb_name, {
2481                         "Volume Name", "afs.vldb.name", FT_STRING, BASE_HEX,
2482                         0, 0, "Volume Name" }},
2483                 { &hf_afs_vldb_partition, {
2484                         "Partition", "afs.vldb.partition", FT_STRING, BASE_HEX,
2485                         0, 0, "Partition" }},
2486                 { &hf_afs_vldb_server, {
2487                         "Server", "afs.vldb.server", FT_IPv4, BASE_HEX,
2488                         0, 0, "Server" }},
2489                 { &hf_afs_vldb_serveruuid, {
2490                         "Server UUID", "afs.vldb.serveruuid", FT_BYTES, BASE_HEX,
2491                         0, 0, "Server UUID" }},
2492
2493                 /* BACKUP Server Fields */
2494                 { &hf_afs_backup_errcode, {
2495                         "Error Code", "afs.backup.errcode", FT_UINT32, BASE_DEC,
2496                         VALS(afs_errors), 0, "Error Code" }},
2497
2498                 /* CB Server Fields */
2499                 { &hf_afs_cb_errcode, {
2500                         "Error Code", "afs.cb.errcode", FT_UINT32, BASE_DEC,
2501                         VALS(afs_errors), 0, "Error Code" }},
2502                 { &hf_afs_cb_callback_version, {
2503                         "Version", "afs.cb.callback.version", FT_UINT32, BASE_DEC,
2504                         0, 0, "Version" }},
2505                 { &hf_afs_cb_callback_expires, {
2506                         "Expires", "afs.cb.callback.expires", FT_ABSOLUTE_TIME, BASE_DEC,
2507                         0, 0, "Expires" }},
2508                 { &hf_afs_cb_callback_type, {
2509                         "Type", "afs.cb.callback.type", FT_UINT32, BASE_DEC,
2510                         VALS(cb_types), 0, "Type" }},
2511                 { &hf_afs_cb_fid_volume, {
2512                         "FileID (Volume)", "afs.cb.fid.volume", FT_UINT32, BASE_DEC,
2513                         0, 0, "File ID (Volume)" }},
2514                 { &hf_afs_cb_fid_vnode, {
2515                         "FileID (VNode)", "afs.cb.fid.vnode", FT_UINT32, BASE_DEC,
2516                         0, 0, "File ID (VNode)" }},
2517                 { &hf_afs_cb_fid_uniqifier, {
2518                         "FileID (Uniqifier)", "afs.cb.fid.uniq", FT_UINT32, BASE_DEC,
2519                         0, 0, "File ID (Uniqifier)" }},
2520
2521                 /* PROT Server Fields */
2522                 { &hf_afs_prot_errcode, {
2523                         "Error Code", "afs.prot.errcode", FT_UINT32, BASE_DEC,
2524                         VALS(afs_errors), 0, "Error Code" }},
2525                 { &hf_afs_prot_name, {
2526                         "Name", "afs.prot.name", FT_STRING, BASE_HEX,
2527                         0, 0, "Name" }},
2528                 { &hf_afs_prot_id, {
2529                         "ID", "afs.prot.id", FT_UINT32, BASE_DEC,
2530                         0, 0, "ID" }},
2531                 { &hf_afs_prot_oldid, {
2532                         "Old ID", "afs.prot.oldid", FT_UINT32, BASE_DEC,
2533                         0, 0, "Old ID" }},
2534                 { &hf_afs_prot_newid, {
2535                         "New ID", "afs.prot.newid", FT_UINT32, BASE_DEC,
2536                         0, 0, "New ID" }},
2537                 { &hf_afs_prot_gid, {
2538                         "Group ID", "afs.prot.gid", FT_UINT32, BASE_DEC,
2539                         0, 0, "Group ID" }},
2540                 { &hf_afs_prot_uid, {
2541                         "User ID", "afs.prot.uid", FT_UINT32, BASE_DEC,
2542                         0, 0, "User ID" }},
2543                 { &hf_afs_prot_count, {
2544                         "Count", "afs.prot.count", FT_UINT32, BASE_DEC,
2545                         0, 0, "Count" }},
2546                 { &hf_afs_prot_maxgid, {
2547                         "Maximum Group ID", "afs.prot.maxgid", FT_UINT32, BASE_DEC,
2548                         0, 0, "Maximum Group ID" }},
2549                 { &hf_afs_prot_maxuid, {
2550                         "Maximum User ID", "afs.prot.maxuid", FT_UINT32, BASE_DEC,
2551                         0, 0, "Maximum User ID" }},
2552                 { &hf_afs_prot_pos, {
2553                         "Position", "afs.prot.pos", FT_UINT32, BASE_DEC,
2554                         0, 0, "Position" }},
2555                 { &hf_afs_prot_flag, {
2556                         "Flag", "afs.prot.flag", FT_UINT32, BASE_HEX,
2557                         0, 0, "Flag" }},
2558
2559                 /* UBIK Fields */
2560                 { &hf_afs_ubik_errcode, {
2561                         "Error Code", "afs.ubik.errcode", FT_UINT32, BASE_DEC,
2562                         VALS(afs_errors), 0, "Error Code" }},
2563                 { &hf_afs_ubik_version_epoch, {
2564                         "Epoch", "afs.ubik.version.epoch", FT_ABSOLUTE_TIME, BASE_DEC,
2565                         0, 0, "Epoch" }},
2566                 { &hf_afs_ubik_votestart, {
2567                         "Vote Started", "afs.ubik.votestart", FT_ABSOLUTE_TIME, BASE_DEC,
2568                         0, 0, "Vote Started" }},
2569                 { &hf_afs_ubik_voteend, {
2570                         "Vote Ends", "afs.ubik.voteend", FT_ABSOLUTE_TIME, BASE_DEC,
2571                         0, 0, "Vote Ends" }},
2572                 { &hf_afs_ubik_version_counter, {
2573                         "Counter", "afs.ubik.version.counter", FT_UINT32, BASE_DEC,
2574                         0, 0, "Counter" }},
2575                 { &hf_afs_ubik_file, {
2576                         "File", "afs.ubik.file", FT_UINT32, BASE_DEC,
2577                         0, 0, "File" }},
2578                 { &hf_afs_ubik_pos, {
2579                         "Position", "afs.ubik.position", FT_UINT32, BASE_DEC,
2580                         0, 0, "Position" }},
2581                 { &hf_afs_ubik_length, {
2582                         "Length", "afs.ubik.length", FT_UINT32, BASE_DEC,
2583                         0, 0, "Length" }},
2584                 { &hf_afs_ubik_locktype, {
2585                         "Lock Type", "afs.ubik.locktype", FT_UINT32, BASE_DEC,
2586                         VALS(ubik_lock_types), 0, "Lock Type" }},
2587                 { &hf_afs_ubik_votetype, {
2588                         "Vote Type", "afs.ubik.votetype", FT_BOOLEAN, BASE_HEX,
2589                         0, 0, "Vote Type" }},
2590                 { &hf_afs_ubik_syncsite, {
2591                         "Syncsite", "afs.ubik.syncsite", FT_BOOLEAN, BASE_HEX,
2592                         0, 0, "Syncsite" }},
2593                 { &hf_afs_ubik_site, {
2594                         "Site", "afs.ubik.site", FT_IPv4, BASE_HEX,
2595                         0, 0, "Site" }},
2596
2597         };
2598         static gint *ett[] = {
2599                 &ett_afs,
2600                 &ett_afs_op,
2601                 &ett_afs_acl,
2602                 &ett_afs_fid,
2603                 &ett_afs_callback,
2604                 &ett_afs_ubikver,
2605         };
2606
2607         proto_afs = proto_register_protocol("Andrew File System (AFS)", "afs");
2608         proto_register_field_array(proto_afs, hf, array_length(hf));
2609         proto_register_subtree_array(ett, array_length(ett));
2610         register_init_routine(&afs_init_protocol);
2611 }