More nd_ification of structures.

[tcpdump] / print-rx.c

diff --git a/print-rx.c b/print-rx.c
index 9df6b6aeec522b73ef977074fb53d3265811320b..3f3eea1aed69c7d619000c14737a988a8654fc51 100644 (file)
--- a/print-rx.c
+++ b/print-rx.c
@@ -75,12 +75,12 @@
 #define        PRSFS_ADMINISTER        64 /* Change ACL's */
 
 struct rx_header {
 #define        PRSFS_ADMINISTER        64 /* Change ACL's */
 
 struct rx_header {

-       uint32_t epoch;
-       uint32_t cid;
-       uint32_t callNumber;
-       uint32_t seq;
-       uint32_t serial;
-       uint8_t type;
+       nd_uint32_t epoch;
+       nd_uint32_t cid;
+       nd_uint32_t callNumber;
+       nd_uint32_t seq;
+       nd_uint32_t serial;
+       nd_uint8_t type;

 #define RX_PACKET_TYPE_DATA            1
 #define RX_PACKET_TYPE_ACK             2
 #define RX_PACKET_TYPE_BUSY            3
 #define RX_PACKET_TYPE_DATA            1
 #define RX_PACKET_TYPE_ACK             2
 #define RX_PACKET_TYPE_BUSY            3


@@ -91,7 +91,7 @@ struct rx_header {
 #define RX_PACKET_TYPE_DEBUG           8
 #define RX_PACKET_TYPE_PARAMS          9
 #define RX_PACKET_TYPE_VERSION         13
 #define RX_PACKET_TYPE_DEBUG           8
 #define RX_PACKET_TYPE_PARAMS          9
 #define RX_PACKET_TYPE_VERSION         13

-       uint8_t flags;
+       nd_uint8_t flags;

 #define RX_CLIENT_INITIATED    1
 #define RX_REQUEST_ACK         2
 #define RX_LAST_PACKET         4
 #define RX_CLIENT_INITIATED    1
 #define RX_REQUEST_ACK         2
 #define RX_LAST_PACKET         4


@@ -99,10 +99,10 @@ struct rx_header {
 #define RX_FREE_PACKET         16
 #define RX_SLOW_START_OK       32
 #define RX_JUMBO_PACKET                32
 #define RX_FREE_PACKET         16
 #define RX_SLOW_START_OK       32
 #define RX_JUMBO_PACKET                32

-       uint8_t userStatus;
-       uint8_t securityIndex;
-       uint16_t spare;         /* How clever: even though the AFS */
-       uint16_t serviceId;             /* header files indicate that the */
+       nd_uint8_t userStatus;
+       nd_uint8_t securityIndex;
+       nd_uint16_t spare;              /* How clever: even though the AFS */
+       nd_uint16_t serviceId;          /* header files indicate that the */

 };                                     /* serviceId is first, it's really */
                                        /* encoded _after_ the spare field */
                                        /* I wasted a day figuring that out! */
 };                                     /* serviceId is first, it's really */
                                        /* encoded _after_ the spare field */
                                        /* I wasted a day figuring that out! */


@@ -112,15 +112,18 @@ struct rx_header {
 #define RX_MAXACKS 255
 
 struct rx_ackPacket {
 #define RX_MAXACKS 255
 
 struct rx_ackPacket {

-       uint16_t bufferSpace;           /* Number of packet buffers available */
-       uint16_t maxSkew;               /* Max diff between ack'd packet and */
+       nd_uint16_t bufferSpace;        /* Number of packet buffers available */
+       nd_uint16_t maxSkew;            /* Max diff between ack'd packet and */

                                        /* highest packet received */
                                        /* highest packet received */

-       uint32_t firstPacket;           /* The first packet in ack list */
-       uint32_t previousPacket;        /* Previous packet recv'd (obsolete) */
-       uint32_t serial;                /* # of packet that prompted the ack */
-       uint8_t reason;         /* Reason for acknowledgement */
-       uint8_t nAcks;                  /* Number of acknowledgements */
+       nd_uint32_t firstPacket;        /* The first packet in ack list */
+       nd_uint32_t previousPacket;     /* Previous packet recv'd (obsolete) */
+       nd_uint32_t serial;             /* # of packet that prompted the ack */
+       nd_uint8_t reason;              /* Reason for acknowledgement */
+       nd_uint8_t nAcks;               /* Number of acknowledgements */
+       /* Followed by nAcks acknowledgments */
+#if 0

        uint8_t acks[RX_MAXACKS];       /* Up to RX_MAXACKS acknowledgements */
        uint8_t acks[RX_MAXACKS];       /* Up to RX_MAXACKS acknowledgements */

+#endif

 };
 
 /*
 };
 
 /*


@@ -145,8 +148,8 @@ static const struct tok rx_types[] = {
 };
 
 static const struct double_tok {
 };
 
 static const struct double_tok {

-       int flag;               /* Rx flag */
-       int packetType;         /* Packet type */
+       uint32_t flag;          /* Rx flag */
+       uint32_t packetType;    /* Packet type */

        const char *s;          /* Flag string */
 } rx_flags[] = {
        { RX_CLIENT_INITIATED,  0,                      "client-init" },
        const char *s;          /* Flag string */
 } rx_flags[] = {
        { RX_CLIENT_INITIATED,  0,                      "client-init" },


@@ -479,8 +482,8 @@ struct rx_cache_entry {
        uint32_t        callnum;        /* Call number (net order) */
        struct in_addr  client;         /* client IP address (net order) */
        struct in_addr  server;         /* server IP address (net order) */
        uint32_t        callnum;        /* Call number (net order) */
        struct in_addr  client;         /* client IP address (net order) */
        struct in_addr  server;         /* server IP address (net order) */

-       int             dport;          /* server port (host order) */
-       u_short         serviceId;      /* Service identifier (net order) */
+       u_int           dport;          /* server port (host order) */
+       uint16_t        serviceId;      /* Service identifier (net order) */

        uint32_t        opcode;         /* RX opcode (host order) */
 };
 
        uint32_t        opcode;         /* RX opcode (host order) */
 };
 


@@ -488,31 +491,31 @@ struct rx_cache_entry {
 
 static struct rx_cache_entry   rx_cache[RX_CACHE_SIZE];
 
 
 static struct rx_cache_entry   rx_cache[RX_CACHE_SIZE];
 

-static int     rx_cache_next = 0;
-static int     rx_cache_hint = 0;
-static void    rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, int);
+static uint32_t        rx_cache_next = 0;
+static uint32_t        rx_cache_hint = 0;
+static void    rx_cache_insert(netdissect_options *, const u_char *, const struct ip *, u_int);

 static int     rx_cache_find(const struct rx_header *, const struct ip *,
 static int     rx_cache_find(const struct rx_header *, const struct ip *,

-                             int, int32_t *);
+                             uint32_t, uint32_t *);

 
 

-static void fs_print(netdissect_options *, const u_char *, int);
-static void fs_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void fs_print(netdissect_options *, const u_char *, u_int);
+static void fs_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);

 static void acl_print(netdissect_options *, u_char *, int, u_char *);
 static void acl_print(netdissect_options *, u_char *, int, u_char *);

-static void cb_print(netdissect_options *, const u_char *, int);
-static void cb_reply_print(netdissect_options *, const u_char *, int, int32_t);
-static void prot_print(netdissect_options *, const u_char *, int);
-static void prot_reply_print(netdissect_options *, const u_char *, int, int32_t);
-static void vldb_print(netdissect_options *, const u_char *, int);
-static void vldb_reply_print(netdissect_options *, const u_char *, int, int32_t);
-static void kauth_print(netdissect_options *, const u_char *, int);
-static void kauth_reply_print(netdissect_options *, const u_char *, int, int32_t);
-static void vol_print(netdissect_options *, const u_char *, int);
-static void vol_reply_print(netdissect_options *, const u_char *, int, int32_t);
-static void bos_print(netdissect_options *, const u_char *, int);
-static void bos_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void cb_print(netdissect_options *, const u_char *, u_int);
+static void cb_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
+static void prot_print(netdissect_options *, const u_char *, u_int);
+static void prot_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
+static void vldb_print(netdissect_options *, const u_char *, u_int);
+static void vldb_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
+static void kauth_print(netdissect_options *, const u_char *, u_int);
+static void kauth_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
+static void vol_print(netdissect_options *, const u_char *, u_int);
+static void vol_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);
+static void bos_print(netdissect_options *, const u_char *, u_int);
+static void bos_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);

 static void ubik_print(netdissect_options *, const u_char *);
 static void ubik_print(netdissect_options *, const u_char *);

-static void ubik_reply_print(netdissect_options *, const u_char *, int, int32_t);
+static void ubik_reply_print(netdissect_options *, const u_char *, u_int, uint32_t);

 
 

-static void rx_ack_print(netdissect_options *, const u_char *, int);
+static void rx_ack_print(netdissect_options *, const u_char *, u_int);

 
 static int is_ubik(uint32_t);
 
 
 static int is_ubik(uint32_t);
 


@@ -523,44 +526,47 @@ static int is_ubik(uint32_t);
 
 void
 rx_print(netdissect_options *ndo,
 
 void
 rx_print(netdissect_options *ndo,

-         register const u_char *bp, int length, int sport, int dport,
+         register const u_char *bp, u_int length, u_int sport, u_int dport,

          const u_char *bp2)
 {
        register const struct rx_header *rxh;
          const u_char *bp2)
 {
        register const struct rx_header *rxh;

-       int i;
-       int32_t opcode;
+       uint32_t i;
+       uint8_t type, flags;
+       uint32_t opcode;

 
 

-       if (ndo->ndo_snapend - bp < (int)sizeof (struct rx_header)) {
-               ND_PRINT((ndo, " [|rx] (%d)", length));
+       if (!ND_TTEST2(*bp, sizeof (struct rx_header))) {
+               ND_PRINT((ndo, " [|rx] (%u)", length));

                return;
        }
 
        rxh = (const struct rx_header *) bp;
 
                return;
        }
 
        rxh = (const struct rx_header *) bp;
 

-       ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %d", rxh->type)));
+       type = EXTRACT_U_1(rxh->type);
+       ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %u", type)));

 
 

+       flags = EXTRACT_U_1(rxh->flags);

        if (ndo->ndo_vflag) {
                int firstflag = 0;
 
                if (ndo->ndo_vflag > 1)
        if (ndo->ndo_vflag) {
                int firstflag = 0;
 
                if (ndo->ndo_vflag > 1)

-                       ND_PRINT((ndo, " cid %08x call# %d",
-                              (int) EXTRACT_32BITS(&rxh->cid),
-                              (int) EXTRACT_32BITS(&rxh->callNumber)));
+                       ND_PRINT((ndo, " cid %08x call# %u",
+                              EXTRACT_BE_U_4(rxh->cid),
+                              EXTRACT_BE_U_4(rxh->callNumber)));

 
 

-               ND_PRINT((ndo, " seq %d ser %d",
-                      (int) EXTRACT_32BITS(&rxh->seq),
-                      (int) EXTRACT_32BITS(&rxh->serial)));
+               ND_PRINT((ndo, " seq %u ser %u",
+                      EXTRACT_BE_U_4(rxh->seq),
+                      EXTRACT_BE_U_4(rxh->serial)));

 
                if (ndo->ndo_vflag > 2)
 
                if (ndo->ndo_vflag > 2)

-                       ND_PRINT((ndo, " secindex %d serviceid %hu",
-                               (int) rxh->securityIndex,
-                               EXTRACT_16BITS(&rxh->serviceId)));
+                       ND_PRINT((ndo, " secindex %u serviceid %hu",
+                               EXTRACT_U_1(rxh->securityIndex),
+                               EXTRACT_BE_U_2(rxh->serviceId)));

 
                if (ndo->ndo_vflag > 1)
                        for (i = 0; i < NUM_RX_FLAGS; i++) {
 
                if (ndo->ndo_vflag > 1)
                        for (i = 0; i < NUM_RX_FLAGS; i++) {

-                               if (rxh->flags & rx_flags[i].flag &&
+                               if (flags & rx_flags[i].flag &&

                                    (!rx_flags[i].packetType ||
                                    (!rx_flags[i].packetType ||

-                                    rxh->type == rx_flags[i].packetType)) {
+                                    type == rx_flags[i].packetType)) {

                                        if (!firstflag) {
                                                firstflag = 1;
                                                ND_PRINT((ndo, " "));
                                        if (!firstflag) {
                                                firstflag = 1;
                                                ND_PRINT((ndo, " "));


@@ -581,9 +587,9 @@ rx_print(netdissect_options *ndo,
         * as well.
         */
 
         * as well.
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA &&
-           EXTRACT_32BITS(&rxh->seq) == 1 &&
-           rxh->flags & RX_CLIENT_INITIATED) {
+       if (type == RX_PACKET_TYPE_DATA &&
+           EXTRACT_BE_U_4(rxh->seq) == 1 &&
+           flags & RX_CLIENT_INITIATED) {

 
                /*
                 * Insert this call into the call cache table, so we
 
                /*
                 * Insert this call into the call cache table, so we


@@ -625,10 +631,10 @@ rx_print(netdissect_options *ndo,
         * because printing out the return code can be useful at times.
         */
 
         * because printing out the return code can be useful at times.
         */
 

-       } else if (((rxh->type == RX_PACKET_TYPE_DATA &&
-                                       EXTRACT_32BITS(&rxh->seq) == 1) ||
-                   rxh->type == RX_PACKET_TYPE_ABORT) &&
-                  (rxh->flags & RX_CLIENT_INITIATED) == 0 &&
+       } else if (((type == RX_PACKET_TYPE_DATA &&
+                                       EXTRACT_BE_U_4(rxh->seq) == 1) ||
+                   type == RX_PACKET_TYPE_ABORT) &&
+                  (flags & RX_CLIENT_INITIATED) == 0 &&

                   rx_cache_find(rxh, (const struct ip *) bp2,
                                 sport, &opcode)) {
 
                   rx_cache_find(rxh, (const struct ip *) bp2,
                                 sport, &opcode)) {
 


@@ -664,11 +670,11 @@ rx_print(netdissect_options *ndo,
         * ack packet, so we can use one for all AFS services)
         */
 
         * ack packet, so we can use one for all AFS services)
         */
 

-       } else if (rxh->type == RX_PACKET_TYPE_ACK)
+       } else if (type == RX_PACKET_TYPE_ACK)

                rx_ack_print(ndo, bp, length);
 
 
                rx_ack_print(ndo, bp, length);
 
 

-       ND_PRINT((ndo, " (%d)", length));
+       ND_PRINT((ndo, " (%u)", length));

 }
 
 /*
 }
 
 /*


@@ -677,12 +683,12 @@ rx_print(netdissect_options *ndo,
 
 static void
 rx_cache_insert(netdissect_options *ndo,
 
 static void
 rx_cache_insert(netdissect_options *ndo,

-                const u_char *bp, const struct ip *ip, int dport)
+                const u_char *bp, const struct ip *ip, u_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 (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t)))
+       if (!ND_TTEST_4(bp + sizeof(struct rx_header)))

                return;
 
        rxent = &rx_cache[rx_cache_next];
                return;
 
        rxent = &rx_cache[rx_cache_next];


@@ -690,12 +696,12 @@ rx_cache_insert(netdissect_options *ndo,
        if (++rx_cache_next >= RX_CACHE_SIZE)
                rx_cache_next = 0;
 
        if (++rx_cache_next >= RX_CACHE_SIZE)
                rx_cache_next = 0;
 

-       rxent->callnum = rxh->callNumber;
+       rxent->callnum = EXTRACT_BE_U_4(rxh->callNumber);

        UNALIGNED_MEMCPY(&rxent->client, &ip->ip_src, sizeof(uint32_t));
        UNALIGNED_MEMCPY(&rxent->server, &ip->ip_dst, sizeof(uint32_t));
        rxent->dport = dport;
        UNALIGNED_MEMCPY(&rxent->client, &ip->ip_src, sizeof(uint32_t));
        UNALIGNED_MEMCPY(&rxent->server, &ip->ip_dst, sizeof(uint32_t));
        rxent->dport = dport;

-       rxent->serviceId = rxh->serviceId;
-       rxent->opcode = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       rxent->serviceId = EXTRACT_BE_U_4(rxh->serviceId);
+       rxent->opcode = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 }
 
 /*
 }
 
 /*


@@ -706,10 +712,10 @@ rx_cache_insert(netdissect_options *ndo,
  */
 
 static int
  */
 
 static int

-rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
-             int32_t *opcode)
+rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
+             uint32_t *opcode)

 {
 {

-       int i;
+       uint32_t i;

        struct rx_cache_entry *rxent;
        uint32_t clip;
        uint32_t sip;
        struct rx_cache_entry *rxent;
        uint32_t clip;
        uint32_t sip;


@@ -722,10 +728,10 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
        i = rx_cache_hint;
        do {
                rxent = &rx_cache[i];
        i = rx_cache_hint;
        do {
                rxent = &rx_cache[i];

-               if (rxent->callnum == rxh->callNumber &&
+               if (rxent->callnum == EXTRACT_BE_U_4(rxh->callNumber) &&

                    rxent->client.s_addr == clip &&
                    rxent->server.s_addr == sip &&
                    rxent->client.s_addr == clip &&
                    rxent->server.s_addr == sip &&

-                   rxent->serviceId == rxh->serviceId &&
+                   rxent->serviceId == EXTRACT_BE_U_4(rxh->serviceId) &&

                    rxent->dport == sport) {
 
                        /* We got a match! */
                    rxent->dport == sport) {
 
                        /* We got a match! */


@@ -746,100 +752,100 @@ 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 FIDOUT() { unsigned long n1, n2, n3; \
-                       ND_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); \
-                       ND_PRINT((ndo, " fid %d/%d/%d", (int) n1, (int) n2, (int) n3)); \
+#define FIDOUT() { uint32_t n1, n2, n3; \
+                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 3); \
+                       n1 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       n2 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       n3 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       ND_PRINT((ndo, " fid %u/%u/%u", n1, n2, n3)); \

                }
 
                }
 

-#define STROUT(MAX) { unsigned int _i; \
-                       ND_TCHECK2(bp[0], sizeof(int32_t)); \
-                       _i = EXTRACT_32BITS(bp); \
+#define STROUT(MAX) { uint32_t _i; \
+                       ND_TCHECK2(bp[0], sizeof(uint32_t)); \
+                       _i = EXTRACT_BE_U_4(bp); \

                        if (_i > (MAX)) \
                                goto trunc; \
                        if (_i > (MAX)) \
                                goto trunc; \

-                       bp += sizeof(int32_t); \
+                       bp += sizeof(uint32_t); \

                        ND_PRINT((ndo, " \"")); \
                        if (fn_printn(ndo, bp, _i, ndo->ndo_snapend)) \
                                goto trunc; \
                        ND_PRINT((ndo, "\"")); \
                        ND_PRINT((ndo, " \"")); \
                        if (fn_printn(ndo, bp, _i, ndo->ndo_snapend)) \
                                goto trunc; \
                        ND_PRINT((ndo, "\"")); \

-                       bp += ((_i + sizeof(int32_t) - 1) / sizeof(int32_t)) * sizeof(int32_t); \
+                       bp += ((_i + sizeof(uint32_t) - 1) / sizeof(uint32_t)) * sizeof(uint32_t); \

                }
 
                }
 

-#define INTOUT() { int _i; \
-                       ND_TCHECK2(bp[0], sizeof(int32_t)); \
-                       _i = (int) EXTRACT_32BITS(bp); \
+#define INTOUT() { int32_t _i; \
+                       ND_TCHECK_4(bp); \
+                       _i = EXTRACT_BE_S_4(bp); \

                        bp += sizeof(int32_t); \
                        ND_PRINT((ndo, " %d", _i)); \
                }
 
                        bp += sizeof(int32_t); \
                        ND_PRINT((ndo, " %d", _i)); \
                }
 

-#define UINTOUT() { unsigned long _i; \
-                       ND_TCHECK2(bp[0], sizeof(int32_t)); \
-                       _i = EXTRACT_32BITS(bp); \
-                       bp += sizeof(int32_t); \
-                       ND_PRINT((ndo, " %lu", _i)); \
+#define UINTOUT() { uint32_t _i; \
+                       ND_TCHECK_4(bp); \
+                       _i = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       ND_PRINT((ndo, " %u", _i)); \

                }
 
 #define UINT64OUT() { uint64_t _i; \
                        ND_TCHECK2(bp[0], sizeof(uint64_t)); \
                }
 
 #define UINT64OUT() { uint64_t _i; \
                        ND_TCHECK2(bp[0], sizeof(uint64_t)); \

-                       _i = EXTRACT_64BITS(bp); \
+                       _i = EXTRACT_BE_U_8(bp); \

                        bp += sizeof(uint64_t); \
                        ND_PRINT((ndo, " %" PRIu64, _i)); \
                }
 
 #define DATEOUT() { time_t _t; struct tm *tm; char str[256]; \
                        bp += sizeof(uint64_t); \
                        ND_PRINT((ndo, " %" PRIu64, _i)); \
                }
 
 #define DATEOUT() { time_t _t; struct tm *tm; char str[256]; \

-                       ND_TCHECK2(bp[0], sizeof(int32_t)); \
-                       _t = (time_t) EXTRACT_32BITS(bp); \
+                       ND_TCHECK_4(bp); \
+                       _t = (time_t) EXTRACT_BE_S_4(bp); \

                        bp += sizeof(int32_t); \
                        tm = localtime(&_t); \
                        strftime(str, 256, "%Y/%m/%d %H:%M:%S", tm); \
                        ND_PRINT((ndo, " %s", str)); \
                }
 
                        bp += sizeof(int32_t); \
                        tm = localtime(&_t); \
                        strftime(str, 256, "%Y/%m/%d %H:%M:%S", tm); \
                        ND_PRINT((ndo, " %s", str)); \
                }
 

-#define STOREATTROUT() { unsigned long mask, _i; \
-                       ND_TCHECK2(bp[0], (sizeof(int32_t)*6)); \
-                       mask = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
+#define STOREATTROUT() { uint32_t mask, _i; \
+                       ND_TCHECK2(bp[0], (sizeof(uint32_t)*6)); \
+                       mask = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \

                        if (mask) ND_PRINT((ndo, " StoreStatus")); \
                        if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \
                        if (mask) ND_PRINT((ndo, " StoreStatus")); \
                        if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \

-                       else bp += sizeof(int32_t); \
-                       _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 2) ND_PRINT((ndo, " owner %lu", _i));  \
-                       _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 4) ND_PRINT((ndo, " group %lu", _i)); \
-                       _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 8) ND_PRINT((ndo, " mode %lo", _i & 07777)); \
-                       _i = EXTRACT_32BITS(bp); bp += sizeof(int32_t); \
-                       if (mask & 16) ND_PRINT((ndo, " segsize %lu", _i)); \
+                       else bp += sizeof(uint32_t); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
+                       if (mask & 2) ND_PRINT((ndo, " owner %u", _i));  \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
+                       if (mask & 4) ND_PRINT((ndo, " group %u", _i)); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
+                       if (mask & 8) ND_PRINT((ndo, " mode %o", _i & 07777)); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
+                       if (mask & 16) ND_PRINT((ndo, " segsize %u", _i)); \

                        /* undocumented in 3.3 docu */ \
                        if (mask & 1024) ND_PRINT((ndo, " fsync"));  \
                }
 
                        /* undocumented in 3.3 docu */ \
                        if (mask & 1024) ND_PRINT((ndo, " fsync"));  \
                }
 

-#define UBIK_VERSIONOUT() {int32_t epoch; int32_t counter; \
-                       ND_TCHECK2(bp[0], sizeof(int32_t) * 2); \
-                       epoch = EXTRACT_32BITS(bp); \
-                       bp += sizeof(int32_t); \
-                       counter = EXTRACT_32BITS(bp); \
-                       bp += sizeof(int32_t); \
-                       ND_PRINT((ndo, " %d.%d", epoch, counter)); \
+#define UBIK_VERSIONOUT() {uint32_t epoch; uint32_t counter; \
+                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 2); \
+                       epoch = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       counter = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       ND_PRINT((ndo, " %u.%u", epoch, counter)); \

                }
 
 #define AFSUUIDOUT() {uint32_t temp; int _i; \
                        ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \
                }
 
 #define AFSUUIDOUT() {uint32_t temp; int _i; \
                        ND_TCHECK2(bp[0], 11*sizeof(uint32_t)); \

-                       temp = EXTRACT_32BITS(bp); \
+                       temp = EXTRACT_BE_U_4(bp); \

                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " %08x", temp)); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " %08x", temp)); \

-                       temp = EXTRACT_32BITS(bp); \
+                       temp = EXTRACT_BE_U_4(bp); \

                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, "%04x", temp)); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, "%04x", temp)); \

-                       temp = EXTRACT_32BITS(bp); \
+                       temp = EXTRACT_BE_U_4(bp); \

                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, "%04x", temp)); \
                        for (_i = 0; _i < 8; _i++) { \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, "%04x", temp)); \
                        for (_i = 0; _i < 8; _i++) { \

-                               temp = EXTRACT_32BITS(bp); \
+                               temp = EXTRACT_BE_U_4(bp); \

                                bp += sizeof(uint32_t); \
                                ND_PRINT((ndo, "%02x", (unsigned char) temp)); \
                        } \
                                bp += sizeof(uint32_t); \
                                ND_PRINT((ndo, "%02x", (unsigned char) temp)); \
                        } \


@@ -851,14 +857,14 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
 
 #define VECOUT(MAX) { u_char *sp; \
                        u_char s[AFSNAMEMAX]; \
 
 #define VECOUT(MAX) { u_char *sp; \
                        u_char s[AFSNAMEMAX]; \

-                       int k; \
+                       uint32_t k; \

                        if ((MAX) + 1 > sizeof(s)) \
                                goto trunc; \
                        if ((MAX) + 1 > sizeof(s)) \
                                goto trunc; \

-                       ND_TCHECK2(bp[0], (MAX) * sizeof(int32_t)); \
+                       ND_TCHECK2(bp[0], (MAX) * sizeof(uint32_t)); \

                        sp = s; \
                        for (k = 0; k < (MAX); k++) { \
                        sp = s; \
                        for (k = 0; k < (MAX); k++) { \

-                               *sp++ = (u_char) EXTRACT_32BITS(bp); \
-                               bp += sizeof(int32_t); \
+                               *sp++ = (u_char) EXTRACT_BE_U_4(bp); \
+                               bp += sizeof(uint32_t); \

                        } \
                        s[(MAX)] = '\0'; \
                        ND_PRINT((ndo, " \"")); \
                        } \
                        s[(MAX)] = '\0'; \
                        ND_PRINT((ndo, " \"")); \


@@ -866,15 +872,15 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
                        ND_PRINT((ndo, "\"")); \
                }
 
                        ND_PRINT((ndo, "\"")); \
                }
 

-#define DESTSERVEROUT() { unsigned long n1, n2, n3; \
-                       ND_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); \
-                       ND_PRINT((ndo, " server %d:%d:%d", (int) n1, (int) n2, (int) n3)); \
+#define DESTSERVEROUT() { uint32_t n1, n2, n3; \
+                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 3); \
+                       n1 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       n2 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       n3 = EXTRACT_BE_U_4(bp); \
+                       bp += sizeof(uint32_t); \
+                       ND_PRINT((ndo, " server %u:%u:%u", n1, n2, n3)); \

                }
 
 /*
                }
 
 /*


@@ -883,26 +889,23 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, int sport,
 
 static void
 fs_print(netdissect_options *ndo,
 
 static void
 fs_print(netdissect_options *ndo,

-         register const u_char *bp, int length)
+         register const u_char *bp, u_int length)

 {
 {

-       int fs_op;
-       unsigned long i;
+       uint32_t fs_op;
+       uint32_t i;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from fsint/afsint.xg
         */
 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from fsint/afsint.xg
         */
 

-       fs_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       fs_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
 

-       ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%d", fs_op)));
+       ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%u", fs_op)));

 
        /*
         * Print out arguments to some of the AFS calls.  This stuff is
 
        /*
         * Print out arguments to some of the AFS calls.  This stuff is


@@ -951,9 +954,9 @@ fs_print(netdissect_options *ndo,
                {
                        char a[AFSOPAQUEMAX+1];
                        FIDOUT();
                {
                        char a[AFSOPAQUEMAX+1];
                        FIDOUT();

-                       ND_TCHECK2(bp[0], 4);
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        ND_TCHECK2(bp[0], i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        ND_TCHECK2(bp[0], i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);


@@ -1007,10 +1010,10 @@ fs_print(netdissect_options *ndo,
                case 155:       /* Bulk stat */
                case 65536:     /* Inline bulk stat */
                {
                case 155:       /* Bulk stat */
                case 65536:     /* Inline bulk stat */
                {

-                       unsigned long j;
-                       ND_TCHECK2(bp[0], 4);
-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       uint32_t j;
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

 
                        for (i = 0; i < j; i++) {
                                FIDOUT();
 
                        for (i = 0; i < j; i++) {
                                FIDOUT();


@@ -1056,12 +1059,13 @@ trunc:
 
 static void
 fs_reply_print(netdissect_options *ndo,
 
 static void
 fs_reply_print(netdissect_options *ndo,

-               register const u_char *bp, int length, int32_t opcode)
+               register const u_char *bp, u_int length, uint32_t opcode)

 {
 {

-       unsigned long i;
+       uint32_t i;

        const struct rx_header *rxh;
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -1071,22 +1075,23 @@ fs_reply_print(netdissect_options *ndo,
         * gleaned from fsint/afsint.xg
         */
 
         * gleaned from fsint/afsint.xg
         */
 

-       ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA) {
+       if (type == RX_PACKET_TYPE_DATA) {

                switch (opcode) {
                case 131:       /* Fetch ACL */
                {
                        char a[AFSOPAQUEMAX+1];
                switch (opcode) {
                case 131:       /* Fetch ACL */
                {
                        char a[AFSOPAQUEMAX+1];

-                       ND_TCHECK2(bp[0], 4);
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        ND_TCHECK2(bp[0], i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        ND_TCHECK2(bp[0], i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);


@@ -1109,17 +1114,19 @@ fs_reply_print(netdissect_options *ndo,
                default:
                        ;
                }
                default:
                        ;
                }

-       } else if (rxh->type == RX_PACKET_TYPE_ABORT) {
+       } else if (type == RX_PACKET_TYPE_ABORT) {

                /*
                 * Otherwise, just print out the return code
                 */
                /*
                 * Otherwise, just print out the return code
                 */

-               ND_TCHECK2(bp[0], sizeof(int32_t));
-               i = (int) EXTRACT_32BITS(bp);
+               int32_t errcode;
+
+               ND_TCHECK_4(bp);
+               errcode = EXTRACT_BE_S_4(bp);

                bp += sizeof(int32_t);
 
                bp += sizeof(int32_t);
 

-               ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", i)));
+               ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", errcode)));

        } else {
        } else {

-               ND_PRINT((ndo, " strange fs reply of type %d", rxh->type));
+               ND_PRINT((ndo, " strange fs reply of type %u", type));

        }
 
        return;
        }
 
        return;


@@ -1217,26 +1224,23 @@ finish:
 
 static void
 cb_print(netdissect_options *ndo,
 
 static void
 cb_print(netdissect_options *ndo,

-         register const u_char *bp, int length)
+         register const u_char *bp, u_int length)

 {
 {

-       int cb_op;
-       unsigned long i;
+       uint32_t cb_op;
+       uint32_t i;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * 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
         */
 

-       cb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       cb_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
 

-       ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%d", cb_op)));
+       ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%u", cb_op)));

 
        bp += sizeof(struct rx_header) + 4;
 
 
        bp += sizeof(struct rx_header) + 4;
 


@@ -1248,10 +1252,10 @@ cb_print(netdissect_options *ndo,
        switch (cb_op) {
                case 204:               /* Callback */
                {
        switch (cb_op) {
                case 204:               /* Callback */
                {

-                       unsigned long j, t;
-                       ND_TCHECK2(bp[0], 4);
-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       uint32_t j, t;
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

 
                        for (i = 0; i < j; i++) {
                                FIDOUT();
 
                        for (i = 0; i < j; i++) {
                                FIDOUT();


@@ -1262,8 +1266,9 @@ cb_print(netdissect_options *ndo,
                        if (j == 0)
                                ND_PRINT((ndo, " <none!>"));
 
                        if (j == 0)
                                ND_PRINT((ndo, " <none!>"));
 

-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

 
                        if (j != 0)
                                ND_PRINT((ndo, ";"));
 
                        if (j != 0)
                                ND_PRINT((ndo, ";"));


@@ -1273,10 +1278,10 @@ cb_print(netdissect_options *ndo,
                                INTOUT();
                                ND_PRINT((ndo, " expires"));
                                DATEOUT();
                                INTOUT();
                                ND_PRINT((ndo, " expires"));
                                DATEOUT();

-                               ND_TCHECK2(bp[0], 4);
-                               t = EXTRACT_32BITS(bp);
-                               bp += sizeof(int32_t);
-                               tok2str(cb_types, "type %d", t);
+                               ND_TCHECK_4(bp);
+                               t = EXTRACT_BE_U_4(bp);
+                               bp += sizeof(uint32_t);
+                               tok2str(cb_types, "type %u", t);

                        }
                }
                case 214: {
                        }
                }
                case 214: {


@@ -1300,11 +1305,12 @@ trunc:
 
 static void
 cb_reply_print(netdissect_options *ndo,
 
 static void
 cb_reply_print(netdissect_options *ndo,

-               register const u_char *bp, int length, int32_t opcode)
+               register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -1314,15 +1320,16 @@ cb_reply_print(netdissect_options *ndo,
         * gleaned from fsint/afscbint.xg
         */
 
         * gleaned from fsint/afscbint.xg
         */
 

-       ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                switch (opcode) {
                case 213:       /* InitCallBackState3 */
                        AFSUUIDOUT();
                switch (opcode) {
                case 213:       /* InitCallBackState3 */
                        AFSUUIDOUT();


@@ -1350,24 +1357,21 @@ trunc:
 
 static void
 prot_print(netdissect_options *ndo,
 
 static void
 prot_print(netdissect_options *ndo,

-           register const u_char *bp, int length)
+           register const u_char *bp, u_int length)

 {
 {

-       unsigned long i;
-       int pt_op;
+       uint32_t i;
+       uint32_t pt_op;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from ptserver/ptint.xg
         */
 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from ptserver/ptint.xg
         */
 

-       pt_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       pt_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
        ND_PRINT((ndo, " pt"));
 
 
        ND_PRINT((ndo, " pt"));
 


@@ -1376,7 +1380,7 @@ prot_print(netdissect_options *ndo,
                return;
        }
 
                return;
        }
 

-       ND_PRINT((ndo, " call %s", tok2str(pt_req, "op#%d", pt_op)));
+       ND_PRINT((ndo, " call %s", tok2str(pt_req, "op#%u", pt_op)));

 
        /*
         * Decode some of the arguments to the PT calls
 
        /*
         * Decode some of the arguments to the PT calls


@@ -1418,10 +1422,10 @@ prot_print(netdissect_options *ndo,
                        break;
                case 504:       /* Name to ID */
                {
                        break;
                case 504:       /* Name to ID */
                {

-                       unsigned long j;
-                       ND_TCHECK2(bp[0], 4);
-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       uint32_t j;
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

 
                        /*
                         * Who designed this chicken-shit protocol?
 
                        /*
                         * Who designed this chicken-shit protocol?


@@ -1439,11 +1443,11 @@ prot_print(netdissect_options *ndo,
                        break;
                case 505:       /* Id to name */
                {
                        break;
                case 505:       /* Id to name */
                {

-                       unsigned long j;
+                       uint32_t j;

                        ND_PRINT((ndo, " ids:"));
                        ND_PRINT((ndo, " ids:"));

-                       ND_TCHECK2(bp[0], 4);
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        for (j = 0; j < i; j++)
                                INTOUT();
                        if (j == 0)
                        for (j = 0; j < i; j++)
                                INTOUT();
                        if (j == 0)


@@ -1494,12 +1498,13 @@ trunc:
 
 static void
 prot_reply_print(netdissect_options *ndo,
 
 static void
 prot_reply_print(netdissect_options *ndo,

-                 register const u_char *bp, int length, int32_t opcode)
+                 register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

-       unsigned long i;
+       uint8_t type;
+       uint32_t i;

 
 

-       if (length < (int)sizeof(struct rx_header))
+       if (length < sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -1517,23 +1522,24 @@ prot_reply_print(netdissect_options *ndo,
                return;
        }
 
                return;
        }
 

-       ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                switch (opcode) {
                case 504:               /* Name to ID */
                {
                switch (opcode) {
                case 504:               /* Name to ID */
                {

-                       unsigned long j;
+                       uint32_t j;

                        ND_PRINT((ndo, " ids:"));
                        ND_PRINT((ndo, " ids:"));

-                       ND_TCHECK2(bp[0], 4);
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        for (j = 0; j < i; j++)
                                INTOUT();
                        if (j == 0)
                        for (j = 0; j < i; j++)
                                INTOUT();
                        if (j == 0)


@@ -1542,10 +1548,10 @@ prot_reply_print(netdissect_options *ndo,
                        break;
                case 505:               /* ID to name */
                {
                        break;
                case 505:               /* ID to name */
                {

-                       unsigned long j;
-                       ND_TCHECK2(bp[0], 4);
-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       uint32_t j;
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

 
                        /*
                         * Who designed this chicken-shit protocol?
 
                        /*
                         * Who designed this chicken-shit protocol?


@@ -1567,10 +1573,10 @@ prot_reply_print(netdissect_options *ndo,
                case 518:               /* Get CPS2 */
                case 519:               /* Get host CPS */
                {
                case 518:               /* Get CPS2 */
                case 519:               /* Get host CPS */
                {

-                       unsigned long j;
-                       ND_TCHECK2(bp[0], 4);
-                       j = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       uint32_t j;
+                       ND_TCHECK_4(bp);
+                       j = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        for (i = 0; i < j; i++) {
                                INTOUT();
                        }
                        for (i = 0; i < j; i++) {
                                INTOUT();
                        }


@@ -1607,24 +1613,21 @@ trunc:
 
 static void
 vldb_print(netdissect_options *ndo,
 
 static void
 vldb_print(netdissect_options *ndo,

-           register const u_char *bp, int length)
+           register const u_char *bp, u_int length)

 {
 {

-       int vldb_op;
-       unsigned long i;
+       uint32_t vldb_op;
+       uint32_t i;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from vlserver/vldbint.xg
         */
 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from vlserver/vldbint.xg
         */
 

-       vldb_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       vldb_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
        ND_PRINT((ndo, " vldb"));
 
 
        ND_PRINT((ndo, " vldb"));
 


@@ -1632,7 +1635,7 @@ vldb_print(netdissect_options *ndo,
                ubik_print(ndo, bp);
                return;
        }
                ubik_print(ndo, bp);
                return;
        }

-       ND_PRINT((ndo, " call %s", tok2str(vldb_req, "op#%d", vldb_op)));
+       ND_PRINT((ndo, " call %s", tok2str(vldb_req, "op#%u", vldb_op)));

 
        /*
         * Decode some of the arguments to the VLDB calls
 
        /*
         * Decode some of the arguments to the VLDB calls


@@ -1653,9 +1656,9 @@ vldb_print(netdissect_options *ndo,
                case 518:       /* Get entry by ID N */
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                case 518:       /* Get entry by ID N */
                        ND_PRINT((ndo, " volid"));
                        INTOUT();

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        break;
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        break;


@@ -1673,9 +1676,9 @@ vldb_print(netdissect_options *ndo,
                case 520:       /* Replace entry N */
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                case 520:       /* Replace entry N */
                        ND_PRINT((ndo, " volid"));
                        INTOUT();

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       i = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        VECOUT(VLNAMEMAX);
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        VECOUT(VLNAMEMAX);


@@ -1701,12 +1704,13 @@ trunc:
 
 static void
 vldb_reply_print(netdissect_options *ndo,
 
 static void
 vldb_reply_print(netdissect_options *ndo,

-                 register const u_char *bp, int length, int32_t opcode)
+                 register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

-       unsigned long i;
+       uint8_t type;
+       uint32_t i;

 
 

-       if (length < (int)sizeof(struct rx_header))
+       if (length < sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -1724,15 +1728,16 @@ vldb_reply_print(netdissect_options *ndo,
                return;
        }
 
                return;
        }
 

-       ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                switch (opcode) {
                case 510:       /* List entry */
                        ND_PRINT((ndo, " count"));
                switch (opcode) {
                case 510:       /* List entry */
                        ND_PRINT((ndo, " count"));


@@ -1741,35 +1746,35 @@ vldb_reply_print(netdissect_options *ndo,
                        INTOUT();
                case 503:       /* Get entry by id */
                case 504:       /* Get entry by name */
                        INTOUT();
                case 503:       /* Get entry by id */
                case 504:       /* Get entry by name */

-               {       unsigned long nservers, j;
+               {       uint32_t nservers, j;

                        VECOUT(VLNAMEMAX);
                        VECOUT(VLNAMEMAX);

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       bp += sizeof(uint32_t);

                        ND_PRINT((ndo, " numservers"));
                        ND_PRINT((ndo, " numservers"));

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       nservers = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
-                       ND_PRINT((ndo, " %lu", nservers));
+                       ND_TCHECK_4(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);
+                       ND_PRINT((ndo, " %u", nservers));

                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 8; i++) {
                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 8; i++) {

-                               ND_TCHECK2(bp[0], sizeof(int32_t));
+                               ND_TCHECK_4(bp);

                                if (i < nservers)
                                        ND_PRINT((ndo, " %s",
                                           intoa(((const struct in_addr *) bp)->s_addr)));
                                if (i < nservers)
                                        ND_PRINT((ndo, " %s",
                                           intoa(((const struct in_addr *) bp)->s_addr)));

-                               bp += sizeof(int32_t);
+                               bp += sizeof(uint32_t);

                        }
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 8; i++) {
                        }
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 8; i++) {

-                               ND_TCHECK2(bp[0], sizeof(int32_t));
-                               j = EXTRACT_32BITS(bp);
+                               ND_TCHECK_4(bp);
+                               j = EXTRACT_BE_U_4(bp);

                                if (i < nservers && j <= 26)
                                if (i < nservers && j <= 26)

-                                       ND_PRINT((ndo, " %c", 'a' + (int)j));
+                                       ND_PRINT((ndo, " %c", 'a' + j));

                                else if (i < nservers)
                                else if (i < nservers)

-                                       ND_PRINT((ndo, " %lu", j));
-                               bp += sizeof(int32_t);
+                                       ND_PRINT((ndo, " %u", j));
+                               bp += sizeof(uint32_t);

                        }
                        }

-                       ND_TCHECK2(bp[0], 8 * sizeof(int32_t));
-                       bp += 8 * sizeof(int32_t);
+                       ND_TCHECK2(bp[0], 8 * sizeof(uint32_t));
+                       bp += 8 * sizeof(uint32_t);

                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));


@@ -1790,33 +1795,33 @@ vldb_reply_print(netdissect_options *ndo,
                        INTOUT();
                case 518:       /* Get entry by ID N */
                case 519:       /* Get entry by name N */
                        INTOUT();
                case 518:       /* Get entry by ID N */
                case 519:       /* Get entry by name N */

-               {       unsigned long nservers, j;
+               {       uint32_t nservers, j;

                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       nservers = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
-                       ND_PRINT((ndo, " %lu", nservers));
+                       ND_TCHECK_4(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);
+                       ND_PRINT((ndo, " %u", nservers));

                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 13; i++) {
                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 13; i++) {

-                               ND_TCHECK2(bp[0], sizeof(int32_t));
+                               ND_TCHECK_4(bp);

                                if (i < nservers)
                                        ND_PRINT((ndo, " %s",
                                           intoa(((const struct in_addr *) bp)->s_addr)));
                                if (i < nservers)
                                        ND_PRINT((ndo, " %s",
                                           intoa(((const struct in_addr *) bp)->s_addr)));

-                               bp += sizeof(int32_t);
+                               bp += sizeof(uint32_t);

                        }
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                        }
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {

-                               ND_TCHECK2(bp[0], sizeof(int32_t));
-                               j = EXTRACT_32BITS(bp);
+                               ND_TCHECK_4(bp);
+                               j = EXTRACT_BE_U_4(bp);

                                if (i < nservers && j <= 26)
                                if (i < nservers && j <= 26)

-                                       ND_PRINT((ndo, " %c", 'a' + (int)j));
+                                       ND_PRINT((ndo, " %c", 'a' + j));

                                else if (i < nservers)
                                else if (i < nservers)

-                                       ND_PRINT((ndo, " %lu", j));
-                               bp += sizeof(int32_t);
+                                       ND_PRINT((ndo, " %u", j));
+                               bp += sizeof(uint32_t);

                        }
                        }

-                       ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
-                       bp += 13 * sizeof(int32_t);
+                       ND_TCHECK2(bp[0], 13 * sizeof(uint32_t));
+                       bp += 13 * sizeof(uint32_t);

                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));


@@ -1827,13 +1832,13 @@ vldb_reply_print(netdissect_options *ndo,
                        break;
                case 526:       /* Get entry by ID U */
                case 527:       /* Get entry by name U */
                        break;
                case 526:       /* Get entry by ID U */
                case 527:       /* Get entry by name U */

-               {       unsigned long nservers, j;
+               {       uint32_t nservers, j;

                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       nservers = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
-                       ND_PRINT((ndo, " %lu", nservers));
+                       ND_TCHECK_4(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);
+                       ND_PRINT((ndo, " %u", nservers));

                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 13; i++) {
                                if (i < nservers) {
                        ND_PRINT((ndo, " servers"));
                        for (i = 0; i < 13; i++) {
                                if (i < nservers) {


@@ -1848,16 +1853,16 @@ vldb_reply_print(netdissect_options *ndo,
                        bp += 4 * 13;
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                        bp += 4 * 13;
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {

-                               ND_TCHECK2(bp[0], sizeof(int32_t));
-                               j = EXTRACT_32BITS(bp);
+                               ND_TCHECK_4(bp);
+                               j = EXTRACT_BE_U_4(bp);

                                if (i < nservers && j <= 26)
                                if (i < nservers && j <= 26)

-                                       ND_PRINT((ndo, " %c", 'a' + (int)j));
+                                       ND_PRINT((ndo, " %c", 'a' + j));

                                else if (i < nservers)
                                else if (i < nservers)

-                                       ND_PRINT((ndo, " %lu", j));
-                               bp += sizeof(int32_t);
+                                       ND_PRINT((ndo, " %u", j));
+                               bp += sizeof(uint32_t);

                        }
                        }

-                       ND_TCHECK2(bp[0], 13 * sizeof(int32_t));
-                       bp += 13 * sizeof(int32_t);
+                       ND_TCHECK2(bp[0], 13 * sizeof(uint32_t));
+                       bp += 13 * sizeof(uint32_t);

                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        ND_PRINT((ndo, " rovol"));


@@ -1889,23 +1894,20 @@ trunc:
 
 static void
 kauth_print(netdissect_options *ndo,
 
 static void
 kauth_print(netdissect_options *ndo,

-            register const u_char *bp, int length)
+            register const u_char *bp, u_int length)

 {
 {

-       int kauth_op;
+       uint32_t kauth_op;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * 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
         */
 

-       kauth_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       kauth_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
        ND_PRINT((ndo, " kauth"));
 
 
        ND_PRINT((ndo, " kauth"));
 


@@ -1915,7 +1917,7 @@ kauth_print(netdissect_options *ndo,
        }
 
 
        }
 
 

-       ND_PRINT((ndo, " call %s", tok2str(kauth_req, "op#%d", kauth_op)));
+       ND_PRINT((ndo, " call %s", tok2str(kauth_req, "op#%u", kauth_op)));

 
        /*
         * Decode some of the arguments to the KA calls
 
        /*
         * Decode some of the arguments to the KA calls


@@ -1941,14 +1943,14 @@ kauth_print(netdissect_options *ndo,
                case 3:         /* GetTicket-old */
                case 23:        /* GetTicket */
                {
                case 3:         /* GetTicket-old */
                case 23:        /* GetTicket */
                {

-                       int i;
+                       uint32_t i;

                        ND_PRINT((ndo, " kvno"));
                        INTOUT();
                        ND_PRINT((ndo, " domain"));
                        STROUT(KANAMEMAX);
                        ND_PRINT((ndo, " kvno"));
                        INTOUT();
                        ND_PRINT((ndo, " domain"));
                        STROUT(KANAMEMAX);

-                       ND_TCHECK2(bp[0], sizeof(int32_t));
-                       i = (int) EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        ND_TCHECK2(bp[0], i);
                        bp += i;
                        ND_PRINT((ndo, " principal"));
                        ND_TCHECK2(bp[0], i);
                        bp += i;
                        ND_PRINT((ndo, " principal"));


@@ -1983,11 +1985,12 @@ trunc:
 
 static void
 kauth_reply_print(netdissect_options *ndo,
 
 static void
 kauth_reply_print(netdissect_options *ndo,

-                  register const u_char *bp, int length, int32_t opcode)
+                  register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -2004,15 +2007,16 @@ kauth_reply_print(netdissect_options *ndo,
                return;
        }
 
                return;
        }
 

-       ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                /* Well, no, not really.  Leave this for later */
                ;
        else {
                /* Well, no, not really.  Leave this for later */
                ;
        else {


@@ -2035,25 +2039,22 @@ trunc:
 
 static void
 vol_print(netdissect_options *ndo,
 
 static void
 vol_print(netdissect_options *ndo,

-          register const u_char *bp, int length)
+          register const u_char *bp, u_int length)

 {
 {

-       int vol_op;
+       uint32_t vol_op;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * 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
         */
 

-       vol_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       vol_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
 

-       ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%d", vol_op)));
+       ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%u", vol_op)));

 
        bp += sizeof(struct rx_header) + 4;
 
 
        bp += sizeof(struct rx_header) + 4;
 


@@ -2201,10 +2202,10 @@ vol_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " fromdate"));
                        DATEOUT();
                        {
                        ND_PRINT((ndo, " fromdate"));
                        DATEOUT();
                        {

-                               unsigned long i, j;
-                               ND_TCHECK2(bp[0], 4);
-                               j = EXTRACT_32BITS(bp);
-                               bp += sizeof(int32_t);
+                               uint32_t i, j;
+                               ND_TCHECK_4(bp);
+                               j = EXTRACT_BE_U_4(bp);
+                               bp += sizeof(uint32_t);

                                for (i = 0; i < j; i++) {
                                        DESTSERVEROUT();
                                        if (i != j - 1)
                                for (i = 0; i < j; i++) {
                                        DESTSERVEROUT();
                                        if (i != j - 1)


@@ -2237,11 +2238,12 @@ trunc:
 
 static void
 vol_reply_print(netdissect_options *ndo,
 
 static void
 vol_reply_print(netdissect_options *ndo,

-                register const u_char *bp, int length, int32_t opcode)
+                register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -2251,15 +2253,16 @@ vol_reply_print(netdissect_options *ndo,
         * gleaned from volser/volint.xg
         */
 
         * gleaned from volser/volint.xg
         */
 

-       ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA) {
+       if (type == RX_PACKET_TYPE_DATA) {

                switch (opcode) {
                        case 100:       /* Create volume */
                                ND_PRINT((ndo, " volid"));
                switch (opcode) {
                        case 100:       /* Create volume */
                                ND_PRINT((ndo, " volid"));


@@ -2329,17 +2332,17 @@ vol_reply_print(netdissect_options *ndo,
                        case 116:       /* List volumes */
                        case 121:       /* List one volume */
                                {
                        case 116:       /* List volumes */
                        case 121:       /* List one volume */
                                {

-                                       unsigned long i, j;
-                                       ND_TCHECK2(bp[0], 4);
-                                       j = EXTRACT_32BITS(bp);
-                                       bp += sizeof(int32_t);
+                                       uint32_t i, j;
+                                       ND_TCHECK_4(bp);
+                                       j = EXTRACT_BE_U_4(bp);
+                                       bp += sizeof(uint32_t);

                                        for (i = 0; i < j; i++) {
                                                ND_PRINT((ndo, " name"));
                                                VECOUT(32);
                                                ND_PRINT((ndo, " volid"));
                                                UINTOUT();
                                                ND_PRINT((ndo, " type"));
                                        for (i = 0; i < j; i++) {
                                                ND_PRINT((ndo, " name"));
                                                VECOUT(32);
                                                ND_PRINT((ndo, " volid"));
                                                UINTOUT();
                                                ND_PRINT((ndo, " type"));

-                                               bp += sizeof(int32_t) * 21;
+                                               bp += sizeof(uint32_t) * 21;

                                                if (i != j - 1)
                                                        ND_PRINT((ndo, ","));
                                        }
                                                if (i != j - 1)
                                                        ND_PRINT((ndo, ","));
                                        }


@@ -2372,25 +2375,22 @@ trunc:
 
 static void
 bos_print(netdissect_options *ndo,
 
 static void
 bos_print(netdissect_options *ndo,

-          register const u_char *bp, int length)
+          register const u_char *bp, u_int length)

 {
 {

-       int bos_op;
+       uint32_t bos_op;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
                return;
 

-       if (ndo->ndo_snapend - bp + 1 <= (int)(sizeof(struct rx_header) + sizeof(int32_t))) {
-               goto trunc;
-       }
-

        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from bozo/bosint.xg
         */
 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from bozo/bosint.xg
         */
 

-       bos_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       ND_TCHECK_4(bp + sizeof(struct rx_header));
+       bos_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
 

-       ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%d", bos_op)));
+       ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%u", bos_op)));

 
        /*
         * Decode some of the arguments to the BOS calls
 
        /*
         * Decode some of the arguments to the BOS calls


@@ -2464,11 +2464,12 @@ trunc:
 
 static void
 bos_reply_print(netdissect_options *ndo,
 
 static void
 bos_reply_print(netdissect_options *ndo,

-                register const u_char *bp, int length, int32_t opcode)
+                register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length <= (int)sizeof(struct rx_header))
+       if (length <= sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -2478,15 +2479,16 @@ bos_reply_print(netdissect_options *ndo,
         * gleaned from volser/volint.xg
         */
 
         * gleaned from volser/volint.xg
         */
 

-       ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, interpret the response.
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                /* Well, no, not really.  Leave this for later */
                ;
        else {
                /* Well, no, not really.  Leave this for later */
                ;
        else {


@@ -2525,17 +2527,21 @@ static void
 ubik_print(netdissect_options *ndo,
            register const u_char *bp)
 {
 ubik_print(netdissect_options *ndo,
            register const u_char *bp)
 {

-       int ubik_op;
-       int32_t temp;
+       uint32_t ubik_op;
+       uint32_t temp;

 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from ubik/ubik_int.xg
         */
 
 
        /*
         * Print out the afs call we're invoking.  The table used here was
         * gleaned from ubik/ubik_int.xg
         */
 

-       ubik_op = EXTRACT_32BITS(bp + sizeof(struct rx_header));
+       /* Every function that calls this function first makes a bounds check
+        * for (sizeof(rx_header) + 4) bytes, so long as it remains this way
+        * the line below will not over-read.
+        */
+       ubik_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));

 
 

-       ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%d", ubik_op)));
+       ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%u", ubik_op)));

 
        /*
         * Decode some of the arguments to the Ubik calls
 
        /*
         * Decode some of the arguments to the Ubik calls


@@ -2545,9 +2551,9 @@ ubik_print(netdissect_options *ndo,
 
        switch (ubik_op) {
                case 10000:             /* Beacon */
 
        switch (ubik_op) {
                case 10000:             /* Beacon */

-                       ND_TCHECK2(bp[0], 4);
-                       temp = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
+                       ND_TCHECK_4(bp);
+                       temp = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);

                        ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
                        ND_PRINT((ndo, " votestart"));
                        DATEOUT();
                        ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
                        ND_PRINT((ndo, " votestart"));
                        DATEOUT();


@@ -2577,9 +2583,10 @@ ubik_print(netdissect_options *ndo,
                        INTOUT();
                        ND_PRINT((ndo, " length"));
                        INTOUT();
                        INTOUT();
                        ND_PRINT((ndo, " length"));
                        INTOUT();

-                       temp = EXTRACT_32BITS(bp);
-                       bp += sizeof(int32_t);
-                       tok2str(ubik_lock_types, "type %d", temp);
+                       ND_TCHECK_4(bp);
+                       temp = EXTRACT_BE_U_4(bp);
+                       bp += sizeof(uint32_t);
+                       tok2str(ubik_lock_types, "type %u", temp);

                        break;
                case 20003:             /* Write */
                        ND_PRINT((ndo, " tid"));
                        break;
                case 20003:             /* Write */
                        ND_PRINT((ndo, " tid"));


@@ -2633,11 +2640,12 @@ trunc:
 
 static void
 ubik_reply_print(netdissect_options *ndo,
 
 static void
 ubik_reply_print(netdissect_options *ndo,

-                 register const u_char *bp, int length, int32_t opcode)
+                 register const u_char *bp, u_int length, uint32_t opcode)

 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;

+       uint8_t type;

 
 

-       if (length < (int)sizeof(struct rx_header))
+       if (length < sizeof(struct rx_header))

                return;
 
        rxh = (const struct rx_header *) bp;
                return;
 
        rxh = (const struct rx_header *) bp;


@@ -2647,15 +2655,16 @@ ubik_reply_print(netdissect_options *ndo,
         * from ubik/ubik_int.xg
         */
 
         * from ubik/ubik_int.xg
         */
 

-       ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%d", opcode)));
+       ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%u", opcode)));

 
 

+       type = EXTRACT_U_1(rxh->type);

        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, print out the arguments to the Ubik calls
         */
 
        bp += sizeof(struct rx_header);
 
        /*
         * If it was a data packet, print out the arguments to the Ubik calls
         */
 

-       if (rxh->type == RX_PACKET_TYPE_DATA)
+       if (type == RX_PACKET_TYPE_DATA)

                switch (opcode) {
                case 10000:             /* Beacon */
                        ND_PRINT((ndo, " vote no"));
                switch (opcode) {
                case 10000:             /* Beacon */
                        ND_PRINT((ndo, " vote no"));


@@ -2697,43 +2706,36 @@ trunc:
 
 static void
 rx_ack_print(netdissect_options *ndo,
 
 static void
 rx_ack_print(netdissect_options *ndo,

-             register const u_char *bp, int length)
+             register const u_char *bp, u_int length)

 {
        const struct rx_ackPacket *rxa;
 {
        const struct rx_ackPacket *rxa;

+       uint8_t nAcks;

        int i, start, last;
        uint32_t firstPacket;
 
        int i, start, last;
        uint32_t firstPacket;
 

-       if (length < (int)sizeof(struct rx_header))
+       if (length < sizeof(struct rx_header))

                return;
 
        bp += sizeof(struct rx_header);
 
                return;
 
        bp += sizeof(struct rx_header);
 

-       /*
-        * This may seem a little odd .... the rx_ackPacket structure
-        * contains an array of individual packet acknowledgements
-        * (used for selective ack/nack), but since it's variable in size,
-        * we don't want to truncate based on the size of the whole
-        * rx_ackPacket structure.
-        */
-
-       ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket) - RX_MAXACKS);
+       ND_TCHECK2(bp[0], sizeof(struct rx_ackPacket));

 
        rxa = (const struct rx_ackPacket *) bp;
 
        rxa = (const struct rx_ackPacket *) bp;

-       bp += (sizeof(struct rx_ackPacket) - RX_MAXACKS);
+       bp += sizeof(struct rx_ackPacket);

 
        /*
         * Print out a few useful things from the ack packet structure
         */
 
        if (ndo->ndo_vflag > 2)
 
        /*
         * Print out a few useful things from the ack packet structure
         */
 
        if (ndo->ndo_vflag > 2)

-               ND_PRINT((ndo, " bufspace %d maxskew %d",
-                      (int) EXTRACT_16BITS(&rxa->bufferSpace),
-                      (int) EXTRACT_16BITS(&rxa->maxSkew)));
+               ND_PRINT((ndo, " bufspace %u maxskew %d",
+                      EXTRACT_BE_U_2(rxa->bufferSpace),
+                      EXTRACT_BE_U_2(rxa->maxSkew)));

 
 

-       firstPacket = EXTRACT_32BITS(&rxa->firstPacket);
-       ND_PRINT((ndo, " first %d serial %d reason %s",
-              firstPacket, EXTRACT_32BITS(&rxa->serial),
-              tok2str(rx_ack_reasons, "#%d", (int) rxa->reason)));
+       firstPacket = EXTRACT_BE_U_4(rxa->firstPacket);
+       ND_PRINT((ndo, " first %u serial %u reason %s",
+              firstPacket, EXTRACT_BE_U_4(rxa->serial),
+              tok2str(rx_ack_reasons, "#%u", EXTRACT_U_1(rxa->reason))));

 
        /*
         * Okay, now we print out the ack array.  The way _this_ works
 
        /*
         * Okay, now we print out the ack array.  The way _this_ works


@@ -2754,17 +2756,18 @@ rx_ack_print(netdissect_options *ndo,
         * to bp after this, so bp ends up at the right spot.  Go figure.
         */
 
         * to bp after this, so bp ends up at the right spot.  Go figure.
         */
 

-       if (rxa->nAcks != 0) {
+       nAcks = EXTRACT_U_1(rxa->nAcks);
+       if (nAcks != 0) {

 
 

-               ND_TCHECK2(bp[0], rxa->nAcks);
+               ND_TCHECK2(bp[0], nAcks);

 
                /*
                 * Sigh, this is gross, but it seems to work to collapse
                 * ranges correctly.
                 */
 
 
                /*
                 * Sigh, this is gross, but it seems to work to collapse
                 * ranges correctly.
                 */
 

-               for (i = 0, start = last = -2; i < rxa->nAcks; i++)
-                       if (rxa->acks[i] == RX_ACK_TYPE_ACK) {
+               for (i = 0, start = last = -2; i < nAcks; i++)
+                       if (EXTRACT_U_1(bp + i) == RX_ACK_TYPE_ACK) {

 
                                /*
                                 * I figured this deserved _some_ explanation.
 
                                /*
                                 * I figured this deserved _some_ explanation.


@@ -2774,7 +2777,7 @@ rx_ack_print(netdissect_options *ndo,
                                 */
 
                                if (last == -2) {
                                 */
 
                                if (last == -2) {

-                                       ND_PRINT((ndo, " acked %d", firstPacket + i));
+                                       ND_PRINT((ndo, " acked %u", firstPacket + i));

                                        start = i;
                                }
 
                                        start = i;
                                }
 


@@ -2788,7 +2791,7 @@ rx_ack_print(netdissect_options *ndo,
                                 */
 
                                else if (last != i - 1) {
                                 */
 
                                else if (last != i - 1) {

-                                       ND_PRINT((ndo, ",%d", firstPacket + i));
+                                       ND_PRINT((ndo, ",%u", firstPacket + i));

                                        start = i;
                                }
 
                                        start = i;
                                }
 


@@ -2814,7 +2817,7 @@ rx_ack_print(netdissect_options *ndo,
                                 * range.
                                 */
                        } else if (last == i - 1 && start != last)
                                 * range.
                                 */
                        } else if (last == i - 1 && start != last)

-                               ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+                               ND_PRINT((ndo, "-%u", firstPacket + i - 1));

 
                /*
                 * So, what's going on here?  We ran off the end of the
 
                /*
                 * So, what's going on here?  We ran off the end of the


@@ -2828,31 +2831,33 @@ rx_ack_print(netdissect_options *ndo,
                 */
 
                if (last == i - 1 && start != last)
                 */
 
                if (last == i - 1 && start != last)

-                       ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+                       ND_PRINT((ndo, "-%u", 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) {
+               for (i = 0, start = last = -2; i < nAcks; i++)
+                       if (EXTRACT_U_1(bp + i) == RX_ACK_TYPE_NACK) {

                                if (last == -2) {
                                if (last == -2) {

-                                       ND_PRINT((ndo, " nacked %d", firstPacket + i));
+                                       ND_PRINT((ndo, " nacked %u", firstPacket + i));

                                        start = i;
                                } else if (last != i - 1) {
                                        start = i;
                                } else if (last != i - 1) {

-                                       ND_PRINT((ndo, ",%d", firstPacket + i));
+                                       ND_PRINT((ndo, ",%u", firstPacket + i));

                                        start = i;
                                }
                                last = i;
                        } else if (last == i - 1 && start != last)
                                        start = i;
                                }
                                last = i;
                        } else if (last == i - 1 && start != last)

-                               ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+                               ND_PRINT((ndo, "-%u", firstPacket + i - 1));

 
                if (last == i - 1 && start != last)
 
                if (last == i - 1 && start != last)

-                       ND_PRINT((ndo, "-%d", firstPacket + i - 1));
+                       ND_PRINT((ndo, "-%u", firstPacket + i - 1));

 
 

-               bp += rxa->nAcks;
+               bp += nAcks;

        }
 
        }
 

+       /* Padding. */
+       bp += 3;

 
        /*
         * These are optional fields; depending on your version of AFS,
 
        /*
         * These are optional fields; depending on your version of AFS,


@@ -2864,19 +2869,19 @@ rx_ack_print(netdissect_options *ndo,
        if (ndo->ndo_vflag > 1) {
                TRUNCRET(4);
                ND_PRINT((ndo, " ifmtu"));
        if (ndo->ndo_vflag > 1) {
                TRUNCRET(4);
                ND_PRINT((ndo, " ifmtu"));

-               INTOUT();
+               UINTOUT();

 
                TRUNCRET(4);
                ND_PRINT((ndo, " maxmtu"));
 
                TRUNCRET(4);
                ND_PRINT((ndo, " maxmtu"));

-               INTOUT();
+               UINTOUT();

 
                TRUNCRET(4);
                ND_PRINT((ndo, " rwind"));
 
                TRUNCRET(4);
                ND_PRINT((ndo, " rwind"));

-               INTOUT();
+               UINTOUT();

 
                TRUNCRET(4);
                ND_PRINT((ndo, " maxpackets"));
 
                TRUNCRET(4);
                ND_PRINT((ndo, " maxpackets"));

-               INTOUT();
+               UINTOUT();

        }
 
        return;
        }
 
        return;