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