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.

4 files changed, 95 insertions, 12 deletions

diff --git a/cpack.c b/cpack.c
index bae7e632..7628a5c3 100644
--- 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 3072e0c3..b9a37850 100644
--- 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 e25104e7..82ccae3c 100644
--- 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 35889815..e6e88a02 100644
--- 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;
 		}