Remove old versions of tcpdump.
[dragonfly.git] / contrib / tcpdump-3.9 / print-rx.c
1 /*
2  * Copyright: (c) 2000 United States Government as represented by the
3  *      Secretary of the Navy. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  *   1. Redistributions of source code must retain the above copyright
10  *      notice, this list of conditions and the following disclaimer.
11  *   2. Redistributions in binary form must reproduce the above copyright
12  *      notice, this list of conditions and the following disclaimer in
13  *      the documentation and/or other materials provided with the
14  *      distribution.
15  *   3. The names of the authors may not be used to endorse or promote
16  *      products derived from this software without specific prior
17  *      written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
20  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22  */
23 /*
24  * This code unmangles RX packets.  RX is the mutant form of RPC that AFS
25  * uses to communicate between clients and servers.
26  *
27  * In this code, I mainly concern myself with decoding the AFS calls, not
28  * with the guts of RX, per se.
29  *
30  * Bah.  If I never look at rx_packet.h again, it will be too soon.
31  *
32  * Ken Hornstein <kenh@cmf.nrl.navy.mil>
33  */
34
35 #ifndef lint
36 static const char rcsid[] _U_ =
37     "@(#) $Header: /tcpdump/master/tcpdump/print-rx.c,v 1.37.2.2 2007/06/15 19:43:15 guy Exp $";
38 #endif
39
40 #ifdef HAVE_CONFIG_H
41 #include "config.h"
42 #endif
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <tcpdump-stdinc.h>
48
49 #include "interface.h"
50 #include "addrtoname.h"
51 #include "extract.h"
52
53 #include "rx.h"
54
55 #include "ip.h"
56
57 static struct tok rx_types[] = {
58         { RX_PACKET_TYPE_DATA,          "data" },
59         { RX_PACKET_TYPE_ACK,           "ack" },
60         { RX_PACKET_TYPE_BUSY,          "busy" },
61         { RX_PACKET_TYPE_ABORT,         "abort" },
62         { RX_PACKET_TYPE_ACKALL,        "ackall" },
63         { RX_PACKET_TYPE_CHALLENGE,     "challenge" },
64         { RX_PACKET_TYPE_RESPONSE,      "response" },
65         { RX_PACKET_TYPE_DEBUG,         "debug" },
66         { RX_PACKET_TYPE_PARAMS,        "params" },
67         { RX_PACKET_TYPE_VERSION,       "version" },
68         { 0,                            NULL },
69 };
70
71 static struct double_tok {
72         int flag;               /* Rx flag */
73         int packetType;         /* Packet type */
74         const char *s;          /* Flag string */
75 } rx_flags[] = {
76         { RX_CLIENT_INITIATED,  0,                      "client-init" },
77         { RX_REQUEST_ACK,       0,                      "req-ack" },
78         { RX_LAST_PACKET,       0,                      "last-pckt" },
79         { RX_MORE_PACKETS,      0,                      "more-pckts" },
80         { RX_FREE_PACKET,       0,                      "free-pckt" },
81         { RX_SLOW_START_OK,     RX_PACKET_TYPE_ACK,     "slow-start" },
82         { RX_JUMBO_PACKET,      RX_PACKET_TYPE_DATA,    "jumbogram" }
83 };
84
85 static struct tok fs_req[] = {
86         { 130,          "fetch-data" },
87         { 131,          "fetch-acl" },
88         { 132,          "fetch-status" },
89         { 133,          "store-data" },
90         { 134,          "store-acl" },
91         { 135,          "store-status" },
92         { 136,          "remove-file" },
93         { 137,          "create-file" },
94         { 138,          "rename" },
95         { 139,          "symlink" },
96         { 140,          "link" },
97         { 141,          "makedir" },
98         { 142,          "rmdir" },
99         { 143,          "oldsetlock" },
100         { 144,          "oldextlock" },
101         { 145,          "oldrellock" },
102         { 146,          "get-stats" },
103         { 147,          "give-cbs" },
104         { 148,          "get-vlinfo" },
105         { 149,          "get-vlstats" },
106         { 150,          "set-vlstats" },
107         { 151,          "get-rootvl" },
108         { 152,          "check-token" },
109         { 153,          "get-time" },
110         { 154,          "nget-vlinfo" },
111         { 155,          "bulk-stat" },
112         { 156,          "setlock" },
113         { 157,          "extlock" },
114         { 158,          "rellock" },
115         { 159,          "xstat-ver" },
116         { 160,          "get-xstat" },
117         { 161,          "dfs-lookup" },
118         { 162,          "dfs-flushcps" },
119         { 163,          "dfs-symlink" },
120         { 220,          "residency" },
121         { 0,            NULL },
122 };
123
124 static struct tok cb_req[] = {
125         { 204,          "callback" },
126         { 205,          "initcb" },
127         { 206,          "probe" },
128         { 207,          "getlock" },
129         { 208,          "getce" },
130         { 209,          "xstatver" },
131         { 210,          "getxstat" },
132         { 211,          "initcb2" },
133         { 212,          "whoareyou" },
134         { 213,          "initcb3" },
135         { 214,          "probeuuid" },
136         { 215,          "getsrvprefs" },
137         { 216,          "getcellservdb" },
138         { 217,          "getlocalcell" },
139         { 218,          "getcacheconf" },
140         { 0,            NULL },
141 };
142
143 static struct tok pt_req[] = {
144         { 500,          "new-user" },
145         { 501,          "where-is-it" },
146         { 502,          "dump-entry" },
147         { 503,          "add-to-group" },
148         { 504,          "name-to-id" },
149         { 505,          "id-to-name" },
150         { 506,          "delete" },
151         { 507,          "remove-from-group" },
152         { 508,          "get-cps" },
153         { 509,          "new-entry" },
154         { 510,          "list-max" },
155         { 511,          "set-max" },
156         { 512,          "list-entry" },
157         { 513,          "change-entry" },
158         { 514,          "list-elements" },
159         { 515,          "same-mbr-of" },
160         { 516,          "set-fld-sentry" },
161         { 517,          "list-owned" },
162         { 518,          "get-cps2" },
163         { 519,          "get-host-cps" },
164         { 520,          "update-entry" },
165         { 521,          "list-entries" },
166         { 0,            NULL },
167 };
168
169 static struct tok vldb_req[] = {
170         { 501,          "create-entry" },
171         { 502,          "delete-entry" },
172         { 503,          "get-entry-by-id" },
173         { 504,          "get-entry-by-name" },
174         { 505,          "get-new-volume-id" },
175         { 506,          "replace-entry" },
176         { 507,          "update-entry" },
177         { 508,          "setlock" },
178         { 509,          "releaselock" },
179         { 510,          "list-entry" },
180         { 511,          "list-attrib" },
181         { 512,          "linked-list" },
182         { 513,          "get-stats" },
183         { 514,          "probe" },
184         { 515,          "get-addrs" },
185         { 516,          "change-addr" },
186         { 517,          "create-entry-n" },
187         { 518,          "get-entry-by-id-n" },
188         { 519,          "get-entry-by-name-n" },
189         { 520,          "replace-entry-n" },
190         { 521,          "list-entry-n" },
191         { 522,          "list-attrib-n" },
192         { 523,          "linked-list-n" },
193         { 524,          "update-entry-by-name" },
194         { 525,          "create-entry-u" },
195         { 526,          "get-entry-by-id-u" },
196         { 527,          "get-entry-by-name-u" },
197         { 528,          "replace-entry-u" },
198         { 529,          "list-entry-u" },
199         { 530,          "list-attrib-u" },
200         { 531,          "linked-list-u" },
201         { 532,          "regaddr" },
202         { 533,          "get-addrs-u" },
203         { 534,          "list-attrib-n2" },
204         { 0,            NULL },
205 };
206
207 static struct tok kauth_req[] = {
208         { 1,            "auth-old" },
209         { 21,           "authenticate" },
210         { 22,           "authenticate-v2" },
211         { 2,            "change-pw" },
212         { 3,            "get-ticket-old" },
213         { 23,           "get-ticket" },
214         { 4,            "set-pw" },
215         { 5,            "set-fields" },
216         { 6,            "create-user" },
217         { 7,            "delete-user" },
218         { 8,            "get-entry" },
219         { 9,            "list-entry" },
220         { 10,           "get-stats" },
221         { 11,           "debug" },
222         { 12,           "get-pw" },
223         { 13,           "get-random-key" },
224         { 14,           "unlock" },
225         { 15,           "lock-status" },
226         { 0,            NULL },
227 };
228
229 static struct tok vol_req[] = {
230         { 100,          "create-volume" },
231         { 101,          "delete-volume" },
232         { 102,          "restore" },
233         { 103,          "forward" },
234         { 104,          "end-trans" },
235         { 105,          "clone" },
236         { 106,          "set-flags" },
237         { 107,          "get-flags" },
238         { 108,          "trans-create" },
239         { 109,          "dump" },
240         { 110,          "get-nth-volume" },
241         { 111,          "set-forwarding" },
242         { 112,          "get-name" },
243         { 113,          "get-status" },
244         { 114,          "sig-restore" },
245         { 115,          "list-partitions" },
246         { 116,          "list-volumes" },
247         { 117,          "set-id-types" },
248         { 118,          "monitor" },
249         { 119,          "partition-info" },
250         { 120,          "reclone" },
251         { 121,          "list-one-volume" },
252         { 122,          "nuke" },
253         { 123,          "set-date" },
254         { 124,          "x-list-volumes" },
255         { 125,          "x-list-one-volume" },
256         { 126,          "set-info" },
257         { 127,          "x-list-partitions" },
258         { 128,          "forward-multiple" },
259         { 0,            NULL },
260 };
261
262 static struct tok bos_req[] = {
263         { 80,           "create-bnode" },
264         { 81,           "delete-bnode" },
265         { 82,           "set-status" },
266         { 83,           "get-status" },
267         { 84,           "enumerate-instance" },
268         { 85,           "get-instance-info" },
269         { 86,           "get-instance-parm" },
270         { 87,           "add-superuser" },
271         { 88,           "delete-superuser" },
272         { 89,           "list-superusers" },
273         { 90,           "list-keys" },
274         { 91,           "add-key" },
275         { 92,           "delete-key" },
276         { 93,           "set-cell-name" },
277         { 94,           "get-cell-name" },
278         { 95,           "get-cell-host" },
279         { 96,           "add-cell-host" },
280         { 97,           "delete-cell-host" },
281         { 98,           "set-t-status" },
282         { 99,           "shutdown-all" },
283         { 100,          "restart-all" },
284         { 101,          "startup-all" },
285         { 102,          "set-noauth-flag" },
286         { 103,          "re-bozo" },
287         { 104,          "restart" },
288         { 105,          "start-bozo-install" },
289         { 106,          "uninstall" },
290         { 107,          "get-dates" },
291         { 108,          "exec" },
292         { 109,          "prune" },
293         { 110,          "set-restart-time" },
294         { 111,          "get-restart-time" },
295         { 112,          "start-bozo-log" },
296         { 113,          "wait-all" },
297         { 114,          "get-instance-strings" },
298         { 115,          "get-restricted" },
299         { 116,          "set-restricted" },
300         { 0,            NULL },
301 };
302
303 static struct tok ubik_req[] = {
304         { 10000,        "vote-beacon" },
305         { 10001,        "vote-debug-old" },
306         { 10002,        "vote-sdebug-old" },
307         { 10003,        "vote-getsyncsite" },
308         { 10004,        "vote-debug" },
309         { 10005,        "vote-sdebug" },
310         { 20000,        "disk-begin" },
311         { 20001,        "disk-commit" },
312         { 20002,        "disk-lock" },
313         { 20003,        "disk-write" },
314         { 20004,        "disk-getversion" },
315         { 20005,        "disk-getfile" },
316         { 20006,        "disk-sendfile" },
317         { 20007,        "disk-abort" },
318         { 20008,        "disk-releaselocks" },
319         { 20009,        "disk-truncate" },
320         { 20010,        "disk-probe" },
321         { 20011,        "disk-writev" },
322         { 20012,        "disk-interfaceaddr" },
323         { 20013,        "disk-setversion" },
324         { 0,            NULL },
325 };
326
327 #define VOTE_LOW        10000
328 #define VOTE_HIGH       10005
329 #define DISK_LOW        20000
330 #define DISK_HIGH       20013
331
332 static struct tok cb_types[] = {
333         { 1,            "exclusive" },
334         { 2,            "shared" },
335         { 3,            "dropped" },
336         { 0,            NULL },
337 };
338
339 static struct tok ubik_lock_types[] = {
340         { 1,            "read" },
341         { 2,            "write" },
342         { 3,            "wait" },
343         { 0,            NULL },
344 };
345
346 static const char *voltype[] = { "read-write", "read-only", "backup" };
347
348 static struct tok afs_fs_errors[] = {
349         { 101,          "salvage volume" },
350         { 102,          "no such vnode" },
351         { 103,          "no such volume" },
352         { 104,          "volume exist" },
353         { 105,          "no service" },
354         { 106,          "volume offline" },
355         { 107,          "voline online" },
356         { 108,          "diskfull" },
357         { 109,          "diskquota exceeded" },
358         { 110,          "volume busy" },
359         { 111,          "volume moved" },
360         { 112,          "AFS IO error" },
361         { -100,         "restarting fileserver" },
362         { 0,            NULL }
363 };
364
365 /*
366  * Reasons for acknowledging a packet
367  */
368
369 static struct tok rx_ack_reasons[] = {
370         { 1,            "ack requested" },
371         { 2,            "duplicate packet" },
372         { 3,            "out of sequence" },
373         { 4,            "exceeds window" },
374         { 5,            "no buffer space" },
375         { 6,            "ping" },
376         { 7,            "ping response" },
377         { 8,            "delay" },
378         { 9,            "idle" },
379         { 0,            NULL },
380 };
381
382 /*
383  * Cache entries we keep around so we can figure out the RX opcode
384  * numbers for replies.  This allows us to make sense of RX reply packets.
385  */
386
387 struct rx_cache_entry {
388         u_int32_t       callnum;        /* Call number (net order) */
389         struct in_addr  client;         /* client IP address (net order) */
390         struct in_addr  server;         /* server IP address (net order) */
391         int             dport;          /* server port (host order) */
392         u_short         serviceId;      /* Service identifier (net order) */
393         u_int32_t       opcode;         /* RX opcode (host order) */
394 };
395
396 #define RX_CACHE_SIZE   64
397
398 static struct rx_cache_entry    rx_cache[RX_CACHE_SIZE];
399
400 static int      rx_cache_next = 0;
401 static int      rx_cache_hint = 0;
402 static void     rx_cache_insert(const u_char *, const struct ip *, int);
403 static int      rx_cache_find(const struct rx_header *, const struct ip *,
404                               int, int32_t *);
405
406 static void fs_print(const u_char *, int);
407 static void fs_reply_print(const u_char *, int, int32_t);
408 static void acl_print(u_char *, int, u_char *);
409 static void cb_print(const u_char *, int);
410 static void cb_reply_print(const u_char *, int, int32_t);
411 static void prot_print(const u_char *, int);
412 static void prot_reply_print(const u_char *, int, int32_t);
413 static void vldb_print(const u_char *, int);
414 static void vldb_reply_print(const u_char *, int, int32_t);
415 static void kauth_print(const u_char *, int);
416 static void kauth_reply_print(const u_char *, int, int32_t);
417 static void vol_print(const u_char *, int);
418 static void vol_reply_print(const u_char *, int, int32_t);
419 static void bos_print(const u_char *, int);
420 static void bos_reply_print(const u_char *, int, int32_t);
421 static void ubik_print(const u_char *);
422 static void ubik_reply_print(const u_char *, int, int32_t);
423
424 static void rx_ack_print(const u_char *, int);
425
426 static int is_ubik(u_int32_t);
427
428 /*
429  * Handle the rx-level packet.  See if we know what port it's going to so
430  * we can peek at the afs call inside
431  */
432
433 void
434 rx_print(register const u_char *bp, int length, int sport, int dport,
435          u_char *bp2)
436 {
437         register struct rx_header *rxh;
438         int i;
439         int32_t opcode;
440
441         if (snapend - bp < (int)sizeof (struct rx_header)) {
442                 printf(" [|rx] (%d)", length);
443                 return;
444         }
445
446         rxh = (struct rx_header *) bp;
447
448         printf(" rx %s", tok2str(rx_types, "type %d", rxh->type));
449
450         if (vflag) {
451                 int firstflag = 0;
452
453                 if (vflag > 1)
454                         printf(" cid %08x call# %d",
455                                (int) EXTRACT_32BITS(&rxh->cid),
456                                (int) EXTRACT_32BITS(&rxh->callNumber));
457
458                 printf(" seq %d ser %d",
459                        (int) EXTRACT_32BITS(&rxh->seq),
460                        (int) EXTRACT_32BITS(&rxh->serial));
461
462                 if (vflag > 2)
463                         printf(" secindex %d serviceid %hu",
464                                 (int) rxh->securityIndex,
465                                 EXTRACT_16BITS(&rxh->serviceId));
466
467                 if (vflag > 1)
468                         for (i = 0; i < NUM_RX_FLAGS; i++) {
469                                 if (rxh->flags & rx_flags[i].flag &&
470                                     (!rx_flags[i].packetType ||
471                                      rxh->type == rx_flags[i].packetType)) {
472                                         if (!firstflag) {
473                                                 firstflag = 1;
474                                                 printf(" ");
475                                         } else {
476                                                 printf(",");
477                                         }
478                                         printf("<%s>", rx_flags[i].s);
479                                 }
480                         }
481         }
482
483         /*
484          * Try to handle AFS calls that we know about.  Check the destination
485          * port and make sure it's a data packet.  Also, make sure the
486          * seq number is 1 (because otherwise it's a continuation packet,
487          * and we can't interpret that).  Also, seems that reply packets
488          * do not have the client-init flag set, so we check for that
489          * as well.
490          */
491
492         if (rxh->type == RX_PACKET_TYPE_DATA &&
493             EXTRACT_32BITS(&rxh->seq) == 1 &&
494             rxh->flags & RX_CLIENT_INITIATED) {
495
496                 /*
497                  * Insert this call into the call cache table, so we
498                  * have a chance to print out replies
499                  */
500
501                 rx_cache_insert(bp, (const struct ip *) bp2, dport);
502
503                 switch (dport) {
504                         case FS_RX_PORT:        /* AFS file service */
505                                 fs_print(bp, length);
506                                 break;
507                         case CB_RX_PORT:        /* AFS callback service */
508                                 cb_print(bp, length);
509                                 break;
510                         case PROT_RX_PORT:      /* AFS protection service */
511                                 prot_print(bp, length);
512                                 break;
513                         case VLDB_RX_PORT:      /* AFS VLDB service */
514                                 vldb_print(bp, length);
515                                 break;
516                         case KAUTH_RX_PORT:     /* AFS Kerberos auth service */
517                                 kauth_print(bp, length);
518                                 break;
519                         case VOL_RX_PORT:       /* AFS Volume service */
520                                 vol_print(bp, length);
521                                 break;
522                         case BOS_RX_PORT:       /* AFS BOS service */
523                                 bos_print(bp, length);
524                                 break;
525                         default:
526                                 ;
527                 }
528
529         /*
530          * If it's a reply (client-init is _not_ set, but seq is one)
531          * then look it up in the cache.  If we find it, call the reply
532          * printing functions  Note that we handle abort packets here,
533          * because printing out the return code can be useful at times.
534          */
535
536         } else if (((rxh->type == RX_PACKET_TYPE_DATA &&
537                                         EXTRACT_32BITS(&rxh->seq) == 1) ||
538                     rxh->type == RX_PACKET_TYPE_ABORT) &&
539                    (rxh->flags & RX_CLIENT_INITIATED) == 0 &&
540                    rx_cache_find(rxh, (const struct ip *) bp2,
541                                  sport, &opcode)) {
542
543                 switch (sport) {
544                         case FS_RX_PORT:        /* AFS file service */
545                                 fs_reply_print(bp, length, opcode);
546                                 break;
547                         case CB_RX_PORT:        /* AFS callback service */
548                                 cb_reply_print(bp, length, opcode);
549                                 break;
550                         case PROT_RX_PORT:      /* AFS PT service */
551                                 prot_reply_print(bp, length, opcode);
552                                 break;
553                         case VLDB_RX_PORT:      /* AFS VLDB service */
554                                 vldb_reply_print(bp, length, opcode);
555                                 break;
556                         case KAUTH_RX_PORT:     /* AFS Kerberos auth service */
557                                 kauth_reply_print(bp, length, opcode);
558                                 break;
559                         case VOL_RX_PORT:       /* AFS Volume service */
560                                 vol_reply_print(bp, length, opcode);
561                                 break;
562                         case BOS_RX_PORT:       /* AFS BOS service */
563                                 bos_reply_print(bp, length, opcode);
564                                 break;
565                         default:
566                                 ;
567                 }
568
569         /*
570          * If it's an RX ack packet, then use the appropriate ack decoding
571          * function (there isn't any service-specific information in the
572          * ack packet, so we can use one for all AFS services)
573          */
574
575         } else if (rxh->type == RX_PACKET_TYPE_ACK)
576                 rx_ack_print(bp, length);
577
578
579         printf(" (%d)", length);
580 }
581
582 /*
583  * Insert an entry into the cache.  Taken from print-nfs.c
584  */
585
586 static void
587 rx_cache_insert(const u_char *bp, const struct ip *ip, int dport)
588 {
589         struct rx_cache_entry *rxent;
590         const struct rx_header *rxh = (const struct rx_header *) bp;
591
592         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
593                 return;
594
595         rxent = &rx_cache[rx_cache_next];
596
597         if (++rx_cache_next >= RX_CACHE_SIZE)
598                 rx_cache_next = 0;
599
600         rxent->callnum = rxh->callNumber;
601         rxent->client = ip->ip_src;
602         rxent->server = ip->ip_dst;
603         rxent->dport = dport;
604         rxent->serviceId = rxh->serviceId;
605         rxent->opcode = EXTRACT_32BITS(bp + sizeof(struct rx_header));
606 }
607
608 /*
609  * Lookup an entry in the cache.  Also taken from print-nfs.c
610  *
611  * Note that because this is a reply, we're looking at the _source_
612  * port.
613  */
614
615 static int
616 rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
617               int32_t *opcode)
618 {
619         int i;
620         struct rx_cache_entry *rxent;
621         u_int32_t clip = ip->ip_dst.s_addr;
622         u_int32_t sip = ip->ip_src.s_addr;
623
624         /* Start the search where we last left off */
625
626         i = rx_cache_hint;
627         do {
628                 rxent = &rx_cache[i];
629                 if (rxent->callnum == rxh->callNumber &&
630                     rxent->client.s_addr == clip &&
631                     rxent->server.s_addr == sip &&
632                     rxent->serviceId == rxh->serviceId &&
633                     rxent->dport == sport) {
634
635                         /* We got a match! */
636
637                         rx_cache_hint = i;
638                         *opcode = rxent->opcode;
639                         return(1);
640                 }
641                 if (++i > RX_CACHE_SIZE)
642                         i = 0;
643         } while (i != rx_cache_hint);
644
645         /* Our search failed */
646         return(0);
647 }
648
649 /*
650  * These extrememly grody macros handle the printing of various AFS stuff.
651  */
652
653 #define FIDOUT() { unsigned long n1, n2, n3; \
654                         TCHECK2(bp[0], sizeof(int32_t) * 3); \
655                         n1 = EXTRACT_32BITS(bp); \
656                         bp += sizeof(int32_t); \
657                         n2 = EXTRACT_32BITS(bp); \
658                         bp += sizeof(int32_t); \
659                         n3 = EXTRACT_32BITS(bp); \
660                         bp += sizeof(int32_t); \
661                         printf(" fid %d/%d/%d", (int) n1, (int) n2, (int) n3); \
662                 }
663
664 #define STROUT(MAX) { unsigned int i; \
665                         TCHECK2(bp[0], sizeof(int32_t)); \
666                         i = EXTRACT_32BITS(bp); \
667                         if (i > (MAX)) \
668                                 goto trunc; \
669                         bp += sizeof(int32_t); \
670                         printf(" \""); \
671                         if (fn_printn(bp, i, snapend)) \
672                                 goto trunc; \
673                         printf("\""); \
674                         bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
675                 }
676
677 #define INTOUT() { int i; \
678                         TCHECK2(bp[0], sizeof(int32_t)); \
679                         i = (int) EXTRACT_32BITS(bp); \
680                         bp += sizeof(int32_t); \
681                         printf(" %d", i); \
682                 }
683
684 #define UINTOUT() { unsigned long i; \
685                         TCHECK2(bp[0], sizeof(int32_t)); \
686                         i = EXTRACT_32BITS(bp); \
687                         bp += sizeof(int32_t); \
688                         printf(" %lu", i); \
689                 }
690
691 #define DATEOUT() { time_t t; struct tm *tm; char str[256]; \
692                         TCHECK2(bp[0], sizeof(int32_t)); \
693                         t = (time_t) EXTRACT_32BITS(bp); \
694                         bp += sizeof(int32_t); \
695                         tm = localtime(&t); \
696                         strftime(str, 256, "%Y/%m/%d %T", tm); \
697                         printf(" %s", str); \
698                 }
699
700 #define STOREATTROUT() { unsigned long mask, i; \
701                         TCHECK2(bp[0], (sizeof(int32_t)*6)); \
702                         mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
703                         if (mask) printf (" StoreStatus"); \
704                         if (mask & 1) { printf(" date"); DATEOUT(); } \
705                         else bp += sizeof(int32_t); \
706                         i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
707                         if (mask & 2) printf(" owner %lu", i);  \
708                         i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
709                         if (mask & 4) printf(" group %lu", i); \
710                         i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
711                         if (mask & 8) printf(" mode %lo", i & 07777); \
712                         i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
713                         if (mask & 16) printf(" segsize %lu", i); \
714                         /* undocumented in 3.3 docu */ \
715                         if (mask & 1024) printf(" fsync");  \
716                 }
717
718 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
719                         TCHECK2(bp[0], sizeof(int32_t) * 2); \
720                         epoch = EXTRACT_32BITS(bp); \
721                         bp += sizeof(int32_t); \
722                         counter = EXTRACT_32BITS(bp); \
723                         bp += sizeof(int32_t); \
724                         printf(" %d.%d", epoch, counter); \
725                 }
726
727 #define AFSUUIDOUT() {u_int32_t temp; int i; \
728                         TCHECK2(bp[0], 11*sizeof(u_int32_t)); \
729                         temp = EXTRACT_32BITS(bp); \
730                         bp += sizeof(u_int32_t); \
731                         printf(" %08x", temp); \
732                         temp = EXTRACT_32BITS(bp); \
733                         bp += sizeof(u_int32_t); \
734                         printf("%04x", temp); \
735                         temp = EXTRACT_32BITS(bp); \
736                         bp += sizeof(u_int32_t); \
737                         printf("%04x", temp); \
738                         for (i = 0; i < 8; i++) { \
739                                 temp = EXTRACT_32BITS(bp); \
740                                 bp += sizeof(u_int32_t); \
741                                 printf("%02x", (unsigned char) temp); \
742                         } \
743                 }
744
745 /*
746  * This is the sickest one of all
747  */
748
749 #define VECOUT(MAX) { u_char *sp; \
750                         u_char s[AFSNAMEMAX]; \
751                         int k; \
752                         if ((MAX) + 1 > sizeof(s)) \
753                                 goto trunc; \
754                         TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \
755                         sp = s; \
756                         for (k = 0; k < (MAX); k++) { \
757                                 *sp++ = (u_char) EXTRACT_32BITS(bp); \
758                                 bp += sizeof(int32_t); \
759                         } \
760                         s[(MAX)] = '\0'; \
761                         printf(" \""); \
762                         fn_print(s, NULL); \
763                         printf("\""); \
764                 }
765
766 /*
767  * Handle calls to the AFS file service (fs)
768  */
769
770 static void
771 fs_print(register const u_char *bp, int length)
772 {
773         int fs_op;
774         unsigned long i;
775
776         if (length <= (int)sizeof(struct rx_header))
777                 return;
778
779         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
780                 goto trunc;
781         }
782
783         /*
784          * Print out the afs call we're invoking.  The table used here was
785          * gleaned from fsint/afsint.xg
786          */
787
788         fs_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
789
790         printf(" fs call %s", tok2str(fs_req, "op#%d", fs_op));
791
792         /*
793          * Print out arguments to some of the AFS calls.  This stuff is
794          * all from afsint.xg
795          */
796
797         bp += sizeof(struct rx_header) + 4;
798
799         /*
800          * Sigh.  This is gross.  Ritchie forgive me.
801          */
802
803         switch (fs_op) {
804                 case 130:       /* Fetch data */
805                         FIDOUT();
806                         printf(" offset");
807                         UINTOUT();
808                         printf(" length");
809                         UINTOUT();
810                         break;
811                 case 131:       /* Fetch ACL */
812                 case 132:       /* Fetch Status */
813                 case 143:       /* Old set lock */
814                 case 144:       /* Old extend lock */
815                 case 145:       /* Old release lock */
816                 case 156:       /* Set lock */
817                 case 157:       /* Extend lock */
818                 case 158:       /* Release lock */
819                         FIDOUT();
820                         break;
821                 case 135:       /* Store status */
822                         FIDOUT();
823                         STOREATTROUT();
824                         break;
825                 case 133:       /* Store data */
826                         FIDOUT();
827                         STOREATTROUT();
828                         printf(" offset");
829                         UINTOUT();
830                         printf(" length");
831                         UINTOUT();
832                         printf(" flen");
833                         UINTOUT();
834                         break;
835                 case 134:       /* Store ACL */
836                 {
837                         char a[AFSOPAQUEMAX+1];
838                         FIDOUT();
839                         TCHECK2(bp[0], 4);
840                         i = EXTRACT_32BITS(bp);
841                         bp += sizeof(int32_t);
842                         TCHECK2(bp[0], i);
843                         i = min(AFSOPAQUEMAX, i);
844                         strncpy(a, (char *) bp, i);
845                         a[i] = '\0';
846                         acl_print((u_char *) a, sizeof(a), (u_char *) a + i);
847                         break;
848                 }
849                 case 137:       /* Create file */
850                 case 141:       /* MakeDir */
851                         FIDOUT();
852                         STROUT(AFSNAMEMAX);
853                         STOREATTROUT();
854                         break;
855                 case 136:       /* Remove file */
856                 case 142:       /* Remove directory */
857                         FIDOUT();
858                         STROUT(AFSNAMEMAX);
859                         break;
860                 case 138:       /* Rename file */
861                         printf(" old");
862                         FIDOUT();
863                         STROUT(AFSNAMEMAX);
864                         printf(" new");
865                         FIDOUT();
866                         STROUT(AFSNAMEMAX);
867                         break;
868                 case 139:       /* Symlink */
869                         FIDOUT();
870                         STROUT(AFSNAMEMAX);
871                         printf(" link to");
872                         STROUT(AFSNAMEMAX);
873                         break;
874                 case 140:       /* Link */
875                         FIDOUT();
876                         STROUT(AFSNAMEMAX);
877                         printf(" link to");
878                         FIDOUT();
879                         break;
880                 case 148:       /* Get volume info */
881                         STROUT(AFSNAMEMAX);
882                         break;
883                 case 149:       /* Get volume stats */
884                 case 150:       /* Set volume stats */
885                         printf(" volid");
886                         UINTOUT();
887                         break;
888                 case 154:       /* New get volume info */
889                         printf(" volname");
890                         STROUT(AFSNAMEMAX);
891                         break;
892                 case 155:       /* Bulk stat */
893                 {
894                         unsigned long j;
895                         TCHECK2(bp[0], 4);
896                         j = EXTRACT_32BITS(bp);
897                         bp += sizeof(int32_t);
898
899                         for (i = 0; i < j; i++) {
900                                 FIDOUT();
901                                 if (i != j - 1)
902                                         printf(",");
903                         }
904                         if (j == 0)
905                                 printf(" <none!>");
906                 }
907                 default:
908                         ;
909         }
910
911         return;
912
913 trunc:
914         printf(" [|fs]");
915 }
916
917 /*
918  * Handle replies to the AFS file service
919  */
920
921 static void
922 fs_reply_print(register const u_char *bp, int length, int32_t opcode)
923 {
924         unsigned long i;
925         struct rx_header *rxh;
926
927         if (length <= (int)sizeof(struct rx_header))
928                 return;
929
930         rxh = (struct rx_header *) bp;
931
932         /*
933          * Print out the afs call we're invoking.  The table used here was
934          * gleaned from fsint/afsint.xg
935          */
936
937         printf(" fs reply %s", tok2str(fs_req, "op#%d", opcode));
938
939         bp += sizeof(struct rx_header);
940
941         /*
942          * If it was a data packet, interpret the response
943          */
944
945         if (rxh->type == RX_PACKET_TYPE_DATA) {
946                 switch (opcode) {
947                 case 131:       /* Fetch ACL */
948                 {
949                         char a[AFSOPAQUEMAX+1];
950                         TCHECK2(bp[0], 4);
951                         i = EXTRACT_32BITS(bp);
952                         bp += sizeof(int32_t);
953                         TCHECK2(bp[0], i);
954                         i = min(AFSOPAQUEMAX, i);
955                         strncpy(a, (char *) bp, i);
956                         a[i] = '\0';
957                         acl_print((u_char *) a, sizeof(a), (u_char *) a + i);
958                         break;
959                 }
960                 case 137:       /* Create file */
961                 case 141:       /* MakeDir */
962                         printf(" new");
963                         FIDOUT();
964                         break;
965                 case 151:       /* Get root volume */
966                         printf(" root volume");
967                         STROUT(AFSNAMEMAX);
968                         break;
969                 case 153:       /* Get time */
970                         DATEOUT();
971                         break;
972                 default:
973                         ;
974                 }
975         } else if (rxh->type == RX_PACKET_TYPE_ABORT) {
976                 int i;
977
978                 /*
979                  * Otherwise, just print out the return code
980                  */
981                 TCHECK2(bp[0], sizeof(int32_t));
982                 i = (int) EXTRACT_32BITS(bp);
983                 bp += sizeof(int32_t);
984
985                 printf(" error %s", tok2str(afs_fs_errors, "#%d", i));
986         } else {
987                 printf(" strange fs reply of type %d", rxh->type);
988         }
989
990         return;
991
992 trunc:
993         printf(" [|fs]");
994 }
995
996 /*
997  * Print out an AFS ACL string.  An AFS ACL is a string that has the
998  * following format:
999  *
1000  * <positive> <negative>
1001  * <uid1> <aclbits1>
1002  * ....
1003  *
1004  * "positive" and "negative" are integers which contain the number of
1005  * positive and negative ACL's in the string.  The uid/aclbits pair are
1006  * ASCII strings containing the UID/PTS record and and a ascii number
1007  * representing a logical OR of all the ACL permission bits
1008  */
1009
1010 static void
1011 acl_print(u_char *s, int maxsize, u_char *end)
1012 {
1013         int pos, neg, acl;
1014         int n, i;
1015         char *user;
1016         char fmt[1024];
1017
1018         if ((user = (char *)malloc(maxsize)) == NULL)
1019                 return;
1020
1021         if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
1022                 goto finish;
1023
1024         s += n;
1025
1026         if (s > end)
1027                 goto finish;
1028
1029         /*
1030          * This wacky order preserves the order used by the "fs" command
1031          */
1032
1033 #define ACLOUT(acl) \
1034         if (acl & PRSFS_READ) \
1035                 printf("r"); \
1036         if (acl & PRSFS_LOOKUP) \
1037                 printf("l"); \
1038         if (acl & PRSFS_INSERT) \
1039                 printf("i"); \
1040         if (acl & PRSFS_DELETE) \
1041                 printf("d"); \
1042         if (acl & PRSFS_WRITE) \
1043                 printf("w"); \
1044         if (acl & PRSFS_LOCK) \
1045                 printf("k"); \
1046         if (acl & PRSFS_ADMINISTER) \
1047                 printf("a");
1048
1049         for (i = 0; i < pos; i++) {
1050                 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
1051                 if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
1052                         goto finish;
1053                 s += n;
1054                 printf(" +{");
1055                 fn_print((u_char *)user, NULL);
1056                 printf(" ");
1057                 ACLOUT(acl);
1058                 printf("}");
1059                 if (s > end)
1060                         goto finish;
1061         }
1062
1063         for (i = 0; i < neg; i++) {
1064                 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
1065                 if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
1066                         goto finish;
1067                 s += n;
1068                 printf(" -{");
1069                 fn_print((u_char *)user, NULL);
1070                 printf(" ");
1071                 ACLOUT(acl);
1072                 printf("}");
1073                 if (s > end)
1074                         goto finish;
1075         }
1076
1077 finish:
1078         free(user);
1079         return;
1080 }
1081
1082 #undef ACLOUT
1083
1084 /*
1085  * Handle calls to the AFS callback service
1086  */
1087
1088 static void
1089 cb_print(register const u_char *bp, int length)
1090 {
1091         int cb_op;
1092         unsigned long i;
1093
1094         if (length <= (int)sizeof(struct rx_header))
1095                 return;
1096
1097         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1098                 goto trunc;
1099         }
1100
1101         /*
1102          * Print out the afs call we're invoking.  The table used here was
1103          * gleaned from fsint/afscbint.xg
1104          */
1105
1106         cb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1107
1108         printf(" cb call %s", tok2str(cb_req, "op#%d", cb_op));
1109
1110         bp += sizeof(struct rx_header) + 4;
1111
1112         /*
1113          * Print out the afs call we're invoking.  The table used here was
1114          * gleaned from fsint/afscbint.xg
1115          */
1116
1117         switch (cb_op) {
1118                 case 204:               /* Callback */
1119                 {
1120                         unsigned long j, t;
1121                         TCHECK2(bp[0], 4);
1122                         j = EXTRACT_32BITS(bp);
1123                         bp += sizeof(int32_t);
1124
1125                         for (i = 0; i < j; i++) {
1126                                 FIDOUT();
1127                                 if (i != j - 1)
1128                                         printf(",");
1129                         }
1130
1131                         if (j == 0)
1132                                 printf(" <none!>");
1133
1134                         j = EXTRACT_32BITS(bp);
1135                         bp += sizeof(int32_t);
1136
1137                         if (j != 0)
1138                                 printf(";");
1139
1140                         for (i = 0; i < j; i++) {
1141                                 printf(" ver");
1142                                 INTOUT();
1143                                 printf(" expires");
1144                                 DATEOUT();
1145                                 TCHECK2(bp[0], 4);
1146                                 t = EXTRACT_32BITS(bp);
1147                                 bp += sizeof(int32_t);
1148                                 tok2str(cb_types, "type %d", t);
1149                         }
1150                 }
1151                 case 214: {
1152                         printf(" afsuuid");
1153                         AFSUUIDOUT();
1154                         break;
1155                 }
1156                 default:
1157                         ;
1158         }
1159
1160         return;
1161
1162 trunc:
1163         printf(" [|cb]");
1164 }
1165
1166 /*
1167  * Handle replies to the AFS Callback Service
1168  */
1169
1170 static void
1171 cb_reply_print(register const u_char *bp, int length, int32_t opcode)
1172 {
1173         struct rx_header *rxh;
1174
1175         if (length <= (int)sizeof(struct rx_header))
1176                 return;
1177
1178         rxh = (struct rx_header *) bp;
1179
1180         /*
1181          * Print out the afs call we're invoking.  The table used here was
1182          * gleaned from fsint/afscbint.xg
1183          */
1184
1185         printf(" cb reply %s", tok2str(cb_req, "op#%d", opcode));
1186
1187         bp += sizeof(struct rx_header);
1188
1189         /*
1190          * If it was a data packet, interpret the response.
1191          */
1192
1193         if (rxh->type == RX_PACKET_TYPE_DATA)
1194                 switch (opcode) {
1195                 case 213:       /* InitCallBackState3 */
1196                         AFSUUIDOUT();
1197                         break;
1198                 default:
1199                 ;
1200                 }
1201         else {
1202                 /*
1203                  * Otherwise, just print out the return code
1204                  */
1205                 printf(" errcode");
1206                 INTOUT();
1207         }
1208
1209         return;
1210
1211 trunc:
1212         printf(" [|cb]");
1213 }
1214
1215 /*
1216  * Handle calls to the AFS protection database server
1217  */
1218
1219 static void
1220 prot_print(register const u_char *bp, int length)
1221 {
1222         unsigned long i;
1223         int pt_op;
1224
1225         if (length <= (int)sizeof(struct rx_header))
1226                 return;
1227
1228         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1229                 goto trunc;
1230         }
1231
1232         /*
1233          * Print out the afs call we're invoking.  The table used here was
1234          * gleaned from ptserver/ptint.xg
1235          */
1236
1237         pt_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1238
1239         printf(" pt");
1240
1241         if (is_ubik(pt_op)) {
1242                 ubik_print(bp);
1243                 return;
1244         }
1245
1246         printf(" call %s", tok2str(pt_req, "op#%d", pt_op));
1247
1248         /*
1249          * Decode some of the arguments to the PT calls
1250          */
1251
1252         bp += sizeof(struct rx_header) + 4;
1253
1254         switch (pt_op) {
1255                 case 500:       /* I New User */
1256                         STROUT(PRNAMEMAX);
1257                         printf(" id");
1258                         INTOUT();
1259                         printf(" oldid");
1260                         INTOUT();
1261                         break;
1262                 case 501:       /* Where is it */
1263                 case 506:       /* Delete */
1264                 case 508:       /* Get CPS */
1265                 case 512:       /* List entry */
1266                 case 514:       /* List elements */
1267                 case 517:       /* List owned */
1268                 case 518:       /* Get CPS2 */
1269                 case 519:       /* Get host CPS */
1270                         printf(" id");
1271                         INTOUT();
1272                         break;
1273                 case 502:       /* Dump entry */
1274                         printf(" pos");
1275                         INTOUT();
1276                         break;
1277                 case 503:       /* Add to group */
1278                 case 507:       /* Remove from group */
1279                 case 515:       /* Is a member of? */
1280                         printf(" uid");
1281                         INTOUT();
1282                         printf(" gid");
1283                         INTOUT();
1284                         break;
1285                 case 504:       /* Name to ID */
1286                 {
1287                         unsigned long j;
1288                         TCHECK2(bp[0], 4);
1289                         j = EXTRACT_32BITS(bp);
1290                         bp += sizeof(int32_t);
1291
1292                         /*
1293                          * Who designed this chicken-shit protocol?
1294                          *
1295                          * Each character is stored as a 32-bit
1296                          * integer!
1297                          */
1298
1299                         for (i = 0; i < j; i++) {
1300                                 VECOUT(PRNAMEMAX);
1301                         }
1302                         if (j == 0)
1303                                 printf(" <none!>");
1304                 }
1305                         break;
1306                 case 505:       /* Id to name */
1307                 {
1308                         unsigned long j;
1309                         printf(" ids:");
1310                         TCHECK2(bp[0], 4);
1311                         i = EXTRACT_32BITS(bp);
1312                         bp += sizeof(int32_t);
1313                         for (j = 0; j < i; j++)
1314                                 INTOUT();
1315                         if (j == 0)
1316                                 printf(" <none!>");
1317                 }
1318                         break;
1319                 case 509:       /* New entry */
1320                         STROUT(PRNAMEMAX);
1321                         printf(" flag");
1322                         INTOUT();
1323                         printf(" oid");
1324                         INTOUT();
1325                         break;
1326                 case 511:       /* Set max */
1327                         printf(" id");
1328                         INTOUT();
1329                         printf(" gflag");
1330                         INTOUT();
1331                         break;
1332                 case 513:       /* Change entry */
1333                         printf(" id");
1334                         INTOUT();
1335                         STROUT(PRNAMEMAX);
1336                         printf(" oldid");
1337                         INTOUT();
1338                         printf(" newid");
1339                         INTOUT();
1340                         break;
1341                 case 520:       /* Update entry */
1342                         printf(" id");
1343                         INTOUT();
1344                         STROUT(PRNAMEMAX);
1345                         break;
1346                 default:
1347                         ;
1348         }
1349
1350
1351         return;
1352
1353 trunc:
1354         printf(" [|pt]");
1355 }
1356
1357 /*
1358  * Handle replies to the AFS protection service
1359  */
1360
1361 static void
1362 prot_reply_print(register const u_char *bp, int length, int32_t opcode)
1363 {
1364         struct rx_header *rxh;
1365         unsigned long i;
1366
1367         if (length < (int)sizeof(struct rx_header))
1368                 return;
1369
1370         rxh = (struct rx_header *) bp;
1371
1372         /*
1373          * Print out the afs call we're invoking.  The table used here was
1374          * gleaned from ptserver/ptint.xg.  Check to see if it's a
1375          * Ubik call, however.
1376          */
1377
1378         printf(" pt");
1379
1380         if (is_ubik(opcode)) {
1381                 ubik_reply_print(bp, length, opcode);
1382                 return;
1383         }
1384
1385         printf(" reply %s", tok2str(pt_req, "op#%d", opcode));
1386
1387         bp += sizeof(struct rx_header);
1388
1389         /*
1390          * If it was a data packet, interpret the response
1391          */
1392
1393         if (rxh->type == RX_PACKET_TYPE_DATA)
1394                 switch (opcode) {
1395                 case 504:               /* Name to ID */
1396                 {
1397                         unsigned long j;
1398                         printf(" ids:");
1399                         TCHECK2(bp[0], 4);
1400                         i = EXTRACT_32BITS(bp);
1401                         bp += sizeof(int32_t);
1402                         for (j = 0; j < i; j++)
1403                                 INTOUT();
1404                         if (j == 0)
1405                                 printf(" <none!>");
1406                 }
1407                         break;
1408                 case 505:               /* ID to name */
1409                 {
1410                         unsigned long j;
1411                         TCHECK2(bp[0], 4);
1412                         j = EXTRACT_32BITS(bp);
1413                         bp += sizeof(int32_t);
1414
1415                         /*
1416                          * Who designed this chicken-shit protocol?
1417                          *
1418                          * Each character is stored as a 32-bit
1419                          * integer!
1420                          */
1421
1422                         for (i = 0; i < j; i++) {
1423                                 VECOUT(PRNAMEMAX);
1424                         }
1425                         if (j == 0)
1426                                 printf(" <none!>");
1427                 }
1428                         break;
1429                 case 508:               /* Get CPS */
1430                 case 514:               /* List elements */
1431                 case 517:               /* List owned */
1432                 case 518:               /* Get CPS2 */
1433                 case 519:               /* Get host CPS */
1434                 {
1435                         unsigned long j;
1436                         TCHECK2(bp[0], 4);
1437                         j = EXTRACT_32BITS(bp);
1438                         bp += sizeof(int32_t);
1439                         for (i = 0; i < j; i++) {
1440                                 INTOUT();
1441                         }
1442                         if (j == 0)
1443                                 printf(" <none!>");
1444                 }
1445                         break;
1446                 case 510:               /* List max */
1447                         printf(" maxuid");
1448                         INTOUT();
1449                         printf(" maxgid");
1450                         INTOUT();
1451                         break;
1452                 default:
1453                         ;
1454                 }
1455         else {
1456                 /*
1457                  * Otherwise, just print out the return code
1458                  */
1459                 printf(" errcode");
1460                 INTOUT();
1461         }
1462
1463         return;
1464
1465 trunc:
1466         printf(" [|pt]");
1467 }
1468
1469 /*
1470  * Handle calls to the AFS volume location database service
1471  */
1472
1473 static void
1474 vldb_print(register const u_char *bp, int length)
1475 {
1476         int vldb_op;
1477         unsigned long i;
1478
1479         if (length <= (int)sizeof(struct rx_header))
1480                 return;
1481
1482         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1483                 goto trunc;
1484         }
1485
1486         /*
1487          * Print out the afs call we're invoking.  The table used here was
1488          * gleaned from vlserver/vldbint.xg
1489          */
1490
1491         vldb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1492
1493         printf(" vldb");
1494
1495         if (is_ubik(vldb_op)) {
1496                 ubik_print(bp);
1497                 return;
1498         }
1499         printf(" call %s", tok2str(vldb_req, "op#%d", vldb_op));
1500
1501         /*
1502          * Decode some of the arguments to the VLDB calls
1503          */
1504
1505         bp += sizeof(struct rx_header) + 4;
1506
1507         switch (vldb_op) {
1508                 case 501:       /* Create new volume */
1509                 case 517:       /* Create entry N */
1510                         VECOUT(VLNAMEMAX);
1511                         break;
1512                 case 502:       /* Delete entry */
1513                 case 503:       /* Get entry by ID */
1514                 case 507:       /* Update entry */
1515                 case 508:       /* Set lock */
1516                 case 509:       /* Release lock */
1517                 case 518:       /* Get entry by ID N */
1518                         printf(" volid");
1519                         INTOUT();
1520                         TCHECK2(bp[0], sizeof(int32_t));
1521                         i = EXTRACT_32BITS(bp);
1522                         bp += sizeof(int32_t);
1523                         if (i <= 2)
1524                                 printf(" type %s", voltype[i]);
1525                         break;
1526                 case 504:       /* Get entry by name */
1527                 case 519:       /* Get entry by name N */
1528                 case 524:       /* Update entry by name */
1529                 case 527:       /* Get entry by name U */
1530                         STROUT(VLNAMEMAX);
1531                         break;
1532                 case 505:       /* Get new vol id */
1533                         printf(" bump");
1534                         INTOUT();
1535                         break;
1536                 case 506:       /* Replace entry */
1537                 case 520:       /* Replace entry N */
1538                         printf(" volid");
1539                         INTOUT();
1540                         TCHECK2(bp[0], sizeof(int32_t));
1541                         i = EXTRACT_32BITS(bp);
1542                         bp += sizeof(int32_t);
1543                         if (i <= 2)
1544                                 printf(" type %s", voltype[i]);
1545                         VECOUT(VLNAMEMAX);
1546                         break;
1547                 case 510:       /* List entry */
1548                 case 521:       /* List entry N */
1549                         printf(" index");
1550                         INTOUT();
1551                         break;
1552                 default:
1553                         ;
1554         }
1555
1556         return;
1557
1558 trunc:
1559         printf(" [|vldb]");
1560 }
1561
1562 /*
1563  * Handle replies to the AFS volume location database service
1564  */
1565
1566 static void
1567 vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
1568 {
1569         struct rx_header *rxh;
1570         unsigned long i;
1571
1572         if (length < (int)sizeof(struct rx_header))
1573                 return;
1574
1575         rxh = (struct rx_header *) bp;
1576
1577         /*
1578          * Print out the afs call we're invoking.  The table used here was
1579          * gleaned from vlserver/vldbint.xg.  Check to see if it's a
1580          * Ubik call, however.
1581          */
1582
1583         printf(" vldb");
1584
1585         if (is_ubik(opcode)) {
1586                 ubik_reply_print(bp, length, opcode);
1587                 return;
1588         }
1589
1590         printf(" reply %s", tok2str(vldb_req, "op#%d", opcode));
1591
1592         bp += sizeof(struct rx_header);
1593
1594         /*
1595          * If it was a data packet, interpret the response
1596          */
1597
1598         if (rxh->type == RX_PACKET_TYPE_DATA)
1599                 switch (opcode) {
1600                 case 510:       /* List entry */
1601                         printf(" count");
1602                         INTOUT();
1603                         printf(" nextindex");
1604                         INTOUT();
1605                 case 503:       /* Get entry by id */
1606                 case 504:       /* Get entry by name */
1607                 {       unsigned long nservers, j;
1608                         VECOUT(VLNAMEMAX);
1609                         TCHECK2(bp[0], sizeof(int32_t));
1610                         bp += sizeof(int32_t);
1611                         printf(" numservers");
1612                         TCHECK2(bp[0], sizeof(int32_t));
1613                         nservers = EXTRACT_32BITS(bp);
1614                         bp += sizeof(int32_t);
1615                         printf(" %lu", nservers);
1616                         printf(" servers");
1617                         for (i = 0; i < 8; i++) {
1618                                 TCHECK2(bp[0], sizeof(int32_t));
1619                                 if (i < nservers)
1620                                         printf(" %s",
1621                                            intoa(((struct in_addr *) bp)->s_addr));
1622                                 bp += sizeof(int32_t);
1623                         }
1624                         printf(" partitions");
1625                         for (i = 0; i < 8; i++) {
1626                                 TCHECK2(bp[0], sizeof(int32_t));
1627                                 j = EXTRACT_32BITS(bp);
1628                                 if (i < nservers && j <= 26)
1629                                         printf(" %c", 'a' + (int)j);
1630                                 else if (i < nservers)
1631                                         printf(" %lu", j);
1632                                 bp += sizeof(int32_t);
1633                         }
1634                         TCHECK2(bp[0], 8 * sizeof(int32_t));
1635                         bp += 8 * sizeof(int32_t);
1636                         printf(" rwvol");
1637                         UINTOUT();
1638                         printf(" rovol");
1639                         UINTOUT();
1640                         printf(" backup");
1641                         UINTOUT();
1642                 }
1643                         break;
1644                 case 505:       /* Get new volume ID */
1645                         printf(" newvol");
1646                         UINTOUT();
1647                         break;
1648                 case 521:       /* List entry */
1649                 case 529:       /* List entry U */
1650                         printf(" count");
1651                         INTOUT();
1652                         printf(" nextindex");
1653                         INTOUT();
1654                 case 518:       /* Get entry by ID N */
1655                 case 519:       /* Get entry by name N */
1656                 {       unsigned long nservers, j;
1657                         VECOUT(VLNAMEMAX);
1658                         printf(" numservers");
1659                         TCHECK2(bp[0], sizeof(int32_t));
1660                         nservers = EXTRACT_32BITS(bp);
1661                         bp += sizeof(int32_t);
1662                         printf(" %lu", nservers);
1663                         printf(" servers");
1664                         for (i = 0; i < 13; i++) {
1665                                 TCHECK2(bp[0], sizeof(int32_t));
1666                                 if (i < nservers)
1667                                         printf(" %s",
1668                                            intoa(((struct in_addr *) bp)->s_addr));
1669                                 bp += sizeof(int32_t);
1670                         }
1671                         printf(" partitions");
1672                         for (i = 0; i < 13; i++) {
1673                                 TCHECK2(bp[0], sizeof(int32_t));
1674                                 j = EXTRACT_32BITS(bp);
1675                                 if (i < nservers && j <= 26)
1676                                         printf(" %c", 'a' + (int)j);
1677                                 else if (i < nservers)
1678                                         printf(" %lu", j);
1679                                 bp += sizeof(int32_t);
1680                         }
1681                         TCHECK2(bp[0], 13 * sizeof(int32_t));
1682                         bp += 13 * sizeof(int32_t);
1683                         printf(" rwvol");
1684                         UINTOUT();
1685                         printf(" rovol");
1686                         UINTOUT();
1687                         printf(" backup");
1688                         UINTOUT();
1689                 }
1690                         break;
1691                 case 526:       /* Get entry by ID U */
1692                 case 527:       /* Get entry by name U */
1693                 {       unsigned long nservers, j;
1694                         VECOUT(VLNAMEMAX);
1695                         printf(" numservers");
1696                         TCHECK2(bp[0], sizeof(int32_t));
1697                         nservers = EXTRACT_32BITS(bp);
1698                         bp += sizeof(int32_t);
1699                         printf(" %lu", nservers);
1700                         printf(" servers");
1701                         for (i = 0; i < 13; i++) {
1702                                 if (i < nservers) {
1703                                         printf(" afsuuid");
1704                                         AFSUUIDOUT();
1705                                 } else {
1706                                         TCHECK2(bp[0], 44);
1707                                         bp += 44;
1708                                 }
1709                         }
1710                         TCHECK2(bp[0], 4 * 13);
1711                         bp += 4 * 13;
1712                         printf(" partitions");
1713                         for (i = 0; i < 13; i++) {
1714                                 TCHECK2(bp[0], sizeof(int32_t));
1715                                 j = EXTRACT_32BITS(bp);
1716                                 if (i < nservers && j <= 26)
1717                                         printf(" %c", 'a' + (int)j);
1718                                 else if (i < nservers)
1719                                         printf(" %lu", j);
1720                                 bp += sizeof(int32_t);
1721                         }
1722                         TCHECK2(bp[0], 13 * sizeof(int32_t));
1723                         bp += 13 * sizeof(int32_t);
1724                         printf(" rwvol");
1725                         UINTOUT();
1726                         printf(" rovol");
1727                         UINTOUT();
1728                         printf(" backup");
1729                         UINTOUT();
1730                 }
1731                 default:
1732                         ;
1733                 }
1734
1735         else {
1736                 /*
1737                  * Otherwise, just print out the return code
1738                  */
1739                 printf(" errcode");
1740                 INTOUT();
1741         }
1742
1743         return;
1744
1745 trunc:
1746         printf(" [|vldb]");
1747 }
1748
1749 /*
1750  * Handle calls to the AFS Kerberos Authentication service
1751  */
1752
1753 static void
1754 kauth_print(register const u_char *bp, int length)
1755 {
1756         int kauth_op;
1757
1758         if (length <= (int)sizeof(struct rx_header))
1759                 return;
1760
1761         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1762                 goto trunc;
1763         }
1764
1765         /*
1766          * Print out the afs call we're invoking.  The table used here was
1767          * gleaned from kauth/kauth.rg
1768          */
1769
1770         kauth_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1771
1772         printf(" kauth");
1773
1774         if (is_ubik(kauth_op)) {
1775                 ubik_print(bp);
1776                 return;
1777         }
1778
1779
1780         printf(" call %s", tok2str(kauth_req, "op#%d", kauth_op));
1781
1782         /*
1783          * Decode some of the arguments to the KA calls
1784          */
1785
1786         bp += sizeof(struct rx_header) + 4;
1787
1788         switch (kauth_op) {
1789                 case 1:         /* Authenticate old */;
1790                 case 21:        /* Authenticate */
1791                 case 22:        /* Authenticate-V2 */
1792                 case 2:         /* Change PW */
1793                 case 5:         /* Set fields */
1794                 case 6:         /* Create user */
1795                 case 7:         /* Delete user */
1796                 case 8:         /* Get entry */
1797                 case 14:        /* Unlock */
1798                 case 15:        /* Lock status */
1799                         printf(" principal");
1800                         STROUT(KANAMEMAX);
1801                         STROUT(KANAMEMAX);
1802                         break;
1803                 case 3:         /* GetTicket-old */
1804                 case 23:        /* GetTicket */
1805                 {
1806                         int i;
1807                         printf(" kvno");
1808                         INTOUT();
1809                         printf(" domain");
1810                         STROUT(KANAMEMAX);
1811                         TCHECK2(bp[0], sizeof(int32_t));
1812                         i = (int) EXTRACT_32BITS(bp);
1813                         bp += sizeof(int32_t);
1814                         TCHECK2(bp[0], i);
1815                         bp += i;
1816                         printf(" principal");
1817                         STROUT(KANAMEMAX);
1818                         STROUT(KANAMEMAX);
1819                         break;
1820                 }
1821                 case 4:         /* Set Password */
1822                         printf(" principal");
1823                         STROUT(KANAMEMAX);
1824                         STROUT(KANAMEMAX);
1825                         printf(" kvno");
1826                         INTOUT();
1827                         break;
1828                 case 12:        /* Get password */
1829                         printf(" name");
1830                         STROUT(KANAMEMAX);
1831                         break;
1832                 default:
1833                         ;
1834         }
1835
1836         return;
1837
1838 trunc:
1839         printf(" [|kauth]");
1840 }
1841
1842 /*
1843  * Handle replies to the AFS Kerberos Authentication Service
1844  */
1845
1846 static void
1847 kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
1848 {
1849         struct rx_header *rxh;
1850
1851         if (length <= (int)sizeof(struct rx_header))
1852                 return;
1853
1854         rxh = (struct rx_header *) bp;
1855
1856         /*
1857          * Print out the afs call we're invoking.  The table used here was
1858          * gleaned from kauth/kauth.rg
1859          */
1860
1861         printf(" kauth");
1862
1863         if (is_ubik(opcode)) {
1864                 ubik_reply_print(bp, length, opcode);
1865                 return;
1866         }
1867
1868         printf(" reply %s", tok2str(kauth_req, "op#%d", opcode));
1869
1870         bp += sizeof(struct rx_header);
1871
1872         /*
1873          * If it was a data packet, interpret the response.
1874          */
1875
1876         if (rxh->type == RX_PACKET_TYPE_DATA)
1877                 /* Well, no, not really.  Leave this for later */
1878                 ;
1879         else {
1880                 /*
1881                  * Otherwise, just print out the return code
1882                  */
1883                 printf(" errcode");
1884                 INTOUT();
1885         }
1886
1887         return;
1888
1889 trunc:
1890         printf(" [|kauth]");
1891 }
1892
1893 /*
1894  * Handle calls to the AFS Volume location service
1895  */
1896
1897 static void
1898 vol_print(register const u_char *bp, int length)
1899 {
1900         int vol_op;
1901
1902         if (length <= (int)sizeof(struct rx_header))
1903                 return;
1904
1905         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1906                 goto trunc;
1907         }
1908
1909         /*
1910          * Print out the afs call we're invoking.  The table used here was
1911          * gleaned from volser/volint.xg
1912          */
1913
1914         vol_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1915
1916         printf(" vol call %s", tok2str(vol_req, "op#%d", vol_op));
1917
1918         /*
1919          * Normally there would be a switch statement here to decode the
1920          * arguments to the AFS call, but since I don't have access to
1921          * an AFS server (yet) and I'm not an AFS admin, I can't
1922          * test any of these calls.  Leave this blank for now.
1923          */
1924
1925         return;
1926
1927 trunc:
1928         printf(" [|vol]");
1929 }
1930
1931 /*
1932  * Handle replies to the AFS Volume Service
1933  */
1934
1935 static void
1936 vol_reply_print(register const u_char *bp, int length, int32_t opcode)
1937 {
1938         struct rx_header *rxh;
1939
1940         if (length <= (int)sizeof(struct rx_header))
1941                 return;
1942
1943         rxh = (struct rx_header *) bp;
1944
1945         /*
1946          * Print out the afs call we're invoking.  The table used here was
1947          * gleaned from volser/volint.xg
1948          */
1949
1950         printf(" vol reply %s", tok2str(vol_req, "op#%d", opcode));
1951
1952         bp += sizeof(struct rx_header);
1953
1954         /*
1955          * If it was a data packet, interpret the response.
1956          */
1957
1958         if (rxh->type == RX_PACKET_TYPE_DATA)
1959                 /* Well, no, not really.  Leave this for later */
1960                 ;
1961         else {
1962                 /*
1963                  * Otherwise, just print out the return code
1964                  */
1965                 printf(" errcode");
1966                 INTOUT();
1967         }
1968
1969         return;
1970
1971 trunc:
1972         printf(" [|vol]");
1973 }
1974
1975 /*
1976  * Handle calls to the AFS BOS service
1977  */
1978
1979 static void
1980 bos_print(register const u_char *bp, int length)
1981 {
1982         int bos_op;
1983
1984         if (length <= (int)sizeof(struct rx_header))
1985                 return;
1986
1987         if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1988                 goto trunc;
1989         }
1990
1991         /*
1992          * Print out the afs call we're invoking.  The table used here was
1993          * gleaned from bozo/bosint.xg
1994          */
1995
1996         bos_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1997
1998         printf(" bos call %s", tok2str(bos_req, "op#%d", bos_op));
1999
2000         /*
2001          * Decode some of the arguments to the BOS calls
2002          */
2003
2004         bp += sizeof(struct rx_header) + 4;
2005
2006         switch (bos_op) {
2007                 case 80:        /* Create B node */
2008                         printf(" type");
2009                         STROUT(BOSNAMEMAX);
2010                         printf(" instance");
2011                         STROUT(BOSNAMEMAX);
2012                         break;
2013                 case 81:        /* Delete B node */
2014                 case 83:        /* Get status */
2015                 case 85:        /* Get instance info */
2016                 case 87:        /* Add super user */
2017                 case 88:        /* Delete super user */
2018                 case 93:        /* Set cell name */
2019                 case 96:        /* Add cell host */
2020                 case 97:        /* Delete cell host */
2021                 case 104:       /* Restart */
2022                 case 106:       /* Uninstall */
2023                 case 108:       /* Exec */
2024                 case 112:       /* Getlog */
2025                 case 114:       /* Get instance strings */
2026                         STROUT(BOSNAMEMAX);
2027                         break;
2028                 case 82:        /* Set status */
2029                 case 98:        /* Set T status */
2030                         STROUT(BOSNAMEMAX);
2031                         printf(" status");
2032                         INTOUT();
2033                         break;
2034                 case 86:        /* Get instance parm */
2035                         STROUT(BOSNAMEMAX);
2036                         printf(" num");
2037                         INTOUT();
2038                         break;
2039                 case 84:        /* Enumerate instance */
2040                 case 89:        /* List super users */
2041                 case 90:        /* List keys */
2042                 case 91:        /* Add key */
2043                 case 92:        /* Delete key */
2044                 case 95:        /* Get cell host */
2045                         INTOUT();
2046                         break;
2047                 case 105:       /* Install */
2048                         STROUT(BOSNAMEMAX);
2049                         printf(" size");
2050                         INTOUT();
2051                         printf(" flags");
2052                         INTOUT();
2053                         printf(" date");
2054                         INTOUT();
2055                         break;
2056                 default:
2057                         ;
2058         }
2059
2060         return;
2061
2062 trunc:
2063         printf(" [|bos]");
2064 }
2065
2066 /*
2067  * Handle replies to the AFS BOS Service
2068  */
2069
2070 static void
2071 bos_reply_print(register const u_char *bp, int length, int32_t opcode)
2072 {
2073         struct rx_header *rxh;
2074
2075         if (length <= (int)sizeof(struct rx_header))
2076                 return;
2077
2078         rxh = (struct rx_header *) bp;
2079
2080         /*
2081          * Print out the afs call we're invoking.  The table used here was
2082          * gleaned from volser/volint.xg
2083          */
2084
2085         printf(" bos reply %s", tok2str(bos_req, "op#%d", opcode));
2086
2087         bp += sizeof(struct rx_header);
2088
2089         /*
2090          * If it was a data packet, interpret the response.
2091          */
2092
2093         if (rxh->type == RX_PACKET_TYPE_DATA)
2094                 /* Well, no, not really.  Leave this for later */
2095                 ;
2096         else {
2097                 /*
2098                  * Otherwise, just print out the return code
2099                  */
2100                 printf(" errcode");
2101                 INTOUT();
2102         }
2103
2104         return;
2105
2106 trunc:
2107         printf(" [|bos]");
2108 }
2109
2110 /*
2111  * Check to see if this is a Ubik opcode.
2112  */
2113
2114 static int
2115 is_ubik(u_int32_t opcode)
2116 {
2117         if ((opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
2118             (opcode >= DISK_LOW && opcode <= DISK_HIGH))
2119                 return(1);
2120         else
2121                 return(0);
2122 }
2123
2124 /*
2125  * Handle Ubik opcodes to any one of the replicated database services
2126  */
2127
2128 static void
2129 ubik_print(register const u_char *bp)
2130 {
2131         int ubik_op;
2132         int32_t temp;
2133
2134         /*
2135          * Print out the afs call we're invoking.  The table used here was
2136          * gleaned from ubik/ubik_int.xg
2137          */
2138
2139         ubik_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
2140
2141         printf(" ubik call %s", tok2str(ubik_req, "op#%d", ubik_op));
2142
2143         /*
2144          * Decode some of the arguments to the Ubik calls
2145          */
2146
2147         bp += sizeof(struct rx_header) + 4;
2148
2149         switch (ubik_op) {
2150                 case 10000:             /* Beacon */
2151                         TCHECK2(bp[0], 4);
2152                         temp = EXTRACT_32BITS(bp);
2153                         bp += sizeof(int32_t);
2154                         printf(" syncsite %s", temp ? "yes" : "no");
2155                         printf(" votestart");
2156                         DATEOUT();
2157                         printf(" dbversion");
2158                         UBIK_VERSIONOUT();
2159                         printf(" tid");
2160                         UBIK_VERSIONOUT();
2161                         break;
2162                 case 10003:             /* Get sync site */
2163                         printf(" site");
2164                         UINTOUT();
2165                         break;
2166                 case 20000:             /* Begin */
2167                 case 20001:             /* Commit */
2168                 case 20007:             /* Abort */
2169                 case 20008:             /* Release locks */
2170                 case 20010:             /* Writev */
2171                         printf(" tid");
2172                         UBIK_VERSIONOUT();
2173                         break;
2174                 case 20002:             /* Lock */
2175                         printf(" tid");
2176                         UBIK_VERSIONOUT();
2177                         printf(" file");
2178                         INTOUT();
2179                         printf(" pos");
2180                         INTOUT();
2181                         printf(" length");
2182                         INTOUT();
2183                         temp = EXTRACT_32BITS(bp);
2184                         bp += sizeof(int32_t);
2185                         tok2str(ubik_lock_types, "type %d", temp);
2186                         break;
2187                 case 20003:             /* Write */
2188                         printf(" tid");
2189                         UBIK_VERSIONOUT();
2190                         printf(" file");
2191                         INTOUT();
2192                         printf(" pos");
2193                         INTOUT();
2194                         break;
2195                 case 20005:             /* Get file */
2196                         printf(" file");
2197                         INTOUT();
2198                         break;
2199                 case 20006:             /* Send file */
2200                         printf(" file");
2201                         INTOUT();
2202                         printf(" length");
2203                         INTOUT();
2204                         printf(" dbversion");
2205                         UBIK_VERSIONOUT();
2206                         break;
2207                 case 20009:             /* Truncate */
2208                         printf(" tid");
2209                         UBIK_VERSIONOUT();
2210                         printf(" file");
2211                         INTOUT();
2212                         printf(" length");
2213                         INTOUT();
2214                         break;
2215                 case 20012:             /* Set version */
2216                         printf(" tid");
2217                         UBIK_VERSIONOUT();
2218                         printf(" oldversion");
2219                         UBIK_VERSIONOUT();
2220                         printf(" newversion");
2221                         UBIK_VERSIONOUT();
2222                         break;
2223                 default:
2224                         ;
2225         }
2226
2227         return;
2228
2229 trunc:
2230         printf(" [|ubik]");
2231 }
2232
2233 /*
2234  * Handle Ubik replies to any one of the replicated database services
2235  */
2236
2237 static void
2238 ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
2239 {
2240         struct rx_header *rxh;
2241
2242         if (length < (int)sizeof(struct rx_header))
2243                 return;
2244
2245         rxh = (struct rx_header *) bp;
2246
2247         /*
2248          * Print out the ubik call we're invoking.  This table was gleaned
2249          * from ubik/ubik_int.xg
2250          */
2251
2252         printf(" ubik reply %s", tok2str(ubik_req, "op#%d", opcode));
2253
2254         bp += sizeof(struct rx_header);
2255
2256         /*
2257          * If it was a data packet, print out the arguments to the Ubik calls
2258          */
2259
2260         if (rxh->type == RX_PACKET_TYPE_DATA)
2261                 switch (opcode) {
2262                 case 10000:             /* Beacon */
2263                         printf(" vote no");
2264                         break;
2265                 case 20004:             /* Get version */
2266                         printf(" dbversion");
2267                         UBIK_VERSIONOUT();
2268                         break;
2269                 default:
2270                         ;
2271                 }
2272
2273         /*
2274          * Otherwise, print out "yes" it it was a beacon packet (because
2275          * that's how yes votes are returned, go figure), otherwise
2276          * just print out the error code.
2277          */
2278
2279         else
2280                 switch (opcode) {
2281                 case 10000:             /* Beacon */
2282                         printf(" vote yes until");
2283                         DATEOUT();
2284                         break;
2285                 default:
2286                         printf(" errcode");
2287                         INTOUT();
2288                 }
2289
2290         return;
2291
2292 trunc:
2293         printf(" [|ubik]");
2294 }
2295
2296 /*
2297  * Handle RX ACK packets.
2298  */
2299
2300 static void
2301 rx_ack_print(register const u_char *bp, int length)
2302 {
2303         struct rx_ackPacket *rxa;
2304         int i, start, last;
2305         u_int32_t firstPacket;
2306
2307         if (length < (int)sizeof(struct rx_header))
2308                 return;
2309
2310         bp += sizeof(struct rx_header);
2311
2312         /*
2313          * This may seem a little odd .... the rx_ackPacket structure
2314          * contains an array of individual packet acknowledgements
2315          * (used for selective ack/nack), but since it's variable in size,
2316          * we don't want to truncate based on the size of the whole
2317          * rx_ackPacket structure.
2318          */
2319
2320         TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);
2321
2322         rxa = (struct rx_ackPacket *) bp;
2323         bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
2324
2325         /*
2326          * Print out a few useful things from the ack packet structure
2327          */
2328
2329         if (vflag > 2)
2330                 printf(" bufspace %d maxskew %d",
2331                        (int) EXTRACT_16BITS(&rxa->bufferSpace),
2332                        (int) EXTRACT_16BITS(&rxa->maxSkew));
2333
2334         firstPacket = EXTRACT_32BITS(&rxa->firstPacket);
2335         printf(" first %d serial %d reason %s",
2336                firstPacket, EXTRACT_32BITS(&rxa->serial),
2337                tok2str(rx_ack_reasons, "#%d", (int) rxa->reason));
2338
2339         /*
2340          * Okay, now we print out the ack array.  The way _this_ works
2341          * is that we start at "first", and step through the ack array.
2342          * If we have a contiguous range of acks/nacks, try to
2343          * collapse them into a range.
2344          *
2345          * If you're really clever, you might have noticed that this
2346          * doesn't seem quite correct.  Specifically, due to structure
2347          * padding, sizeof(struct rx_ackPacket) - RX_MAXACKS won't actually
2348          * yield the start of the ack array (because RX_MAXACKS is 255
2349          * and the structure will likely get padded to a 2 or 4 byte
2350          * boundary).  However, this is the way it's implemented inside
2351          * of AFS - the start of the extra fields are at
2352          * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_
2353          * the exact start of the ack array.  Sigh.  That's why we aren't
2354          * using bp, but instead use rxa->acks[].  But nAcks gets added
2355          * to bp after this, so bp ends up at the right spot.  Go figure.
2356          */
2357
2358         if (rxa->nAcks != 0) {
2359
2360                 TCHECK2(bp[0], rxa->nAcks);
2361
2362                 /*
2363                  * Sigh, this is gross, but it seems to work to collapse
2364                  * ranges correctly.
2365                  */
2366
2367                 for (i = 0, start = last = -2; i < rxa->nAcks; i++)
2368                         if (rxa->acks[i] == RX_ACK_TYPE_ACK) {
2369
2370                                 /*
2371                                  * I figured this deserved _some_ explanation.
2372                                  * First, print "acked" and the packet seq
2373                                  * number if this is the first time we've
2374                                  * seen an acked packet.
2375                                  */
2376
2377                                 if (last == -2) {
2378                                         printf(" acked %d",
2379                                                firstPacket + i);
2380                                         start = i;
2381                                 }
2382
2383                                 /*
2384                                  * Otherwise, if the there is a skip in
2385                                  * the range (such as an nacked packet in
2386                                  * the middle of some acked packets),
2387                                  * then print the current packet number
2388                                  * seperated from the last number by
2389                                  * a comma.
2390                                  */
2391
2392                                 else if (last != i - 1) {
2393                                         printf(",%d", firstPacket + i);
2394                                         start = i;
2395                                 }
2396
2397                                 /*
2398                                  * We always set last to the value of
2399                                  * the last ack we saw.  Conversely, start
2400                                  * is set to the value of the first ack
2401                                  * we saw in a range.
2402                                  */
2403
2404                                 last = i;
2405
2406                                 /*
2407                                  * Okay, this bit a code gets executed when
2408                                  * we hit a nack ... in _this_ case we
2409                                  * want to print out the range of packets
2410                                  * that were acked, so we need to print
2411                                  * the _previous_ packet number seperated
2412                                  * from the first by a dash (-).  Since we
2413                                  * already printed the first packet above,
2414                                  * just print the final packet.  Don't
2415                                  * do this if there will be a single-length
2416                                  * range.
2417                                  */
2418                         } else if (last == i - 1 && start != last)
2419                                 printf("-%d", firstPacket + i - 1);
2420
2421                 /*
2422                  * So, what's going on here?  We ran off the end of the
2423                  * ack list, and if we got a range we need to finish it up.
2424                  * So we need to determine if the last packet in the list
2425                  * was an ack (if so, then last will be set to it) and
2426                  * we need to see if the last range didn't start with the
2427                  * last packet (because if it _did_, then that would mean
2428                  * that the packet number has already been printed and
2429                  * we don't need to print it again).
2430                  */
2431
2432                 if (last == i - 1 && start != last)
2433                         printf("-%d", firstPacket + i - 1);
2434
2435                 /*
2436                  * Same as above, just without comments
2437                  */
2438
2439                 for (i = 0, start = last = -2; i < rxa->nAcks; i++)
2440                         if (rxa->acks[i] == RX_ACK_TYPE_NACK) {
2441                                 if (last == -2) {
2442                                         printf(" nacked %d",
2443                                                firstPacket + i);
2444                                         start = i;
2445                                 } else if (last != i - 1) {
2446                                         printf(",%d", firstPacket + i);
2447                                         start = i;
2448                                 }
2449                                 last = i;
2450                         } else if (last == i - 1 && start != last)
2451                                 printf("-%d", firstPacket + i - 1);
2452
2453                 if (last == i - 1 && start != last)
2454                         printf("-%d", firstPacket + i - 1);
2455
2456                 bp += rxa->nAcks;
2457         }
2458
2459
2460         /*
2461          * These are optional fields; depending on your version of AFS,
2462          * you may or may not see them
2463          */
2464
2465 #define TRUNCRET(n)     if (snapend - bp + 1 <= n) return;
2466
2467         if (vflag > 1) {
2468                 TRUNCRET(4);
2469                 printf(" ifmtu");
2470                 INTOUT();
2471
2472                 TRUNCRET(4);
2473                 printf(" maxmtu");
2474                 INTOUT();
2475
2476                 TRUNCRET(4);
2477                 printf(" rwind");
2478                 INTOUT();
2479
2480                 TRUNCRET(4);
2481                 printf(" maxpackets");
2482                 INTOUT();
2483         }
2484
2485         return;
2486
2487 trunc:
2488         printf(" [|ack]");
2489 }
2490 #undef TRUNCRET