edhoc 1.0.4 → 1.1.0

package/external/libedhoc/externals/zcbor/include/zcbor_encode.h

@@ -16,6 +16,7 @@
 extern "C" {
 #endif
 
+
 /** The zcbor_encode library provides functions for encoding CBOR data elements.
  *
  * See The README for an introduction to CBOR, including the meaning of pint,
@@ -23,139 +24,72 @@ extern "C" {
  */
 
 
-/** The following param and retval docs apply to all single value encoding functions
- *
- * @param[inout] state  The current state of the encoding.
- * @param[in]    input  The value to encode.
- *
- * @retval true   Everything is ok.
- * @retval false  If the payload is exhausted. Or an unexpected error happened.
- */
-
-/** Encode a pint/nint. */
-bool zcbor_int32_put(zcbor_state_t *state, int32_t input);
-bool zcbor_int64_put(zcbor_state_t *state, int64_t input);
-bool zcbor_uint32_put(zcbor_state_t *state, uint32_t input);
-bool zcbor_uint64_put(zcbor_state_t *state, uint64_t input);
-bool zcbor_size_put(zcbor_state_t *state, size_t input);
-
-/** Encode a pint/nint from a pointer.
- *
- *  Can be used for bulk encoding with @ref zcbor_multi_encode.
- */
-bool zcbor_int_encode(zcbor_state_t *state, const void *input_int, size_t int_size);
-bool zcbor_int32_encode(zcbor_state_t *state, const int32_t *input);
-bool zcbor_int64_encode(zcbor_state_t *state, const int64_t *input);
-bool zcbor_uint_encode(zcbor_state_t *state, const void *input_uint, size_t uint_size);
-bool zcbor_uint32_encode(zcbor_state_t *state, const uint32_t *input);
-bool zcbor_uint64_encode(zcbor_state_t *state, const uint64_t *input);
-bool zcbor_size_encode(zcbor_state_t *state, const size_t *input);
-
-/** Encode a bstr. */
-bool zcbor_bstr_encode(zcbor_state_t *state, const struct zcbor_string *input);
-/** Encode a tstr. */
-bool zcbor_tstr_encode(zcbor_state_t *state, const struct zcbor_string *input);
-
-/** Encode a pointer to a string as a bstr/tstr.
- *
- * @param[inout] state   The current state of the encoding.
- * @param[in]    string  The value to encode. A pointer to the string
- * @param[in]    len     The length of the string pointed to by @p string.
- */
-static inline bool zcbor_bstr_encode_ptr(zcbor_state_t *state, const char *ptr, size_t len)
-{
-	const struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
-
-	return zcbor_bstr_encode(state, &zs);
-}
-static inline bool zcbor_tstr_encode_ptr(zcbor_state_t *state, const char *ptr, size_t len)
-{
-	const struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
-
-	return zcbor_tstr_encode(state, &zs);
-}
-
-/** Encode a string literal as a bstr/tstr.
- *
- * @param[inout] state   The current state of the encoding.
- * @param[in]    string  The value to encode. A string literal, e.g. "Foo", so
- *                       that sizeof(string) - 1 is the length of the string.
- */
-#define zcbor_bstr_put_lit(state, string) \
-	zcbor_bstr_encode_ptr(state, string, sizeof(string) - 1)
-#define zcbor_tstr_put_lit(state, string) \
-	zcbor_tstr_encode_ptr(state, string, sizeof(string) - 1)
+/** See @ref zcbor_new_state() */
+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);
 
-/** Encode null-terminated string as a bstr/tstr.
+/** Convenience macro for declaring and initializing an encoding state with backups.
  *
- * @param[inout] state   The current state of the encoding.
- * @param[in]    string  The value to encode. Must be a null-terminated string,
- *                       so that strlen can be used.
- */
-#define zcbor_bstr_put_term(state, string) \
-	zcbor_bstr_encode_ptr(state, string, strlen(string))
-#define zcbor_tstr_put_term(state, string) \
-	zcbor_tstr_encode_ptr(state, string, strlen(string))
-
-/** Encode a char array literal as a bstr/tstr.
+ *  This gives you a state variable named @p name. The variable functions like
+ *  a pointer.
  *
- * @param[inout] state   The current state of the encoding.
- * @param[in]    string  The value to encode. An array literal, e.g. {'F', 'o', 'o'},
- *                       so that sizeof(string) is the length of the string.
+ *  @param[in]  name          The name of the new state variable.
+ *  @param[in]  num_backups   The number of backup slots to keep in the state.
+ *  @param[in]  payload       The payload to work on.
+ *  @param[in]  payload_size  The size (in bytes) of @p payload.
+ *  @param[in]  elem_count    The starting elem_count (typically 1).
  */
-#define zcbor_bstr_put_arr(state, string) \
-	zcbor_bstr_encode_ptr(state, string, sizeof(string))
-#define zcbor_tstr_put_arr(state, string) \
-	zcbor_tstr_encode_ptr(state, string, sizeof(string))
-
-/** Encode a tag. Must be called before encoding the value being tagged. */
-bool zcbor_tag_encode(zcbor_state_t *state, uint32_t tag);
-
-/** Encode a simple value. */
-bool zcbor_simple_encode(zcbor_state_t *state, uint8_t *input);
-bool zcbor_simple_put(zcbor_state_t *state, uint8_t input);
-
-/** Encode a boolean simple value. */
-bool zcbor_bool_put(zcbor_state_t *state, bool input);
-bool zcbor_bool_encode(zcbor_state_t *state, const bool *input);
+#define ZCBOR_STATE_E(name, num_backups, payload, payload_size, elem_count) \
+zcbor_state_t name[((num_backups) + 2)]; \
+do { \
+	zcbor_new_encode_state(name, ZCBOR_ARRAY_SIZE(name), payload, payload_size, elem_count); \
+} while(0)
 
-/** Encode an IEEE754 float */
-bool zcbor_float16_put(zcbor_state_t *state, float input);
-bool zcbor_float16_encode(zcbor_state_t *state, const float *input);
-bool zcbor_float16_bytes_put(zcbor_state_t *state, uint16_t input);
-bool zcbor_float16_bytes_encode(zcbor_state_t *state, const uint16_t *input);
-bool zcbor_float32_put(zcbor_state_t *state, float input);
-bool zcbor_float32_encode(zcbor_state_t *state, const float *input);
-bool zcbor_float64_put(zcbor_state_t *state, double input);
-bool zcbor_float64_encode(zcbor_state_t *state, const double *input);
 
-/** Encode a "nil"/"undefined" simple value. @p unused should be NULL.
+/** The following applies to all _put and _encode functions listed directly below.
  *
- * @param[inout] state   The current state of the encoding.
- * @param[in]    unused  Unused parameter to maintain signature parity with
- *                       @ref zcbor_encoder_t.
- */
-bool zcbor_nil_put(zcbor_state_t *state, const void *unused);
-bool zcbor_undefined_put(zcbor_state_t *state, const void *unused);
-
-/** Encode a bstr header.
+ * The difference between _put and _encode is only in the argument type,
+ * but when a @ref zcbor_encoder_t is needed, such as for  @ref zcbor_multi_encode,
+ * the _encode variant must be used.
  *
- * The rest of the string can be encoded as CBOR.
- * A state backup is created to keep track of the element count.
- * Call @ref zcbor_bstr_end_encode when done encoding the contents of the bstr.
- *
- * @param[inout] state   The current state of the encoding.
- *
- * @retval true   Header encoded correctly
- * @retval false  Header encoded incorrectly, or backup failed.
- */
-bool zcbor_bstr_start_encode(zcbor_state_t *state);
-
-/** Finalize encoding a CBOR-encoded bstr.
+ * @param[inout] state  The current state of the encoding.
+ * @param[in]    input  The value to encode.
  *
- * Restore element count from backup.
- */
-bool zcbor_bstr_end_encode(zcbor_state_t *state, struct zcbor_string *result);
+ * @retval true   Everything is ok.
+ * @retval false  If the payload is exhausted. Or an unexpected error happened.
+ *                Use zcbor_peek_error() to see the error code.
+ */
+bool zcbor_int32_put(zcbor_state_t *state, int32_t input); /* pint/nint */
+bool zcbor_int64_put(zcbor_state_t *state, int64_t input); /* pint/nint */
+bool zcbor_uint32_put(zcbor_state_t *state, uint32_t input); /* pint */
+bool zcbor_uint64_put(zcbor_state_t *state, uint64_t input); /* pint */
+bool zcbor_size_put(zcbor_state_t *state, size_t input); /* pint */
+bool zcbor_tag_put(zcbor_state_t *state, uint32_t tag); /* CBOR tag */
+bool zcbor_simple_put(zcbor_state_t *state, uint8_t input); /* CBOR simple value */
+bool zcbor_bool_put(zcbor_state_t *state, bool input); /* boolean CBOR simple value */
+bool zcbor_nil_put(zcbor_state_t *state, const void *unused); /* 'nil' CBOR simple value */
+bool zcbor_undefined_put(zcbor_state_t *state, const void *unused); /* 'undefined' CBOR simple value */
+bool zcbor_float16_put(zcbor_state_t *state, float input); /* IEEE754 float16 */
+bool zcbor_float16_bytes_put(zcbor_state_t *state, uint16_t input); /* IEEE754 float16 raw bytes */
+bool zcbor_float32_put(zcbor_state_t *state, float input); /* IEEE754 float32 */
+bool zcbor_float64_put(zcbor_state_t *state, double input); /* IEEE754 float64 */
+
+bool zcbor_int32_encode(zcbor_state_t *state, const int32_t *input); /* pint/nint */
+bool zcbor_int64_encode(zcbor_state_t *state, const int64_t *input); /* pint/nint */
+bool zcbor_uint32_encode(zcbor_state_t *state, const uint32_t *input); /* pint */
+bool zcbor_uint64_encode(zcbor_state_t *state, const uint64_t *input); /* pint */
+bool zcbor_size_encode(zcbor_state_t *state, const size_t *input); /* pint */
+bool zcbor_int_encode(zcbor_state_t *state, const void *input_int, size_t int_size);
+bool zcbor_uint_encode(zcbor_state_t *state, const void *input_uint, size_t uint_size);
+bool zcbor_bstr_encode(zcbor_state_t *state, const struct zcbor_string *input); /* bstr */
+bool zcbor_tstr_encode(zcbor_state_t *state, const struct zcbor_string *input); /* tstr */
+bool zcbor_tag_encode(zcbor_state_t *state, uint32_t *tag); /* CBOR tag. Note that zcbor_tag_encode()'s argument was changed to be a pointer. See also zcbor_tag_put(). */
+bool zcbor_simple_encode(zcbor_state_t *state, uint8_t *input); /* CBOR simple value */
+bool zcbor_bool_encode(zcbor_state_t *state, const bool *input); /* boolean CBOR simple value */
+bool zcbor_float16_encode(zcbor_state_t *state, const float *input); /* IEEE754 float16 */
+bool zcbor_float16_bytes_encode(zcbor_state_t *state, const uint16_t *input); /* IEEE754 float16 raw bytes */
+bool zcbor_float32_encode(zcbor_state_t *state, const float *input); /* IEEE754 float32 */
+bool zcbor_float64_encode(zcbor_state_t *state, const double *input); /* IEEE754 float64 */
 
 /** Encode a list/map header.
  *
@@ -245,49 +179,59 @@ bool zcbor_list_map_end_force_encode(zcbor_state_t *state);
  * @retval false  If @p encoder failed before having encoded @p min_encode
  *                values.
  */
-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(size_t num_encode, zcbor_encoder_t encoder,
+		zcbor_state_t *state, const void *input, size_t result_len);
 
 /** Works like @ref zcbor_multi_encode
  *
  * But first checks that @p num_encode is between @p min_encode and @p max_encode.
  */
-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 input_len);
+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 input_len);
 
-/** Runs @p encoder on @p state and @p input if @p present is true.
- *
- * Calls @ref zcbor_multi_encode under the hood.
- */
-bool zcbor_present_encode(const bool *present,
-		zcbor_encoder_t encoder,
-		zcbor_state_t *state,
-		const void *input);
 
-/** See @ref zcbor_new_state() */
-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);
+/* Supplementary string (bstr/tstr) encoding functions: */
 
-/** Convenience macro for declaring and initializing a state with backups.
+/** Encode a char/uint8_t pointer as a bstr/tstr.
  *
- *  This gives you a state variable named @p name. The variable functions like
- *  a pointer.
+ * @param[inout] state   The current state of the encoding.
+ * @param[in]    str     The value to encode. A pointer to the string/array.
+ *                       _term() uses strnlen(), so @p str must be null-terminated.
+ *                       _lit() uses sizeof()-1, so @p str must be a (null-terminated) string literal.
+ *                       _arr() uses sizeof(), so @p str must be a uint8_t array (not null-terminated).
+ * @param[in]    len     (if present) The length of the string pointed to by @p str
+ * @param[in]    maxlen  (if present) The maximum length of the string pointed to by @p str.
+ *                       This value is passed to strnlen.
+ */
+bool zcbor_bstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len);
+bool zcbor_tstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len);
+bool zcbor_bstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen);
+bool zcbor_tstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen);
+#define zcbor_bstr_put_lit(state, str) zcbor_bstr_encode_ptr(state, str, sizeof(str) - 1)
+#define zcbor_tstr_put_lit(state, str) zcbor_tstr_encode_ptr(state, str, sizeof(str) - 1)
+#define zcbor_bstr_put_arr(state, str) zcbor_bstr_encode_ptr(state, str, sizeof(str))
+#define zcbor_tstr_put_arr(state, str) zcbor_tstr_encode_ptr(state, str, sizeof(str))
+
+/** Encode a bstr header.
  *
- *  @param[in]  name          The name of the new state variable.
- *  @param[in]  num_backups   The number of backup slots to keep in the state.
- *  @param[in]  payload       The payload to work on.
- *  @param[in]  payload_size  The size (in bytes) of @p payload.
- *  @param[in]  elem_count    The starting elem_count (typically 1).
+ * The rest of the string can be encoded as CBOR.
+ * A state backup is created to keep track of the element count.
+ * Call @ref zcbor_bstr_end_encode when done encoding the contents of the bstr.
+ *
+ * @param[inout] state   The current state of the encoding.
+ *
+ * @retval true   Header encoded correctly
+ * @retval false  Header encoded incorrectly, or backup failed.
  */
-#define ZCBOR_STATE_E(name, num_backups, payload, payload_size, elem_count) \
-zcbor_state_t name[((num_backups) + 2)]; \
-do { \
-	zcbor_new_encode_state(name, ZCBOR_ARRAY_SIZE(name), payload, payload_size, elem_count); \
-} while(0)
+bool zcbor_bstr_start_encode(zcbor_state_t *state);
+
+/** Finalize encoding a CBOR-encoded bstr.
+ *
+ * This writes the final size of the bstr to the header.
+ * Restore element count from backup.
+ */
+bool zcbor_bstr_end_encode(zcbor_state_t *state, struct zcbor_string *result);
 
 #ifdef __cplusplus
 }

package/external/libedhoc/externals/zcbor/include/zcbor_print.h

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZCBOR_PRINT_H__
+#define ZCBOR_PRINT_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ZCBOR_PRINT_FUNC
+#include <stdio.h>
+#define zcbor_do_print(...) printf(__VA_ARGS__)
+#else
+#define zcbor_do_print(...) ZCBOR_PRINT_FUNC(__VA_ARGS__)
+#endif
+
+#ifdef ZCBOR_VERBOSE
+#define zcbor_trace_raw(state) (zcbor_do_print("rem: %zu, cur: 0x%x, ec: 0x%zx, err: %d",\
+	(size_t)state->payload_end - (size_t)state->payload, *state->payload, state->elem_count, \
+	state->constant_state ? state->constant_state->error : 0))
+#define zcbor_trace(state, appendix) do { \
+	zcbor_trace_raw(state); \
+	zcbor_do_print(", %s\n", appendix); \
+} while(0)
+#define zcbor_trace_file(state) do { \
+	zcbor_trace_raw(state); \
+	zcbor_do_print(", %s:%d\n", __FILE__, __LINE__); \
+} while(0)
+
+#define zcbor_log_assert(expr, ...) \
+do { \
+	zcbor_do_print("ASSERTION \n  \"" #expr \
+		"\"\nfailed at %s:%d with message:\n  ", \
+		__FILE__, __LINE__); \
+	zcbor_do_print(__VA_ARGS__);\
+} while(0)
+#define zcbor_log(...) zcbor_do_print(__VA_ARGS__)
+#else
+#define zcbor_trace(state, appendix)
+#define zcbor_trace_file(state) ((void)state)
+#define zcbor_log_assert(...)
+#define zcbor_log(...)
+#endif
+
+#ifdef ZCBOR_ASSERTS
+#define zcbor_assert(expr, ...) \
+do { \
+	if (!(expr)) { \
+		zcbor_log_assert(expr, __VA_ARGS__); \
+		ZCBOR_FAIL(); \
+	} \
+} while(0)
+#define zcbor_assert_state(expr, ...) \
+do { \
+	if (!(expr)) { \
+		zcbor_log_assert(expr, __VA_ARGS__); \
+		ZCBOR_ERR(ZCBOR_ERR_ASSERTION); \
+	} \
+} while(0)
+#else
+#define zcbor_assert(expr, ...)
+#define zcbor_assert_state(expr, ...)
+#endif
+
+__attribute__((used))
+static void zcbor_print_compare_lines(const uint8_t *str1, const uint8_t *str2, size_t size)
+{
+	for (size_t j = 0; j < size; j++) {
+		zcbor_do_print("%x ", str1[j]);
+	}
+	zcbor_do_print("\r\n");
+	for (size_t j = 0; j < size; j++) {
+		zcbor_do_print("%x ", str2[j]);
+	}
+	zcbor_do_print("\r\n");
+	for (size_t j = 0; j < size; j++) {
+		zcbor_do_print("%x ", str1[j] != str2[j]);
+	}
+	zcbor_do_print("\r\n");
+	zcbor_do_print("\r\n");
+}
+
+__attribute__((used))
+static void zcbor_print_compare_strings(const uint8_t *str1, const uint8_t *str2, size_t size)
+{
+	const size_t col_width = 16;
+
+	for (size_t i = 0; i <= size / col_width; i++) {
+		zcbor_do_print("line %zu (char %zu)\r\n", i, i*col_width);
+		zcbor_print_compare_lines(&str1[i*col_width], &str2[i*col_width],
+			MIN(col_width, (size - i*col_width)));
+	}
+	zcbor_do_print("\r\n");
+}
+
+__attribute__((used))
+static void zcbor_print_compare_strings_diff(const uint8_t *str1, const uint8_t *str2, size_t size)
+{
+	const size_t col_width = 16;
+	bool printed = false;
+
+	for (size_t i = 0; i <= size / col_width; i++) {
+		if (memcmp(&str1[i*col_width], &str2[i*col_width], MIN(col_width, (size - i*col_width))) != 0) {
+			zcbor_do_print("line %zu (char %zu)\r\n", i, i*col_width);
+			zcbor_print_compare_lines(&str1[i*col_width], &str2[i*col_width],
+				MIN(col_width, (size - i*col_width)));
+			printed = true;
+		}
+	}
+	if (printed) {
+		zcbor_do_print("\r\n");
+	}
+}
+
+__attribute__((used))
+static const char *zcbor_error_str(int error)
+{
+	#define ZCBOR_ERR_CASE(err) case err: \
+		return #err; /* The literal is static per C99 6.4.5 paragraph 5. */\
+
+	switch(error) {
+		ZCBOR_ERR_CASE(ZCBOR_SUCCESS)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_NO_BACKUP_MEM)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_NO_BACKUP_ACTIVE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_LOW_ELEM_COUNT)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_HIGH_ELEM_COUNT)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_INT_SIZE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_FLOAT_SIZE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_ADDITIONAL_INVAL)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_NO_PAYLOAD)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_PAYLOAD_NOT_CONSUMED)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_WRONG_TYPE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_WRONG_VALUE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_WRONG_RANGE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_ITERATIONS)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_ASSERTION)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_PAYLOAD_OUTDATED)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_ELEM_NOT_FOUND)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_MAP_MISALIGNED)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_ELEMS_NOT_PROCESSED)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_NOT_AT_END)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_MAP_FLAGS_NOT_AVAILABLE)
+		ZCBOR_ERR_CASE(ZCBOR_ERR_INVALID_VALUE_ENCODING)
+	}
+	#undef ZCBOR_ERR_CASE
+
+	return "ZCBOR_ERR_UNKNOWN";
+}
+
+__attribute__((used))
+static void zcbor_print_error(int error)
+{
+	zcbor_do_print("%s\r\n", zcbor_error_str(error));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZCBOR_PRINT_H__ */

package/external/libedhoc/externals/zcbor/samples/hello_world/src/main.c

@@ -27,7 +27,7 @@ void main(void)
 	}
 
 	/* Create zcbor state variable for decoding. */
-	ZCBOR_STATE_D(decoding_state, 0, cbor_payload, sizeof(cbor_payload), 1);
+	ZCBOR_STATE_D(decoding_state, 0, cbor_payload, sizeof(cbor_payload), 1, 0);
 
 	/* Decode the text string into the cbor_payload buffer */
 	success = zcbor_tstr_decode(decoding_state, &decoded_string);

package/external/libedhoc/externals/zcbor/samples/pet/include/pet_decode.h

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  *
- * Generated using zcbor version 0.7.0
+ * Generated using zcbor version 0.8.1
  * https://github.com/NordicSemiconductor/zcbor
  * Generated with a --default-max-qty of 3
  */

package/external/libedhoc/externals/zcbor/samples/pet/include/pet_encode.h

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  *
- * Generated using zcbor version 0.7.0
+ * Generated using zcbor version 0.8.1
  * https://github.com/NordicSemiconductor/zcbor
  * Generated with a --default-max-qty of 3
  */

package/external/libedhoc/externals/zcbor/samples/pet/include/pet_types.h

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  *
- * Generated using zcbor version 0.7.0
+ * Generated using zcbor version 0.8.1
  * https://github.com/NordicSemiconductor/zcbor
  * Generated with a --default-max-qty of 3
  */
@@ -34,9 +34,9 @@ struct Pet {
 	size_t names_count;
 	struct zcbor_string birthday;
 	enum {
-		_Pet_species_cat = 1,
-		_Pet_species_dog = 2,
-		_Pet_species_other = 3,
+		Pet_species_cat_c = 1,
+		Pet_species_dog_c = 2,
+		Pet_species_other_c = 3,
 	} species_choice;
 };
 

package/external/libedhoc/externals/zcbor/samples/pet/src/main.c

@@ -21,13 +21,13 @@ static void print_pet(const struct Pet *pet)
 		printf("%02x", pet->birthday.value[i]);
 	}
 	switch (pet->species_choice) {
-	case _Pet_species_cat:
+	case Pet_species_cat_c:
 		printf("\nSpecies: Cat\n\n");
 		return;
-	case _Pet_species_dog:
+	case Pet_species_dog_c:
 		printf("\nSpecies: Dog\n\n");
 		return;
-	case _Pet_species_other:
+	case Pet_species_other_c:
 		printf("\nSpecies: Other\n\n");
 		return;
 	}
@@ -101,7 +101,7 @@ static void get_pet3(void)
 	encoded_pet.names_count = 2;
 	encoded_pet.birthday.value = timestamp3;
 	encoded_pet.birthday.len = sizeof(timestamp3);
-	encoded_pet.species_choice = _Pet_species_other;
+	encoded_pet.species_choice = Pet_species_other_c;
 
 	err = cbor_encode_Pet(pet3, sizeof(pet3), &encoded_pet, NULL);
 

package/external/libedhoc/externals/zcbor/samples/pet/src/pet_decode.c

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  *
- * Generated using zcbor version 0.7.0
+ * Generated using zcbor version 0.8.1
  * https://github.com/NordicSemiconductor/zcbor
  * Generated with a --default-max-qty of 3
  */
@@ -14,6 +14,7 @@
 #include <string.h>
 #include "zcbor_decode.h"
 #include "pet_decode.h"
+#include "zcbor_print.h"
 
 #if DEFAULT_MAX_QTY != 3
 #error "The type file was generated with a different default_max_qty than this file"
@@ -25,18 +26,22 @@ static bool decode_Pet(zcbor_state_t *state, struct Pet *result);
 static bool decode_Pet(
 		zcbor_state_t *state, struct Pet *result)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
 	bool tmp_result = (((zcbor_list_start_decode(state) && ((((zcbor_list_start_decode(state) && ((zcbor_multi_decode(1, 3, &(*result).names_count, (zcbor_decoder_t *)zcbor_tstr_decode, state, (&(*result).names), sizeof(struct zcbor_string))) || (zcbor_list_map_end_force_decode(state), false)) && zcbor_list_end_decode(state)))
 	&& ((zcbor_bstr_decode(state, (&(*result).birthday)))
 	&& ((((((*result).birthday.len >= 8)
 	&& ((*result).birthday.len <= 8)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false)))
-	&& ((((zcbor_int_decode(state, &(*result).species_choice, sizeof((*result).species_choice)))) && ((((((*result).species_choice == _Pet_species_cat) && ((1)))
-	|| (((*result).species_choice == _Pet_species_dog) && ((1)))
-	|| (((*result).species_choice == _Pet_species_other) && ((1)))) || (zcbor_error(state, ZCBOR_ERR_WRONG_VALUE), false)))))) || (zcbor_list_map_end_force_decode(state), false)) && zcbor_list_end_decode(state))));
-
-	if (!tmp_result)
-		zcbor_trace();
+	&& ((((zcbor_uint_decode(state, &(*result).species_choice, sizeof((*result).species_choice)))) && ((((((*result).species_choice == Pet_species_cat_c) && ((1)))
+	|| (((*result).species_choice == Pet_species_dog_c) && ((1)))
+	|| (((*result).species_choice == Pet_species_other_c) && ((1)))) || (zcbor_error(state, ZCBOR_ERR_WRONG_VALUE), false)))))) || (zcbor_list_map_end_force_decode(state), false)) && zcbor_list_end_decode(state))));
+
+	if (!tmp_result) {
+		zcbor_trace_file(state);
+		zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state)));
+	} else {
+		zcbor_log("%s success\r\n", __func__);
+	}
 
 	return tmp_result;
 }
@@ -50,20 +55,6 @@ int cbor_decode_Pet(
 {
 	zcbor_state_t states[4];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
-
-	bool ret = decode_Pet(states, result);
-
-	if (ret && (payload_len_out != NULL)) {
-		*payload_len_out = MIN(payload_len,
-				(size_t)states[0].payload - (size_t)payload);
-	}
-
-	if (!ret) {
-		int err = zcbor_pop_error(states);
-
-		zcbor_print("Return error: %d\r\n", err);
-		return (err == ZCBOR_SUCCESS) ? ZCBOR_ERR_UNKNOWN : err;
-	}
-	return ZCBOR_SUCCESS;
+	return zcbor_entry_function(payload, payload_len, (void *)result, payload_len_out, states,
+		(zcbor_decoder_t *)decode_Pet, sizeof(states) / sizeof(zcbor_state_t), 1);
 }