]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-rx.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Address Michael's comments.
[tcpdump] / print-rx.c
diff --git a/print-rx.c b/print-rx.c
index 6e5c2bd90f831f03eb1055e72f860f7e8f2660fb..70393ea5cbbe2c290971d012a349d81f74edde1d 100644 (file)
--- a/print-rx.c
+++ b/print-rx.c
@@ -1,3 +1,25 @@
+/*
+ * Copyright: (c) 2000 United States Government as represented by the
+ *     Secretary of the Navy. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in
+ *      the documentation and/or other materials provided with the
+ *      distribution.
+ *   3. The names of the authors may not be used to endorse or promote
+ *      products derived from this software without specific prior
+ *      written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
 /*
  * This code unmangles RX packets.  RX is the mutant form of RPC that AFS
  * uses to communicate between clients and servers.
 /*
  * This code unmangles RX packets.  RX is the mutant form of RPC that AFS
  * uses to communicate between clients and servers.
@@ -8,12 +30,11 @@
  * Bah.  If I never look at rx_packet.h again, it will be too soon.
  *
  * Ken Hornstein <[email protected]>
  * Bah.  If I never look at rx_packet.h again, it will be too soon.
  *
  * Ken Hornstein <[email protected]>
- *
  */
 
 #ifndef lint
  */
 
 #ifndef lint
-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-rx.c,v 1.12 2000-07-10 04:38:25 assar Exp $";
+static const char rcsid[] _U_ =
+    "@(#) $Header: /tcpdump/master/tcpdump/print-rx.c,v 1.42 2008-07-01 07:44:50 guy Exp $";
 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H
@@ -21,26 +42,18 @@ static const char rcsid[] =
 #endif
 
 #include <stdio.h>
 #endif
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <string.h>
-#include <time.h>
-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <arpa/inet.h>
+#include <tcpdump-stdinc.h>
 
 #include "interface.h"
 #include "addrtoname.h"
 #include "extract.h"
 
 
 #include "interface.h"
 #include "addrtoname.h"
 #include "extract.h"
 
-#undef NOERROR                                 /* Solaris sucks */
-#include <arpa/nameser.h>
-
 #include "rx.h"
 
 #include "rx.h"
 
+#include "ip.h"
+
 static struct tok rx_types[] = {
        { RX_PACKET_TYPE_DATA,          "data" },
        { RX_PACKET_TYPE_ACK,           "ack" },
 static struct tok rx_types[] = {
        { RX_PACKET_TYPE_DATA,          "data" },
        { RX_PACKET_TYPE_ACK,           "ack" },
@@ -55,12 +68,18 @@ static struct tok rx_types[] = {
        { 0,                            NULL },
 };
 
        { 0,                            NULL },
 };
 
-static struct tok rx_flags[] = {
-       { RX_CLIENT_INITIATED,  "client-init" },
-       { RX_REQUEST_ACK,       "req-ack" },
-       { RX_LAST_PACKET,       "last-pckt" },
-       { RX_MORE_PACKETS,      "more-pckts" },
-       { RX_FREE_PACKET,       "free-pckt" }
+static struct double_tok {
+       int flag;               /* Rx flag */
+       int packetType;         /* Packet type */
+       const char *s;          /* Flag string */
+} rx_flags[] = {
+       { RX_CLIENT_INITIATED,  0,                      "client-init" },
+       { RX_REQUEST_ACK,       0,                      "req-ack" },
+       { RX_LAST_PACKET,       0,                      "last-pckt" },
+       { RX_MORE_PACKETS,      0,                      "more-pckts" },
+       { RX_FREE_PACKET,       0,                      "free-pckt" },
+       { RX_SLOW_START_OK,     RX_PACKET_TYPE_ACK,     "slow-start" },
+       { RX_JUMBO_PACKET,      RX_PACKET_TYPE_DATA,    "jumbogram" }
 };
 
 static struct tok fs_req[] = {
 };
 
 static struct tok fs_req[] = {
@@ -98,6 +117,13 @@ static struct tok fs_req[] = {
        { 161,          "dfs-lookup" },
        { 162,          "dfs-flushcps" },
        { 163,          "dfs-symlink" },
        { 161,          "dfs-lookup" },
        { 162,          "dfs-flushcps" },
        { 163,          "dfs-symlink" },
+       { 220,          "residency" },
+       { 65536,        "inline-bulk-status" },
+       { 65537,        "fetch-data-64" },
+       { 65538,        "store-data-64" },
+       { 65539,        "give-up-all-cbs" },
+       { 65540,        "get-caps" },
+       { 65541,        "cb-rx-conn-addr" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -113,6 +139,13 @@ static struct tok cb_req[] = {
        { 212,          "whoareyou" },
        { 213,          "initcb3" },
        { 214,          "probeuuid" },
        { 212,          "whoareyou" },
        { 213,          "initcb3" },
        { 214,          "probeuuid" },
+       { 215,          "getsrvprefs" },
+       { 216,          "getcellservdb" },
+       { 217,          "getlocalcell" },
+       { 218,          "getcacheconf" },
+       { 65536,        "getce64" },
+       { 65537,        "getcellbynum" },
+       { 65538,        "tellmeaboutyourself" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -138,6 +171,8 @@ static struct tok pt_req[] = {
        { 518,          "get-cps2" },
        { 519,          "get-host-cps" },
        { 520,          "update-entry" },
        { 518,          "get-cps2" },
        { 519,          "get-host-cps" },
        { 520,          "update-entry" },
+       { 521,          "list-entries" },
+       { 530,          "list-super-groups" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -175,6 +210,7 @@ static struct tok vldb_req[] = {
        { 531,          "linked-list-u" },
        { 532,          "regaddr" },
        { 533,          "get-addrs-u" },
        { 531,          "linked-list-u" },
        { 532,          "regaddr" },
        { 533,          "get-addrs-u" },
+       { 534,          "list-attrib-n2" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -230,6 +266,9 @@ static struct tok vol_req[] = {
        { 126,          "set-info" },
        { 127,          "x-list-partitions" },
        { 128,          "forward-multiple" },
        { 126,          "set-info" },
        { 127,          "x-list-partitions" },
        { 128,          "forward-multiple" },
+       { 65536,        "convert-ro" },
+       { 65537,        "get-size" },
+       { 65538,        "dump-v2" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -269,6 +308,8 @@ static struct tok bos_req[] = {
        { 112,          "start-bozo-log" },
        { 113,          "wait-all" },
        { 114,          "get-instance-strings" },
        { 112,          "start-bozo-log" },
        { 113,          "wait-all" },
        { 114,          "get-instance-strings" },
+       { 115,          "get-restricted" },
+       { 116,          "set-restricted" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -279,6 +320,8 @@ static struct tok ubik_req[] = {
        { 10003,        "vote-getsyncsite" },
        { 10004,        "vote-debug" },
        { 10005,        "vote-sdebug" },
        { 10003,        "vote-getsyncsite" },
        { 10004,        "vote-debug" },
        { 10005,        "vote-sdebug" },
+       { 10006,        "vote-xdebug" },
+       { 10007,        "vote-xsdebug" },
        { 20000,        "disk-begin" },
        { 20001,        "disk-commit" },
        { 20002,        "disk-lock" },
        { 20000,        "disk-begin" },
        { 20001,        "disk-commit" },
        { 20002,        "disk-lock" },
@@ -297,7 +340,7 @@ static struct tok ubik_req[] = {
 };
 
 #define VOTE_LOW       10000
 };
 
 #define VOTE_LOW       10000
-#define VOTE_HIGH      10005
+#define VOTE_HIGH      10007
 #define DISK_LOW       20000
 #define DISK_HIGH      20013
 
 #define DISK_LOW       20000
 #define DISK_HIGH      20013
 
@@ -315,7 +358,7 @@ static struct tok ubik_lock_types[] = {
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
-static char *voltype[] = { "read-write", "read-only", "backup" };
+static const char *voltype[] = { "read-write", "read-only", "backup" };
 
 static struct tok afs_fs_errors[] = {
        { 101,          "salvage volume" },
 
 static struct tok afs_fs_errors[] = {
        { 101,          "salvage volume" },
@@ -347,6 +390,7 @@ static struct tok rx_ack_reasons[] = {
        { 6,            "ping" },
        { 7,            "ping response" },
        { 8,            "delay" },
        { 6,            "ping" },
        { 7,            "ping response" },
        { 8,            "delay" },
+       { 9,            "idle" },
        { 0,            NULL },
 };
 
        { 0,            NULL },
 };
 
@@ -370,13 +414,13 @@ static struct rx_cache_entry      rx_cache[RX_CACHE_SIZE];
 
 static int     rx_cache_next = 0;
 static int     rx_cache_hint = 0;
 
 static int     rx_cache_next = 0;
 static int     rx_cache_hint = 0;
-static void    rx_cache_insert(const u_char *, const struct ip *, int, int);
+static void    rx_cache_insert(const u_char *, const struct ip *, int);
 static int     rx_cache_find(const struct rx_header *, const struct ip *,
                              int, int32_t *);
 
 static void fs_print(const u_char *, int);
 static void fs_reply_print(const u_char *, int, int32_t);
 static int     rx_cache_find(const struct rx_header *, const struct ip *,
                              int, int32_t *);
 
 static void fs_print(const u_char *, int);
 static void fs_reply_print(const u_char *, int, int32_t);
-static void acl_print(u_char *, u_char *);
+static void acl_print(u_char *, int, u_char *);
 static void cb_print(const u_char *, int);
 static void cb_reply_print(const u_char *, int, int32_t);
 static void prot_print(const u_char *, int);
 static void cb_print(const u_char *, int);
 static void cb_reply_print(const u_char *, int, int32_t);
 static void prot_print(const u_char *, int);
@@ -389,7 +433,7 @@ static void vol_print(const u_char *, int);
 static void vol_reply_print(const u_char *, int, int32_t);
 static void bos_print(const u_char *, int);
 static void bos_reply_print(const u_char *, int, int32_t);
 static void vol_reply_print(const u_char *, int, int32_t);
 static void bos_print(const u_char *, int);
 static void bos_reply_print(const u_char *, int, int32_t);
-static void ubik_print(const u_char *, int);
+static void ubik_print(const u_char *);
 static void ubik_reply_print(const u_char *, int, int32_t);
 
 static void rx_ack_print(const u_char *, int);
 static void ubik_reply_print(const u_char *, int, int32_t);
 
 static void rx_ack_print(const u_char *, int);
@@ -409,7 +453,7 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
        int i;
        int32_t opcode;
 
        int i;
        int32_t opcode;
 
-       if (snapend - bp < sizeof (struct rx_header)) {
+       if (snapend - bp < (int)sizeof (struct rx_header)) {
                printf(" [|rx] (%d)", length);
                return;
        }
                printf(" [|rx] (%d)", length);
                return;
        }
@@ -437,7 +481,9 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
 
                if (vflag > 1)
                        for (i = 0; i < NUM_RX_FLAGS; i++) {
 
                if (vflag > 1)
                        for (i = 0; i < NUM_RX_FLAGS; i++) {
-                               if (rxh->flags & rx_flags[i].v) {
+                               if (rxh->flags & rx_flags[i].flag &&
+                                   (!rx_flags[i].packetType ||
+                                    rxh->type == rx_flags[i].packetType)) {
                                        if (!firstflag) {
                                                firstflag = 1;
                                                printf(" ");
                                        if (!firstflag) {
                                                firstflag = 1;
                                                printf(" ");
@@ -467,7 +513,7 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
                 * have a chance to print out replies
                 */
 
                 * have a chance to print out replies
                 */
 
-               rx_cache_insert(bp, (const struct ip *) bp2, dport, length);
+               rx_cache_insert(bp, (const struct ip *) bp2, dport);
 
                switch (dport) {
                        case FS_RX_PORT:        /* AFS file service */
 
                switch (dport) {
                        case FS_RX_PORT:        /* AFS file service */
@@ -494,7 +540,7 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
                        default:
                                ;
                }
                        default:
                                ;
                }
-       
+
        /*
         * If it's a reply (client-init is _not_ set, but seq is one)
         * then look it up in the cache.  If we find it, call the reply
        /*
         * If it's a reply (client-init is _not_ set, but seq is one)
         * then look it up in the cache.  If we find it, call the reply
@@ -553,20 +599,19 @@ rx_print(register const u_char *bp, int length, int sport, int dport,
  */
 
 static void
  */
 
 static void
-rx_cache_insert(const u_char *bp, const struct ip *ip, int dport,
-               int length)
+rx_cache_insert(const u_char *bp, const struct ip *ip, int dport)
 {
        struct rx_cache_entry *rxent;
        const struct rx_header *rxh = (const struct rx_header *) bp;
 
 {
        struct rx_cache_entry *rxent;
        const struct rx_header *rxh = (const struct rx_header *) bp;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t))
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
                return;
 
        rxent = &rx_cache[rx_cache_next];
 
        if (++rx_cache_next >= RX_CACHE_SIZE)
                rx_cache_next = 0;
                return;
 
        rxent = &rx_cache[rx_cache_next];
 
        if (++rx_cache_next >= RX_CACHE_SIZE)
                rx_cache_next = 0;
-       
+
        rxent->callnum = rxh->callNumber;
        rxent->client = ip->ip_src;
        rxent->server = ip->ip_dst;
        rxent->callnum = rxh->callNumber;
        rxent->client = ip->ip_src;
        rxent->server = ip->ip_dst;
@@ -598,7 +643,7 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
                rxent = &rx_cache[i];
                if (rxent->callnum == rxh->callNumber &&
                    rxent->client.s_addr == clip &&
                rxent = &rx_cache[i];
                if (rxent->callnum == rxh->callNumber &&
                    rxent->client.s_addr == clip &&
-                   rxent->server.s_addr == sip && 
+                   rxent->server.s_addr == sip &&
                    rxent->serviceId == rxh->serviceId &&
                    rxent->dport == sport) {
 
                    rxent->serviceId == rxh->serviceId &&
                    rxent->dport == sport) {
 
@@ -620,9 +665,8 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
  * These extrememly grody macros handle the printing of various AFS stuff.
  */
 
  * These extrememly grody macros handle the printing of various AFS stuff.
  */
 
-#define TRUNC(n) if (snapend - bp + 1 <= n) goto trunc;
 #define FIDOUT() { unsigned long n1, n2, n3; \
 #define FIDOUT() { unsigned long n1, n2, n3; \
-                       TRUNC(sizeof(int32_t) * 3); \
+                       TCHECK2(bp[0], sizeof(int32_t) * 3); \
                        n1 = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        n2 = EXTRACT_32BITS(bp); \
                        n1 = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        n2 = EXTRACT_32BITS(bp); \
@@ -632,33 +676,42 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
                        printf(" fid %d/%d/%d", (int) n1, (int) n2, (int) n3); \
                }
 
                        printf(" fid %d/%d/%d", (int) n1, (int) n2, (int) n3); \
                }
 
-#define STROUT(MAX) { int i; \
-                       TRUNC(sizeof(int32_t)); \
-                       i = (int) EXTRACT_32BITS(bp); \
+#define STROUT(MAX) { unsigned int i; \
+                       TCHECK2(bp[0], sizeof(int32_t)); \
+                       i = EXTRACT_32BITS(bp); \
+                       if (i > (MAX)) \
+                               goto trunc; \
                        bp += sizeof(int32_t); \
                        bp += sizeof(int32_t); \
-                       TRUNC(i); \
-                       strncpy(s, (char *) bp, min(MAX, i)); \
-                       s[i] = '\0'; \
-                       printf(" \"%s\"", s); \
+                       printf(" \""); \
+                       if (fn_printn(bp, i, snapend)) \
+                               goto trunc; \
+                       printf("\""); \
                        bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
                }
 
 #define INTOUT() { int i; \
                        bp += ((i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
                }
 
 #define INTOUT() { int i; \
-                       TRUNC(sizeof(int32_t)); \
+                       TCHECK2(bp[0], sizeof(int32_t)); \
                        i = (int) EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        printf(" %d", i); \
                }
 
 #define UINTOUT() { unsigned long i; \
                        i = (int) EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        printf(" %d", i); \
                }
 
 #define UINTOUT() { unsigned long i; \
-                       TRUNC(sizeof(int32_t)); \
+                       TCHECK2(bp[0], sizeof(int32_t)); \
                        i = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        printf(" %lu", i); \
                }
 
                        i = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        printf(" %lu", i); \
                }
 
+#define UINT64OUT() { u_int64_t i; \
+                       TCHECK2(bp[0], sizeof(u_int64_t)); \
+                       i = EXTRACT_64BITS(bp); \
+                       bp += sizeof(u_int64_t); \
+                       printf(" %" PRIu64, i); \
+               }
+
 #define DATEOUT() { time_t t; struct tm *tm; char str[256]; \
 #define DATEOUT() { time_t t; struct tm *tm; char str[256]; \
-                       TRUNC(sizeof(int32_t)); \
+                       TCHECK2(bp[0], sizeof(int32_t)); \
                        t = (time_t) EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        tm = localtime(&t); \
                        t = (time_t) EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        tm = localtime(&t); \
@@ -667,25 +720,25 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
                }
 
 #define STOREATTROUT() { unsigned long mask, i; \
                }
 
 #define STOREATTROUT() { unsigned long mask, i; \
-                       TRUNC((sizeof(int32_t)*6)); \
+                       TCHECK2(bp[0], (sizeof(int32_t)*6)); \
                        mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        if (mask) printf (" StoreStatus"); \
                        mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        if (mask) printf (" StoreStatus"); \
-                       if (mask & 1) { printf(" date"); DATEOUT(); } \
+                       if (mask & 1) { printf(" date"); DATEOUT(); } \
                        else bp += sizeof(int32_t); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        else bp += sizeof(int32_t); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 2) printf(" owner %lu", i);  \
+                       if (mask & 2) printf(" owner %lu", i);  \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 4) printf(" group %lu", i); \
+                       if (mask & 4) printf(" group %lu", i); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 8) printf(" mode %lo", i & 07777); \
+                       if (mask & 8) printf(" mode %lo", i & 07777); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
                        i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 16) printf(" segsize %lu", i); \
+                       if (mask & 16) printf(" segsize %lu", i); \
                        /* undocumented in 3.3 docu */ \
                        /* undocumented in 3.3 docu */ \
-                       if (mask & 1024) printf(" fsync");  \
+                       if (mask & 1024) printf(" fsync");  \
                }
 
 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
                }
 
 #define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
-                       TRUNC(sizeof(int32_t) * 2); \
+                       TCHECK2(bp[0], sizeof(int32_t) * 2); \
                        epoch = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        counter = EXTRACT_32BITS(bp); \
                        epoch = EXTRACT_32BITS(bp); \
                        bp += sizeof(int32_t); \
                        counter = EXTRACT_32BITS(bp); \
@@ -694,7 +747,7 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
                }
 
 #define AFSUUIDOUT() {u_int32_t temp; int i; \
                }
 
 #define AFSUUIDOUT() {u_int32_t temp; int i; \
-                       TRUNC(11*sizeof(u_int32_t)); \
+                       TCHECK2(bp[0], 11*sizeof(u_int32_t)); \
                        temp = EXTRACT_32BITS(bp); \
                        bp += sizeof(u_int32_t); \
                        printf(" %08x", temp); \
                        temp = EXTRACT_32BITS(bp); \
                        bp += sizeof(u_int32_t); \
                        printf(" %08x", temp); \
@@ -715,33 +768,48 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
  * This is the sickest one of all
  */
 
  * This is the sickest one of all
  */
 
-#define VECOUT(MAX) { char *sp; \
+#define VECOUT(MAX) { u_char *sp; \
+                       u_char s[AFSNAMEMAX]; \
                        int k; \
                        int k; \
-                       TRUNC(MAX * sizeof(int32_t)); \
+                       if ((MAX) + 1 > sizeof(s)) \
+                               goto trunc; \
+                       TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \
                        sp = s; \
                        sp = s; \
-                       for (k = 0; k < MAX; k++) { \
-                               *sp++ = (char) EXTRACT_32BITS(bp); \
+                       for (k = 0; k < (MAX); k++) { \
+                               *sp++ = (u_char) EXTRACT_32BITS(bp); \
                                bp += sizeof(int32_t); \
                        } \
                                bp += sizeof(int32_t); \
                        } \
-                       s[MAX] = '\0'; \
-                       printf(" \"%s\"", s); \
+                       s[(MAX)] = '\0'; \
+                       printf(" \""); \
+                       fn_print(s, NULL); \
+                       printf("\""); \
+               }
+
+#define DESTSERVEROUT() { unsigned long n1, n2, n3; \
+                       TCHECK2(bp[0], sizeof(int32_t) * 3); \
+                       n1 = EXTRACT_32BITS(bp); \
+                       bp += sizeof(int32_t); \
+                       n2 = EXTRACT_32BITS(bp); \
+                       bp += sizeof(int32_t); \
+                       n3 = EXTRACT_32BITS(bp); \
+                       bp += sizeof(int32_t); \
+                       printf(" server %d:%d:%d", (int) n1, (int) n2, (int) n3); \
                }
 
 /*
  * Handle calls to the AFS file service (fs)
  */
 
                }
 
 /*
  * Handle calls to the AFS file service (fs)
  */
 
-void
+static void
 fs_print(register const u_char *bp, int length)
 {
        int fs_op;
        unsigned long i;
 fs_print(register const u_char *bp, int length)
 {
        int fs_op;
        unsigned long i;
-       char s[AFSNAMEMAX];
 
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -799,15 +867,16 @@ fs_print(register const u_char *bp, int length)
                        break;
                case 134:       /* Store ACL */
                {
                        break;
                case 134:       /* Store ACL */
                {
-                       char a[AFSOPAQUEMAX];
+                       char a[AFSOPAQUEMAX+1];
                        FIDOUT();
                        FIDOUT();
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
-                       TRUNC(i);
-                       strncpy(a, (char *) bp, min(AFSOPAQUEMAX, i));
+                       TCHECK2(bp[0], i);
+                       i = min(AFSOPAQUEMAX, i);
+                       strncpy(a, (char *) bp, i);
                        a[i] = '\0';
                        a[i] = '\0';
-                       acl_print((u_char *) a, (u_char *) a + i);
+                       acl_print((u_char *) a, sizeof(a), (u_char *) a + i);
                        break;
                }
                case 137:       /* Create file */
                        break;
                }
                case 137:       /* Create file */
@@ -854,9 +923,10 @@ fs_print(register const u_char *bp, int length)
                        STROUT(AFSNAMEMAX);
                        break;
                case 155:       /* Bulk stat */
                        STROUT(AFSNAMEMAX);
                        break;
                case 155:       /* Bulk stat */
+               case 65536:     /* Inline bulk stat */
                {
                        unsigned long j;
                {
                        unsigned long j;
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
@@ -868,6 +938,26 @@ fs_print(register const u_char *bp, int length)
                        if (j == 0)
                                printf(" <none!>");
                }
                        if (j == 0)
                                printf(" <none!>");
                }
+               case 65537:     /* Fetch data 64 */
+                       FIDOUT();
+                       printf(" offset");
+                       UINT64OUT();
+                       printf(" length");
+                       UINT64OUT();
+                       break;
+               case 65538:     /* Store data 64 */
+                       FIDOUT();
+                       STOREATTROUT();
+                       printf(" offset");
+                       UINT64OUT();
+                       printf(" length");
+                       UINT64OUT();
+                       printf(" flen");
+                       UINT64OUT();
+                       break;
+               case 65541:    /* CallBack rx conn address */
+                       printf(" addr");
+                       UINTOUT();
                default:
                        ;
        }
                default:
                        ;
        }
@@ -886,10 +976,9 @@ static void
 fs_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        unsigned long i;
 fs_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        unsigned long i;
-       char s[AFSNAMEMAX];
        struct rx_header *rxh;
 
        struct rx_header *rxh;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -911,14 +1000,15 @@ fs_reply_print(register const u_char *bp, int length, int32_t opcode)
                switch (opcode) {
                case 131:       /* Fetch ACL */
                {
                switch (opcode) {
                case 131:       /* Fetch ACL */
                {
-                       char a[AFSOPAQUEMAX];
-                       TRUNC(4);
+                       char a[AFSOPAQUEMAX+1];
+                       TCHECK2(bp[0], 4);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
-                       TRUNC(i);
-                       strncpy(a, (char *) bp, min(AFSOPAQUEMAX, i));
+                       TCHECK2(bp[0], i);
+                       i = min(AFSOPAQUEMAX, i);
+                       strncpy(a, (char *) bp, i);
                        a[i] = '\0';
                        a[i] = '\0';
-                       acl_print((u_char *) a, (u_char *) a + i);
+                       acl_print((u_char *) a, sizeof(a), (u_char *) a + i);
                        break;
                }
                case 137:       /* Create file */
                        break;
                }
                case 137:       /* Create file */
@@ -939,12 +1029,12 @@ fs_reply_print(register const u_char *bp, int length, int32_t opcode)
        } else if (rxh->type == RX_PACKET_TYPE_ABORT) {
                int i;
 
        } else if (rxh->type == RX_PACKET_TYPE_ABORT) {
                int i;
 
-               /*
-                * Otherwise, just print out the return code
-                */
-               TRUNC(sizeof(int32_t)); 
-               i = (int) EXTRACT_32BITS(bp); 
-               bp += sizeof(int32_t); 
+               /*
+                * Otherwise, just print out the return code
+                */
+               TCHECK2(bp[0], sizeof(int32_t));
+               i = (int) EXTRACT_32BITS(bp);
+               bp += sizeof(int32_t);
 
                printf(" error %s", tok2str(afs_fs_errors, "#%d", i));
        } else {
 
                printf(" error %s", tok2str(afs_fs_errors, "#%d", i));
        } else {
@@ -964,7 +1054,7 @@ trunc:
  * <positive> <negative>
  * <uid1> <aclbits1>
  * ....
  * <positive> <negative>
  * <uid1> <aclbits1>
  * ....
- * 
+ *
  * "positive" and "negative" are integers which contain the number of
  * positive and negative ACL's in the string.  The uid/aclbits pair are
  * ASCII strings containing the UID/PTS record and and a ascii number
  * "positive" and "negative" are integers which contain the number of
  * positive and negative ACL's in the string.  The uid/aclbits pair are
  * ASCII strings containing the UID/PTS record and and a ascii number
@@ -972,19 +1062,23 @@ trunc:
  */
 
 static void
  */
 
 static void
-acl_print(u_char *s, u_char *end)
+acl_print(u_char *s, int maxsize, u_char *end)
 {
        int pos, neg, acl;
        int n, i;
 {
        int pos, neg, acl;
        int n, i;
-       char user[128];
+       char *user;
+       char fmt[1024];
 
 
-       if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
+       if ((user = (char *)malloc(maxsize)) == NULL)
                return;
                return;
-       
+
+       if (sscanf((char *) s, "%d %d\n%n", &pos, &neg, &n) != 2)
+               goto finish;
+
        s += n;
 
        if (s > end)
        s += n;
 
        if (s > end)
-               return;
+               goto finish;
 
        /*
         * This wacky order preserves the order used by the "fs" command
 
        /*
         * This wacky order preserves the order used by the "fs" command
@@ -1007,26 +1101,36 @@ acl_print(u_char *s, u_char *end)
                printf("a");
 
        for (i = 0; i < pos; i++) {
                printf("a");
 
        for (i = 0; i < pos; i++) {
-               if (sscanf((char *) s, "%s %d\n%n", user, &acl, &n) != 2)
-                       return;
+               snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
+               if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
+                       goto finish;
                s += n;
                s += n;
-               printf(" +{%s ", user);
+               printf(" +{");
+               fn_print((u_char *)user, NULL);
+               printf(" ");
                ACLOUT(acl);
                printf("}");
                if (s > end)
                ACLOUT(acl);
                printf("}");
                if (s > end)
-                       return;
+                       goto finish;
        }
 
        for (i = 0; i < neg; i++) {
        }
 
        for (i = 0; i < neg; i++) {
-               if (sscanf((char *) s, "%s %d\n%n", user, &acl, &n) != 2)
-                       return;
+               snprintf(fmt, sizeof(fmt), "%%%ds %%d\n%%n", maxsize - 1);
+               if (sscanf((char *) s, fmt, user, &acl, &n) != 2)
+                       goto finish;
                s += n;
                s += n;
-               printf(" -{%s ", user);
+               printf(" -{");
+               fn_print((u_char *)user, NULL);
+               printf(" ");
                ACLOUT(acl);
                printf("}");
                if (s > end)
                ACLOUT(acl);
                printf("}");
                if (s > end)
-                       return;
+                       goto finish;
        }
        }
+
+finish:
+       free(user);
+       return;
 }
 
 #undef ACLOUT
 }
 
 #undef ACLOUT
@@ -1041,10 +1145,10 @@ cb_print(register const u_char *bp, int length)
        int cb_op;
        unsigned long i;
 
        int cb_op;
        unsigned long i;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -1068,7 +1172,7 @@ cb_print(register const u_char *bp, int length)
                case 204:               /* Callback */
                {
                        unsigned long j, t;
                case 204:               /* Callback */
                {
                        unsigned long j, t;
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
@@ -1092,7 +1196,7 @@ cb_print(register const u_char *bp, int length)
                                INTOUT();
                                printf(" expires");
                                DATEOUT();
                                INTOUT();
                                printf(" expires");
                                DATEOUT();
-                               TRUNC(4);
+                               TCHECK2(bp[0], 4);
                                t = EXTRACT_32BITS(bp);
                                bp += sizeof(int32_t);
                                tok2str(cb_types, "type %d", t);
                                t = EXTRACT_32BITS(bp);
                                bp += sizeof(int32_t);
                                tok2str(cb_types, "type %d", t);
@@ -1122,7 +1226,7 @@ cb_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
 
 {
        struct rx_header *rxh;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -1131,7 +1235,7 @@ cb_reply_print(register const u_char *bp, int length, int32_t opcode)
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from fsint/afscbint.xg
         */
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from fsint/afscbint.xg
         */
-       
+
        printf(" cb reply %s", tok2str(cb_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
        printf(" cb reply %s", tok2str(cb_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
@@ -1170,13 +1274,12 @@ static void
 prot_print(register const u_char *bp, int length)
 {
        unsigned long i;
 prot_print(register const u_char *bp, int length)
 {
        unsigned long i;
-       char s[AFSNAMEMAX];
        int pt_op;
 
        int pt_op;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -1190,7 +1293,7 @@ prot_print(register const u_char *bp, int length)
        printf(" pt");
 
        if (is_ubik(pt_op)) {
        printf(" pt");
 
        if (is_ubik(pt_op)) {
-               ubik_print(bp, length);
+               ubik_print(bp);
                return;
        }
 
                return;
        }
 
@@ -1218,6 +1321,7 @@ prot_print(register const u_char *bp, int length)
                case 517:       /* List owned */
                case 518:       /* Get CPS2 */
                case 519:       /* Get host CPS */
                case 517:       /* List owned */
                case 518:       /* Get CPS2 */
                case 519:       /* Get host CPS */
+               case 530:       /* List super groups */
                        printf(" id");
                        INTOUT();
                        break;
                        printf(" id");
                        INTOUT();
                        break;
@@ -1236,7 +1340,7 @@ prot_print(register const u_char *bp, int length)
                case 504:       /* Name to ID */
                {
                        unsigned long j;
                case 504:       /* Name to ID */
                {
                        unsigned long j;
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
@@ -1258,7 +1362,7 @@ prot_print(register const u_char *bp, int length)
                {
                        unsigned long j;
                        printf(" ids:");
                {
                        unsigned long j;
                        printf(" ids:");
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (j = 0; j < i; j++)
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (j = 0; j < i; j++)
@@ -1314,9 +1418,8 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
        unsigned long i;
 {
        struct rx_header *rxh;
        unsigned long i;
-       char s[AFSNAMEMAX];
 
 
-       if (length < sizeof(struct rx_header))
+       if (length < (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -1348,7 +1451,7 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
                {
                        unsigned long j;
                        printf(" ids:");
                {
                        unsigned long j;
                        printf(" ids:");
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (j = 0; j < i; j++)
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (j = 0; j < i; j++)
@@ -1360,7 +1463,7 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
                case 505:               /* ID to name */
                {
                        unsigned long j;
                case 505:               /* ID to name */
                {
                        unsigned long j;
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
 
@@ -1385,7 +1488,7 @@ prot_reply_print(register const u_char *bp, int length, int32_t opcode)
                case 519:               /* Get host CPS */
                {
                        unsigned long j;
                case 519:               /* Get host CPS */
                {
                        unsigned long j;
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (i = 0; i < j; i++) {
                        j = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        for (i = 0; i < j; i++) {
@@ -1427,12 +1530,11 @@ vldb_print(register const u_char *bp, int length)
 {
        int vldb_op;
        unsigned long i;
 {
        int vldb_op;
        unsigned long i;
-       char s[AFSNAMEMAX];
 
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -1446,7 +1548,7 @@ vldb_print(register const u_char *bp, int length)
        printf(" vldb");
 
        if (is_ubik(vldb_op)) {
        printf(" vldb");
 
        if (is_ubik(vldb_op)) {
-               ubik_print(bp, length);
+               ubik_print(bp);
                return;
        }
        printf(" call %s", tok2str(vldb_req, "op#%d", vldb_op));
                return;
        }
        printf(" call %s", tok2str(vldb_req, "op#%d", vldb_op));
@@ -1470,7 +1572,7 @@ vldb_print(register const u_char *bp, int length)
                case 518:       /* Get entry by ID N */
                        printf(" volid");
                        INTOUT();
                case 518:       /* Get entry by ID N */
                        printf(" volid");
                        INTOUT();
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        if (i <= 2)
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        if (i <= 2)
@@ -1490,7 +1592,7 @@ vldb_print(register const u_char *bp, int length)
                case 520:       /* Replace entry N */
                        printf(" volid");
                        INTOUT();
                case 520:       /* Replace entry N */
                        printf(" volid");
                        INTOUT();
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        if (i <= 2)
                        i = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        if (i <= 2)
@@ -1521,9 +1623,8 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
        unsigned long i;
 {
        struct rx_header *rxh;
        unsigned long i;
-       char s[AFSNAMEMAX];
 
 
-       if (length < sizeof(struct rx_header))
+       if (length < (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -1560,24 +1661,24 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                case 504:       /* Get entry by name */
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
                case 504:       /* Get entry by name */
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        bp += sizeof(int32_t);
                        printf(" numservers");
                        bp += sizeof(int32_t);
                        printf(" numservers");
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
                        printf(" servers");
                        for (i = 0; i < 8; i++) {
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
                        printf(" servers");
                        for (i = 0; i < 8; i++) {
-                               TRUNC(sizeof(int32_t));
+                               TCHECK2(bp[0], sizeof(int32_t));
                                if (i < nservers)
                                        printf(" %s",
                                if (i < nservers)
                                        printf(" %s",
-                                          inet_ntoa(*((struct in_addr *) bp)));
+                                          intoa(((struct in_addr *) bp)->s_addr));
                                bp += sizeof(int32_t);
                        }
                        printf(" partitions");
                        for (i = 0; i < 8; i++) {
                                bp += sizeof(int32_t);
                        }
                        printf(" partitions");
                        for (i = 0; i < 8; i++) {
-                               TRUNC(sizeof(int32_t));
+                               TCHECK2(bp[0], sizeof(int32_t));
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
@@ -1585,7 +1686,7 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
-                       TRUNC(8 * sizeof(int32_t));
+                       TCHECK2(bp[0], 8 * sizeof(int32_t));
                        bp += 8 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
                        bp += 8 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
@@ -1610,21 +1711,21 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
                        printf(" numservers");
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
                        printf(" numservers");
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
                        printf(" servers");
                        for (i = 0; i < 13; i++) {
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
                        printf(" servers");
                        for (i = 0; i < 13; i++) {
-                               TRUNC(sizeof(int32_t));
+                               TCHECK2(bp[0], sizeof(int32_t));
                                if (i < nservers)
                                        printf(" %s",
                                if (i < nservers)
                                        printf(" %s",
-                                          inet_ntoa(*((struct in_addr *) bp)));
+                                          intoa(((struct in_addr *) bp)->s_addr));
                                bp += sizeof(int32_t);
                        }
                        printf(" partitions");
                        for (i = 0; i < 13; i++) {
                                bp += sizeof(int32_t);
                        }
                        printf(" partitions");
                        for (i = 0; i < 13; i++) {
-                               TRUNC(sizeof(int32_t));
+                               TCHECK2(bp[0], sizeof(int32_t));
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
@@ -1632,7 +1733,7 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
-                       TRUNC(13 * sizeof(int32_t));
+                       TCHECK2(bp[0], 13 * sizeof(int32_t));
                        bp += 13 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
                        bp += 13 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
@@ -1647,7 +1748,7 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
                        printf(" numservers");
                {       unsigned long nservers, j;
                        VECOUT(VLNAMEMAX);
                        printf(" numservers");
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
                        nservers = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" %lu", nservers);
@@ -1657,15 +1758,15 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                                        printf(" afsuuid");
                                        AFSUUIDOUT();
                                } else {
                                        printf(" afsuuid");
                                        AFSUUIDOUT();
                                } else {
-                                       TRUNC(44);
+                                       TCHECK2(bp[0], 44);
                                        bp += 44;
                                }
                        }
                                        bp += 44;
                                }
                        }
-                       TRUNC(4 * 13);
+                       TCHECK2(bp[0], 4 * 13);
                        bp += 4 * 13;
                        printf(" partitions");
                        for (i = 0; i < 13; i++) {
                        bp += 4 * 13;
                        printf(" partitions");
                        for (i = 0; i < 13; i++) {
-                               TRUNC(sizeof(int32_t));
+                               TCHECK2(bp[0], sizeof(int32_t));
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
                                j = EXTRACT_32BITS(bp);
                                if (i < nservers && j <= 26)
                                        printf(" %c", 'a' + (int)j);
@@ -1673,7 +1774,7 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
                                        printf(" %lu", j);
                                bp += sizeof(int32_t);
                        }
-                       TRUNC(13 * sizeof(int32_t));
+                       TCHECK2(bp[0], 13 * sizeof(int32_t));
                        bp += 13 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
                        bp += 13 * sizeof(int32_t);
                        printf(" rwvol");
                        UINTOUT();
@@ -1685,7 +1786,7 @@ vldb_reply_print(register const u_char *bp, int length, int32_t opcode)
                default:
                        ;
                }
                default:
                        ;
                }
-                       
+
        else {
                /*
                 * Otherwise, just print out the return code
        else {
                /*
                 * Otherwise, just print out the return code
@@ -1708,12 +1809,11 @@ static void
 kauth_print(register const u_char *bp, int length)
 {
        int kauth_op;
 kauth_print(register const u_char *bp, int length)
 {
        int kauth_op;
-       char s[AFSNAMEMAX];
 
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -1727,7 +1827,7 @@ kauth_print(register const u_char *bp, int length)
        printf(" kauth");
 
        if (is_ubik(kauth_op)) {
        printf(" kauth");
 
        if (is_ubik(kauth_op)) {
-               ubik_print(bp, length);
+               ubik_print(bp);
                return;
        }
 
                return;
        }
 
@@ -1763,10 +1863,10 @@ kauth_print(register const u_char *bp, int length)
                        INTOUT();
                        printf(" domain");
                        STROUT(KANAMEMAX);
                        INTOUT();
                        printf(" domain");
                        STROUT(KANAMEMAX);
-                       TRUNC(sizeof(int32_t));
+                       TCHECK2(bp[0], sizeof(int32_t));
                        i = (int) EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        i = (int) EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
-                       TRUNC(i);
+                       TCHECK2(bp[0], i);
                        bp += i;
                        printf(" principal");
                        STROUT(KANAMEMAX);
                        bp += i;
                        printf(" principal");
                        STROUT(KANAMEMAX);
@@ -1803,7 +1903,7 @@ kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
 
 {
        struct rx_header *rxh;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -1812,7 +1912,7 @@ kauth_reply_print(register const u_char *bp, int length, int32_t opcode)
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from kauth/kauth.rg
         */
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from kauth/kauth.rg
         */
-       
+
        printf(" kauth");
 
        if (is_ubik(opcode)) {
        printf(" kauth");
 
        if (is_ubik(opcode)) {
@@ -1854,10 +1954,10 @@ vol_print(register const u_char *bp, int length)
 {
        int vol_op;
 
 {
        int vol_op;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -1870,13 +1970,176 @@ vol_print(register const u_char *bp, int length)
 
        printf(" vol call %s", tok2str(vol_req, "op#%d", vol_op));
 
 
        printf(" vol call %s", tok2str(vol_req, "op#%d", vol_op));
 
-       /*
-        * Normally there would be a switch statement here to decode the
-        * arguments to the AFS call, but since I don't have access to
-        * an AFS server (yet) and I'm not an AFS admin, I can't
-        * test any of these calls.  Leave this blank for now.
-        */
+       bp += sizeof(struct rx_header) + 4;
 
 
+       switch (vol_op) {
+               case 100:       /* Create volume */
+                       printf(" partition");
+                       UINTOUT();
+                       printf(" name");
+                       STROUT(AFSNAMEMAX);
+                       printf(" type");
+                       UINTOUT();
+                       printf(" parent");
+                       UINTOUT();
+                       break;
+               case 101:       /* Delete volume */
+               case 107:       /* Get flags */
+                       printf(" trans");
+                       UINTOUT();
+                       break;
+               case 102:       /* Restore */
+                       printf(" totrans");
+                       UINTOUT();
+                       printf(" flags");
+                       UINTOUT();
+                       break;
+               case 103:       /* Forward */
+                       printf(" fromtrans");
+                       UINTOUT();
+                       printf(" fromdate");
+                       DATEOUT();
+                       DESTSERVEROUT();
+                       printf(" desttrans");
+                       INTOUT();
+                       break;
+               case 104:       /* End trans */
+                       printf(" trans");
+                       UINTOUT();
+                       break;
+               case 105:       /* Clone */
+                       printf(" trans");
+                       UINTOUT();
+                       printf(" purgevol");
+                       UINTOUT();
+                       printf(" newtype");
+                       UINTOUT();
+                       printf(" newname");
+                       STROUT(AFSNAMEMAX);
+                       break;
+               case 106:       /* Set flags */
+                       printf(" trans");
+                       UINTOUT();
+                       printf(" flags");
+                       UINTOUT();
+                       break;
+               case 108:       /* Trans create */
+                       printf(" vol");
+                       UINTOUT();
+                       printf(" partition");
+                       UINTOUT();
+                       printf(" flags");
+                       UINTOUT();
+                       break;
+               case 109:       /* Dump */
+               case 655537:    /* Get size */
+                       printf(" fromtrans");
+                       UINTOUT();
+                       printf(" fromdate");
+                       DATEOUT();
+                       break;
+               case 110:       /* Get n-th volume */
+                       printf(" index");
+                       UINTOUT();
+                       break;
+               case 111:       /* Set forwarding */
+                       printf(" tid");
+                       UINTOUT();
+                       printf(" newsite");
+                       UINTOUT();
+                       break;
+               case 112:       /* Get name */
+               case 113:       /* Get status */
+                       printf(" tid");
+                       break;
+               case 114:       /* Signal restore */
+                       printf(" name");
+                       STROUT(AFSNAMEMAX);
+                       printf(" type");
+                       UINTOUT();
+                       printf(" pid");
+                       UINTOUT();
+                       printf(" cloneid");
+                       UINTOUT();
+                       break;
+               case 116:       /* List volumes */
+                       printf(" partition");
+                       UINTOUT();
+                       printf(" flags");
+                       UINTOUT();
+                       break;
+               case 117:       /* Set id types */
+                       printf(" tid");
+                       UINTOUT();
+                       printf(" name");
+                       STROUT(AFSNAMEMAX);
+                       printf(" type");
+                       UINTOUT();
+                       printf(" pid");
+                       UINTOUT();
+                       printf(" clone");
+                       UINTOUT();
+                       printf(" backup");
+                       UINTOUT();
+                       break;
+               case 119:       /* Partition info */
+                       printf(" name");
+                       STROUT(AFSNAMEMAX);
+                       break;
+               case 120:       /* Reclone */
+                       printf(" tid");
+                       UINTOUT();
+                       break;
+               case 121:       /* List one volume */
+               case 122:       /* Nuke volume */
+               case 124:       /* Extended List volumes */
+               case 125:       /* Extended List one volume */
+               case 65536:     /* Convert RO to RW volume */
+                       printf(" partid");
+                       UINTOUT();
+                       printf(" volid");
+                       UINTOUT();
+                       break;
+               case 123:       /* Set date */
+                       printf(" tid");
+                       UINTOUT();
+                       printf(" date");
+                       DATEOUT();
+                       break;
+               case 126:       /* Set info */
+                       printf(" tid");
+                       UINTOUT();
+                       break;
+               case 128:       /* Forward multiple */
+                       printf(" fromtrans");
+                       UINTOUT();
+                       printf(" fromdate");
+                       DATEOUT();
+                       {
+                               unsigned long i, j;
+                               TCHECK2(bp[0], 4);
+                               j = EXTRACT_32BITS(bp);
+                               bp += sizeof(int32_t);
+                               for (i = 0; i < j; i++) {
+                                       DESTSERVEROUT();
+                                       if (i != j - 1)
+                                               printf(",");
+                               }
+                               if (j == 0)
+                                       printf(" <none!>");
+                       }
+                       break;
+               case 65538:     /* Dump version 2 */
+                       printf(" fromtrans");
+                       UINTOUT();
+                       printf(" fromdate");
+                       DATEOUT();
+                       printf(" flags");
+                       UINTOUT();
+                       break;
+               default:
+                       ;
+       }
        return;
 
 trunc:
        return;
 
 trunc:
@@ -1892,7 +2155,7 @@ vol_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
 
 {
        struct rx_header *rxh;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -1901,7 +2164,7 @@ vol_reply_print(register const u_char *bp, int length, int32_t opcode)
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from volser/volint.xg
         */
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from volser/volint.xg
         */
-       
+
        printf(" vol reply %s", tok2str(vol_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
        printf(" vol reply %s", tok2str(vol_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
@@ -1910,10 +2173,100 @@ vol_reply_print(register const u_char *bp, int length, int32_t opcode)
         * If it was a data packet, interpret the response.
         */
 
         * If it was a data packet, interpret the response.
         */
 
-       if (rxh->type == RX_PACKET_TYPE_DATA)
-               /* Well, no, not really.  Leave this for later */
-               ;
-       else {
+       if (rxh->type == RX_PACKET_TYPE_DATA) {
+               switch (opcode) {
+                       case 100:       /* Create volume */
+                               printf(" volid");
+                               UINTOUT();
+                               printf(" trans");
+                               UINTOUT();
+                               break;
+                       case 104:       /* End transaction */
+                               UINTOUT();
+                               break;
+                       case 105:       /* Clone */
+                               printf(" newvol");
+                               UINTOUT();
+                               break;
+                       case 107:       /* Get flags */
+                               UINTOUT();
+                               break;
+                       case 108:       /* Transaction create */
+                               printf(" trans");
+                               UINTOUT();
+                               break;
+                       case 110:       /* Get n-th volume */
+                               printf(" volume");
+                               UINTOUT();
+                               printf(" partition");
+                               UINTOUT();
+                               break;
+                       case 112:       /* Get name */
+                               STROUT(AFSNAMEMAX);
+                               break;
+                       case 113:       /* Get status */
+                               printf(" volid");
+                               UINTOUT();
+                               printf(" nextuniq");
+                               UINTOUT();
+                               printf(" type");
+                               UINTOUT();
+                               printf(" parentid");
+                               UINTOUT();
+                               printf(" clone");
+                               UINTOUT();
+                               printf(" backup");
+                               UINTOUT();
+                               printf(" restore");
+                               UINTOUT();
+                               printf(" maxquota");
+                               UINTOUT();
+                               printf(" minquota");
+                               UINTOUT();
+                               printf(" owner");
+                               UINTOUT();
+                               printf(" create");
+                               DATEOUT();
+                               printf(" access");
+                               DATEOUT();
+                               printf(" update");
+                               DATEOUT();
+                               printf(" expire");
+                               DATEOUT();
+                               printf(" backup");
+                               DATEOUT();
+                               printf(" copy");
+                               DATEOUT();
+                               break;
+                       case 115:       /* Old list partitions */
+                               break;
+                       case 116:       /* List volumes */
+                       case 121:       /* List one volume */
+                               {
+                                       unsigned long i, j;
+                                       TCHECK2(bp[0], 4);
+                                       j = EXTRACT_32BITS(bp);
+                                       bp += sizeof(int32_t);
+                                       for (i = 0; i < j; i++) {
+                                               printf(" name");
+                                               VECOUT(32);
+                                               printf(" volid");
+                                               UINTOUT();
+                                               printf(" type");
+                                               bp += sizeof(int32_t) * 21;
+                                               if (i != j - 1)
+                                                       printf(",");
+                                       }
+                                       if (j == 0)
+                                               printf(" <none!>");
+                               }
+                               break;
+                               
+
+                       default:
+                               ;
+               }
+       } else {
                /*
                 * Otherwise, just print out the return code
                 */
                /*
                 * Otherwise, just print out the return code
                 */
@@ -1935,12 +2288,11 @@ static void
 bos_print(register const u_char *bp, int length)
 {
        int bos_op;
 bos_print(register const u_char *bp, int length)
 {
        int bos_op;
-       char s[BOSNAMEMAX];
 
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
                return;
 
-       if (snapend - bp + 1 <= sizeof(struct rx_header) + sizeof(int32_t)) {
+       if (snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
                goto trunc;
        }
 
                goto trunc;
        }
 
@@ -2028,7 +2380,7 @@ bos_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
 
 {
        struct rx_header *rxh;
 
-       if (length <= sizeof(struct rx_header))
+       if (length <= (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -2037,7 +2389,7 @@ bos_reply_print(register const u_char *bp, int length, int32_t opcode)
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from volser/volint.xg
         */
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from volser/volint.xg
         */
-       
+
        printf(" bos reply %s", tok2str(bos_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
        printf(" bos reply %s", tok2str(bos_req, "op#%d", opcode));
 
        bp += sizeof(struct rx_header);
@@ -2082,7 +2434,7 @@ is_ubik(u_int32_t opcode)
  */
 
 static void
  */
 
 static void
-ubik_print(register const u_char *bp, int length)
+ubik_print(register const u_char *bp)
 {
        int ubik_op;
        int32_t temp;
 {
        int ubik_op;
        int32_t temp;
@@ -2104,7 +2456,7 @@ ubik_print(register const u_char *bp, int length)
 
        switch (ubik_op) {
                case 10000:             /* Beacon */
 
        switch (ubik_op) {
                case 10000:             /* Beacon */
-                       TRUNC(4);
+                       TCHECK2(bp[0], 4);
                        temp = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" syncsite %s", temp ? "yes" : "no");
                        temp = EXTRACT_32BITS(bp);
                        bp += sizeof(int32_t);
                        printf(" syncsite %s", temp ? "yes" : "no");
@@ -2195,7 +2547,7 @@ ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
 {
        struct rx_header *rxh;
 
 {
        struct rx_header *rxh;
 
-       if (length < sizeof(struct rx_header))
+       if (length < (int)sizeof(struct rx_header))
                return;
 
        rxh = (struct rx_header *) bp;
                return;
 
        rxh = (struct rx_header *) bp;
@@ -2212,7 +2564,7 @@ ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
        /*
         * If it was a data packet, print out the arguments to the Ubik calls
         */
        /*
         * If it was a data packet, print out the arguments to the Ubik calls
         */
-       
+
        if (rxh->type == RX_PACKET_TYPE_DATA)
                switch (opcode) {
                case 10000:             /* Beacon */
        if (rxh->type == RX_PACKET_TYPE_DATA)
                switch (opcode) {
                case 10000:             /* Beacon */
@@ -2225,7 +2577,7 @@ ubik_reply_print(register const u_char *bp, int length, int32_t opcode)
                default:
                        ;
                }
                default:
                        ;
                }
-       
+
        /*
         * Otherwise, print out "yes" it it was a beacon packet (because
         * that's how yes votes are returned, go figure), otherwise
        /*
         * Otherwise, print out "yes" it it was a beacon packet (because
         * that's how yes votes are returned, go figure), otherwise
@@ -2253,13 +2605,14 @@ trunc:
  * Handle RX ACK packets.
  */
 
  * Handle RX ACK packets.
  */
 
-void
+static void
 rx_ack_print(register const u_char *bp, int length)
 {
        struct rx_ackPacket *rxa;
        int i, start, last;
 rx_ack_print(register const u_char *bp, int length)
 {
        struct rx_ackPacket *rxa;
        int i, start, last;
+       u_int32_t firstPacket;
 
 
-       if (length < sizeof(struct rx_header))
+       if (length < (int)sizeof(struct rx_header))
                return;
 
        bp += sizeof(struct rx_header);
                return;
 
        bp += sizeof(struct rx_header);
@@ -2272,7 +2625,7 @@ rx_ack_print(register const u_char *bp, int length)
         * rx_ackPacket structure.
         */
 
         * rx_ackPacket structure.
         */
 
-       TRUNC(sizeof(struct rx_ackPacket) - RX_MAXACKS);
+       TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);
 
        rxa = (struct rx_ackPacket *) bp;
        bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
 
        rxa = (struct rx_ackPacket *) bp;
        bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
@@ -2285,11 +2638,12 @@ rx_ack_print(register const u_char *bp, int length)
                printf(" bufspace %d maxskew %d",
                       (int) EXTRACT_16BITS(&rxa->bufferSpace),
                       (int) EXTRACT_16BITS(&rxa->maxSkew));
                printf(" bufspace %d maxskew %d",
                       (int) EXTRACT_16BITS(&rxa->bufferSpace),
                       (int) EXTRACT_16BITS(&rxa->maxSkew));
-       
+
+       firstPacket = EXTRACT_32BITS(&rxa->firstPacket);
        printf(" first %d serial %d reason %s",
        printf(" first %d serial %d reason %s",
-              EXTRACT_32BITS(&rxa->firstPacket), EXTRACT_32BITS(&rxa->serial),
+              firstPacket, EXTRACT_32BITS(&rxa->serial),
               tok2str(rx_ack_reasons, "#%d", (int) rxa->reason));
               tok2str(rx_ack_reasons, "#%d", (int) rxa->reason));
-       
+
        /*
         * Okay, now we print out the ack array.  The way _this_ works
         * is that we start at "first", and step through the ack array.
        /*
         * Okay, now we print out the ack array.  The way _this_ works
         * is that we start at "first", and step through the ack array.
@@ -2302,7 +2656,7 @@ rx_ack_print(register const u_char *bp, int length)
         * yield the start of the ack array (because RX_MAXACKS is 255
         * and the structure will likely get padded to a 2 or 4 byte
         * boundary).  However, this is the way it's implemented inside
         * yield the start of the ack array (because RX_MAXACKS is 255
         * and the structure will likely get padded to a 2 or 4 byte
         * boundary).  However, this is the way it's implemented inside
-        * of AFS - the start of the extra fields are at 
+        * of AFS - the start of the extra fields are at
         * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_
         * the exact start of the ack array.  Sigh.  That's why we aren't
         * using bp, but instead use rxa->acks[].  But nAcks gets added
         * sizeof(struct rx_ackPacket) - RX_MAXACKS + nAcks, which _isn't_
         * the exact start of the ack array.  Sigh.  That's why we aren't
         * using bp, but instead use rxa->acks[].  But nAcks gets added
@@ -2311,7 +2665,7 @@ rx_ack_print(register const u_char *bp, int length)
 
        if (rxa->nAcks != 0) {
 
 
        if (rxa->nAcks != 0) {
 
-               TRUNC(rxa->nAcks);
+               TCHECK2(bp[0], rxa->nAcks);
 
                /*
                 * Sigh, this is gross, but it seems to work to collapse
 
                /*
                 * Sigh, this is gross, but it seems to work to collapse
@@ -2330,7 +2684,7 @@ rx_ack_print(register const u_char *bp, int length)
 
                                if (last == -2) {
                                        printf(" acked %d",
 
                                if (last == -2) {
                                        printf(" acked %d",
-                                              rxa->firstPacket + i);
+                                              firstPacket + i);
                                        start = i;
                                }
 
                                        start = i;
                                }
 
@@ -2344,7 +2698,7 @@ rx_ack_print(register const u_char *bp, int length)
                                 */
 
                                else if (last != i - 1) {
                                 */
 
                                else if (last != i - 1) {
-                                       printf(",%d", rxa->firstPacket + i);
+                                       printf(",%d", firstPacket + i);
                                        start = i;
                                }
 
                                        start = i;
                                }
 
@@ -2370,8 +2724,8 @@ rx_ack_print(register const u_char *bp, int length)
                                 * range.
                                 */
                        } else if (last == i - 1 && start != last)
                                 * range.
                                 */
                        } else if (last == i - 1 && start != last)
-                               printf("-%d", rxa->firstPacket + i - 1);
-               
+                               printf("-%d", firstPacket + i - 1);
+
                /*
                 * So, what's going on here?  We ran off the end of the
                 * ack list, and if we got a range we need to finish it up.
                /*
                 * So, what's going on here?  We ran off the end of the
                 * ack list, and if we got a range we need to finish it up.
@@ -2384,28 +2738,28 @@ rx_ack_print(register const u_char *bp, int length)
                 */
 
                if (last == i - 1 && start != last)
                 */
 
                if (last == i - 1 && start != last)
-                       printf("-%d", rxa->firstPacket + i - 1);
+                       printf("-%d", firstPacket + i - 1);
 
                /*
                 * Same as above, just without comments
                 */
 
                /*
                 * Same as above, just without comments
                 */
-               
+
                for (i = 0, start = last = -2; i < rxa->nAcks; i++)
                        if (rxa->acks[i] == RX_ACK_TYPE_NACK) {
                                if (last == -2) {
                                        printf(" nacked %d",
                for (i = 0, start = last = -2; i < rxa->nAcks; i++)
                        if (rxa->acks[i] == RX_ACK_TYPE_NACK) {
                                if (last == -2) {
                                        printf(" nacked %d",
-                                              rxa->firstPacket + i);
+                                              firstPacket + i);
                                        start = i;
                                } else if (last != i - 1) {
                                        start = i;
                                } else if (last != i - 1) {
-                                       printf(",%d", rxa->firstPacket + i);
+                                       printf(",%d", firstPacket + i);
                                        start = i;
                                }
                                last = i;
                        } else if (last == i - 1 && start != last)
                                        start = i;
                                }
                                last = i;
                        } else if (last == i - 1 && start != last)
-                               printf("-%d", rxa->firstPacket + i - 1);
-               
+                               printf("-%d", firstPacket + i - 1);
+
                if (last == i - 1 && start != last)
                if (last == i - 1 && start != last)
-                       printf("-%d", rxa->firstPacket + i - 1);
+                       printf("-%d", firstPacket + i - 1);
 
                bp += rxa->nAcks;
        }
 
                bp += rxa->nAcks;
        }
[mirror] the TCPdump network dissector