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