Remove unneeded '&' when getting a pointer to an nd_uintN_t type

They are arrays.

diff --git a/print-dhcp6.c b/print-dhcp6.c
index 5e8585c0578482f1b281c6b42eca4874855de2f9..e9920082b413304a983cc4c8f77c2b30c8d279fd 100644 (file)
--- a/print-dhcp6.c
+++ b/print-dhcp6.c
@@ -303,10 +303,10 @@ dhcp6opt_print(netdissect_options *ndo,
                        goto trunc;
                dh6o = (const struct dhcp6opt *)cp;
                ND_TCHECK_SIZE(dh6o);
-               optlen = EXTRACT_BE_U_2(&dh6o->dh6opt_len);
+               optlen = EXTRACT_BE_U_2(dh6o->dh6opt_len);
                if (ep < cp + sizeof(*dh6o) + optlen)
                        goto trunc;
-               opttype = EXTRACT_BE_U_2(&dh6o->dh6opt_type);
+               opttype = EXTRACT_BE_U_2(dh6o->dh6opt_type);
                ND_PRINT(" (%s", tok2str(dh6opt_str, "opt_%u", opttype));
                ND_TCHECK_LEN(cp + sizeof(*dh6o), optlen);
                switch (opttype) {

diff --git a/print-forces.c b/print-forces.c
index 373360781456601f691a0564342410d750f0c417..03807a0be826ae3f6a4520d9bfc1daaf9cf7e654 100644 (file)
--- a/print-forces.c
+++ b/print-forces.c
@@ -387,14 +387,14 @@ struct forces_tlv {
 #define        GET_TOP_TLV(fhdr) ((const struct forces_tlv *)((fhdr) + sizeof (struct forcesh)))
 #define TLV_SET_LEN(len)  (F_ALN_LEN(TLV_HDRL) + (len))
 #define TLV_DATA(tlvp)   ((const void*)(((const char*)(tlvp)) + TLV_SET_LEN(0)))
-#define GO_NXT_TLV(tlv,rlen) ((rlen) -= F_ALN_LEN(EXTRACT_BE_U_2(&(tlv)->length)), \
+#define GO_NXT_TLV(tlv,rlen) ((rlen) -= F_ALN_LEN(EXTRACT_BE_U_2((tlv)->length)), \
                              (const struct forces_tlv*)(((const char*)(tlv)) \
-                                     + F_ALN_LEN(EXTRACT_BE_U_2(&(tlv)->length))))
+                                     + F_ALN_LEN(EXTRACT_BE_U_2((tlv)->length))))
 #define ILV_SET_LEN(len)  (F_ALN_LEN(ILV_HDRL) + (len))
 #define ILV_DATA(ilvp)   ((const void*)(((const char*)(ilvp)) + ILV_SET_LEN(0)))
-#define GO_NXT_ILV(ilv,rlen) ((rlen) -= F_ALN_LEN(EXTRACT_BE_U_4(&(ilv)->length)), \
+#define GO_NXT_ILV(ilv,rlen) ((rlen) -= F_ALN_LEN(EXTRACT_BE_U_4((ilv)->length)), \
                              (const struct forces_ilv *)(((const char*)(ilv)) \
-                                     + F_ALN_LEN(EXTRACT_BE_U_4(&(ilv)->length))))
+                                     + F_ALN_LEN(EXTRACT_BE_U_4((ilv)->length))))
 #define INVALID_RLEN 1
 #define INVALID_STLN 2
 #define INVALID_LTLN 3
@@ -412,11 +412,11 @@ static inline u_int tlv_valid(const struct forces_tlv *tlv, u_int rlen)
 {
        if (rlen < TLV_HDRL)
                return INVALID_RLEN;
-       if (EXTRACT_BE_U_2(&tlv->length) < TLV_HDRL)
+       if (EXTRACT_BE_U_2(tlv->length) < TLV_HDRL)
                return INVALID_STLN;
-       if (EXTRACT_BE_U_2(&tlv->length) > rlen)
+       if (EXTRACT_BE_U_2(tlv->length) > rlen)
                return INVALID_LTLN;
-       if (rlen < F_ALN_LEN(EXTRACT_BE_U_2(&tlv->length)))
+       if (rlen < F_ALN_LEN(EXTRACT_BE_U_2(tlv->length)))
                return INVALID_ALEN;
 
        return 0;
@@ -426,11 +426,11 @@ static inline int ilv_valid(const struct forces_ilv *ilv, u_int rlen)
 {
        if (rlen < ILV_HDRL)
                return INVALID_RLEN;
-       if (EXTRACT_BE_U_4(&ilv->length) < ILV_HDRL)
+       if (EXTRACT_BE_U_4(ilv->length) < ILV_HDRL)
                return INVALID_STLN;
-       if (EXTRACT_BE_U_4(&ilv->length) > rlen)
+       if (EXTRACT_BE_U_4(ilv->length) > rlen)
                return INVALID_LTLN;
-       if (rlen < F_ALN_LEN(EXTRACT_BE_U_4(&ilv->length)))
+       if (rlen < F_ALN_LEN(EXTRACT_BE_U_4(ilv->length)))
                return INVALID_ALEN;
 
        return 0;
@@ -691,7 +691,7 @@ fdatatlv_print(netdissect_options *ndo,
         */
        rlen = len - TLV_HDRL;
        ND_TCHECK_SIZE(tlv);
-       type = EXTRACT_BE_U_2(&tlv->type);
+       type = EXTRACT_BE_U_2(tlv->type);
        if (type != F_TLV_FULD) {
                ND_PRINT("Error: expecting FULLDATA!\n");
                return -1;
@@ -740,9 +740,9 @@ sdatailv_print(netdissect_options *ndo,
                        return -1;
                }
                if (ndo->ndo_vflag >= 3) {
-                       int ilvl = EXTRACT_BE_U_4(&ilv->length);
+                       int ilvl = EXTRACT_BE_U_4(ilv->length);
                        ND_PRINT("\n%s ILV: type %x length %d\n", ib + 1,
-                                 EXTRACT_BE_U_4(&ilv->type), ilvl);
+                                 EXTRACT_BE_U_4(ilv->type), ilvl);
                        hex_print_with_offset(ndo, "\t\t[", tdp, ilvl-ILV_HDRL, 0);
                }
 
@@ -772,7 +772,7 @@ sdatatlv_print(netdissect_options *ndo,
         */
        rlen = len - TLV_HDRL;
        ND_TCHECK_SIZE(tlv);
-       type = EXTRACT_BE_U_2(&tlv->type);
+       type = EXTRACT_BE_U_2(tlv->type);
        if (type != F_TLV_SPAD) {
                ND_PRINT("Error: expecting SPARSEDATA!\n");
                return -1;
@@ -803,13 +803,13 @@ pkeyitlv_print(netdissect_options *ndo,
        id = EXTRACT_BE_U_4(tdp);
        ND_PRINT("%sKeyinfo: Key 0x%x\n", ib, id);
        ND_TCHECK_SIZE(kdtlv);
-       type = EXTRACT_BE_U_2(&kdtlv->type);
+       type = EXTRACT_BE_U_2(kdtlv->type);
        invtlv = tlv_valid(kdtlv, len);
 
        if (invtlv) {
                ND_PRINT("%s TLV type 0x%x len %d\n",
                       tok2str(ForCES_TLV_err, NULL, invtlv), type,
-                      EXTRACT_BE_U_2(&kdtlv->length));
+                      EXTRACT_BE_U_2(kdtlv->length));
                return -1;
        }
        /*
@@ -817,7 +817,7 @@ pkeyitlv_print(netdissect_options *ndo,
         * length is large enough but not too large (it doesn't
         * go past the end of the containing TLV).
         */
-       tll = EXTRACT_BE_U_2(&kdtlv->length);
+       tll = EXTRACT_BE_U_2(kdtlv->length);
        dp = (const u_char *) TLV_DATA(kdtlv);
        return fdatatlv_print(ndo, dp, tll, op_msk, indent);
 
@@ -894,7 +894,7 @@ pdatacnt_print(netdissect_options *ndo,
                        pptr += sizeof(struct forces_tlv);
                        len -= sizeof(struct forces_tlv);
                        /* skip key content */
-                       tll = EXTRACT_BE_U_2(&keytlv->length);
+                       tll = EXTRACT_BE_U_2(keytlv->length);
                        if (tll < TLV_HDRL) {
                                ND_PRINT("key content length %u < %u\n",
                                        tll, TLV_HDRL);
@@ -920,12 +920,12 @@ pdatacnt_print(netdissect_options *ndo,
                u_int invtlv;
 
                ND_TCHECK_SIZE(pdtlv);
-               type = EXTRACT_BE_U_2(&pdtlv->type);
+               type = EXTRACT_BE_U_2(pdtlv->type);
                invtlv = tlv_valid(pdtlv, len);
                if (invtlv) {
                        ND_PRINT("%s Outstanding bytes %d for TLV type 0x%x TLV len %d\n",
                                  tok2str(ForCES_TLV_err, NULL, invtlv), len, type,
-                                 EXTRACT_BE_U_2(&pdtlv->length));
+                                 EXTRACT_BE_U_2(pdtlv->length));
                        goto pd_err;
                }
                /*
@@ -933,14 +933,15 @@ pdatacnt_print(netdissect_options *ndo,
                 * length is large enough but not too large (it doesn't
                 * go past the end of the containing TLV).
                 */
-               tll = EXTRACT_BE_U_2(&pdtlv->length) - TLV_HDRL;
-               aln = F_ALN_LEN(EXTRACT_BE_U_2(&pdtlv->length));
-               if (aln > EXTRACT_BE_U_2(&pdtlv->length)) {
+               tll = EXTRACT_BE_U_2(pdtlv->length) - TLV_HDRL;
+               aln = F_ALN_LEN(EXTRACT_BE_U_2(pdtlv->length));
+               if (aln > EXTRACT_BE_U_2(pdtlv->length)) {
                        if (aln > len) {
                                ND_PRINT("Invalid padded pathdata TLV type 0x%x len %d missing %d pad bytes\n",
-                                         type, EXTRACT_BE_U_2(&pdtlv->length), aln - len);
+                                         type, EXTRACT_BE_U_2(pdtlv->length),
+                                         aln - len);
                        } else {
-                               pad = aln - EXTRACT_BE_U_2(&pdtlv->length);
+                               pad = aln - EXTRACT_BE_U_2(pdtlv->length);
                        }
                }
                if (pd_valid(type)) {
@@ -949,10 +950,14 @@ pdatacnt_print(netdissect_options *ndo,
                        if (ndo->ndo_vflag >= 3 && ops->v != F_TLV_PDAT) {
                                if (pad)
                                        ND_PRINT("%s  %s (Length %d DataLen %d pad %d Bytes)\n",
-                                                 ib, ops->s, EXTRACT_BE_U_2(&pdtlv->length), tll, pad);
+                                                 ib, ops->s,
+                                                 EXTRACT_BE_U_2(pdtlv->length),
+                                                 tll, pad);
                                else
                                        ND_PRINT("%s  %s (Length %d DataLen %d Bytes)\n",
-                                                 ib, ops->s, EXTRACT_BE_U_2(&pdtlv->length), tll);
+                                                 ib, ops->s,
+                                                 EXTRACT_BE_U_2(pdtlv->length),
+                                                 tll);
                        }
 
                        chk_op_type(ndo, type, op_msk, ops->op_msk);
@@ -964,9 +969,9 @@ pdatacnt_print(netdissect_options *ndo,
                        len -= (TLV_HDRL + pad + tll);
                } else {
                        ND_PRINT("Invalid path data content type 0x%x len %d\n",
-                              type, EXTRACT_BE_U_2(&pdtlv->length));
+                              type, EXTRACT_BE_U_2(pdtlv->length));
 pd_err:
-                       if (EXTRACT_BE_U_2(&pdtlv->length)) {
+                       if (EXTRACT_BE_U_2(pdtlv->length)) {
                                 hex_print_with_offset(ndo, "Bad Data val\n\t  [",
                                                      pptr, len, 0);
                                ND_PRINT("]\n");
@@ -998,25 +1003,26 @@ pdata_print(netdissect_options *ndo,
                goto trunc;
        if (ndo->ndo_vflag >= 3) {
                ND_PRINT("\n%sPathdata: Flags 0x%x ID count %d\n",
-                      ib, EXTRACT_BE_U_2(&pdh->pflags), EXTRACT_BE_U_2(&pdh->pIDcnt));
+                      ib, EXTRACT_BE_U_2(pdh->pflags),
+                      EXTRACT_BE_U_2(pdh->pIDcnt));
        }
 
-       if (EXTRACT_BE_U_2(&pdh->pflags) & F_SELKEY) {
+       if (EXTRACT_BE_U_2(pdh->pflags) & F_SELKEY) {
                op_msk |= B_KEYIN;
        }
 
        /* Table GET Range operation */
-       if (EXTRACT_BE_U_2(&pdh->pflags) & F_SELTABRANGE) {
+       if (EXTRACT_BE_U_2(pdh->pflags) & F_SELTABRANGE) {
                op_msk |= B_TRNG;
        }
        /* Table SET append operation */
-       if (EXTRACT_BE_U_2(&pdh->pflags) & F_TABAPPEND) {
+       if (EXTRACT_BE_U_2(pdh->pflags) & F_TABAPPEND) {
                op_msk |= B_APPND;
        }
 
        pptr += sizeof(struct pathdata_h);
        len -= sizeof(struct pathdata_h);
-       idcnt = EXTRACT_BE_U_2(&pdh->pIDcnt);
+       idcnt = EXTRACT_BE_U_2(pdh->pIDcnt);
        minsize = idcnt * 4;
        if (len < minsize) {
                ND_PRINT("\t\t\ttruncated IDs expected %uB got %uB\n", minsize,
@@ -1058,11 +1064,12 @@ genoptlv_print(netdissect_options *ndo,
        char *ib = indent_pr(indent, 0);
 
        ND_TCHECK_SIZE(pdtlv);
-       type = EXTRACT_BE_U_2(&pdtlv->type);
-       tll = EXTRACT_BE_U_2(&pdtlv->length) - TLV_HDRL;
+       type = EXTRACT_BE_U_2(pdtlv->type);
+       tll = EXTRACT_BE_U_2(pdtlv->length) - TLV_HDRL;
        invtlv = tlv_valid(pdtlv, len);
        ND_PRINT("genoptlvprint - %s TLV type 0x%x len %d\n",
-              tok2str(ForCES_TLV, NULL, type), type, EXTRACT_BE_U_2(&pdtlv->length));
+              tok2str(ForCES_TLV, NULL, type), type,
+              EXTRACT_BE_U_2(pdtlv->length));
        if (!invtlv) {
                /*
                 * At this point, tlv_valid() has ensured that the TLV
@@ -1073,13 +1080,13 @@ genoptlv_print(netdissect_options *ndo,
                if (!ttlv_valid(type)) {
                        ND_PRINT("%s TLV type 0x%x len %d\n",
                               tok2str(ForCES_TLV_err, NULL, invtlv), type,
-                              EXTRACT_BE_U_2(&pdtlv->length));
+                              EXTRACT_BE_U_2(pdtlv->length));
                        return -1;
                }
                if (ndo->ndo_vflag >= 3)
                        ND_PRINT("%s%s, length %d (data length %d Bytes)",
                               ib, tok2str(ForCES_TLV, NULL, type),
-                              EXTRACT_BE_U_2(&pdtlv->length), tll);
+                              EXTRACT_BE_U_2(pdtlv->length), tll);
 
                return pdata_print(ndo, dp, tll, op_msk, indent + 1);
        } else {
@@ -1117,15 +1124,15 @@ recpdoptlv_print(netdissect_options *ndo,
                 * go past the end of the containing TLV).
                 */
                ib = indent_pr(indent, 0);
-               type = EXTRACT_BE_U_2(&pdtlv->type);
+               type = EXTRACT_BE_U_2(pdtlv->type);
                dp = (const u_char *) TLV_DATA(pdtlv);
-               tll = EXTRACT_BE_U_2(&pdtlv->length) - TLV_HDRL;
+               tll = EXTRACT_BE_U_2(pdtlv->length) - TLV_HDRL;
 
                if (ndo->ndo_vflag >= 3)
                        ND_PRINT("%s%s, length %d (data encapsulated %d Bytes)",
                                  ib, tok2str(ForCES_TLV, NULL, type),
-                                 EXTRACT_BE_U_2(&pdtlv->length),
-                                 EXTRACT_BE_U_2(&pdtlv->length) - TLV_HDRL);
+                                 EXTRACT_BE_U_2(pdtlv->length),
+                                 EXTRACT_BE_U_2(pdtlv->length) - TLV_HDRL);
 
                if (pdata_print(ndo, dp, tll, op_msk, indent + 1) == -1)
                        return -1;
@@ -1134,7 +1141,8 @@ recpdoptlv_print(netdissect_options *ndo,
 
        if (len) {
                ND_PRINT("\n\t\tMessy PATHDATA TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
-                         EXTRACT_BE_U_2(&pdtlv->type), len - EXTRACT_BE_U_2(&pdtlv->length));
+                         EXTRACT_BE_U_2(pdtlv->type),
+                         len - EXTRACT_BE_U_2(pdtlv->length));
                return -1;
        }
 
@@ -1172,21 +1180,21 @@ otlv_print(netdissect_options *ndo,
        const struct optlv_h *ops;
 
        /*
-        * lfbselect_print() has ensured that EXTRACT_BE_U_2(&otlv->length)
+        * lfbselect_print() has ensured that EXTRACT_BE_U_2(otlv->length)
         * >= TLV_HDRL.
         */
        ND_TCHECK_SIZE(otlv);
-       type = EXTRACT_BE_U_2(&otlv->type);
-       tll = EXTRACT_BE_U_2(&otlv->length) - TLV_HDRL;
+       type = EXTRACT_BE_U_2(otlv->type);
+       tll = EXTRACT_BE_U_2(otlv->length) - TLV_HDRL;
        ops = get_forces_optlv_h(type);
        if (ndo->ndo_vflag >= 3) {
                ND_PRINT("%sOper TLV %s(0x%x) length %d\n", ib, ops->s, type,
-                      EXTRACT_BE_U_2(&otlv->length));
+                      EXTRACT_BE_U_2(otlv->length));
        }
        /* rest of ops must at least have 12B {pathinfo} */
        if (tll < OP_MIN_SIZ) {
                ND_PRINT("\t\tOper TLV %s(0x%x) length %d\n", ops->s, type,
-                      EXTRACT_BE_U_2(&otlv->length));
+                      EXTRACT_BE_U_2(otlv->length));
                ND_PRINT("\t\tTruncated data size %d minimum required %d\n", tll,
                       OP_MIN_SIZ);
                return invoptlv_print(ndo, dp, tll, ops->op_msk, indent);
@@ -1349,10 +1357,10 @@ print_metailv(netdissect_options *ndo,
         * print_metatlv() has ensured that len (what remains in the
         * ILV) >= ILV_HDRL.
         */
-       rlen = EXTRACT_BE_U_4(&ilv->length) - ILV_HDRL;
+       rlen = EXTRACT_BE_U_4(ilv->length) - ILV_HDRL;
        ND_TCHECK_SIZE(ilv);
-       ND_PRINT("%sMetaID 0x%x length %d\n", ib, EXTRACT_BE_U_4(&ilv->type),
-                 EXTRACT_BE_U_4(&ilv->length));
+       ND_PRINT("%sMetaID 0x%x length %d\n", ib, EXTRACT_BE_U_4(ilv->type),
+                 EXTRACT_BE_U_4(ilv->length));
        if (ndo->ndo_vflag >= 3) {
                hex_print_with_offset(ndo, "\t\t[", ILV_DATA(ilv), rlen, 0);
                ND_PRINT(" ]\n");
@@ -1464,18 +1472,18 @@ redirect_print(netdissect_options *ndo,
                 * length is large enough but not too large (it doesn't
                 * go past the end of the containing TLV).
                 */
-               if (EXTRACT_BE_U_2(&tlv->type) == F_TLV_METD) {
+               if (EXTRACT_BE_U_2(tlv->type) == F_TLV_METD) {
                        print_metatlv(ndo, (const u_char *) TLV_DATA(tlv),
-                                     EXTRACT_BE_U_2(&tlv->length), 0,
+                                     EXTRACT_BE_U_2(tlv->length), 0,
                                      indent);
-               } else if ((EXTRACT_BE_U_2(&tlv->type) == F_TLV_REDD)) {
+               } else if ((EXTRACT_BE_U_2(tlv->type) == F_TLV_REDD)) {
                        print_reddata(ndo, (const u_char *) TLV_DATA(tlv),
-                                     EXTRACT_BE_U_2(&tlv->length), 0,
+                                     EXTRACT_BE_U_2(tlv->length), 0,
                                      indent);
                } else {
                        ND_PRINT("Unknown REDIRECT TLV 0x%x len %d\n",
-                              EXTRACT_BE_U_2(&tlv->type),
-                              EXTRACT_BE_U_2(&tlv->length));
+                              EXTRACT_BE_U_2(tlv->type),
+                              EXTRACT_BE_U_2(tlv->length));
                }
 
                tlv = GO_NXT_TLV(tlv, rlen);
@@ -1483,8 +1491,8 @@ redirect_print(netdissect_options *ndo,
 
        if (rlen) {
                ND_PRINT("\n\t\tMessy Redirect TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
-                         EXTRACT_BE_U_2(&tlv->type),
-                         rlen - EXTRACT_BE_U_2(&tlv->length));
+                         EXTRACT_BE_U_2(tlv->type),
+                         rlen - EXTRACT_BE_U_2(tlv->length));
                return -1;
        }
 
@@ -1531,9 +1539,10 @@ lfbselect_print(netdissect_options *ndo,
        ND_TCHECK_SIZE(lfbs);
        if (ndo->ndo_vflag >= 3) {
                ND_PRINT("\n%s%s(Classid %x) instance %x\n",
-                      ib, tok2str(ForCES_LFBs, NULL, EXTRACT_BE_U_4(&lfbs->class)),
-                      EXTRACT_BE_U_4(&lfbs->class),
-                      EXTRACT_BE_U_4(&lfbs->instance));
+                      ib,
+                      tok2str(ForCES_LFBs, NULL, EXTRACT_BE_U_4(lfbs->class)),
+                      EXTRACT_BE_U_4(lfbs->class),
+                      EXTRACT_BE_U_4(lfbs->instance));
        }
 
        otlv = (const struct forces_tlv *)(lfbs + 1);
@@ -1550,13 +1559,14 @@ lfbselect_print(netdissect_options *ndo,
                 * length is large enough but not too large (it doesn't
                 * go past the end of the containing TLV).
                 */
-               if (op_valid(EXTRACT_BE_U_2(&otlv->type), op_msk)) {
+               if (op_valid(EXTRACT_BE_U_2(otlv->type), op_msk)) {
                        otlv_print(ndo, otlv, 0, indent);
                } else {
                        if (ndo->ndo_vflag < 3)
                                ND_PRINT("\n");
                        ND_PRINT("\t\tINValid oper-TLV type 0x%x length %d for this ForCES message\n",
-                                 EXTRACT_BE_U_2(&otlv->type), EXTRACT_BE_U_2(&otlv->length));
+                                 EXTRACT_BE_U_2(otlv->type),
+                                 EXTRACT_BE_U_2(otlv->length));
                        invoptlv_print(ndo, (const u_char *)otlv, rlen, 0, indent);
                }
                otlv = GO_NXT_TLV(otlv, rlen);
@@ -1564,7 +1574,8 @@ lfbselect_print(netdissect_options *ndo,
 
        if (rlen) {
                ND_PRINT("\n\t\tMessy oper TLV header, type (0x%x)\n\t\texcess of %d Bytes ",
-                         EXTRACT_BE_U_2(&otlv->type), rlen - EXTRACT_BE_U_2(&otlv->length));
+                         EXTRACT_BE_U_2(otlv->type),
+                         rlen - EXTRACT_BE_U_2(otlv->length));
                return -1;
        }
 
@@ -1626,20 +1637,20 @@ forces_type_print(netdissect_options *ndo,
                 * length is large enough but not too large (it doesn't
                 * go past the end of the packet).
                 */
-               if (!ttlv_valid(EXTRACT_BE_U_2(&tltlv->type))) {
+               if (!ttlv_valid(EXTRACT_BE_U_2(tltlv->type))) {
                        ND_PRINT("\n\tInvalid ForCES Top TLV type=0x%x",
-                              EXTRACT_BE_U_2(&tltlv->type));
+                              EXTRACT_BE_U_2(tltlv->type));
                        return -1;
                }
 
                if (ndo->ndo_vflag >= 3)
                        ND_PRINT("\t%s, length %d (data length %d Bytes)",
-                              tok2str(ForCES_TLV, NULL, EXTRACT_BE_U_2(&tltlv->type)),
-                              EXTRACT_BE_U_2(&tltlv->length),
-                              EXTRACT_BE_U_2(&tltlv->length) - TLV_HDRL);
+                              tok2str(ForCES_TLV, NULL, EXTRACT_BE_U_2(tltlv->type)),
+                              EXTRACT_BE_U_2(tltlv->length),
+                              EXTRACT_BE_U_2(tltlv->length) - TLV_HDRL);
 
                rc = tops->print(ndo, (const u_char *) TLV_DATA(tltlv),
-                                EXTRACT_BE_U_2(&tltlv->length),
+                                EXTRACT_BE_U_2(tltlv->length),
                                 tops->op_msk, 9);
                if (rc < 0) {
                        return -1;
@@ -1655,7 +1666,7 @@ forces_type_print(netdissect_options *ndo,
         */
        if (rlen) {
                ND_PRINT("\tMess TopTLV header: min %u, total %d advertised %d ",
-                      TLV_HDRL, rlen, EXTRACT_BE_U_2(&tltlv->length));
+                      TLV_HDRL, rlen, EXTRACT_BE_U_2(tltlv->length));
                return -1;
        }
 

diff --git a/print-medsa.c b/print-medsa.c
index f7d501a535167c8771bd3ad6412b6fe732726e36..2d25beced35c912bb95240f853dac1a28912c8ef 100644 (file)
--- a/print-medsa.c
+++ b/print-medsa.c
@@ -160,7 +160,7 @@ medsa_print(netdissect_options *ndo,
        length -= 8;
        caplen -= 8;
 
-       ether_type = EXTRACT_BE_U_2(&medsa->ether_type);
+       ether_type = EXTRACT_BE_U_2(medsa->ether_type);
        if (ether_type <= MAX_ETHERNET_LENGTH_VAL) {
                /* Try to print the LLC-layer header & higher layers */
                if (llc_print(ndo, bp, length, caplen, src, dst) < 0) {

diff --git a/print-ntp.c b/print-ntp.c
index be12162d327be287061fef753e826d2b83ef5616..e30f8845e9fed26b5f2089861833a83cc5daa38b 100644 (file)
--- a/print-ntp.c
+++ b/print-ntp.c
@@ -317,7 +317,7 @@ ntp_time_print(netdissect_options *ndo,
        default:
                /* In NTPv4 (RFC 5905) refid is an IPv4 address or first 32 bits of
                   MD5 sum of IPv6 address */
-               ND_PRINT("0x%08x", EXTRACT_BE_U_4(&bp->refid));
+               ND_PRINT("0x%08x", EXTRACT_BE_U_4(bp->refid));
                break;
        }
 
@@ -499,8 +499,8 @@ p_sfix(netdissect_options *ndo,
        int f;
        double ff;
 
-       i = EXTRACT_BE_U_2(&sfp->int_part);
-       f = EXTRACT_BE_U_2(&sfp->fraction);
+       i = EXTRACT_BE_U_2(sfp->int_part);
+       f = EXTRACT_BE_U_2(sfp->fraction);
        ff = f / 65536.0;               /* shift radix point by 16 bits */
        f = (int)(ff * 1000000.0);      /* Treat fraction as parts per million */
        ND_PRINT("%d.%06d", i, f);
@@ -517,8 +517,8 @@ p_ntp_time(netdissect_options *ndo,
        uint32_t f;
        double ff;
 
-       i = EXTRACT_BE_U_4(&lfp->int_part);
-       uf = EXTRACT_BE_U_4(&lfp->fraction);
+       i = EXTRACT_BE_U_4(lfp->int_part);
+       uf = EXTRACT_BE_U_4(lfp->fraction);
        ff = uf;
        if (ff < 0.0)           /* some compilers are buggy */
                ff += FMAXINT;
@@ -575,10 +575,10 @@ p_ntp_delta(netdissect_options *ndo,
        double ff;
        int signbit;
 
-       u = EXTRACT_BE_U_4(&lfp->int_part);
-       ou = EXTRACT_BE_U_4(&olfp->int_part);
-       uf = EXTRACT_BE_U_4(&lfp->fraction);
-       ouf = EXTRACT_BE_U_4(&olfp->fraction);
+       u = EXTRACT_BE_U_4(lfp->int_part);
+       ou = EXTRACT_BE_U_4(olfp->int_part);
+       uf = EXTRACT_BE_U_4(lfp->fraction);
+       ouf = EXTRACT_BE_U_4(olfp->fraction);
        if (ou == 0 && ouf == 0) {
                p_ntp_time(ndo, lfp);
                return;