edhoc 1.0.4 → 1.1.0

package/external/libedhoc/externals/zcbor/src/zcbor_encode.c

@@ -10,6 +10,7 @@
 #include <string.h>
 #include "zcbor_encode.h"
 #include "zcbor_common.h"
+#include "zcbor_print.h"
 
 _Static_assert((sizeof(size_t) == sizeof(void *)),
 	"This code needs size_t to be the same length as pointers.");
@@ -28,7 +29,7 @@ static uint8_t log2ceil(size_t val)
 		case 8: return 3;
 	}
 
-	zcbor_print("Should not come here.\r\n");
+	zcbor_log("Should not come here.\r\n");
 	return 0;
 }
 
@@ -45,101 +46,57 @@ static bool encode_header_byte(zcbor_state_t *state,
 	ZCBOR_CHECK_ERROR();
 	ZCBOR_CHECK_PAYLOAD();
 
-	zcbor_assert_state(additional < 32, NULL);
+	zcbor_assert_state(additional < 32, "Unsupported additional value: %d\r\n", additional);
 
 	*(state->payload_mut++) = (uint8_t)((major_type << 5) | (additional & 0x1F));
 	return true;
 }
 
 
-static size_t get_encoded_len(const void *const result, size_t result_len);
-
-
 /** Encode a single value.
  */
 static bool value_encode_len(zcbor_state_t *state, zcbor_major_type_t major_type,
 		const void *const result, size_t result_len)
 {
 	uint8_t *u8_result  = (uint8_t *)result;
-	size_t encoded_len = get_encoded_len(result, result_len);
 
-	if ((state->payload + 1 + encoded_len) > state->payload_end) {
+	if ((state->payload + 1 + result_len) > state->payload_end) {
 		ZCBOR_ERR(ZCBOR_ERR_NO_PAYLOAD);
 	}
 
 	if (!encode_header_byte(state, major_type,
-				get_additional(encoded_len, u8_result[0]))) {
+				get_additional(result_len, u8_result[0]))) {
 		ZCBOR_FAIL();
 	}
 	state->payload_mut--;
-	zcbor_trace();
+	zcbor_trace(state, "value_encode_len");
 	state->payload_mut++;
 
-#ifdef CONFIG_BIG_ENDIAN
-	memcpy(state->payload_mut, u8_result, encoded_len);
-	state->payload_mut += encoded_len;
+#ifdef ZCBOR_BIG_ENDIAN
+	memcpy(state->payload_mut, u8_result, result_len);
+	state->payload_mut += result_len;
 #else
-	for (; encoded_len > 0; encoded_len--) {
-		*(state->payload_mut++) = u8_result[encoded_len - 1];
+	for (; result_len > 0; result_len--) {
+		*(state->payload_mut++) = u8_result[result_len - 1];
 	}
-#endif /* CONFIG_BIG_ENDIAN */
+#endif /* ZCBOR_BIG_ENDIAN */
 
 	state->elem_count++;
 	return true;
 }
 
 
-static size_t get_result_len(const void *const input, size_t max_result_len)
-{
-	uint8_t *u8_result  = (uint8_t *)input;
-	size_t len = max_result_len;
-
-	for (; len > 0; len--) {
-#ifdef CONFIG_BIG_ENDIAN
-		if (u8_result[max_result_len - len] != 0) {
-#else
-		if (u8_result[len - 1] != 0) {
-#endif /* CONFIG_BIG_ENDIAN */
-			break;
-		}
-	}
-
-	/* Round up to nearest power of 2. */
-	return len <= 2 ? len : (uint8_t)(1 << log2ceil(len));
-}
-
-
-static const void *get_result(const void *const input, size_t max_result_len,
-	size_t result_len)
-{
-#ifdef CONFIG_BIG_ENDIAN
-	return &((uint8_t *)input)[max_result_len - (result_len ? result_len : 1)];
-#else
-	(void)max_result_len;
-	(void)result_len;
-	return input;
-#endif
-}
-
-
-static size_t get_encoded_len(const void *const result, size_t result_len)
-{
-	const uint8_t *u8_result  = (const uint8_t *)result;
-
-	if ((result_len == 1) && (u8_result[0] <= ZCBOR_VALUE_IN_HEADER)) {
-		return 0;
-	}
-	return result_len;
-}
-
-
 static bool value_encode(zcbor_state_t *state, zcbor_major_type_t major_type,
 		const void *const input, size_t max_result_len)
 {
 	zcbor_assert_state(max_result_len != 0, "0-length result not supported.\r\n");
 
-	size_t result_len = get_result_len(input, max_result_len);
-	const void *const result = get_result(input, max_result_len, result_len);
+	size_t result_len = zcbor_header_len_ptr(input, max_result_len) - 1;
+	const void *result = input;
+
+#ifdef ZCBOR_BIG_ENDIAN
+	result = (uint8_t *)input + max_result_len - (result_len ? result_len : 1);
+#endif
 
 	return value_encode_len(state, major_type, result, result_len);
 }
@@ -157,7 +114,7 @@ bool zcbor_int_encode(zcbor_state_t *state, const void *input_int, size_t int_si
 		ZCBOR_ERR(ZCBOR_ERR_INT_SIZE);
 	}
 
-#ifdef CONFIG_BIG_ENDIAN
+#ifdef ZCBOR_BIG_ENDIAN
 	if (input_int8[0] < 0) {
 #else
 	if (input_int8[int_size - 1] < 0) {
@@ -184,7 +141,7 @@ bool zcbor_int_encode(zcbor_state_t *state, const void *input_int, size_t int_si
 bool zcbor_uint_encode(zcbor_state_t *state, const void *input_uint, size_t uint_size)
 {
 	if (!value_encode(state, ZCBOR_MAJOR_TYPE_PINT, input_uint, uint_size)) {
-		zcbor_print("uint with size %d failed.\r\n", uint_size);
+		zcbor_log("uint with size %zu failed.\r\n", uint_size);
 		ZCBOR_FAIL();
 	}
 	return true;
@@ -255,8 +212,8 @@ bool zcbor_size_encode(zcbor_state_t *state, const size_t *input)
 static bool str_start_encode(zcbor_state_t *state,
 		const struct zcbor_string *input, zcbor_major_type_t major_type)
 {
-	if (input->value && ((get_result_len(&input->len, sizeof(input->len))
-			+ 1 + input->len + (size_t)state->payload)
+	if (input->value && ((zcbor_header_len_ptr(&input->len, sizeof(input->len))
+			+ input->len + (size_t)state->payload)
 			> (size_t)state->payload_end)) {
 		ZCBOR_ERR(ZCBOR_ERR_NO_PAYLOAD);
 	}
@@ -271,7 +228,7 @@ static bool str_start_encode(zcbor_state_t *state,
 static size_t remaining_str_len(zcbor_state_t *state)
 {
 	size_t max_len = (size_t)state->payload_end - (size_t)state->payload;
-	size_t result_len = get_result_len(&max_len, sizeof(max_len));
+	size_t result_len = zcbor_header_len_ptr(&max_len, sizeof(max_len)) - 1;
 
 	return max_len - result_len - 1;
 }
@@ -352,6 +309,34 @@ bool zcbor_tstr_encode(zcbor_state_t *state, const struct zcbor_string *input)
 }
 
 
+bool zcbor_bstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len)
+{
+	const struct zcbor_string zs = { .value = (const uint8_t *)str, .len = len };
+
+	return zcbor_bstr_encode(state, &zs);
+}
+
+
+bool zcbor_tstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len)
+{
+	const struct zcbor_string zs = { .value = (const uint8_t *)str, .len = len };
+
+	return zcbor_tstr_encode(state, &zs);
+}
+
+
+bool zcbor_bstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen)
+{
+	return zcbor_bstr_encode_ptr(state, str, strnlen(str, maxlen));
+}
+
+
+bool zcbor_tstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen)
+{
+	return zcbor_tstr_encode_ptr(state, str, strnlen(str, maxlen));
+}
+
+
 static bool list_map_start_encode(zcbor_state_t *state, size_t max_num,
 		zcbor_major_type_t major_type)
 {
@@ -388,17 +373,6 @@ bool zcbor_map_start_encode(zcbor_state_t *state, size_t max_num)
 }
 
 
-#ifdef ZCBOR_CANONICAL
-static size_t get_encoded_len2(const void *const input, size_t max_result_len)
-{
-	size_t result_len = get_result_len(input, max_result_len);
-	const void *const result = get_result(input, max_result_len, result_len);
-
-	return get_encoded_len(result, result_len);
-}
-#endif
-
-
 static bool list_map_end_encode(zcbor_state_t *state, size_t max_num,
 			zcbor_major_type_t major_type)
 {
@@ -409,21 +383,21 @@ static bool list_map_end_encode(zcbor_state_t *state, size_t max_num,
 
 	const uint8_t *payload = state->payload;
 
-	size_t max_header_len = get_encoded_len2(&max_num, 4);
-	size_t header_len = get_encoded_len2(&list_count, 4);
+	size_t max_header_len = zcbor_header_len_ptr(&max_num, 4) - 1;
+	size_t header_len = zcbor_header_len_ptr(&list_count, 4) - 1;
 
 	if (!zcbor_process_backup(state, ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME, 0xFFFFFFFF)) {
 		ZCBOR_FAIL();
 	}
 
-	zcbor_print("list_count: %" PRIuFAST32 "\r\n", list_count);
+	zcbor_log("list_count: %zu\r\n", list_count);
 
 
 	/** If max_num is smaller than the actual number of encoded elements,
 	  * the value_encode() below will corrupt the data if the encoded
 	  * header is larger than the previously encoded header. */
 	if (header_len > max_header_len) {
-		zcbor_print("max_num too small.\r\n");
+		zcbor_log("max_num too small.\r\n");
 		ZCBOR_ERR(ZCBOR_ERR_HIGH_ELEM_COUNT);
 	}
 
@@ -482,7 +456,7 @@ bool zcbor_list_map_end_force_encode(zcbor_state_t *state)
 bool zcbor_simple_encode(zcbor_state_t *state, uint8_t *input)
 {
 	if (!value_encode(state, ZCBOR_MAJOR_TYPE_SIMPLE, input, sizeof(*input))) {
-		zcbor_print("Error encoding %u (0x%p)\r\n", *input, input);
+		zcbor_log("Error encoding %u (0x%p)\r\n", *input, input);
 		ZCBOR_FAIL();
 	}
 	return true;
@@ -560,87 +534,10 @@ bool zcbor_float16_encode(zcbor_state_t *state, const float *input)
 	return zcbor_float16_put(state, *input);
 }
 
-/* Float16: */
-#define F16_SIGN_OFFS 15 /* Bit offset of the sign bit. */
-#define F16_EXPO_OFFS 10 /* Bit offset of the exponent. */
-#define F16_EXPO_MSK 0x1F /* Bitmask for the exponent (right shifted by F16_EXPO_OFFS). */
-#define F16_MANTISSA_MSK 0x3FF /* Bitmask for the mantissa. */
-#define F16_MAX 65520 /* Lowest float32 value that rounds up to float16 infinity.
-		       * (65519.996 rounds to 65504) */
-#define F16_MIN_EXPO 24 /* Negative exponent of the non-zero float16 value closest to 0 (2^-24) */
-#define F16_MIN (1.0 / (1 << F16_MIN_EXPO)) /* The non-zero float16 value closest to 0 (2^-24) */
-#define F16_MIN_NORM (1.0 / (1 << 14)) /* The normalized float16 value closest to 0 (2^-14) */
-#define F16_BIAS 15 /* The exponent bias of normalized float16 values. */
-
-/* Float32: */
-#define F32_SIGN_OFFS 31 /* Bit offset of the sign bit. */
-#define F32_EXPO_OFFS 23 /* Bit offset of the exponent. */
-#define F32_EXPO_MSK 0xFF /* Bitmask for the exponent (right shifted by F32_EXPO_OFFS). */
-#define F32_MANTISSA_MSK 0x7FFFFF /* Bitmask for the mantissa. */
-#define F32_BIAS 127 /* The exponent bias of normalized float32 values. */
-
-/* Rounding: */
-#define SUBNORM_ROUND_MSK (F32_MANTISSA_MSK | (1 << F32_EXPO_OFFS)) /* mantissa + lsb of expo for
-								     * tiebreak. */
-#define SUBNORM_ROUND_BIT_MSK (1 << (F32_EXPO_OFFS - 1)) /* msb of mantissa (0x400000) */
-#define NORM_ROUND_MSK (F32_MANTISSA_MSK >> (F16_EXPO_OFFS - 1)) /* excess mantissa when going from
-								  * float32 to float16 + 1 extra bit
-								  * for tiebreak. */
-#define NORM_ROUND_BIT_MSK (1 << (F32_EXPO_OFFS - F16_EXPO_OFFS - 1)) /* bit 12 (0x1000) */
 
 bool zcbor_float16_put(zcbor_state_t *state, float input)
 {
-	uint32_t value32 = *(uint32_t *)&input;
-
-	uint32_t sign = value32 >> F32_SIGN_OFFS;
-	uint32_t expo = (value32 >> F32_EXPO_OFFS) & F32_EXPO_MSK;
-	uint32_t mantissa = value32 & F32_MANTISSA_MSK;
-
-	uint16_t value16 = (uint16_t)(sign << F16_SIGN_OFFS);
-
-	float abs_input;
-	*(uint32_t *)&abs_input = value32 & ~(1 << F32_SIGN_OFFS);
-
-	if (abs_input <= (F16_MIN / 2)) {
-		/* 0 or too small for float16. Round down to 0. value16 is already correct. */
-	} else if (abs_input < F16_MIN) {
-		/* Round up to 2^(-24) (F16_MIN), has other rounding rules than larger values. */
-		value16 |= 0x0001;
-	} else if (abs_input < F16_MIN_NORM) {
-		/* Subnormal float16 (normal float32) */
-		uint32_t adjusted_mantissa =
-			/* Adjust for the purposes of checking rounding. */
-			/* The lsb of expo is needed for the cases where expo is 103 (minimum). */
-			((value32 << (expo - (F32_BIAS - F16_MIN_EXPO))) & SUBNORM_ROUND_MSK);
-		uint16_t rounding_bit =
-			/* "Round to nearest, ties to even". */
-			/* 0x400000 means ties go down towards even. (0xC00000 means ties go up.) */
-			(adjusted_mantissa & SUBNORM_ROUND_BIT_MSK)
-				&& (adjusted_mantissa != SUBNORM_ROUND_BIT_MSK);
-		value16 |= ((uint16_t)(abs_input * (1 << 24)) + rounding_bit); /* expo is 0 */
-	} else if (abs_input < F16_MAX) {
-		/* Normal float16 (normal float32) */
-		uint16_t rounding_bit =
-			/* Bit 13 of the mantissa represents which way to round, except for the */
-			/* special case where bits 0-12 and 14 are 0. */
-			/* This is because of "Round to nearest, ties to even". */
-			/* 0x1000 means ties go down towards even. (0x3000 means ties go up.) */
-			((mantissa & NORM_ROUND_BIT_MSK)
-				&& ((mantissa & NORM_ROUND_MSK) != NORM_ROUND_BIT_MSK));
-		value16 |= (uint16_t)((expo - (F32_BIAS - F16_BIAS)) << F16_EXPO_OFFS);
-		value16 |= (uint16_t)(mantissa >> (F32_EXPO_OFFS - F16_EXPO_OFFS));
-		value16 += rounding_bit; /* Might propagate to exponent. */
-	} else if (expo != F32_EXPO_MSK || !mantissa) {
-		/* Infinite, or finite normal float32 too large for float16. Round up to inf. */
-		value16 |= (F16_EXPO_MSK << F16_EXPO_OFFS);
-	} else {
-		/* NaN */
-		/* Preserve msbit of mantissa. */
-		uint16_t new_mantissa = (uint16_t)(mantissa >> (F32_EXPO_OFFS - F16_EXPO_OFFS));
-		value16 |= (F16_EXPO_MSK << F16_EXPO_OFFS) | (new_mantissa ? new_mantissa : 1);
-	}
-
-	return zcbor_float16_bytes_put(state, value16);
+	return zcbor_float16_bytes_put(state, zcbor_float32_to_16(input));
 }
 
 
@@ -661,7 +558,7 @@ bool zcbor_float16_bytes_put(zcbor_state_t *state, uint16_t input)
 }
 
 
-bool zcbor_tag_encode(zcbor_state_t *state, uint32_t tag)
+bool zcbor_tag_put(zcbor_state_t *state, uint32_t tag)
 {
 	if (!value_encode(state, ZCBOR_MAJOR_TYPE_TAG, &tag, sizeof(tag))) {
 		ZCBOR_FAIL();
@@ -672,13 +569,15 @@ bool zcbor_tag_encode(zcbor_state_t *state, uint32_t tag)
 }
 
 
-bool zcbor_multi_encode_minmax(size_t min_encode,
-		size_t max_encode,
-		const size_t *num_encode,
-		zcbor_encoder_t encoder,
-		zcbor_state_t *state,
-		const void *input,
-		size_t result_len)
+bool zcbor_tag_encode(zcbor_state_t *state, uint32_t *tag)
+{
+	return zcbor_tag_put(state, *tag);
+}
+
+
+bool zcbor_multi_encode_minmax(size_t min_encode, size_t max_encode,
+		const size_t *num_encode, zcbor_encoder_t encoder,
+		zcbor_state_t *state, const void *input, size_t result_len)
 {
 
 	if ((*num_encode >= min_encode) && (*num_encode <= max_encode)) {
@@ -689,11 +588,8 @@ bool zcbor_multi_encode_minmax(size_t min_encode,
 }
 
 
-bool zcbor_multi_encode(size_t num_encode,
-		zcbor_encoder_t encoder,
-		zcbor_state_t *state,
-		const void *input,
-		size_t result_len)
+bool zcbor_multi_encode(const size_t num_encode, zcbor_encoder_t encoder,
+		zcbor_state_t *state, const void *input, size_t result_len)
 {
 	ZCBOR_CHECK_ERROR();
 	for (size_t i = 0; i < num_encode; i++) {
@@ -701,22 +597,13 @@ bool zcbor_multi_encode(size_t num_encode,
 			ZCBOR_FAIL();
 		}
 	}
-	zcbor_print("Encoded %" PRIuFAST32 " elements.\n", num_encode);
+	zcbor_log("Encoded %zu elements.\n", num_encode);
 	return true;
 }
 
 
-bool zcbor_present_encode(const bool *present,
-		zcbor_encoder_t encoder,
-		zcbor_state_t *state,
-		const void *input)
-{
-	return zcbor_multi_encode(!!*present, encoder, state, input, 0);
-}
-
-
 void zcbor_new_encode_state(zcbor_state_t *state_array, size_t n_states,
 		uint8_t *payload, size_t payload_len, size_t elem_count)
 {
-	zcbor_new_state(state_array, n_states, payload, payload_len, elem_count);
+	zcbor_new_state(state_array, n_states, payload, payload_len, elem_count, NULL, 0);
 }