contrib/tcpdump/print-rx.c

   1 /*
   2  * Copyright: (c) 2000 United States Government as represented by the
   3  *      Secretary of the Navy. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *   2. Redistributions in binary form must reproduce the above copyright
  12  *      notice, this list of conditions and the following disclaimer in
  13  *      the documentation and/or other materials provided with the
  14  *      distribution.
  15  *   3. The names of the authors may not be used to endorse or promote
  16  *      products derived from this software without specific prior
  17  *      written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22  */
  23 /*
  24  * This code unmangles RX packets.  RX is the mutant form of RPC that AFS
  25  * uses to communicate between clients and servers.
  26  *
  27  * In this code, I mainly concern myself with decoding the AFS calls, not
  28  * with the guts of RX, per se.
  29  *
  30  * Bah.  If I never look at rx_packet.h again, it will be too soon.
  31  *
  32  * Ken Hornstein <kenh@cmf.nrl.navy.mil>
  33  */
  34
  35 #ifndef lint
  36 static 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
  63 static 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
  77 static 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
  91 static 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
 130 static 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
 149 static 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
 175 static 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
 213 static 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
 235 static 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
 268 static 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
 309 static 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
 338 static struct tok cb_types[] = {
 339         { 1,            "exclusive" },
 340         { 2,            "shared" },
 341         { 3,            "dropped" },
 342         { 0,            NULL },
 343 };
 344
 345 static struct tok ubik_lock_types[] = {
 346         { 1,            "read" },
 347         { 2,            "write" },
 348         { 3,            "wait" },
 349         { 0,            NULL },
 350 };
 351
 352 static char *voltype[] = { "read-write", "read-only", "backup" };
 353
 354 static 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
 375 static 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
 392 struct 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
 403 static struct rx_cache_entry    rx_cache[RX_CACHE_SIZE];
 404
 405 static int      rx_cache_next = 0;
 406 static int      rx_cache_hint = 0;
 407 static void     rx_cache_insert(const u_char *, const struct ip *, int, int);
 408 static int      rx_cache_find(const struct rx_header *, const struct ip *,
 409                               int, int32_t *);
 410
 411 static void ack_print(const u_char *, int);
 412 static void fs_print(const u_char *, int);
 413 static void fs_reply_print(const u_char *, int, int32_t);
 414 static void acl_print(u_char *, int, u_char *);
 415 static void cb_print(const u_char *, int);
 416 static void cb_reply_print(const u_char *, int, int32_t);
 417 static void prot_print(const u_char *, int);
 418 static void prot_reply_print(const u_char *, int, int32_t);
 419 static void vldb_print(const u_char *, int);
 420 static void vldb_reply_print(const u_char *, int, int32_t);
 421 static void kauth_print(const u_char *, int);
 422 static void kauth_reply_print(const u_char *, int, int32_t);
 423 static void vol_print(const u_char *, int);
 424 static void vol_reply_print(const u_char *, int, int32_t);
 425 static void bos_print(const u_char *, int);
 426 static void bos_reply_print(const u_char *, int, int32_t);
 427 static void ubik_print(const u_char *, int);
 428 static void ubik_reply_print(const u_char *, int, int32_t);
 429
 430 static void rx_ack_print(const u_char *, int);
 431
 432 static 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
 439 void
 440 rx_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
 594 static void
 595 rx_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
 624 static int
 625 rx_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
 775 static void
 776 ack_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
 840 trunc:
 841         printf(" [|ack]");
 842 }
 843
 844 /*
 845  * Handle calls to the AFS file service (fs)
 846  */
 847
 848 static void
 849 fs_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
 991 trunc:
 992         printf(" [|fs]");
 993 }
 994
 995 /*
 996  * Handle replies to the AFS file service
 997  */
 998
 999 static void
1000 fs_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
1070 trunc:
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
1088 static void
1089 acl_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
1152 finish:
1153         free(user);
1154         return;
1155 }
1156
1157 #undef ACLOUT
1158
1159 /*
1160  * Handle calls to the AFS callback service
1161  */
1162
1163 static void
1164 cb_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
1237 trunc:
1238         printf(" [|cb]");
1239 }
1240
1241 /*
1242  * Handle replies to the AFS Callback Service
1243  */
1244
1245 static void
1246 cb_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
1286 trunc:
1287         printf(" [|cb]");
1288 }
1289
1290 /*
1291  * Handle calls to the AFS protection database server
1292  */
1293
1294 static void
1295 prot_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
1428 trunc:
1429         printf(" [|pt]");
1430 }
1431
1432 /*
1433  * Handle replies to the AFS protection service
1434  */
1435
1436 static void
1437 prot_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
1540 trunc:
1541         printf(" [|pt]");
1542 }
1543
1544 /*
1545  * Handle calls to the AFS volume location database service
1546  */
1547
1548 static void
1549 vldb_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
1633 trunc:
1634         printf(" [|vldb]");
1635 }
1636
1637 /*
1638  * Handle replies to the AFS volume location database service
1639  */
1640
1641 static void
1642 vldb_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
1820 trunc:
1821         printf(" [|vldb]");
1822 }
1823
1824 /*
1825  * Handle calls to the AFS Kerberos Authentication service
1826  */
1827
1828 static void
1829 kauth_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
1913 trunc:
1914         printf(" [|kauth]");
1915 }
1916
1917 /*
1918  * Handle replies to the AFS Kerberos Authentication Service
1919  */
1920
1921 static void
1922 kauth_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
1964 trunc:
1965         printf(" [|kauth]");
1966 }
1967
1968 /*
1969  * Handle calls to the AFS Volume location service
1970  */
1971
1972 static void
1973 vol_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
2002 trunc:
2003         printf(" [|vol]");
2004 }
2005
2006 /*
2007  * Handle replies to the AFS Volume Service
2008  */
2009
2010 static void
2011 vol_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
2046 trunc:
2047         printf(" [|vol]");
2048 }
2049
2050 /*
2051  * Handle calls to the AFS BOS service
2052  */
2053
2054 static void
2055 bos_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
2137 trunc:
2138         printf(" [|bos]");
2139 }
2140
2141 /*
2142  * Handle replies to the AFS BOS Service
2143  */
2144
2145 static void
2146 bos_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
2181 trunc:
2182         printf(" [|bos]");
2183 }
2184
2185 /*
2186  * Check to see if this is a Ubik opcode.
2187  */
2188
2189 static int
2190 is_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
2203 static void
2204 ubik_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
2304 trunc:
2305         printf(" [|ubik]");
2306 }
2307
2308 /*
2309  * Handle Ubik replies to any one of the replicated database services
2310  */
2311
2312 static void
2313 ubik_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
2367 trunc:
2368         printf(" [|ubik]");
2369 }
2370
2371 /*
2372  * Handle RX ACK packets.
2373  */
2374
2375 static void
2376 rx_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
2560 trunc:
2561         printf(" [|ack]");
2562 }
2563 #undef TRUNCRET