Clean up signed vs. unsigned.

Have separate cpack_ routines for signed and unsigned numbers, with the
signed ones using _S_ extract macros.  That way, we can do more type
checking.

Add EXTRACT_LE_S_ macros.

Use signed variables for IEEE80211_RADIOTAP_TX_ATTENUATION and
IEEE80211_RADIOTAP_DB_TX_ATTENUATION, rather than using unsigned
variables that we cast to int.

Also, use EXTRACT_U_1() in cpack_uint8.

diff --git a/cpack.c b/cpack.c
index bae7e632dfd6635b26b0a94e45bd3f97ee34e75b..7628a5c3e3dee8b093bc823c07e239a61146edda 100644 (file)
--- a/cpack.c
+++ b/cpack.c
@@ -107,6 +107,22 @@ cpack_uint64(struct cpack_state *cs, uint64_t *u)
        return 0;
 }
 
+/* Unpack a 64-bit signed integer. */
+int
+cpack_int64(struct cpack_state *cs, int64_t *u)
+{
+       const uint8_t *next;
+
+       if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
+               return -1;
+
+       *u = EXTRACT_LE_S_8(next);
+
+       /* Move pointer past the int64_t. */
+       cs->c_next = next + sizeof(*u);
+       return 0;
+}
+
 /* Unpack a 32-bit unsigned integer. */
 int
 cpack_uint32(struct cpack_state *cs, uint32_t *u)
@@ -123,6 +139,22 @@ cpack_uint32(struct cpack_state *cs, uint32_t *u)
        return 0;
 }
 
+/* Unpack a 32-bit signed integer. */
+int
+cpack_int32(struct cpack_state *cs, int32_t *u)
+{
+       const uint8_t *next;
+
+       if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
+               return -1;
+
+       *u = EXTRACT_LE_S_4(next);
+
+       /* Move pointer past the int32_t. */
+       cs->c_next = next + sizeof(*u);
+       return 0;
+}
+
 /* Unpack a 16-bit unsigned integer. */
 int
 cpack_uint16(struct cpack_state *cs, uint16_t *u)
@@ -139,6 +171,22 @@ cpack_uint16(struct cpack_state *cs, uint16_t *u)
        return 0;
 }
 
+/* Unpack a 16-bit signed integer. */
+int
+cpack_int16(struct cpack_state *cs, int16_t *u)
+{
+       const uint8_t *next;
+
+       if ((next = cpack_align_and_reserve(cs, sizeof(*u))) == NULL)
+               return -1;
+
+       *u = EXTRACT_LE_S_2(next);
+
+       /* Move pointer past the int16_t. */
+       cs->c_next = next + sizeof(*u);
+       return 0;
+}
+
 /* Unpack an 8-bit unsigned integer. */
 int
 cpack_uint8(struct cpack_state *cs, uint8_t *u)
@@ -147,9 +195,24 @@ cpack_uint8(struct cpack_state *cs, uint8_t *u)
        if ((size_t)(cs->c_next - cs->c_buf) >= cs->c_len)
                return -1;
 
-       *u = *cs->c_next;
+       *u = EXTRACT_U_1(cs->c_next);
 
        /* Move pointer past the uint8_t. */
        cs->c_next++;
        return 0;
 }
+
+/* Unpack an 8-bit signed integer. */
+int
+cpack_int8(struct cpack_state *cs, int8_t *u)
+{
+       /* No space left? */
+       if ((size_t)(cs->c_next - cs->c_buf) >= cs->c_len)
+               return -1;
+
+       *u = EXTRACT_S_1(cs->c_next);
+
+       /* Move pointer past the int8_t. */
+       cs->c_next++;
+       return 0;
+}

diff --git a/cpack.h b/cpack.h
index 3072e0c37411b28cc3854624e616ffb038681b22..b9a37850a733670a31bdf8aacadbd6dde207cf90 100644 (file)
--- a/cpack.h
+++ b/cpack.h
@@ -39,18 +39,17 @@ struct cpack_state {
 int cpack_init(struct cpack_state *, const uint8_t *, size_t);
 
 int cpack_uint8(struct cpack_state *, uint8_t *);
+int cpack_int8(struct cpack_state *, int8_t *);
 int cpack_uint16(struct cpack_state *, uint16_t *);
+int cpack_int16(struct cpack_state *, int16_t *);
 int cpack_uint32(struct cpack_state *, uint32_t *);
+int cpack_int32(struct cpack_state *, int32_t *);
 int cpack_uint64(struct cpack_state *, uint64_t *);
+int cpack_int64(struct cpack_state *, int64_t *);
 
 const uint8_t *cpack_next_boundary(const uint8_t *buf, const uint8_t *p, size_t alignment);
 const uint8_t *cpack_align_and_reserve(struct cpack_state *cs, size_t wordsize);
 
-#define cpack_int8(__s, __p)   cpack_uint8((__s),  (uint8_t*)(__p))
-#define cpack_int16(__s, __p)  cpack_uint16((__s), (uint16_t*)(__p))
-#define cpack_int32(__s, __p)  cpack_uint32((__s), (uint32_t*)(__p))
-#define cpack_int64(__s, __p)  cpack_uint64((__s), (uint64_t*)(__p))
-
 extern int cpack_advance(struct cpack_state *, const size_t);
 
 #endif /* _CPACK_H */

diff --git a/extract.h b/extract.h
index e25104e78d17693047edfbf4f8913b6660415faa..82ccae3cea6b16e9c090a8cb7690dacbdb04c894 100644 (file)
--- a/extract.h
+++ b/extract.h
@@ -367,15 +367,27 @@ EXTRACT_BE_S_8(const void *p)
 #define EXTRACT_LE_U_2(p) \
        ((uint16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
                    ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
+#define EXTRACT_LE_S_2(p) \
+       ((int16_t)(((uint16_t)(*((const uint8_t *)(p) + 1)) << 8) | \
+                  ((uint16_t)(*((const uint8_t *)(p) + 0)) << 0)))
 #define EXTRACT_LE_U_4(p) \
        ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
                    ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
                    ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
                    ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
+#define EXTRACT_LE_S_4(p) \
+       ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 3)) << 24) | \
+                  ((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
+                  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
+                  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 #define EXTRACT_LE_U_3(p) \
        ((uint32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
                    ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
                    ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
+#define EXTRACT_LE_S_3(p) \
+       ((int32_t)(((uint32_t)(*((const uint8_t *)(p) + 2)) << 16) | \
+                  ((uint32_t)(*((const uint8_t *)(p) + 1)) << 8) | \
+                  ((uint32_t)(*((const uint8_t *)(p) + 0)) << 0)))
 #define EXTRACT_LE_U_8(p) \
        ((uint64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
                    ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
@@ -385,6 +397,15 @@ EXTRACT_BE_S_8(const void *p)
                    ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
                    ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
                    ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
+#define EXTRACT_LE_S_8(p) \
+       ((int64_t)(((uint64_t)(*((const uint8_t *)(p) + 7)) << 56) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 6)) << 48) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 5)) << 40) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 4)) << 32) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 3)) << 24) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 2)) << 16) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 1)) << 8) | \
+                  ((uint64_t)(*((const uint8_t *)(p) + 0)) << 0)))
 
 /*
  * Macros to check the presence of the values in question.

diff --git a/print-802_11.c b/print-802_11.c
index 35889815dcb5c9ef9c2fd4038395ef15ee05b2b5..e6e88a0282ff3c7e497c07eb337bd55845d49490 100644 (file)
--- a/print-802_11.c
+++ b/print-802_11.c
@@ -2707,22 +2707,22 @@ print_radiotap_field(netdissect_options *ndo,
                }
 
        case IEEE80211_RADIOTAP_TX_ATTENUATION: {
-               uint16_t tx_attenuation;
+               int16_t tx_attenuation;
 
-               rc = cpack_uint16(s, &tx_attenuation);
+               rc = cpack_int16(s, &tx_attenuation);
                if (rc != 0)
                        goto trunc;
-               ND_PRINT((ndo, "%d tx power ", -(int)tx_attenuation));
+               ND_PRINT((ndo, "%d tx power ", -tx_attenuation));
                break;
                }
 
        case IEEE80211_RADIOTAP_DB_TX_ATTENUATION: {
-               uint8_t db_tx_attenuation;
+               int8_t db_tx_attenuation;
 
-               rc = cpack_uint8(s, &db_tx_attenuation);
+               rc = cpack_int8(s, &db_tx_attenuation);
                if (rc != 0)
                        goto trunc;
-               ND_PRINT((ndo, "%ddB tx attenuation ", -(int)db_tx_attenuation));
+               ND_PRINT((ndo, "%ddB tx attenuation ", -db_tx_attenuation));
                break;
                }