]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-rx.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Use nd_ types, add EXTRACT_ calls, clean up signed vs. unsigned.
[tcpdump] / print-rx.c
diff --git a/print-rx.c b/print-rx.c
index c6be48e9f9900e5080d2437218d67ee6d706a62f..d4ca5094b06ce6d2178c2acd68e590ccbc1aba73 100644 (file)
--- a/print-rx.c
+++ b/print-rx.c
@@ -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
 };
 
 /*
 };
 
 /*
@@ -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, u_int length, u_int sport, u_int dport,
+         const u_char *bp, u_int length, u_int sport, u_int dport,
          const u_char *bp2)
 {
          const u_char *bp2)
 {
-       register const struct rx_header *rxh;
+       const struct rx_header *rxh;
        uint32_t i;
        uint32_t i;
+       uint8_t type, flags;
        uint32_t opcode;
 
        uint32_t opcode;
 
-       if (!ND_TTEST2(*bp, sizeof (struct rx_header))) {
+       if (!ND_TTEST_LEN(bp, sizeof(struct rx_header))) {
                ND_PRINT((ndo, " [|rx] (%u)", length));
                return;
        }
 
        rxh = (const struct rx_header *) bp;
 
                ND_PRINT((ndo, " [|rx] (%u)", length));
                return;
        }
 
        rxh = (const struct rx_header *) bp;
 
-       ND_PRINT((ndo, " rx %s", tok2str(rx_types, "type %u", 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)
                        ND_PRINT((ndo, " cid %08x call# %u",
        if (ndo->ndo_vflag) {
                int firstflag = 0;
 
                if (ndo->ndo_vflag > 1)
                        ND_PRINT((ndo, " cid %08x call# %u",
-                              EXTRACT_BE_32BITS(&rxh->cid),
-                              EXTRACT_BE_32BITS(&rxh->callNumber)));
+                              EXTRACT_BE_U_4(rxh->cid),
+                              EXTRACT_BE_U_4(rxh->callNumber)));
 
                ND_PRINT((ndo, " seq %u ser %u",
 
                ND_PRINT((ndo, " seq %u ser %u",
-                      EXTRACT_BE_32BITS(&rxh->seq),
-                      EXTRACT_BE_32BITS(&rxh->serial)));
+                      EXTRACT_BE_U_4(rxh->seq),
+                      EXTRACT_BE_U_4(rxh->serial)));
 
                if (ndo->ndo_vflag > 2)
                        ND_PRINT((ndo, " secindex %u serviceid %hu",
 
                if (ndo->ndo_vflag > 2)
                        ND_PRINT((ndo, " secindex %u serviceid %hu",
-                               rxh->securityIndex,
-                               EXTRACT_BE_16BITS(&rxh->serviceId)));
+                               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_BE_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_BE_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,7 +670,7 @@ 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);
 
 
@@ -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 = EXTRACT_BE_32BITS(&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 = EXTRACT_BE_32BITS(&rxh->serviceId);
-       rxent->opcode = EXTRACT_BE_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));
 }
 
 /*
 }
 
 /*
@@ -722,10 +728,10 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
        i = rx_cache_hint;
        do {
                rxent = &rx_cache[i];
        i = rx_cache_hint;
        do {
                rxent = &rx_cache[i];
-               if (rxent->callnum == EXTRACT_BE_32BITS(&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 == EXTRACT_BE_32BITS(&rxh->serviceId) &&
+                   rxent->serviceId == EXTRACT_BE_U_4(rxh->serviceId) &&
                    rxent->dport == sport) {
 
                        /* We got a match! */
                    rxent->dport == sport) {
 
                        /* We got a match! */
@@ -747,19 +753,19 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
  */
 
 #define FIDOUT() { uint32_t n1, n2, n3; \
  */
 
 #define FIDOUT() { uint32_t n1, n2, n3; \
-                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 3); \
-                       n1 = EXTRACT_BE_32BITS(bp); \
+                       ND_TCHECK_LEN(bp, sizeof(uint32_t) * 3); \
+                       n1 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        bp += sizeof(uint32_t); \
-                       n2 = EXTRACT_BE_32BITS(bp); \
+                       n2 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        bp += sizeof(uint32_t); \
-                       n3 = EXTRACT_BE_32BITS(bp); \
+                       n3 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " fid %u/%u/%u", n1, n2, n3)); \
                }
 
 #define STROUT(MAX) { uint32_t _i; \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " fid %u/%u/%u", n1, n2, n3)); \
                }
 
 #define STROUT(MAX) { uint32_t _i; \
-                       ND_TCHECK2(bp[0], sizeof(uint32_t)); \
-                       _i = EXTRACT_BE_32BITS(bp); \
+                       ND_TCHECK_LEN(bp, sizeof(uint32_t)); \
+                       _i = EXTRACT_BE_U_4(bp); \
                        if (_i > (MAX)) \
                                goto trunc; \
                        bp += sizeof(uint32_t); \
                        if (_i > (MAX)) \
                                goto trunc; \
                        bp += sizeof(uint32_t); \
@@ -772,28 +778,28 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
 
 #define INTOUT() { int32_t _i; \
                        ND_TCHECK_4(bp); \
 
 #define INTOUT() { int32_t _i; \
                        ND_TCHECK_4(bp); \
-                       _i = EXTRACT_BE_INT32(bp); \
+                       _i = EXTRACT_BE_S_4(bp); \
                        bp += sizeof(int32_t); \
                        ND_PRINT((ndo, " %d", _i)); \
                }
 
 #define UINTOUT() { uint32_t _i; \
                        ND_TCHECK_4(bp); \
                        bp += sizeof(int32_t); \
                        ND_PRINT((ndo, " %d", _i)); \
                }
 
 #define UINTOUT() { uint32_t _i; \
                        ND_TCHECK_4(bp); \
-                       _i = EXTRACT_BE_32BITS(bp); \
+                       _i = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " %u", _i)); \
                }
 
 #define UINT64OUT() { uint64_t _i; \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " %u", _i)); \
                }
 
 #define UINT64OUT() { uint64_t _i; \
-                       ND_TCHECK2(bp[0], sizeof(uint64_t)); \
-                       _i = EXTRACT_BE_64BITS(bp); \
+                       ND_TCHECK_LEN(bp, sizeof(uint64_t)); \
+                       _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]; \
                        ND_TCHECK_4(bp); \
                        bp += sizeof(uint64_t); \
                        ND_PRINT((ndo, " %" PRIu64, _i)); \
                }
 
 #define DATEOUT() { time_t _t; struct tm *tm; char str[256]; \
                        ND_TCHECK_4(bp); \
-                       _t = (time_t) EXTRACT_BE_INT32(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); \
                        bp += sizeof(int32_t); \
                        tm = localtime(&_t); \
                        strftime(str, 256, "%Y/%m/%d %H:%M:%S", tm); \
@@ -801,45 +807,45 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
                }
 
 #define STOREATTROUT() { uint32_t mask, _i; \
                }
 
 #define STOREATTROUT() { uint32_t mask, _i; \
-                       ND_TCHECK2(bp[0], (sizeof(uint32_t)*6)); \
-                       mask = EXTRACT_BE_32BITS(bp); bp += sizeof(uint32_t); \
+                       ND_TCHECK_LEN(bp, (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(); } \
                        else bp += sizeof(uint32_t); \
                        if (mask) ND_PRINT((ndo, " StoreStatus")); \
                        if (mask & 1) { ND_PRINT((ndo, " date")); DATEOUT(); } \
                        else bp += sizeof(uint32_t); \
-                       _i = EXTRACT_BE_32BITS(bp); bp += sizeof(uint32_t); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
                        if (mask & 2) ND_PRINT((ndo, " owner %u", _i));  \
                        if (mask & 2) ND_PRINT((ndo, " owner %u", _i));  \
-                       _i = EXTRACT_BE_32BITS(bp); bp += sizeof(uint32_t); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
                        if (mask & 4) ND_PRINT((ndo, " group %u", _i)); \
                        if (mask & 4) ND_PRINT((ndo, " group %u", _i)); \
-                       _i = EXTRACT_BE_32BITS(bp); bp += sizeof(uint32_t); \
+                       _i = EXTRACT_BE_U_4(bp); bp += sizeof(uint32_t); \
                        if (mask & 8) ND_PRINT((ndo, " mode %o", _i & 07777)); \
                        if (mask & 8) ND_PRINT((ndo, " mode %o", _i & 07777)); \
-                       _i = EXTRACT_BE_32BITS(bp); bp += sizeof(uint32_t); \
+                       _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"));  \
                }
 
 #define UBIK_VERSIONOUT() {uint32_t epoch; uint32_t counter; \
                        if (mask & 16) ND_PRINT((ndo, " segsize %u", _i)); \
                        /* undocumented in 3.3 docu */ \
                        if (mask & 1024) ND_PRINT((ndo, " fsync"));  \
                }
 
 #define UBIK_VERSIONOUT() {uint32_t epoch; uint32_t counter; \
-                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 2); \
-                       epoch = EXTRACT_BE_32BITS(bp); \
+                       ND_TCHECK_LEN(bp, sizeof(uint32_t) * 2); \
+                       epoch = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        bp += sizeof(uint32_t); \
-                       counter = EXTRACT_BE_32BITS(bp); \
+                       counter = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " %u.%u", epoch, counter)); \
                }
 
 #define AFSUUIDOUT() {uint32_t temp; int _i; \
                        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)); \
-                       temp = EXTRACT_BE_32BITS(bp); \
+                       ND_TCHECK_LEN(bp, 11 * sizeof(uint32_t)); \
+                       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_BE_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_BE_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_BE_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)); \
                        } \
@@ -854,10 +860,10 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
                        uint32_t k; \
                        if ((MAX) + 1 > sizeof(s)) \
                                goto trunc; \
                        uint32_t k; \
                        if ((MAX) + 1 > sizeof(s)) \
                                goto trunc; \
-                       ND_TCHECK2(bp[0], (MAX) * sizeof(uint32_t)); \
+                       ND_TCHECK_LEN(bp, (MAX) * sizeof(uint32_t)); \
                        sp = s; \
                        for (k = 0; k < (MAX); k++) { \
                        sp = s; \
                        for (k = 0; k < (MAX); k++) { \
-                               *sp++ = (u_char) EXTRACT_BE_32BITS(bp); \
+                               *sp++ = (u_char) EXTRACT_BE_U_4(bp); \
                                bp += sizeof(uint32_t); \
                        } \
                        s[(MAX)] = '\0'; \
                                bp += sizeof(uint32_t); \
                        } \
                        s[(MAX)] = '\0'; \
@@ -867,12 +873,12 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
                }
 
 #define DESTSERVEROUT() { uint32_t n1, n2, n3; \
                }
 
 #define DESTSERVEROUT() { uint32_t n1, n2, n3; \
-                       ND_TCHECK2(bp[0], sizeof(uint32_t) * 3); \
-                       n1 = EXTRACT_BE_32BITS(bp); \
+                       ND_TCHECK_LEN(bp, sizeof(uint32_t) * 3); \
+                       n1 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        bp += sizeof(uint32_t); \
-                       n2 = EXTRACT_BE_32BITS(bp); \
+                       n2 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        bp += sizeof(uint32_t); \
-                       n3 = EXTRACT_BE_32BITS(bp); \
+                       n3 = EXTRACT_BE_U_4(bp); \
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " server %u:%u:%u", n1, n2, n3)); \
                }
                        bp += sizeof(uint32_t); \
                        ND_PRINT((ndo, " server %u:%u:%u", n1, n2, n3)); \
                }
@@ -883,7 +889,7 @@ rx_cache_find(const struct rx_header *rxh, const struct ip *ip, u_int sport,
 
 static void
 fs_print(netdissect_options *ndo,
 
 static void
 fs_print(netdissect_options *ndo,
-         register const u_char *bp, u_int length)
+         const u_char *bp, u_int length)
 {
        uint32_t fs_op;
        uint32_t i;
 {
        uint32_t fs_op;
        uint32_t i;
@@ -897,7 +903,7 @@ fs_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       fs_op = EXTRACT_BE_32BITS(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#%u", fs_op)));
 
 
        ND_PRINT((ndo, " fs call %s", tok2str(fs_req, "op#%u", fs_op)));
 
@@ -948,10 +954,10 @@ fs_print(netdissect_options *ndo,
                {
                        char a[AFSOPAQUEMAX+1];
                        FIDOUT();
                {
                        char a[AFSOPAQUEMAX+1];
                        FIDOUT();
-                       ND_TCHECK2(bp[0], 4);
-                       i = EXTRACT_BE_32BITS(bp);
+                       ND_TCHECK_4(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        bp += sizeof(uint32_t);
-                       ND_TCHECK2(bp[0], i);
+                       ND_TCHECK_LEN(bp, i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        a[i] = '\0';
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        a[i] = '\0';
@@ -1006,7 +1012,7 @@ fs_print(netdissect_options *ndo,
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
 
                        for (i = 0; i < j; i++) {
                        bp += sizeof(uint32_t);
 
                        for (i = 0; i < j; i++) {
@@ -1053,10 +1059,11 @@ trunc:
 
 static void
 fs_reply_print(netdissect_options *ndo,
 
 static void
 fs_reply_print(netdissect_options *ndo,
-               register const u_char *bp, u_int length, uint32_t opcode)
+               const u_char *bp, u_int length, uint32_t opcode)
 {
        uint32_t i;
        const struct rx_header *rxh;
 {
        uint32_t i;
        const struct rx_header *rxh;
+       uint8_t type;
 
        if (length <= sizeof(struct rx_header))
                return;
 
        if (length <= sizeof(struct rx_header))
                return;
@@ -1070,21 +1077,22 @@ fs_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " fs reply %s", tok2str(fs_req, "op#%u", 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];
                        ND_TCHECK_4(bp);
                switch (opcode) {
                case 131:       /* Fetch ACL */
                {
                        char a[AFSOPAQUEMAX+1];
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        bp += sizeof(uint32_t);
-                       ND_TCHECK2(bp[0], i);
+                       ND_TCHECK_LEN(bp, i);
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        a[i] = '\0';
                        i = min(AFSOPAQUEMAX, i);
                        strncpy(a, (const char *) bp, i);
                        a[i] = '\0';
@@ -1106,19 +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
                 */
                int32_t errcode;
 
                ND_TCHECK_4(bp);
                /*
                 * Otherwise, just print out the return code
                 */
                int32_t errcode;
 
                ND_TCHECK_4(bp);
-               errcode = EXTRACT_BE_INT32(bp);
+               errcode = EXTRACT_BE_S_4(bp);
                bp += sizeof(int32_t);
 
                ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", errcode)));
        } else {
                bp += sizeof(int32_t);
 
                ND_PRINT((ndo, " error %s", tok2str(afs_fs_errors, "#%d", errcode)));
        } else {
-               ND_PRINT((ndo, " strange fs reply of type %u", rxh->type));
+               ND_PRINT((ndo, " strange fs reply of type %u", type));
        }
 
        return;
        }
 
        return;
@@ -1216,7 +1224,7 @@ finish:
 
 static void
 cb_print(netdissect_options *ndo,
 
 static void
 cb_print(netdissect_options *ndo,
-         register const u_char *bp, u_int length)
+         const u_char *bp, u_int length)
 {
        uint32_t cb_op;
        uint32_t i;
 {
        uint32_t cb_op;
        uint32_t i;
@@ -1230,7 +1238,7 @@ cb_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       cb_op = EXTRACT_BE_32BITS(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#%u", cb_op)));
 
 
        ND_PRINT((ndo, " cb call %s", tok2str(cb_req, "op#%u", cb_op)));
 
@@ -1246,7 +1254,7 @@ cb_print(netdissect_options *ndo,
                {
                        uint32_t j, t;
                        ND_TCHECK_4(bp);
                {
                        uint32_t j, t;
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
 
                        for (i = 0; i < j; i++) {
                        bp += sizeof(uint32_t);
 
                        for (i = 0; i < j; i++) {
@@ -1259,7 +1267,7 @@ cb_print(netdissect_options *ndo,
                                ND_PRINT((ndo, " <none!>"));
 
                        ND_TCHECK_4(bp);
                                ND_PRINT((ndo, " <none!>"));
 
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
 
                        if (j != 0)
                        bp += sizeof(uint32_t);
 
                        if (j != 0)
@@ -1271,7 +1279,7 @@ cb_print(netdissect_options *ndo,
                                ND_PRINT((ndo, " expires"));
                                DATEOUT();
                                ND_TCHECK_4(bp);
                                ND_PRINT((ndo, " expires"));
                                DATEOUT();
                                ND_TCHECK_4(bp);
-                               t = EXTRACT_BE_32BITS(bp);
+                               t = EXTRACT_BE_U_4(bp);
                                bp += sizeof(uint32_t);
                                tok2str(cb_types, "type %u", t);
                        }
                                bp += sizeof(uint32_t);
                                tok2str(cb_types, "type %u", t);
                        }
@@ -1297,9 +1305,10 @@ trunc:
 
 static void
 cb_reply_print(netdissect_options *ndo,
 
 static void
 cb_reply_print(netdissect_options *ndo,
-               register const u_char *bp, u_int length, uint32_t opcode)
+               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 <= sizeof(struct rx_header))
                return;
 
        if (length <= sizeof(struct rx_header))
                return;
@@ -1313,13 +1322,14 @@ cb_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " cb reply %s", tok2str(cb_req, "op#%u", 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();
@@ -1347,7 +1357,7 @@ trunc:
 
 static void
 prot_print(netdissect_options *ndo,
 
 static void
 prot_print(netdissect_options *ndo,
-           register const u_char *bp, u_int length)
+           const u_char *bp, u_int length)
 {
        uint32_t i;
        uint32_t pt_op;
 {
        uint32_t i;
        uint32_t pt_op;
@@ -1361,7 +1371,7 @@ prot_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       pt_op = EXTRACT_BE_32BITS(bp + sizeof(struct rx_header));
+       pt_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));
 
        ND_PRINT((ndo, " pt"));
 
 
        ND_PRINT((ndo, " pt"));
 
@@ -1414,7 +1424,7 @@ prot_print(netdissect_options *ndo,
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
 
                        /*
                        bp += sizeof(uint32_t);
 
                        /*
@@ -1436,7 +1446,7 @@ prot_print(netdissect_options *ndo,
                        uint32_t j;
                        ND_PRINT((ndo, " ids:"));
                        ND_TCHECK_4(bp);
                        uint32_t j;
                        ND_PRINT((ndo, " ids:"));
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        for (j = 0; j < i; j++)
                                INTOUT();
                        bp += sizeof(uint32_t);
                        for (j = 0; j < i; j++)
                                INTOUT();
@@ -1488,9 +1498,10 @@ trunc:
 
 static void
 prot_reply_print(netdissect_options *ndo,
 
 static void
 prot_reply_print(netdissect_options *ndo,
-                 register const u_char *bp, u_int length, uint32_t opcode)
+                 const u_char *bp, u_int length, uint32_t opcode)
 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;
+       uint8_t type;
        uint32_t i;
 
        if (length < sizeof(struct rx_header))
        uint32_t i;
 
        if (length < sizeof(struct rx_header))
@@ -1513,20 +1524,21 @@ prot_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " reply %s", tok2str(pt_req, "op#%u", 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 */
                {
                        uint32_t j;
                        ND_PRINT((ndo, " ids:"));
                        ND_TCHECK_4(bp);
                switch (opcode) {
                case 504:               /* Name to ID */
                {
                        uint32_t j;
                        ND_PRINT((ndo, " ids:"));
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        for (j = 0; j < i; j++)
                                INTOUT();
                        bp += sizeof(uint32_t);
                        for (j = 0; j < i; j++)
                                INTOUT();
@@ -1538,7 +1550,7 @@ prot_reply_print(netdissect_options *ndo,
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
 
                        /*
                        bp += sizeof(uint32_t);
 
                        /*
@@ -1563,7 +1575,7 @@ prot_reply_print(netdissect_options *ndo,
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
                {
                        uint32_t j;
                        ND_TCHECK_4(bp);
-                       j = EXTRACT_BE_32BITS(bp);
+                       j = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        for (i = 0; i < j; i++) {
                                INTOUT();
                        bp += sizeof(uint32_t);
                        for (i = 0; i < j; i++) {
                                INTOUT();
@@ -1601,7 +1613,7 @@ trunc:
 
 static void
 vldb_print(netdissect_options *ndo,
 
 static void
 vldb_print(netdissect_options *ndo,
-           register const u_char *bp, u_int length)
+           const u_char *bp, u_int length)
 {
        uint32_t vldb_op;
        uint32_t i;
 {
        uint32_t vldb_op;
        uint32_t i;
@@ -1615,7 +1627,7 @@ vldb_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       vldb_op = EXTRACT_BE_32BITS(bp + sizeof(struct rx_header));
+       vldb_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));
 
        ND_PRINT((ndo, " vldb"));
 
 
        ND_PRINT((ndo, " vldb"));
 
@@ -1645,7 +1657,7 @@ vldb_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                        ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        bp += sizeof(uint32_t);
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
@@ -1665,7 +1677,7 @@ vldb_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                        ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " volid"));
                        INTOUT();
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
                        bp += sizeof(uint32_t);
                        if (i <= 2)
                                ND_PRINT((ndo, " type %s", voltype[i]));
@@ -1692,9 +1704,10 @@ trunc:
 
 static void
 vldb_reply_print(netdissect_options *ndo,
 
 static void
 vldb_reply_print(netdissect_options *ndo,
-                 register const u_char *bp, u_int length, uint32_t opcode)
+                 const u_char *bp, u_int length, uint32_t opcode)
 {
        const struct rx_header *rxh;
 {
        const struct rx_header *rxh;
+       uint8_t type;
        uint32_t i;
 
        if (length < sizeof(struct rx_header))
        uint32_t i;
 
        if (length < sizeof(struct rx_header))
@@ -1717,13 +1730,14 @@ vldb_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " reply %s", tok2str(vldb_req, "op#%u", 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"));
@@ -1738,7 +1752,7 @@ vldb_reply_print(netdissect_options *ndo,
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
-                       nservers = EXTRACT_BE_32BITS(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
@@ -1752,14 +1766,14 @@ vldb_reply_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 8; i++) {
                                ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 8; i++) {
                                ND_TCHECK_4(bp);
-                               j = EXTRACT_BE_32BITS(bp);
+                               j = EXTRACT_BE_U_4(bp);
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
-                       ND_TCHECK2(bp[0], 8 * sizeof(uint32_t));
+                       ND_TCHECK_LEN(bp, 8 * sizeof(uint32_t));
                        bp += 8 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        bp += 8 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
@@ -1785,7 +1799,7 @@ vldb_reply_print(netdissect_options *ndo,
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
-                       nservers = EXTRACT_BE_32BITS(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
@@ -1799,14 +1813,14 @@ vldb_reply_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                                ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                                ND_TCHECK_4(bp);
-                               j = EXTRACT_BE_32BITS(bp);
+                               j = EXTRACT_BE_U_4(bp);
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
-                       ND_TCHECK2(bp[0], 13 * sizeof(uint32_t));
+                       ND_TCHECK_LEN(bp, 13 * sizeof(uint32_t));
                        bp += 13 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        bp += 13 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
@@ -1822,7 +1836,7 @@ vldb_reply_print(netdissect_options *ndo,
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
                        VECOUT(VLNAMEMAX);
                        ND_PRINT((ndo, " numservers"));
                        ND_TCHECK_4(bp);
-                       nservers = EXTRACT_BE_32BITS(bp);
+                       nservers = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " %u", nservers));
                        ND_PRINT((ndo, " servers"));
@@ -1831,23 +1845,23 @@ vldb_reply_print(netdissect_options *ndo,
                                        ND_PRINT((ndo, " afsuuid"));
                                        AFSUUIDOUT();
                                } else {
                                        ND_PRINT((ndo, " afsuuid"));
                                        AFSUUIDOUT();
                                } else {
-                                       ND_TCHECK2(bp[0], 44);
+                                       ND_TCHECK_LEN(bp, 44);
                                        bp += 44;
                                }
                        }
                                        bp += 44;
                                }
                        }
-                       ND_TCHECK2(bp[0], 4 * 13);
+                       ND_TCHECK_LEN(bp, 4 * 13);
                        bp += 4 * 13;
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                                ND_TCHECK_4(bp);
                        bp += 4 * 13;
                        ND_PRINT((ndo, " partitions"));
                        for (i = 0; i < 13; i++) {
                                ND_TCHECK_4(bp);
-                               j = EXTRACT_BE_32BITS(bp);
+                               j = EXTRACT_BE_U_4(bp);
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
                                if (i < nservers && j <= 26)
                                        ND_PRINT((ndo, " %c", 'a' + j));
                                else if (i < nservers)
                                        ND_PRINT((ndo, " %u", j));
                                bp += sizeof(uint32_t);
                        }
-                       ND_TCHECK2(bp[0], 13 * sizeof(uint32_t));
+                       ND_TCHECK_LEN(bp, 13 * sizeof(uint32_t));
                        bp += 13 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
                        bp += 13 * sizeof(uint32_t);
                        ND_PRINT((ndo, " rwvol"));
                        UINTOUT();
@@ -1880,7 +1894,7 @@ trunc:
 
 static void
 kauth_print(netdissect_options *ndo,
 
 static void
 kauth_print(netdissect_options *ndo,
-            register const u_char *bp, u_int length)
+            const u_char *bp, u_int length)
 {
        uint32_t kauth_op;
 
 {
        uint32_t kauth_op;
 
@@ -1893,7 +1907,7 @@ kauth_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       kauth_op = EXTRACT_BE_32BITS(bp + sizeof(struct rx_header));
+       kauth_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));
 
        ND_PRINT((ndo, " kauth"));
 
 
        ND_PRINT((ndo, " kauth"));
 
@@ -1935,9 +1949,9 @@ kauth_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " domain"));
                        STROUT(KANAMEMAX);
                        ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " domain"));
                        STROUT(KANAMEMAX);
                        ND_TCHECK_4(bp);
-                       i = EXTRACT_BE_32BITS(bp);
+                       i = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        bp += sizeof(uint32_t);
-                       ND_TCHECK2(bp[0], i);
+                       ND_TCHECK_LEN(bp, i);
                        bp += i;
                        ND_PRINT((ndo, " principal"));
                        STROUT(KANAMEMAX);
                        bp += i;
                        ND_PRINT((ndo, " principal"));
                        STROUT(KANAMEMAX);
@@ -1971,9 +1985,10 @@ trunc:
 
 static void
 kauth_reply_print(netdissect_options *ndo,
 
 static void
 kauth_reply_print(netdissect_options *ndo,
-                  register const u_char *bp, u_int length, uint32_t opcode)
+                  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 <= sizeof(struct rx_header))
                return;
 
        if (length <= sizeof(struct rx_header))
                return;
@@ -1994,13 +2009,14 @@ kauth_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " reply %s", tok2str(kauth_req, "op#%u", 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 {
@@ -2023,7 +2039,7 @@ trunc:
 
 static void
 vol_print(netdissect_options *ndo,
 
 static void
 vol_print(netdissect_options *ndo,
-          register const u_char *bp, u_int length)
+          const u_char *bp, u_int length)
 {
        uint32_t vol_op;
 
 {
        uint32_t vol_op;
 
@@ -2036,7 +2052,7 @@ vol_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       vol_op = EXTRACT_BE_32BITS(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#%u", vol_op)));
 
 
        ND_PRINT((ndo, " vol call %s", tok2str(vol_req, "op#%u", vol_op)));
 
@@ -2188,7 +2204,7 @@ vol_print(netdissect_options *ndo,
                        {
                                uint32_t i, j;
                                ND_TCHECK_4(bp);
                        {
                                uint32_t i, j;
                                ND_TCHECK_4(bp);
-                               j = EXTRACT_BE_32BITS(bp);
+                               j = EXTRACT_BE_U_4(bp);
                                bp += sizeof(uint32_t);
                                for (i = 0; i < j; i++) {
                                        DESTSERVEROUT();
                                bp += sizeof(uint32_t);
                                for (i = 0; i < j; i++) {
                                        DESTSERVEROUT();
@@ -2222,9 +2238,10 @@ trunc:
 
 static void
 vol_reply_print(netdissect_options *ndo,
 
 static void
 vol_reply_print(netdissect_options *ndo,
-                register const u_char *bp, u_int length, uint32_t opcode)
+                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 <= sizeof(struct rx_header))
                return;
 
        if (length <= sizeof(struct rx_header))
                return;
@@ -2238,13 +2255,14 @@ vol_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " vol reply %s", tok2str(vol_req, "op#%u", 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"));
@@ -2316,7 +2334,7 @@ vol_reply_print(netdissect_options *ndo,
                                {
                                        uint32_t i, j;
                                        ND_TCHECK_4(bp);
                                {
                                        uint32_t i, j;
                                        ND_TCHECK_4(bp);
-                                       j = EXTRACT_BE_32BITS(bp);
+                                       j = EXTRACT_BE_U_4(bp);
                                        bp += sizeof(uint32_t);
                                        for (i = 0; i < j; i++) {
                                                ND_PRINT((ndo, " name"));
                                        bp += sizeof(uint32_t);
                                        for (i = 0; i < j; i++) {
                                                ND_PRINT((ndo, " name"));
@@ -2357,7 +2375,7 @@ trunc:
 
 static void
 bos_print(netdissect_options *ndo,
 
 static void
 bos_print(netdissect_options *ndo,
-          register const u_char *bp, u_int length)
+          const u_char *bp, u_int length)
 {
        uint32_t bos_op;
 
 {
        uint32_t bos_op;
 
@@ -2370,7 +2388,7 @@ bos_print(netdissect_options *ndo,
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
         */
 
        ND_TCHECK_4(bp + sizeof(struct rx_header));
-       bos_op = EXTRACT_BE_32BITS(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#%u", bos_op)));
 
 
        ND_PRINT((ndo, " bos call %s", tok2str(bos_req, "op#%u", bos_op)));
 
@@ -2446,9 +2464,10 @@ trunc:
 
 static void
 bos_reply_print(netdissect_options *ndo,
 
 static void
 bos_reply_print(netdissect_options *ndo,
-                register const u_char *bp, u_int length, uint32_t opcode)
+                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 <= sizeof(struct rx_header))
                return;
 
        if (length <= sizeof(struct rx_header))
                return;
@@ -2462,13 +2481,14 @@ bos_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " bos reply %s", tok2str(bos_req, "op#%u", 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 {
@@ -2505,7 +2525,7 @@ is_ubik(uint32_t opcode)
 
 static void
 ubik_print(netdissect_options *ndo,
 
 static void
 ubik_print(netdissect_options *ndo,
-           register const u_char *bp)
+           const u_char *bp)
 {
        uint32_t ubik_op;
        uint32_t temp;
 {
        uint32_t ubik_op;
        uint32_t temp;
@@ -2519,7 +2539,7 @@ ubik_print(netdissect_options *ndo,
         * for (sizeof(rx_header) + 4) bytes, so long as it remains this way
         * the line below will not over-read.
         */
         * for (sizeof(rx_header) + 4) bytes, so long as it remains this way
         * the line below will not over-read.
         */
-       ubik_op = EXTRACT_BE_32BITS(bp + sizeof(struct rx_header));
+       ubik_op = EXTRACT_BE_U_4(bp + sizeof(struct rx_header));
 
        ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%u", ubik_op)));
 
 
        ND_PRINT((ndo, " ubik call %s", tok2str(ubik_req, "op#%u", ubik_op)));
 
@@ -2532,7 +2552,7 @@ ubik_print(netdissect_options *ndo,
        switch (ubik_op) {
                case 10000:             /* Beacon */
                        ND_TCHECK_4(bp);
        switch (ubik_op) {
                case 10000:             /* Beacon */
                        ND_TCHECK_4(bp);
-                       temp = EXTRACT_BE_32BITS(bp);
+                       temp = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
                        ND_PRINT((ndo, " votestart"));
                        bp += sizeof(uint32_t);
                        ND_PRINT((ndo, " syncsite %s", temp ? "yes" : "no"));
                        ND_PRINT((ndo, " votestart"));
@@ -2564,7 +2584,7 @@ ubik_print(netdissect_options *ndo,
                        ND_PRINT((ndo, " length"));
                        INTOUT();
                        ND_TCHECK_4(bp);
                        ND_PRINT((ndo, " length"));
                        INTOUT();
                        ND_TCHECK_4(bp);
-                       temp = EXTRACT_BE_32BITS(bp);
+                       temp = EXTRACT_BE_U_4(bp);
                        bp += sizeof(uint32_t);
                        tok2str(ubik_lock_types, "type %u", temp);
                        break;
                        bp += sizeof(uint32_t);
                        tok2str(ubik_lock_types, "type %u", temp);
                        break;
@@ -2620,9 +2640,10 @@ trunc:
 
 static void
 ubik_reply_print(netdissect_options *ndo,
 
 static void
 ubik_reply_print(netdissect_options *ndo,
-                 register const u_char *bp, u_int length, uint32_t opcode)
+                 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 < sizeof(struct rx_header))
                return;
 
        if (length < sizeof(struct rx_header))
                return;
@@ -2636,13 +2657,14 @@ ubik_reply_print(netdissect_options *ndo,
 
        ND_PRINT((ndo, " ubik reply %s", tok2str(ubik_req, "op#%u", 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"));
@@ -2684,9 +2706,10 @@ trunc:
 
 static void
 rx_ack_print(netdissect_options *ndo,
 
 static void
 rx_ack_print(netdissect_options *ndo,
-             register const u_char *bp, u_int length)
+             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;
 
@@ -2695,18 +2718,10 @@ rx_ack_print(netdissect_options *ndo,
 
        bp += sizeof(struct rx_header);
 
 
        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_TCHECK_LEN(bp, 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
 
        /*
         * Print out a few useful things from the ack packet structure
@@ -2714,13 +2729,13 @@ rx_ack_print(netdissect_options *ndo,
 
        if (ndo->ndo_vflag > 2)
                ND_PRINT((ndo, " bufspace %u maxskew %d",
 
        if (ndo->ndo_vflag > 2)
                ND_PRINT((ndo, " bufspace %u maxskew %d",
-                      EXTRACT_BE_16BITS(&rxa->bufferSpace),
-                      EXTRACT_BE_16BITS(&rxa->maxSkew)));
+                      EXTRACT_BE_U_2(rxa->bufferSpace),
+                      EXTRACT_BE_U_2(rxa->maxSkew)));
 
 
-       firstPacket = EXTRACT_BE_32BITS(&rxa->firstPacket);
+       firstPacket = EXTRACT_BE_U_4(rxa->firstPacket);
        ND_PRINT((ndo, " first %u serial %u reason %s",
        ND_PRINT((ndo, " first %u serial %u reason %s",
-              firstPacket, EXTRACT_BE_32BITS(&rxa->serial),
-              tok2str(rx_ack_reasons, "#%u", rxa->reason)));
+              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
@@ -2741,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_TCHECK_LEN(bp, 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.
@@ -2821,8 +2837,8 @@ rx_ack_print(netdissect_options *ndo,
                 * 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) {
                                        ND_PRINT((ndo, " nacked %u", firstPacket + i));
                                        start = i;
                                if (last == -2) {
                                        ND_PRINT((ndo, " nacked %u", firstPacket + i));
                                        start = i;
@@ -2837,9 +2853,11 @@ rx_ack_print(netdissect_options *ndo,
                if (last == i - 1 && start != last)
                        ND_PRINT((ndo, "-%u", firstPacket + i - 1));
 
                if (last == i - 1 && start != last)
                        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,
@@ -2851,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;
[mirror] the TCPdump network dissector