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