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