2 * Copyright: (c) 2000 United States Government as represented by the
3 * Secretary of the Navy. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
15 * 3. The names of the authors may not be used to endorse or promote
16 * products derived from this software without specific prior
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.
24 /* \summary: AFS RX printer */
27 * This code unmangles RX packets. RX is the mutant form of RPC that AFS
28 * uses to communicate between clients and servers.
30 * In this code, I mainly concern myself with decoding the AFS calls, not
31 * with the guts of RX, per se.
33 * Bah. If I never look at rx_packet.h again, it will be too soon.
35 * Ken Hornstein <kenh@cmf.nrl.navy.mil>
45 #include <netdissect-stdinc.h>
47 #include "netdissect.h"
48 #include "addrtoname.h"
53 #define FS_RX_PORT 7000
54 #define CB_RX_PORT 7001
55 #define PROT_RX_PORT 7002
56 #define VLDB_RX_PORT 7003
57 #define KAUTH_RX_PORT 7004
58 #define VOL_RX_PORT 7005
59 #define ERROR_RX_PORT 7006 /* Doesn't seem to be used */
60 #define BOS_RX_PORT 7007
62 #define AFSNAMEMAX 256
63 #define AFSOPAQUEMAX 1024
67 #define BOSNAMEMAX 256
69 #define PRSFS_READ 1 /* Read files */
70 #define PRSFS_WRITE 2 /* Write files */
71 #define PRSFS_INSERT 4 /* Insert files into a directory */
72 #define PRSFS_LOOKUP 8 /* Lookup files into a directory */
73 #define PRSFS_DELETE 16 /* Delete files */
74 #define PRSFS_LOCK 32 /* Lock files */
75 #define PRSFS_ADMINISTER 64 /* Change ACL's */
80 nd_uint32_t callNumber;
84 #define RX_PACKET_TYPE_DATA 1
85 #define RX_PACKET_TYPE_ACK 2
86 #define RX_PACKET_TYPE_BUSY 3
87 #define RX_PACKET_TYPE_ABORT 4
88 #define RX_PACKET_TYPE_ACKALL 5
89 #define RX_PACKET_TYPE_CHALLENGE 6
90 #define RX_PACKET_TYPE_RESPONSE 7
91 #define RX_PACKET_TYPE_DEBUG 8
92 #define RX_PACKET_TYPE_PARAMS 9
93 #define RX_PACKET_TYPE_VERSION 13
95 #define RX_CLIENT_INITIATED 1
96 #define RX_REQUEST_ACK 2
97 #define RX_LAST_PACKET 4
98 #define RX_MORE_PACKETS 8
99 #define RX_FREE_PACKET 16
100 #define RX_SLOW_START_OK 32
101 #define RX_JUMBO_PACKET 32
102 nd_uint8_t userStatus;
103 nd_uint8_t securityIndex;
104 nd_uint16_t spare; /* How clever: even though the AFS */
105 nd_uint16_t serviceId; /* header files indicate that the */
106 }; /* serviceId is first, it's really */
107 /* encoded _after_ the spare field */
108 /* I wasted a day figuring that out! */
110 #define NUM_RX_FLAGS 7
112 #define RX_MAXACKS 255
114 struct rx_ackPacket {
115 uint16_t bufferSpace; /* Number of packet buffers available */
116 uint16_t maxSkew; /* Max diff between ack'd packet and */
117 /* highest packet received */
118 uint32_t firstPacket; /* The first packet in ack list */
119 uint32_t previousPacket; /* Previous packet recv'd (obsolete) */
120 uint32_t serial; /* # of packet that prompted the ack */
121 uint8_t reason; /* Reason for acknowledgement */
122 uint8_t nAcks; /* Number of acknowledgements */
123 uint8_t acks[RX_MAXACKS]; /* Up to RX_MAXACKS acknowledgements */
127 * Values for the acks array
130 #define RX_ACK_TYPE_NACK 0 /* Don't have this packet */
131 #define RX_ACK_TYPE_ACK 1 /* I have this packet */
133 static const struct tok rx_types[] = {
134 { RX_PACKET_TYPE_DATA, "data" },
135 { RX_PACKET_TYPE_ACK, "ack" },
136 { RX_PACKET_TYPE_BUSY, "busy" },
137 { RX_PACKET_TYPE_ABORT, "abort" },
138 { RX_PACKET_TYPE_ACKALL, "ackall" },
139 { RX_PACKET_TYPE_CHALLENGE, "challenge" },
140 { RX_PACKET_TYPE_RESPONSE, "response" },
141 { RX_PACKET_TYPE_DEBUG, "debug" },
142 { RX_PACKET_TYPE_PARAMS, "params" },
143 { RX_PACKET_TYPE_VERSION, "version" },
147 static const struct double_tok {
148 int flag; /* Rx flag */
149 int packetType; /* Packet type */
150 const char *s; /* Flag string */
152 { RX_CLIENT_INITIATED, 0, "client-init" },
153 { RX_REQUEST_ACK, 0, "req-ack" },
154 { RX_LAST_PACKET, 0, "last-pckt" },
155 { RX_MORE_PACKETS, 0, "more-pckts" },
156 { RX_FREE_PACKET, 0, "free-pckt" },
157 { RX_SLOW_START_OK, RX_PACKET_TYPE_ACK, "slow-start" },
158 { RX_JUMBO_PACKET, RX_PACKET_TYPE_DATA, "jumbogram" }
161 static const struct tok fs_req[] = {
162 { 130, "fetch-data" },
163 { 131, "fetch-acl" },
164 { 132, "fetch-status" },
165 { 133, "store-data" },
166 { 134, "store-acl" },
167 { 135, "store-status" },
168 { 136, "remove-file" },
169 { 137, "create-file" },
175 { 143, "oldsetlock" },
176 { 144, "oldextlock" },
177 { 145, "oldrellock" },
178 { 146, "get-stats" },
180 { 148, "get-vlinfo" },
181 { 149, "get-vlstats" },
182 { 150, "set-vlstats" },
183 { 151, "get-rootvl" },
184 { 152, "check-token" },
186 { 154, "nget-vlinfo" },
187 { 155, "bulk-stat" },
191 { 159, "xstat-ver" },
192 { 160, "get-xstat" },
193 { 161, "dfs-lookup" },
194 { 162, "dfs-flushcps" },
195 { 163, "dfs-symlink" },
196 { 220, "residency" },
197 { 65536, "inline-bulk-status" },
198 { 65537, "fetch-data-64" },
199 { 65538, "store-data-64" },
200 { 65539, "give-up-all-cbs" },
201 { 65540, "get-caps" },
202 { 65541, "cb-rx-conn-addr" },
206 static const struct tok cb_req[] = {
215 { 212, "whoareyou" },
217 { 214, "probeuuid" },
218 { 215, "getsrvprefs" },
219 { 216, "getcellservdb" },
220 { 217, "getlocalcell" },
221 { 218, "getcacheconf" },
222 { 65536, "getce64" },
223 { 65537, "getcellbynum" },
224 { 65538, "tellmeaboutyourself" },
228 static const struct tok pt_req[] = {
230 { 501, "where-is-it" },
231 { 502, "dump-entry" },
232 { 503, "add-to-group" },
233 { 504, "name-to-id" },
234 { 505, "id-to-name" },
236 { 507, "remove-from-group" },
238 { 509, "new-entry" },
241 { 512, "list-entry" },
242 { 513, "change-entry" },
243 { 514, "list-elements" },
244 { 515, "same-mbr-of" },
245 { 516, "set-fld-sentry" },
246 { 517, "list-owned" },
248 { 519, "get-host-cps" },
249 { 520, "update-entry" },
250 { 521, "list-entries" },
251 { 530, "list-super-groups" },
255 static const struct tok vldb_req[] = {
256 { 501, "create-entry" },
257 { 502, "delete-entry" },
258 { 503, "get-entry-by-id" },
259 { 504, "get-entry-by-name" },
260 { 505, "get-new-volume-id" },
261 { 506, "replace-entry" },
262 { 507, "update-entry" },
264 { 509, "releaselock" },
265 { 510, "list-entry" },
266 { 511, "list-attrib" },
267 { 512, "linked-list" },
268 { 513, "get-stats" },
270 { 515, "get-addrs" },
271 { 516, "change-addr" },
272 { 517, "create-entry-n" },
273 { 518, "get-entry-by-id-n" },
274 { 519, "get-entry-by-name-n" },
275 { 520, "replace-entry-n" },
276 { 521, "list-entry-n" },
277 { 522, "list-attrib-n" },
278 { 523, "linked-list-n" },
279 { 524, "update-entry-by-name" },
280 { 525, "create-entry-u" },
281 { 526, "get-entry-by-id-u" },
282 { 527, "get-entry-by-name-u" },
283 { 528, "replace-entry-u" },
284 { 529, "list-entry-u" },
285 { 530, "list-attrib-u" },
286 { 531, "linked-list-u" },
288 { 533, "get-addrs-u" },
289 { 534, "list-attrib-n2" },
293 static const struct tok kauth_req[] = {
295 { 21, "authenticate" },
296 { 22, "authenticate-v2" },
298 { 3, "get-ticket-old" },
299 { 23, "get-ticket" },
302 { 6, "create-user" },
303 { 7, "delete-user" },
309 { 13, "get-random-key" },
311 { 15, "lock-status" },
315 static const struct tok vol_req[] = {
316 { 100, "create-volume" },
317 { 101, "delete-volume" },
320 { 104, "end-trans" },
322 { 106, "set-flags" },
323 { 107, "get-flags" },
324 { 108, "trans-create" },
326 { 110, "get-nth-volume" },
327 { 111, "set-forwarding" },
329 { 113, "get-status" },
330 { 114, "sig-restore" },
331 { 115, "list-partitions" },
332 { 116, "list-volumes" },
333 { 117, "set-id-types" },
335 { 119, "partition-info" },
337 { 121, "list-one-volume" },
340 { 124, "x-list-volumes" },
341 { 125, "x-list-one-volume" },
343 { 127, "x-list-partitions" },
344 { 128, "forward-multiple" },
345 { 65536, "convert-ro" },
346 { 65537, "get-size" },
347 { 65538, "dump-v2" },
351 static const struct tok bos_req[] = {
352 { 80, "create-bnode" },
353 { 81, "delete-bnode" },
354 { 82, "set-status" },
355 { 83, "get-status" },
356 { 84, "enumerate-instance" },
357 { 85, "get-instance-info" },
358 { 86, "get-instance-parm" },
359 { 87, "add-superuser" },
360 { 88, "delete-superuser" },
361 { 89, "list-superusers" },
364 { 92, "delete-key" },
365 { 93, "set-cell-name" },
366 { 94, "get-cell-name" },
367 { 95, "get-cell-host" },
368 { 96, "add-cell-host" },
369 { 97, "delete-cell-host" },
370 { 98, "set-t-status" },
371 { 99, "shutdown-all" },
372 { 100, "restart-all" },
373 { 101, "startup-all" },
374 { 102, "set-noauth-flag" },
377 { 105, "start-bozo-install" },
378 { 106, "uninstall" },
379 { 107, "get-dates" },
382 { 110, "set-restart-time" },
383 { 111, "get-restart-time" },
384 { 112, "start-bozo-log" },
386 { 114, "get-instance-strings" },
387 { 115, "get-restricted" },
388 { 116, "set-restricted" },
392 static const struct tok ubik_req[] = {
393 { 10000, "vote-beacon" },
394 { 10001, "vote-debug-old" },
395 { 10002, "vote-sdebug-old" },
396 { 10003, "vote-getsyncsite" },
397 { 10004, "vote-debug" },
398 { 10005, "vote-sdebug" },
399 { 10006, "vote-xdebug" },
400 { 10007, "vote-xsdebug" },
401 { 20000, "disk-begin" },
402 { 20001, "disk-commit" },
403 { 20002, "disk-lock" },
404 { 20003, "disk-write" },
405 { 20004, "disk-getversion" },
406 { 20005, "disk-getfile" },
407 { 20006, "disk-sendfile" },
408 { 20007, "disk-abort" },
409 { 20008, "disk-releaselocks" },
410 { 20009, "disk-truncate" },
411 { 20010, "disk-probe" },
412 { 20011, "disk-writev" },
413 { 20012, "disk-interfaceaddr" },
414 { 20013, "disk-setversion" },
418 #define VOTE_LOW 10000
419 #define VOTE_HIGH 10007
420 #define DISK_LOW 20000
421 #define DISK_HIGH 20013
423 static const struct tok cb_types[] = {
430 static const struct tok ubik_lock_types[] = {
437 static const char *voltype[] = { "read-write", "read-only", "backup" };
439 static const struct tok afs_fs_errors[] = {
440 { 101, "salvage volume" },
441 { 102, "no such vnode" },
442 { 103, "no such volume" },
443 { 104, "volume exist" },
444 { 105, "no service" },
445 { 106, "volume offline" },
446 { 107, "voline online" },
448 { 109, "diskquota exceeded" },
449 { 110, "volume busy" },
450 { 111, "volume moved" },
451 { 112, "AFS IO error" },
452 { 0xffffff9c, "restarting fileserver" }, /* -100, sic! */
457 * Reasons for acknowledging a packet
460 static const struct tok rx_ack_reasons[] = {
461 { 1, "ack requested" },
462 { 2, "duplicate packet" },
463 { 3, "out of sequence" },
464 { 4, "exceeds window" },
465 { 5, "no buffer space" },
467 { 7, "ping response" },
474 * Cache entries we keep around so we can figure out the RX opcode
475 * numbers for replies. This allows us to make sense of RX reply packets.
478 struct rx_cache_entry {
479 uint32_t callnum; /* Call number (net order) */
480 struct in_addr client; /* client IP address (net order) */
481 struct in_addr server; /* server IP address (net order) */
482 int dport; /* server port (host order) */
483 u_short serviceId; /* Service identifier (net order) */
484 uint32_t opcode; /* RX opcode (host order) */
487 #define RX_CACHE_SIZE 64
489 static struct rx_cache_entry rx_cache[RX_CACHE_SIZE];
491 static int rx_cache_next = 0;
492 static int rx_cache_hint = 0;
493 static void rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, int);
494 static int rx_cache_find(const struct rx_header *, const struct ip *,
497 static void fs_print(netdissect_options *, const u_char *, int);
498 static void fs_reply_print(netdissect_options *, const u_char *, int, int32_t);
499 static void acl_print(netdissect_options *, u_char *, int, u_char *);
500 static void cb_print(netdissect_options *, const u_char *, int);
501 static void cb_reply_print(netdissect_options *, const u_char *, int, int32_t);
502 static void prot_print(netdissect_options *, const u_char *, int);
503 static void prot_reply_print(netdissect_options *, const u_char *, int, int32_t);
504 static void vldb_print(netdissect_options *, const u_char *, int);
505 static void vldb_reply_print(netdissect_options *, const u_char *, int, int32_t);
506 static void kauth_print(netdissect_options *, const u_char *, int);
507 static void kauth_reply_print(netdissect_options *, const u_char *, int, int32_t);
508 static void vol_print(netdissect_options *, const u_char *, int);
509 static void vol_reply_print(netdissect_options *, const u_char *, int, int32_t);
510 static void bos_print(netdissect_options *, const u_char *, int);
511 static void bos_reply_print(netdissect_options *, const u_char *, int, int32_t);
512 static void ubik_print(netdissect_options *, const u_char *);
513 static void ubik_reply_print(netdissect_options *, const u_char *, int, int32_t);
515 static void rx_ack_print(netdissect_options *, const u_char *, int);
517 static int is_ubik(uint32_t);
520 * Handle the rx-level packet. See if we know what port it's going to so
521 * we can peek at the afs call inside
525 rx_print(netdissect_options *ndo,
526 register const u_char *bp, int length, int sport, int dport,
529 register const struct rx_header *rxh;
533 if (ndo->ndo_snapend - bp < (int)sizeof (struct rx_header)) {
534 ND_PRINT((ndo, " [|rx] (%d)", length));
538 rxh = (const struct rx_header *) bp;
540 ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %d", rxh->type)));
542 if (ndo->ndo_vflag) {
545 if (ndo->ndo_vflag > 1)
546 ND_PRINT((ndo, " cid %08x call# %d",
547 (int) EXTRACT_32BITS(&rxh->cid),
548 (int) EXTRACT_32BITS(&rxh->callNumber)));
550 ND_PRINT((ndo, " seq %d ser %d",
551 (int) EXTRACT_32BITS(&rxh->seq),
552 (int) EXTRACT_32BITS(&rxh->serial)));
554 if (ndo->ndo_vflag > 2)
555 ND_PRINT((ndo, " secindex %d serviceid %hu",
556 (int) rxh->securityIndex,
557 EXTRACT_16BITS(&rxh->serviceId)));
559 if (ndo->ndo_vflag > 1)
560 for (i = 0; i < NUM_RX_FLAGS; i++) {
561 if (rxh->flags & rx_flags[i].flag &&
562 (!rx_flags[i].packetType ||
563 rxh->type == rx_flags[i].packetType)) {
566 ND_PRINT((ndo, " "));
568 ND_PRINT((ndo, ","));
570 ND_PRINT((ndo, "<%s>", rx_flags[i].s));
576 * Try to handle AFS calls that we know about. Check the destination
577 * port and make sure it's a data packet. Also, make sure the
578 * seq number is 1 (because otherwise it's a continuation packet,
579 * and we can't interpret that). Also, seems that reply packets
580 * do not have the client-init flag set, so we check for that
584 if (rxh->type == RX_PACKET_TYPE_DATA &&
585 EXTRACT_32BITS(&rxh->seq) == 1 &&
586 rxh->flags & RX_CLIENT_INITIATED) {
589 * Insert this call into the call cache table, so we
590 * have a chance to print out replies
593 rx_cache_insert(ndo, bp, (const struct ip *) bp2, dport);
596 case FS_RX_PORT: /* AFS file service */
597 fs_print(ndo, bp, length);
599 case CB_RX_PORT: /* AFS callback service */
600 cb_print(ndo, bp, length);
602 case PROT_RX_PORT: /* AFS protection service */
603 prot_print(ndo, bp, length);
605 case VLDB_RX_PORT: /* AFS VLDB service */
606 vldb_print(ndo, bp, length);
608 case KAUTH_RX_PORT: /* AFS Kerberos auth service */
609 kauth_print(ndo, bp, length);
611 case VOL_RX_PORT: /* AFS Volume service */
612 vol_print(ndo, bp, length);
614 case BOS_RX_PORT: /* AFS BOS service */
615 bos_print(ndo, bp, length);
622 * If it's a reply (client-init is _not_ set, but seq is one)
623 * then look it up in the cache. If we find it, call the reply
624 * printing functions Note that we handle abort packets here,
625 * because printing out the return code can be useful at times.
628 } else if (((rxh->type == RX_PACKET_TYPE_DATA &&
629 EXTRACT_32BITS(&rxh->seq) == 1) ||
630 rxh->type == RX_PACKET_TYPE_ABORT) &&
631 (rxh->flags & RX_CLIENT_INITIATED) == 0 &&
632 rx_cache_find(rxh, (const struct ip *) bp2,
636 case FS_RX_PORT: /* AFS file service */
637 fs_reply_print(ndo, bp, length, opcode);
639 case CB_RX_PORT: /* AFS callback service */
640 cb_reply_print(ndo, bp, length, opcode);
642 case PROT_RX_PORT: /* AFS PT service */
643 prot_reply_print(ndo, bp, length, opcode);
645 case VLDB_RX_PORT: /* AFS VLDB service */
646 vldb_reply_print(ndo, bp, length, opcode);
648 case KAUTH_RX_PORT: /* AFS Kerberos auth service */
649 kauth_reply_print(ndo, bp, length, opcode);
651 case VOL_RX_PORT: /* AFS Volume service */
652 vol_reply_print(ndo, bp, length, opcode);
654 case BOS_RX_PORT: /* AFS BOS service */
655 bos_reply_print(ndo, bp, length, opcode);
662 * If it's an RX ack packet, then use the appropriate ack decoding
663 * function (there isn't any service-specific information in the
664 * ack packet, so we can use one for all AFS services)
667 } else if (rxh->type == RX_PACKET_TYPE_ACK)
668 rx_ack_print(ndo, bp, length);
671 ND_PRINT((ndo, " (%d)", length));
675 * Insert an entry into the cache. Taken from print-nfs.c
679 rx_cache_insert(netdissect_options *ndo,
680 const u_char *bp, const struct ip *ip, int dport)
682 struct rx_cache_entry *rxent;
683 const struct rx_header *rxh = (const struct rx_header *) bp;
685 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
688 rxent = &rx_cache[rx_cache_next];
690 if (++rx_cache_next >= RX_CACHE_SIZE)
693 rxent->callnum = EXTRACT_32BITS(&rxh->callNumber);
694 UNALIGNED_MEMCPY(&rxent->client, &ip->ip_src, sizeof(uint32_t));
695 UNALIGNED_MEMCPY(&rxent->server, &ip->ip_dst, sizeof(uint32_t));
696 rxent->dport = dport;
697 rxent->serviceId = EXTRACT_16BITS(&rxh->serviceId);
698 rxent->opcode = EXTRACT_32BITS(bp + sizeof(struct rx_header));
702 * Lookup an entry in the cache. Also taken from print-nfs.c
704 * Note that because this is a reply, we're looking at the _source_
709 rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
713 struct rx_cache_entry *rxent;
717 UNALIGNED_MEMCPY(&clip, &ip->ip_dst, sizeof(uint32_t));
718 UNALIGNED_MEMCPY(&sip, &ip->ip_src, sizeof(uint32_t));
720 /* Start the search where we last left off */
724 rxent = &rx_cache[i];
725 if (rxent->callnum == EXTRACT_32BITS(&rxh->callNumber) &&
726 rxent->client.s_addr == clip &&
727 rxent->server.s_addr == sip &&
728 rxent->serviceId == EXTRACT_16BITS(&rxh->serviceId) &&
729 rxent->dport == sport) {
731 /* We got a match! */
734 *opcode = rxent->opcode;
737 if (++i >= RX_CACHE_SIZE)
739 } while (i != rx_cache_hint);
741 /* Our search failed */
746 * These extrememly grody macros handle the printing of various AFS stuff.
749 #define FIDOUT() { unsigned long n1, n2, n3; \
750 ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \
751 n1 = EXTRACT_32BITS(bp); \
752 bp += sizeof(int32_t); \
753 n2 = EXTRACT_32BITS(bp); \
754 bp += sizeof(int32_t); \
755 n3 = EXTRACT_32BITS(bp); \
756 bp += sizeof(int32_t); \
757 ND_PRINT((ndo, " fid %d/%d/%d", (int) n1, (int) n2, (int) n3)); \
760 #define STROUT(MAX) { unsigned int _i; \
761 ND_TCHECK2(bp[0], sizeof(int32_t)); \
762 _i = EXTRACT_32BITS(bp); \
765 bp += sizeof(int32_t); \
766 ND_PRINT((ndo, " \"")); \
767 if (fn_printn(ndo, bp, _i, ndo->ndo_snapend)) \
769 ND_PRINT((ndo, "\"")); \
770 bp += ((_i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
773 #define INTOUT() { int _i; \
774 ND_TCHECK2(bp[0], sizeof(int32_t)); \
775 _i = (int) EXTRACT_32BITS(bp); \
776 bp += sizeof(int32_t); \
777 ND_PRINT((ndo, " %d", _i)); \
780 #define UINTOUT() { unsigned long _i; \
781 ND_TCHECK2(bp[0], sizeof(int32_t)); \
782 _i = EXTRACT_32BITS(bp); \
783 bp += sizeof(int32_t); \
784 ND_PRINT((ndo, " %lu", _i)); \
787 #define UINT64OUT() { uint64_t _i; \
788 ND_TCHECK2(bp[0], sizeof(uint64_t)); \
789 _i = EXTRACT_64BITS(bp); \
790 bp += sizeof(uint64_t); \
791 ND_PRINT((ndo, " %" PRIu64, _i)); \
794 #define DATEOUT() { time_t _t; struct tm *tm; char str[256]; \
795 ND_TCHECK2(bp[0], sizeof(int32_t)); \
796 _t = (time_t) EXTRACT_32BITS(bp); \
797 bp += sizeof(int32_t); \
798 tm = localtime(&_t); \
799 strftime(str, 256, "%Y/%m/%d %H:%M:%S", tm); \
800 ND_PRINT((ndo, " %s", str)); \
803 #define STOREATTROUT() { unsigned long mask, _i; \
804 ND_TCHECK2(bp[0], (sizeof(int32_t)*6)); \
805 mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
806 if (mask) ND_PRINT((ndo, " StoreStatus")); \
807 if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \
808 else bp += sizeof(int32_t); \
809 _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
810 if (mask & 2) ND_PRINT((ndo, " owner %lu", _i)); \
811 _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
812 if (mask & 4) ND_PRINT((ndo, " group %lu", _i)); \
813 _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
814 if (mask & 8) ND_PRINT((ndo, " mode %lo", _i & 07777)); \
815 _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
816 if (mask & 16) ND_PRINT((ndo, " segsize %lu", _i)); \
817 /* undocumented in 3.3 docu */ \
818 if (mask & 1024) ND_PRINT((ndo, " fsync")); \
821 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
822 ND_TCHECK2(bp[0], sizeof(int32_t) * 2); \
823 epoch = EXTRACT_32BITS(bp); \
824 bp += sizeof(int32_t); \
825 counter = EXTRACT_32BITS(bp); \
826 bp += sizeof(int32_t); \
827 ND_PRINT((ndo, " %d.%d", epoch, counter)); \
830 #define AFSUUIDOUT() {uint32_t temp; int _i; \
831 ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \
832 temp = EXTRACT_32BITS(bp); \
833 bp += sizeof(uint32_t); \
834 ND_PRINT((ndo, " %08x", temp)); \
835 temp = EXTRACT_32BITS(bp); \
836 bp += sizeof(uint32_t); \
837 ND_PRINT((ndo, "%04x", temp)); \
838 temp = EXTRACT_32BITS(bp); \
839 bp += sizeof(uint32_t); \
840 ND_PRINT((ndo, "%04x", temp)); \
841 for (_i = 0; _i < 8; _i++) { \
842 temp = EXTRACT_32BITS(bp); \
843 bp += sizeof(uint32_t); \
844 ND_PRINT((ndo, "%02x", (unsigned char) temp)); \
849 * This is the sickest one of all
852 #define VECOUT(MAX) { u_char *sp; \
853 u_char s[AFSNAMEMAX]; \
855 if ((MAX) + 1 > sizeof(s)) \
857 ND_TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \
859 for (k = 0; k < (MAX); k++) { \
860 *sp++ = (u_char) EXTRACT_32BITS(bp); \
861 bp += sizeof(int32_t); \
864 ND_PRINT((ndo, " \"")); \
865 fn_print(ndo, s, NULL); \
866 ND_PRINT((ndo, "\"")); \
869 #define DESTSERVEROUT() { unsigned long n1, n2, n3; \
870 ND_TCHECK2(bp[0], sizeof(int32_t) * 3); \
871 n1 = EXTRACT_32BITS(bp); \
872 bp += sizeof(int32_t); \
873 n2 = EXTRACT_32BITS(bp); \
874 bp += sizeof(int32_t); \
875 n3 = EXTRACT_32BITS(bp); \
876 bp += sizeof(int32_t); \
877 ND_PRINT((ndo, " server %d:%d:%d", (int) n1, (int) n2, (int) n3)); \
881 * Handle calls to the AFS file service (fs)
885 fs_print(netdissect_options *ndo,
886 register const u_char *bp, int length)
891 if (length <= (int)sizeof(struct rx_header))
894 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
899 * Print out the afs call we're invoking. The table used here was
900 * gleaned from fsint/afsint.xg
903 fs_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
905 ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%d", fs_op)));
908 * Print out arguments to some of the AFS calls. This stuff is
912 bp += sizeof(struct rx_header) + 4;
915 * Sigh. This is gross. Ritchie forgive me.
919 case 130: /* Fetch data */
921 ND_PRINT((ndo, " offset"));
923 ND_PRINT((ndo, " length"));
926 case 131: /* Fetch ACL */
927 case 132: /* Fetch Status */
928 case 143: /* Old set lock */
929 case 144: /* Old extend lock */
930 case 145: /* Old release lock */
931 case 156: /* Set lock */
932 case 157: /* Extend lock */
933 case 158: /* Release lock */
936 case 135: /* Store status */
940 case 133: /* Store data */
943 ND_PRINT((ndo, " offset"));
945 ND_PRINT((ndo, " length"));
947 ND_PRINT((ndo, " flen"));
950 case 134: /* Store ACL */
952 char a[AFSOPAQUEMAX+1];
954 ND_TCHECK2(bp[0], 4);
955 i = EXTRACT_32BITS(bp);
956 bp += sizeof(int32_t);
957 ND_TCHECK2(bp[0], i);
958 i = min(AFSOPAQUEMAX, i);
959 strncpy(a, (const char *) bp, i);
961 acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i);
964 case 137: /* Create file */
965 case 141: /* MakeDir */
970 case 136: /* Remove file */
971 case 142: /* Remove directory */
975 case 138: /* Rename file */
976 ND_PRINT((ndo, " old"));
979 ND_PRINT((ndo, " new"));
983 case 139: /* Symlink */
986 ND_PRINT((ndo, " link to"));
992 ND_PRINT((ndo, " link to"));
995 case 148: /* Get volume info */
998 case 149: /* Get volume stats */
999 case 150: /* Set volume stats */
1000 ND_PRINT((ndo, " volid"));
1003 case 154: /* New get volume info */
1004 ND_PRINT((ndo, " volname"));
1007 case 155: /* Bulk stat */
1008 case 65536: /* Inline bulk stat */
1011 ND_TCHECK2(bp[0], 4);
1012 j = EXTRACT_32BITS(bp);
1013 bp += sizeof(int32_t);
1015 for (i = 0; i < j; i++) {
1018 ND_PRINT((ndo, ","));
1021 ND_PRINT((ndo, " <none!>"));
1024 case 65537: /* Fetch data 64 */
1026 ND_PRINT((ndo, " offset"));
1028 ND_PRINT((ndo, " length"));
1031 case 65538: /* Store data 64 */
1034 ND_PRINT((ndo, " offset"));
1036 ND_PRINT((ndo, " length"));
1038 ND_PRINT((ndo, " flen"));
1041 case 65541: /* CallBack rx conn address */
1042 ND_PRINT((ndo, " addr"));
1051 ND_PRINT((ndo, " [|fs]"));
1055 * Handle replies to the AFS file service
1059 fs_reply_print(netdissect_options *ndo,
1060 register const u_char *bp, int length, int32_t opcode)
1063 const struct rx_header *rxh;
1065 if (length <= (int)sizeof(struct rx_header))
1068 rxh = (const struct rx_header *) bp;
1071 * Print out the afs call we're invoking. The table used here was
1072 * gleaned from fsint/afsint.xg
1075 ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%d", opcode)));
1077 bp += sizeof(struct rx_header);
1080 * If it was a data packet, interpret the response
1083 if (rxh->type == RX_PACKET_TYPE_DATA) {
1085 case 131: /* Fetch ACL */
1087 char a[AFSOPAQUEMAX+1];
1088 ND_TCHECK2(bp[0], 4);
1089 i = EXTRACT_32BITS(bp);
1090 bp += sizeof(int32_t);
1091 ND_TCHECK2(bp[0], i);
1092 i = min(AFSOPAQUEMAX, i);
1093 strncpy(a, (const char *) bp, i);
1095 acl_print(ndo, (u_char *) a, sizeof(a), (u_char *) a + i);
1098 case 137: /* Create file */
1099 case 141: /* MakeDir */
1100 ND_PRINT((ndo, " new"));
1103 case 151: /* Get root volume */
1104 ND_PRINT((ndo, " root volume"));
1107 case 153: /* Get time */
1113 } else if (rxh->type == RX_PACKET_TYPE_ABORT) {
1115 * Otherwise, just print out the return code
1117 ND_TCHECK2(bp[0], sizeof(int32_t));
1118 i = (int) EXTRACT_32BITS(bp);
1119 bp += sizeof(int32_t);
1121 ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", i)));
1123 ND_PRINT((ndo, " strange fs reply of type %d", rxh->type));
1129 ND_PRINT((ndo, " [|fs]"));
1133 * Print out an AFS ACL string. An AFS ACL is a string that has the
1136 * <positive> <negative>
1140 * "positive" and "negative" are integers which contain the number of
1141 * positive and negative ACL's in the string. The uid/aclbits pair are
1142 * ASCII strings containing the UID/PTS record and and a ascii number
1143 * representing a logical OR of all the ACL permission bits
1147 acl_print(netdissect_options *ndo,
1148 u_char *s, int maxsize, u_char *end)
1155 if ((user = (char *)malloc(maxsize)) == NULL)
1158 if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
1167 * This wacky order preserves the order used by the "fs" command
1170 #define ACLOUT(acl) \
1171 ND_PRINT((ndo, "%s%s%s%s%s%s%s", \
1172 acl & PRSFS_READ ? "r" : "", \
1173 acl & PRSFS_LOOKUP ? "l" : "", \
1174 acl & PRSFS_INSERT ? "i" : "", \
1175 acl & PRSFS_DELETE ? "d" : "", \
1176 acl & PRSFS_WRITE ? "w" : "", \
1177 acl & PRSFS_LOCK ? "k" : "", \
1178 acl & PRSFS_ADMINISTER ? "a" : ""));
1180 for (i = 0; i < pos; i++) {
1181 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
1182 if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
1185 ND_PRINT((ndo, " +{"));
1186 fn_print(ndo, (u_char *)user, NULL);
1187 ND_PRINT((ndo, " "));
1189 ND_PRINT((ndo, "}"));
1194 for (i = 0; i < neg; i++) {
1195 snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
1196 if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
1199 ND_PRINT((ndo, " -{"));
1200 fn_print(ndo, (u_char *)user, NULL);
1201 ND_PRINT((ndo, " "));
1203 ND_PRINT((ndo, "}"));
1216 * Handle calls to the AFS callback service
1220 cb_print(netdissect_options *ndo,
1221 register const u_char *bp, int length)
1226 if (length <= (int)sizeof(struct rx_header))
1229 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1234 * Print out the afs call we're invoking. The table used here was
1235 * gleaned from fsint/afscbint.xg
1238 cb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1240 ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%d", cb_op)));
1242 bp += sizeof(struct rx_header) + 4;
1245 * Print out the afs call we're invoking. The table used here was
1246 * gleaned from fsint/afscbint.xg
1250 case 204: /* Callback */
1253 ND_TCHECK2(bp[0], 4);
1254 j = EXTRACT_32BITS(bp);
1255 bp += sizeof(int32_t);
1257 for (i = 0; i < j; i++) {
1260 ND_PRINT((ndo, ","));
1264 ND_PRINT((ndo, " <none!>"));
1266 ND_TCHECK_32BITS(bp);
1267 j = EXTRACT_32BITS(bp);
1268 bp += sizeof(int32_t);
1271 ND_PRINT((ndo, ";"));
1273 for (i = 0; i < j; i++) {
1274 ND_PRINT((ndo, " ver"));
1276 ND_PRINT((ndo, " expires"));
1278 ND_TCHECK2(bp[0], 4);
1279 t = EXTRACT_32BITS(bp);
1280 bp += sizeof(int32_t);
1281 tok2str(cb_types, "type %d", t);
1286 ND_PRINT((ndo, " afsuuid"));
1297 ND_PRINT((ndo, " [|cb]"));
1301 * Handle replies to the AFS Callback Service
1305 cb_reply_print(netdissect_options *ndo,
1306 register const u_char *bp, int length, int32_t opcode)
1308 const struct rx_header *rxh;
1310 if (length <= (int)sizeof(struct rx_header))
1313 rxh = (const struct rx_header *) bp;
1316 * Print out the afs call we're invoking. The table used here was
1317 * gleaned from fsint/afscbint.xg
1320 ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%d", opcode)));
1322 bp += sizeof(struct rx_header);
1325 * If it was a data packet, interpret the response.
1328 if (rxh->type == RX_PACKET_TYPE_DATA)
1330 case 213: /* InitCallBackState3 */
1338 * Otherwise, just print out the return code
1340 ND_PRINT((ndo, " errcode"));
1347 ND_PRINT((ndo, " [|cb]"));
1351 * Handle calls to the AFS protection database server
1355 prot_print(netdissect_options *ndo,
1356 register const u_char *bp, int length)
1361 if (length <= (int)sizeof(struct rx_header))
1364 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1369 * Print out the afs call we're invoking. The table used here was
1370 * gleaned from ptserver/ptint.xg
1373 pt_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1375 ND_PRINT((ndo, " pt"));
1377 if (is_ubik(pt_op)) {
1378 ubik_print(ndo, bp);
1382 ND_PRINT((ndo, " call %s", tok2str(pt_req, "op#%d", pt_op)));
1385 * Decode some of the arguments to the PT calls
1388 bp += sizeof(struct rx_header) + 4;
1391 case 500: /* I New User */
1393 ND_PRINT((ndo, " id"));
1395 ND_PRINT((ndo, " oldid"));
1398 case 501: /* Where is it */
1399 case 506: /* Delete */
1400 case 508: /* Get CPS */
1401 case 512: /* List entry */
1402 case 514: /* List elements */
1403 case 517: /* List owned */
1404 case 518: /* Get CPS2 */
1405 case 519: /* Get host CPS */
1406 case 530: /* List super groups */
1407 ND_PRINT((ndo, " id"));
1410 case 502: /* Dump entry */
1411 ND_PRINT((ndo, " pos"));
1414 case 503: /* Add to group */
1415 case 507: /* Remove from group */
1416 case 515: /* Is a member of? */
1417 ND_PRINT((ndo, " uid"));
1419 ND_PRINT((ndo, " gid"));
1422 case 504: /* Name to ID */
1425 ND_TCHECK2(bp[0], 4);
1426 j = EXTRACT_32BITS(bp);
1427 bp += sizeof(int32_t);
1430 * Who designed this chicken-shit protocol?
1432 * Each character is stored as a 32-bit
1436 for (i = 0; i < j; i++) {
1440 ND_PRINT((ndo, " <none!>"));
1443 case 505: /* Id to name */
1446 ND_PRINT((ndo, " ids:"));
1447 ND_TCHECK2(bp[0], 4);
1448 i = EXTRACT_32BITS(bp);
1449 bp += sizeof(int32_t);
1450 for (j = 0; j < i; j++)
1453 ND_PRINT((ndo, " <none!>"));
1456 case 509: /* New entry */
1458 ND_PRINT((ndo, " flag"));
1460 ND_PRINT((ndo, " oid"));
1463 case 511: /* Set max */
1464 ND_PRINT((ndo, " id"));
1466 ND_PRINT((ndo, " gflag"));
1469 case 513: /* Change entry */
1470 ND_PRINT((ndo, " id"));
1473 ND_PRINT((ndo, " oldid"));
1475 ND_PRINT((ndo, " newid"));
1478 case 520: /* Update entry */
1479 ND_PRINT((ndo, " id"));
1491 ND_PRINT((ndo, " [|pt]"));
1495 * Handle replies to the AFS protection service
1499 prot_reply_print(netdissect_options *ndo,
1500 register const u_char *bp, int length, int32_t opcode)
1502 const struct rx_header *rxh;
1505 if (length < (int)sizeof(struct rx_header))
1508 rxh = (const struct rx_header *) bp;
1511 * Print out the afs call we're invoking. The table used here was
1512 * gleaned from ptserver/ptint.xg. Check to see if it's a
1513 * Ubik call, however.
1516 ND_PRINT((ndo, " pt"));
1518 if (is_ubik(opcode)) {
1519 ubik_reply_print(ndo, bp, length, opcode);
1523 ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%d", opcode)));
1525 bp += sizeof(struct rx_header);
1528 * If it was a data packet, interpret the response
1531 if (rxh->type == RX_PACKET_TYPE_DATA)
1533 case 504: /* Name to ID */
1536 ND_PRINT((ndo, " ids:"));
1537 ND_TCHECK2(bp[0], 4);
1538 i = EXTRACT_32BITS(bp);
1539 bp += sizeof(int32_t);
1540 for (j = 0; j < i; j++)
1543 ND_PRINT((ndo, " <none!>"));
1546 case 505: /* ID to name */
1549 ND_TCHECK2(bp[0], 4);
1550 j = EXTRACT_32BITS(bp);
1551 bp += sizeof(int32_t);
1554 * Who designed this chicken-shit protocol?
1556 * Each character is stored as a 32-bit
1560 for (i = 0; i < j; i++) {
1564 ND_PRINT((ndo, " <none!>"));
1567 case 508: /* Get CPS */
1568 case 514: /* List elements */
1569 case 517: /* List owned */
1570 case 518: /* Get CPS2 */
1571 case 519: /* Get host CPS */
1574 ND_TCHECK2(bp[0], 4);
1575 j = EXTRACT_32BITS(bp);
1576 bp += sizeof(int32_t);
1577 for (i = 0; i < j; i++) {
1581 ND_PRINT((ndo, " <none!>"));
1584 case 510: /* List max */
1585 ND_PRINT((ndo, " maxuid"));
1587 ND_PRINT((ndo, " maxgid"));
1595 * Otherwise, just print out the return code
1597 ND_PRINT((ndo, " errcode"));
1604 ND_PRINT((ndo, " [|pt]"));
1608 * Handle calls to the AFS volume location database service
1612 vldb_print(netdissect_options *ndo,
1613 register const u_char *bp, int length)
1618 if (length <= (int)sizeof(struct rx_header))
1621 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1626 * Print out the afs call we're invoking. The table used here was
1627 * gleaned from vlserver/vldbint.xg
1630 vldb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1632 ND_PRINT((ndo, " vldb"));
1634 if (is_ubik(vldb_op)) {
1635 ubik_print(ndo, bp);
1638 ND_PRINT((ndo, " call %s", tok2str(vldb_req, "op#%d", vldb_op)));
1641 * Decode some of the arguments to the VLDB calls
1644 bp += sizeof(struct rx_header) + 4;
1647 case 501: /* Create new volume */
1648 case 517: /* Create entry N */
1651 case 502: /* Delete entry */
1652 case 503: /* Get entry by ID */
1653 case 507: /* Update entry */
1654 case 508: /* Set lock */
1655 case 509: /* Release lock */
1656 case 518: /* Get entry by ID N */
1657 ND_PRINT((ndo, " volid"));
1659 ND_TCHECK2(bp[0], sizeof(int32_t));
1660 i = EXTRACT_32BITS(bp);
1661 bp += sizeof(int32_t);
1663 ND_PRINT((ndo, " type %s", voltype[i]));
1665 case 504: /* Get entry by name */
1666 case 519: /* Get entry by name N */
1667 case 524: /* Update entry by name */
1668 case 527: /* Get entry by name U */
1671 case 505: /* Get new vol id */
1672 ND_PRINT((ndo, " bump"));
1675 case 506: /* Replace entry */
1676 case 520: /* Replace entry N */
1677 ND_PRINT((ndo, " volid"));
1679 ND_TCHECK2(bp[0], sizeof(int32_t));
1680 i = EXTRACT_32BITS(bp);
1681 bp += sizeof(int32_t);
1683 ND_PRINT((ndo, " type %s", voltype[i]));
1686 case 510: /* List entry */
1687 case 521: /* List entry N */
1688 ND_PRINT((ndo, " index"));
1698 ND_PRINT((ndo, " [|vldb]"));
1702 * Handle replies to the AFS volume location database service
1706 vldb_reply_print(netdissect_options *ndo,
1707 register const u_char *bp, int length, int32_t opcode)
1709 const struct rx_header *rxh;
1712 if (length < (int)sizeof(struct rx_header))
1715 rxh = (const struct rx_header *) bp;
1718 * Print out the afs call we're invoking. The table used here was
1719 * gleaned from vlserver/vldbint.xg. Check to see if it's a
1720 * Ubik call, however.
1723 ND_PRINT((ndo, " vldb"));
1725 if (is_ubik(opcode)) {
1726 ubik_reply_print(ndo, bp, length, opcode);
1730 ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%d", opcode)));
1732 bp += sizeof(struct rx_header);
1735 * If it was a data packet, interpret the response
1738 if (rxh->type == RX_PACKET_TYPE_DATA)
1740 case 510: /* List entry */
1741 ND_PRINT((ndo, " count"));
1743 ND_PRINT((ndo, " nextindex"));
1746 case 503: /* Get entry by id */
1747 case 504: /* Get entry by name */
1748 { unsigned long nservers, j;
1750 ND_TCHECK2(bp[0], sizeof(int32_t));
1751 bp += sizeof(int32_t);
1752 ND_PRINT((ndo, " numservers"));
1753 ND_TCHECK2(bp[0], sizeof(int32_t));
1754 nservers = EXTRACT_32BITS(bp);
1755 bp += sizeof(int32_t);
1756 ND_PRINT((ndo, " %lu", nservers));
1757 ND_PRINT((ndo, " servers"));
1758 for (i = 0; i < 8; i++) {
1759 ND_TCHECK2(bp[0], sizeof(int32_t));
1761 ND_PRINT((ndo, " %s",
1762 intoa(((const struct in_addr *) bp)->s_addr)));
1763 bp += sizeof(int32_t);
1765 ND_PRINT((ndo, " partitions"));
1766 for (i = 0; i < 8; i++) {
1767 ND_TCHECK2(bp[0], sizeof(int32_t));
1768 j = EXTRACT_32BITS(bp);
1769 if (i < nservers && j <= 26)
1770 ND_PRINT((ndo, " %c", 'a' + (int)j));
1771 else if (i < nservers)
1772 ND_PRINT((ndo, " %lu", j));
1773 bp += sizeof(int32_t);
1775 ND_TCHECK2(bp[0], 8 * sizeof(int32_t));
1776 bp += 8 * sizeof(int32_t);
1777 ND_PRINT((ndo, " rwvol"));
1779 ND_PRINT((ndo, " rovol"));
1781 ND_PRINT((ndo, " backup"));
1785 case 505: /* Get new volume ID */
1786 ND_PRINT((ndo, " newvol"));
1789 case 521: /* List entry */
1790 case 529: /* List entry U */
1791 ND_PRINT((ndo, " count"));
1793 ND_PRINT((ndo, " nextindex"));
1796 case 518: /* Get entry by ID N */
1797 case 519: /* Get entry by name N */
1798 { unsigned long nservers, j;
1800 ND_PRINT((ndo, " numservers"));
1801 ND_TCHECK2(bp[0], sizeof(int32_t));
1802 nservers = EXTRACT_32BITS(bp);
1803 bp += sizeof(int32_t);
1804 ND_PRINT((ndo, " %lu", nservers));
1805 ND_PRINT((ndo, " servers"));
1806 for (i = 0; i < 13; i++) {
1807 ND_TCHECK2(bp[0], sizeof(int32_t));
1809 ND_PRINT((ndo, " %s",
1810 intoa(((const struct in_addr *) bp)->s_addr)));
1811 bp += sizeof(int32_t);
1813 ND_PRINT((ndo, " partitions"));
1814 for (i = 0; i < 13; i++) {
1815 ND_TCHECK2(bp[0], sizeof(int32_t));
1816 j = EXTRACT_32BITS(bp);
1817 if (i < nservers && j <= 26)
1818 ND_PRINT((ndo, " %c", 'a' + (int)j));
1819 else if (i < nservers)
1820 ND_PRINT((ndo, " %lu", j));
1821 bp += sizeof(int32_t);
1823 ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
1824 bp += 13 * sizeof(int32_t);
1825 ND_PRINT((ndo, " rwvol"));
1827 ND_PRINT((ndo, " rovol"));
1829 ND_PRINT((ndo, " backup"));
1833 case 526: /* Get entry by ID U */
1834 case 527: /* Get entry by name U */
1835 { unsigned long nservers, j;
1837 ND_PRINT((ndo, " numservers"));
1838 ND_TCHECK2(bp[0], sizeof(int32_t));
1839 nservers = EXTRACT_32BITS(bp);
1840 bp += sizeof(int32_t);
1841 ND_PRINT((ndo, " %lu", nservers));
1842 ND_PRINT((ndo, " servers"));
1843 for (i = 0; i < 13; i++) {
1845 ND_PRINT((ndo, " afsuuid"));
1848 ND_TCHECK2(bp[0], 44);
1852 ND_TCHECK2(bp[0], 4 * 13);
1854 ND_PRINT((ndo, " partitions"));
1855 for (i = 0; i < 13; i++) {
1856 ND_TCHECK2(bp[0], sizeof(int32_t));
1857 j = EXTRACT_32BITS(bp);
1858 if (i < nservers && j <= 26)
1859 ND_PRINT((ndo, " %c", 'a' + (int)j));
1860 else if (i < nservers)
1861 ND_PRINT((ndo, " %lu", j));
1862 bp += sizeof(int32_t);
1864 ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
1865 bp += 13 * sizeof(int32_t);
1866 ND_PRINT((ndo, " rwvol"));
1868 ND_PRINT((ndo, " rovol"));
1870 ND_PRINT((ndo, " backup"));
1879 * Otherwise, just print out the return code
1881 ND_PRINT((ndo, " errcode"));
1888 ND_PRINT((ndo, " [|vldb]"));
1892 * Handle calls to the AFS Kerberos Authentication service
1896 kauth_print(netdissect_options *ndo,
1897 register const u_char *bp, int length)
1901 if (length <= (int)sizeof(struct rx_header))
1904 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
1909 * Print out the afs call we're invoking. The table used here was
1910 * gleaned from kauth/kauth.rg
1913 kauth_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
1915 ND_PRINT((ndo, " kauth"));
1917 if (is_ubik(kauth_op)) {
1918 ubik_print(ndo, bp);
1923 ND_PRINT((ndo, " call %s", tok2str(kauth_req, "op#%d", kauth_op)));
1926 * Decode some of the arguments to the KA calls
1929 bp += sizeof(struct rx_header) + 4;
1932 case 1: /* Authenticate old */
1933 case 21: /* Authenticate */
1934 case 22: /* Authenticate-V2 */
1935 case 2: /* Change PW */
1936 case 5: /* Set fields */
1937 case 6: /* Create user */
1938 case 7: /* Delete user */
1939 case 8: /* Get entry */
1940 case 14: /* Unlock */
1941 case 15: /* Lock status */
1942 ND_PRINT((ndo, " principal"));
1946 case 3: /* GetTicket-old */
1947 case 23: /* GetTicket */
1950 ND_PRINT((ndo, " kvno"));
1952 ND_PRINT((ndo, " domain"));
1954 ND_TCHECK2(bp[0], sizeof(int32_t));
1955 i = (int) EXTRACT_32BITS(bp);
1956 bp += sizeof(int32_t);
1957 ND_TCHECK2(bp[0], i);
1959 ND_PRINT((ndo, " principal"));
1964 case 4: /* Set Password */
1965 ND_PRINT((ndo, " principal"));
1968 ND_PRINT((ndo, " kvno"));
1971 case 12: /* Get password */
1972 ND_PRINT((ndo, " name"));
1982 ND_PRINT((ndo, " [|kauth]"));
1986 * Handle replies to the AFS Kerberos Authentication Service
1990 kauth_reply_print(netdissect_options *ndo,
1991 register const u_char *bp, int length, int32_t opcode)
1993 const struct rx_header *rxh;
1995 if (length <= (int)sizeof(struct rx_header))
1998 rxh = (const struct rx_header *) bp;
2001 * Print out the afs call we're invoking. The table used here was
2002 * gleaned from kauth/kauth.rg
2005 ND_PRINT((ndo, " kauth"));
2007 if (is_ubik(opcode)) {
2008 ubik_reply_print(ndo, bp, length, opcode);
2012 ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%d", opcode)));
2014 bp += sizeof(struct rx_header);
2017 * If it was a data packet, interpret the response.
2020 if (rxh->type == RX_PACKET_TYPE_DATA)
2021 /* Well, no, not really. Leave this for later */
2025 * Otherwise, just print out the return code
2027 ND_PRINT((ndo, " errcode"));
2034 ND_PRINT((ndo, " [|kauth]"));
2038 * Handle calls to the AFS Volume location service
2042 vol_print(netdissect_options *ndo,
2043 register const u_char *bp, int length)
2047 if (length <= (int)sizeof(struct rx_header))
2050 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
2055 * Print out the afs call we're invoking. The table used here was
2056 * gleaned from volser/volint.xg
2059 vol_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
2061 ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%d", vol_op)));
2063 bp += sizeof(struct rx_header) + 4;
2066 case 100: /* Create volume */
2067 ND_PRINT((ndo, " partition"));
2069 ND_PRINT((ndo, " name"));
2071 ND_PRINT((ndo, " type"));
2073 ND_PRINT((ndo, " parent"));
2076 case 101: /* Delete volume */
2077 case 107: /* Get flags */
2078 ND_PRINT((ndo, " trans"));
2081 case 102: /* Restore */
2082 ND_PRINT((ndo, " totrans"));
2084 ND_PRINT((ndo, " flags"));
2087 case 103: /* Forward */
2088 ND_PRINT((ndo, " fromtrans"));
2090 ND_PRINT((ndo, " fromdate"));
2093 ND_PRINT((ndo, " desttrans"));
2096 case 104: /* End trans */
2097 ND_PRINT((ndo, " trans"));
2100 case 105: /* Clone */
2101 ND_PRINT((ndo, " trans"));
2103 ND_PRINT((ndo, " purgevol"));
2105 ND_PRINT((ndo, " newtype"));
2107 ND_PRINT((ndo, " newname"));
2110 case 106: /* Set flags */
2111 ND_PRINT((ndo, " trans"));
2113 ND_PRINT((ndo, " flags"));
2116 case 108: /* Trans create */
2117 ND_PRINT((ndo, " vol"));
2119 ND_PRINT((ndo, " partition"));
2121 ND_PRINT((ndo, " flags"));
2124 case 109: /* Dump */
2125 case 655537: /* Get size */
2126 ND_PRINT((ndo, " fromtrans"));
2128 ND_PRINT((ndo, " fromdate"));
2131 case 110: /* Get n-th volume */
2132 ND_PRINT((ndo, " index"));
2135 case 111: /* Set forwarding */
2136 ND_PRINT((ndo, " tid"));
2138 ND_PRINT((ndo, " newsite"));
2141 case 112: /* Get name */
2142 case 113: /* Get status */
2143 ND_PRINT((ndo, " tid"));
2145 case 114: /* Signal restore */
2146 ND_PRINT((ndo, " name"));
2148 ND_PRINT((ndo, " type"));
2150 ND_PRINT((ndo, " pid"));
2152 ND_PRINT((ndo, " cloneid"));
2155 case 116: /* List volumes */
2156 ND_PRINT((ndo, " partition"));
2158 ND_PRINT((ndo, " flags"));
2161 case 117: /* Set id types */
2162 ND_PRINT((ndo, " tid"));
2164 ND_PRINT((ndo, " name"));
2166 ND_PRINT((ndo, " type"));
2168 ND_PRINT((ndo, " pid"));
2170 ND_PRINT((ndo, " clone"));
2172 ND_PRINT((ndo, " backup"));
2175 case 119: /* Partition info */
2176 ND_PRINT((ndo, " name"));
2179 case 120: /* Reclone */
2180 ND_PRINT((ndo, " tid"));
2183 case 121: /* List one volume */
2184 case 122: /* Nuke volume */
2185 case 124: /* Extended List volumes */
2186 case 125: /* Extended List one volume */
2187 case 65536: /* Convert RO to RW volume */
2188 ND_PRINT((ndo, " partid"));
2190 ND_PRINT((ndo, " volid"));
2193 case 123: /* Set date */
2194 ND_PRINT((ndo, " tid"));
2196 ND_PRINT((ndo, " date"));
2199 case 126: /* Set info */
2200 ND_PRINT((ndo, " tid"));
2203 case 128: /* Forward multiple */
2204 ND_PRINT((ndo, " fromtrans"));
2206 ND_PRINT((ndo, " fromdate"));
2210 ND_TCHECK2(bp[0], 4);
2211 j = EXTRACT_32BITS(bp);
2212 bp += sizeof(int32_t);
2213 for (i = 0; i < j; i++) {
2216 ND_PRINT((ndo, ","));
2219 ND_PRINT((ndo, " <none!>"));
2222 case 65538: /* Dump version 2 */
2223 ND_PRINT((ndo, " fromtrans"));
2225 ND_PRINT((ndo, " fromdate"));
2227 ND_PRINT((ndo, " flags"));
2236 ND_PRINT((ndo, " [|vol]"));
2240 * Handle replies to the AFS Volume Service
2244 vol_reply_print(netdissect_options *ndo,
2245 register const u_char *bp, int length, int32_t opcode)
2247 const struct rx_header *rxh;
2249 if (length <= (int)sizeof(struct rx_header))
2252 rxh = (const struct rx_header *) bp;
2255 * Print out the afs call we're invoking. The table used here was
2256 * gleaned from volser/volint.xg
2259 ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%d", opcode)));
2261 bp += sizeof(struct rx_header);
2264 * If it was a data packet, interpret the response.
2267 if (rxh->type == RX_PACKET_TYPE_DATA) {
2269 case 100: /* Create volume */
2270 ND_PRINT((ndo, " volid"));
2272 ND_PRINT((ndo, " trans"));
2275 case 104: /* End transaction */
2278 case 105: /* Clone */
2279 ND_PRINT((ndo, " newvol"));
2282 case 107: /* Get flags */
2285 case 108: /* Transaction create */
2286 ND_PRINT((ndo, " trans"));
2289 case 110: /* Get n-th volume */
2290 ND_PRINT((ndo, " volume"));
2292 ND_PRINT((ndo, " partition"));
2295 case 112: /* Get name */
2298 case 113: /* Get status */
2299 ND_PRINT((ndo, " volid"));
2301 ND_PRINT((ndo, " nextuniq"));
2303 ND_PRINT((ndo, " type"));
2305 ND_PRINT((ndo, " parentid"));
2307 ND_PRINT((ndo, " clone"));
2309 ND_PRINT((ndo, " backup"));
2311 ND_PRINT((ndo, " restore"));
2313 ND_PRINT((ndo, " maxquota"));
2315 ND_PRINT((ndo, " minquota"));
2317 ND_PRINT((ndo, " owner"));
2319 ND_PRINT((ndo, " create"));
2321 ND_PRINT((ndo, " access"));
2323 ND_PRINT((ndo, " update"));
2325 ND_PRINT((ndo, " expire"));
2327 ND_PRINT((ndo, " backup"));
2329 ND_PRINT((ndo, " copy"));
2332 case 115: /* Old list partitions */
2334 case 116: /* List volumes */
2335 case 121: /* List one volume */
2338 ND_TCHECK2(bp[0], 4);
2339 j = EXTRACT_32BITS(bp);
2340 bp += sizeof(int32_t);
2341 for (i = 0; i < j; i++) {
2342 ND_PRINT((ndo, " name"));
2344 ND_PRINT((ndo, " volid"));
2346 ND_PRINT((ndo, " type"));
2347 bp += sizeof(int32_t) * 21;
2349 ND_PRINT((ndo, ","));
2352 ND_PRINT((ndo, " <none!>"));
2362 * Otherwise, just print out the return code
2364 ND_PRINT((ndo, " errcode"));
2371 ND_PRINT((ndo, " [|vol]"));
2375 * Handle calls to the AFS BOS service
2379 bos_print(netdissect_options *ndo,
2380 register const u_char *bp, int length)
2384 if (length <= (int)sizeof(struct rx_header))
2387 if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
2392 * Print out the afs call we're invoking. The table used here was
2393 * gleaned from bozo/bosint.xg
2396 bos_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
2398 ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%d", bos_op)));
2401 * Decode some of the arguments to the BOS calls
2404 bp += sizeof(struct rx_header) + 4;
2407 case 80: /* Create B node */
2408 ND_PRINT((ndo, " type"));
2410 ND_PRINT((ndo, " instance"));
2413 case 81: /* Delete B node */
2414 case 83: /* Get status */
2415 case 85: /* Get instance info */
2416 case 87: /* Add super user */
2417 case 88: /* Delete super user */
2418 case 93: /* Set cell name */
2419 case 96: /* Add cell host */
2420 case 97: /* Delete cell host */
2421 case 104: /* Restart */
2422 case 106: /* Uninstall */
2423 case 108: /* Exec */
2424 case 112: /* Getlog */
2425 case 114: /* Get instance strings */
2428 case 82: /* Set status */
2429 case 98: /* Set T status */
2431 ND_PRINT((ndo, " status"));
2434 case 86: /* Get instance parm */
2436 ND_PRINT((ndo, " num"));
2439 case 84: /* Enumerate instance */
2440 case 89: /* List super users */
2441 case 90: /* List keys */
2442 case 91: /* Add key */
2443 case 92: /* Delete key */
2444 case 95: /* Get cell host */
2447 case 105: /* Install */
2449 ND_PRINT((ndo, " size"));
2451 ND_PRINT((ndo, " flags"));
2453 ND_PRINT((ndo, " date"));
2463 ND_PRINT((ndo, " [|bos]"));
2467 * Handle replies to the AFS BOS Service
2471 bos_reply_print(netdissect_options *ndo,
2472 register const u_char *bp, int length, int32_t opcode)
2474 const struct rx_header *rxh;
2476 if (length <= (int)sizeof(struct rx_header))
2479 rxh = (const struct rx_header *) bp;
2482 * Print out the afs call we're invoking. The table used here was
2483 * gleaned from volser/volint.xg
2486 ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%d", opcode)));
2488 bp += sizeof(struct rx_header);
2491 * If it was a data packet, interpret the response.
2494 if (rxh->type == RX_PACKET_TYPE_DATA)
2495 /* Well, no, not really. Leave this for later */
2499 * Otherwise, just print out the return code
2501 ND_PRINT((ndo, " errcode"));
2508 ND_PRINT((ndo, " [|bos]"));
2512 * Check to see if this is a Ubik opcode.
2516 is_ubik(uint32_t opcode)
2518 if ((opcode >= VOTE_LOW && opcode <= VOTE_HIGH) ||
2519 (opcode >= DISK_LOW && opcode <= DISK_HIGH))
2526 * Handle Ubik opcodes to any one of the replicated database services
2530 ubik_print(netdissect_options *ndo,
2531 register const u_char *bp)
2537 * Print out the afs call we're invoking. The table used here was
2538 * gleaned from ubik/ubik_int.xg
2541 /* Every function that calls this function first makes a bounds check
2542 * for (sizeof(rx_header) + 4) bytes, so long as it remains this way
2543 * the line below will not over-read.
2545 ubik_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
2547 ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%d", ubik_op)));
2550 * Decode some of the arguments to the Ubik calls
2553 bp += sizeof(struct rx_header) + 4;
2556 case 10000: /* Beacon */
2557 ND_TCHECK2(bp[0], 4);
2558 temp = EXTRACT_32BITS(bp);
2559 bp += sizeof(int32_t);
2560 ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
2561 ND_PRINT((ndo, " votestart"));
2563 ND_PRINT((ndo, " dbversion"));
2565 ND_PRINT((ndo, " tid"));
2568 case 10003: /* Get sync site */
2569 ND_PRINT((ndo, " site"));
2572 case 20000: /* Begin */
2573 case 20001: /* Commit */
2574 case 20007: /* Abort */
2575 case 20008: /* Release locks */
2576 case 20010: /* Writev */
2577 ND_PRINT((ndo, " tid"));
2580 case 20002: /* Lock */
2581 ND_PRINT((ndo, " tid"));
2583 ND_PRINT((ndo, " file"));
2585 ND_PRINT((ndo, " pos"));
2587 ND_PRINT((ndo, " length"));
2589 ND_TCHECK_32BITS(bp);
2590 temp = EXTRACT_32BITS(bp);
2591 bp += sizeof(int32_t);
2592 tok2str(ubik_lock_types, "type %d", temp);
2594 case 20003: /* Write */
2595 ND_PRINT((ndo, " tid"));
2597 ND_PRINT((ndo, " file"));
2599 ND_PRINT((ndo, " pos"));
2602 case 20005: /* Get file */
2603 ND_PRINT((ndo, " file"));
2606 case 20006: /* Send file */
2607 ND_PRINT((ndo, " file"));
2609 ND_PRINT((ndo, " length"));
2611 ND_PRINT((ndo, " dbversion"));
2614 case 20009: /* Truncate */
2615 ND_PRINT((ndo, " tid"));
2617 ND_PRINT((ndo, " file"));
2619 ND_PRINT((ndo, " length"));
2622 case 20012: /* Set version */
2623 ND_PRINT((ndo, " tid"));
2625 ND_PRINT((ndo, " oldversion"));
2627 ND_PRINT((ndo, " newversion"));
2637 ND_PRINT((ndo, " [|ubik]"));
2641 * Handle Ubik replies to any one of the replicated database services
2645 ubik_reply_print(netdissect_options *ndo,
2646 register const u_char *bp, int length, int32_t opcode)
2648 const struct rx_header *rxh;
2650 if (length < (int)sizeof(struct rx_header))
2653 rxh = (const struct rx_header *) bp;
2656 * Print out the ubik call we're invoking. This table was gleaned
2657 * from ubik/ubik_int.xg
2660 ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%d", opcode)));
2662 bp += sizeof(struct rx_header);
2665 * If it was a data packet, print out the arguments to the Ubik calls
2668 if (rxh->type == RX_PACKET_TYPE_DATA)
2670 case 10000: /* Beacon */
2671 ND_PRINT((ndo, " vote no"));
2673 case 20004: /* Get version */
2674 ND_PRINT((ndo, " dbversion"));
2682 * Otherwise, print out "yes" it it was a beacon packet (because
2683 * that's how yes votes are returned, go figure), otherwise
2684 * just print out the error code.
2689 case 10000: /* Beacon */
2690 ND_PRINT((ndo, " vote yes until"));
2694 ND_PRINT((ndo, " errcode"));
2701 ND_PRINT((ndo, " [|ubik]"));
2705 * Handle RX ACK packets.
2709 rx_ack_print(netdissect_options *ndo,
2710 register const u_char *bp, int length)
2712 const struct rx_ackPacket *rxa;
2714 uint32_t firstPacket;
2716 if (length < (int)sizeof(struct rx_header))
2719 bp += sizeof(struct rx_header);
2722 * This may seem a little odd .... the rx_ackPacket structure
2723 * contains an array of individual packet acknowledgements
2724 * (used for selective ack/nack), but since it's variable in size,
2725 * we don't want to truncate based on the size of the whole
2726 * rx_ackPacket structure.
2729 ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);
2731 rxa = (const struct rx_ackPacket *) bp;
2732 bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
2735 * Print out a few useful things from the ack packet structure
2738 if (ndo->ndo_vflag > 2)
2739 ND_PRINT((ndo, " bufspace %d maxskew %d",
2740 (int) EXTRACT_16BITS(&rxa->bufferSpace),
2741 (int) EXTRACT_16BITS(&rxa->maxSkew)));
2743 firstPacket = EXTRACT_32BITS(&rxa->firstPacket);
2744 ND_PRINT((ndo, " first %d serial %d reason %s",
2745 firstPacket, EXTRACT_32BITS(&rxa->serial),
2746 tok2str(rx_ack_reasons, "#%d", (int) rxa->reason)));
2749 * Okay, now we print out the ack array. The way _this_ works
2750 * is that we start at "first", and step through the ack array.
2751 * If we have a contiguous range of acks/nacks, try to
2752 * collapse them into a range.
2754 * If you're really clever, you might have noticed that this
2755 * doesn't seem quite correct. Specifically, due to structure
2756 * padding, sizeof(struct rx_ackPacket) - RX_MAXACKS won't actually
2757 * yield the start of the ack array (because RX_MAXACKS is 255
2758 * and the structure will likely get padded to a 2 or 4 byte
2759 * boundary). However, this is the way it's implemented inside
2760 * of AFS - the start of the extra fields are at
2761 * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_
2762 * the exact start of the ack array. Sigh. That's why we aren't
2763 * using bp, but instead use rxa->acks[]. But nAcks gets added
2764 * to bp after this, so bp ends up at the right spot. Go figure.
2767 if (rxa->nAcks != 0) {
2769 ND_TCHECK2(bp[0], rxa->nAcks);
2772 * Sigh, this is gross, but it seems to work to collapse
2776 for (i = 0, start = last = -2; i < rxa->nAcks; i++)
2777 if (rxa->acks[i] == RX_ACK_TYPE_ACK) {
2780 * I figured this deserved _some_ explanation.
2781 * First, print "acked" and the packet seq
2782 * number if this is the first time we've
2783 * seen an acked packet.
2787 ND_PRINT((ndo, " acked %d", firstPacket + i));
2792 * Otherwise, if there is a skip in
2793 * the range (such as an nacked packet in
2794 * the middle of some acked packets),
2795 * then print the current packet number
2796 * seperated from the last number by
2800 else if (last != i - 1) {
2801 ND_PRINT((ndo, ",%d", firstPacket + i));
2806 * We always set last to the value of
2807 * the last ack we saw. Conversely, start
2808 * is set to the value of the first ack
2809 * we saw in a range.
2815 * Okay, this bit a code gets executed when
2816 * we hit a nack ... in _this_ case we
2817 * want to print out the range of packets
2818 * that were acked, so we need to print
2819 * the _previous_ packet number seperated
2820 * from the first by a dash (-). Since we
2821 * already printed the first packet above,
2822 * just print the final packet. Don't
2823 * do this if there will be a single-length
2826 } else if (last == i - 1 && start != last)
2827 ND_PRINT((ndo, "-%d", firstPacket + i - 1));
2830 * So, what's going on here? We ran off the end of the
2831 * ack list, and if we got a range we need to finish it up.
2832 * So we need to determine if the last packet in the list
2833 * was an ack (if so, then last will be set to it) and
2834 * we need to see if the last range didn't start with the
2835 * last packet (because if it _did_, then that would mean
2836 * that the packet number has already been printed and
2837 * we don't need to print it again).
2840 if (last == i - 1 && start != last)
2841 ND_PRINT((ndo, "-%d", firstPacket + i - 1));
2844 * Same as above, just without comments
2847 for (i = 0, start = last = -2; i < rxa->nAcks; i++)
2848 if (rxa->acks[i] == RX_ACK_TYPE_NACK) {
2850 ND_PRINT((ndo, " nacked %d", firstPacket + i));
2852 } else if (last != i - 1) {
2853 ND_PRINT((ndo, ",%d", firstPacket + i));
2857 } else if (last == i - 1 && start != last)
2858 ND_PRINT((ndo, "-%d", firstPacket + i - 1));
2860 if (last == i - 1 && start != last)
2861 ND_PRINT((ndo, "-%d", firstPacket + i - 1));
2868 * These are optional fields; depending on your version of AFS,
2869 * you may or may not see them
2872 #define TRUNCRET(n) if (ndo->ndo_snapend - bp + 1 <= n) return;
2874 if (ndo->ndo_vflag > 1) {
2876 ND_PRINT((ndo, " ifmtu"));
2880 ND_PRINT((ndo, " maxmtu"));
2884 ND_PRINT((ndo, " rwind"));
2888 ND_PRINT((ndo, " maxpackets"));
2895 ND_PRINT((ndo, " [|ack]"));