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