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