edhoc 1.0.4 → 1.1.0

package/external/libedhoc/backends/cbor/include/backend_cbor_x509_types.h

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -25,142 +25,152 @@ extern "C" {
  */
 #define DEFAULT_MAX_QTY 3
 
-struct id_cred_x_kid_ {
+struct id_cred_x_kid_r {
 	union {
-		int32_t _id_cred_x_kid_int;
-		struct zcbor_string _id_cred_x_kid_bstr;
+		int32_t id_cred_x_kid_int;
+		struct zcbor_string id_cred_x_kid_bstr;
 	};
 	enum {
-		_id_cred_x_kid_int,
-		_id_cred_x_kid_bstr,
-	} _id_cred_x_kid_choice;
+		id_cred_x_kid_int_c,
+		id_cred_x_kid_bstr_c,
+	} id_cred_x_kid_choice;
 };
 
-struct COSE_X509_ {
+struct COSE_X509_r {
 	union {
-		struct zcbor_string _COSE_X509_bstr;
+		struct zcbor_string COSE_X509_bstr;
 		struct {
-			struct zcbor_string _COSE_X509__certs_certs[3];
-			size_t _COSE_X509__certs_certs_count;
+			struct zcbor_string COSE_X509_certs_l_certs[3];
+			size_t COSE_X509_certs_l_certs_count;
 		};
 	};
 	enum {
-		_COSE_X509_bstr,
-		_COSE_X509__certs,
-	} _COSE_X509_choice;
+		COSE_X509_bstr_c,
+		COSE_X509_certs_l_c,
+	} COSE_X509_choice;
 };
 
 struct id_cred_x_x5chain {
-	struct COSE_X509_ _id_cred_x_x5chain;
+	struct COSE_X509_r id_cred_x_x5chain;
 };
 
 struct COSE_CertHash {
 	union {
-		int32_t _COSE_CertHash_hashAlg_int;
-		struct zcbor_string _COSE_CertHash_hashAlg_tstr;
+		int32_t COSE_CertHash_hashAlg_int;
+		struct zcbor_string COSE_CertHash_hashAlg_tstr;
 	};
 	enum {
-		_COSE_CertHash_hashAlg_int,
-		_COSE_CertHash_hashAlg_tstr,
-	} _COSE_CertHash_hashAlg_choice;
-	struct zcbor_string _COSE_CertHash_hashValue;
+		COSE_CertHash_hashAlg_int_c,
+		COSE_CertHash_hashAlg_tstr_c,
+	} COSE_CertHash_hashAlg_choice;
+	struct zcbor_string COSE_CertHash_hashValue;
 };
 
 struct id_cred_x_x5t {
-	struct COSE_CertHash _id_cred_x_x5t;
+	struct COSE_CertHash id_cred_x_x5t;
 };
 
 struct id_cred_x {
-	struct id_cred_x_kid_ _id_cred_x_kid;
-	bool _id_cred_x_kid_present;
-	struct id_cred_x_x5chain _id_cred_x_x5chain;
-	bool _id_cred_x_x5chain_present;
-	struct id_cred_x_x5t _id_cred_x_x5t;
-	bool _id_cred_x_x5t_present;
+	struct id_cred_x_kid_r id_cred_x_kid;
+	bool id_cred_x_kid_present;
+	struct id_cred_x_x5chain id_cred_x_x5chain;
+	bool id_cred_x_x5chain_present;
+	struct id_cred_x_x5t id_cred_x_x5t;
+	bool id_cred_x_x5t_present;
 };
 
-struct ead_x {
-	int32_t _ead_x_ead_label;
-	struct zcbor_string _ead_x_ead_value;
-	bool _ead_x_ead_value_present;
-};
-
-struct ead_x_ {
-	struct ead_x _ead_x[3];
-	size_t _ead_x_count;
-};
-
-struct plaintext_4_EAD_4 {
-	struct ead_x_ _plaintext_4_EAD_4;
-	bool _plaintext_4_EAD_4_present;
-};
-
-struct map_kid_ {
+struct map_kid_r {
 	union {
-		int32_t _map_kid_int;
-		struct zcbor_string _map_kid_bstr;
+		int32_t map_kid_int;
+		struct zcbor_string map_kid_bstr;
 	};
 	enum {
-		_map_kid_int,
-		_map_kid_bstr,
-	} _map_kid_choice;
+		map_kid_int_c,
+		map_kid_bstr_c,
+	} map_kid_choice;
 };
 
 struct map_x5chain {
-	struct COSE_X509_ _map_x5chain;
+	struct COSE_X509_r map_x5chain;
 };
 
 struct map_x5t {
-	struct COSE_CertHash _map_x5t;
+	struct COSE_CertHash map_x5t;
 };
 
 struct map {
-	struct map_kid_ _map_kid;
-	bool _map_kid_present;
-	struct map_x5chain _map_x5chain;
-	bool _map_x5chain_present;
-	struct map_x5t _map_x5t;
-	bool _map_x5t_present;
+	struct map_kid_r map_kid;
+	bool map_kid_present;
+	struct map_x5chain map_x5chain;
+	bool map_x5chain_present;
+	struct map_x5t map_x5t;
+	bool map_x5t_present;
+};
+
+struct ead_y {
+	int32_t ead_y_ead_label;
+	struct zcbor_string ead_y_ead_value;
+	bool ead_y_ead_value_present;
+};
+
+struct EAD_2 {
+	struct ead_y EAD_2[3];
+	size_t EAD_2_count;
 };
 
 struct plaintext_2 {
 	union {
-		struct zcbor_string _plaintext_2_C_R_bstr;
-		int32_t _plaintext_2_C_R_int;
+		struct zcbor_string plaintext_2_C_R_bstr;
+		int32_t plaintext_2_C_R_int;
 	};
 	enum {
-		_plaintext_2_C_R_bstr,
-		_plaintext_2_C_R_int,
-	} _plaintext_2_C_R_choice;
+		plaintext_2_C_R_bstr_c,
+		plaintext_2_C_R_int_c,
+	} plaintext_2_C_R_choice;
 	union {
-		int32_t _plaintext_2_ID_CRED_R_int;
-		struct zcbor_string _plaintext_2_ID_CRED_R_bstr;
-		struct map _plaintext_2_ID_CRED_R__map;
+		int32_t plaintext_2_ID_CRED_R_int;
+		struct zcbor_string plaintext_2_ID_CRED_R_bstr;
+		struct map plaintext_2_ID_CRED_R_map_m;
 	};
 	enum {
-		_plaintext_2_ID_CRED_R_int,
-		_plaintext_2_ID_CRED_R_bstr,
-		_plaintext_2_ID_CRED_R__map,
-	} _plaintext_2_ID_CRED_R_choice;
-	struct zcbor_string _plaintext_2_Signature_or_MAC_2;
-	struct ead_x_ _plaintext_2_EAD_2;
-	bool _plaintext_2_EAD_2_present;
+		plaintext_2_ID_CRED_R_int_c,
+		plaintext_2_ID_CRED_R_bstr_c,
+		plaintext_2_ID_CRED_R_map_m_c,
+	} plaintext_2_ID_CRED_R_choice;
+	struct zcbor_string plaintext_2_Signature_or_MAC_2;
+	struct EAD_2 plaintext_2_EAD_2_m;
+	bool plaintext_2_EAD_2_m_present;
+};
+
+struct EAD_3 {
+	struct ead_y EAD_3[3];
+	size_t EAD_3_count;
 };
 
 struct plaintext_3 {
 	union {
-		int32_t _plaintext_3_ID_CRED_I_int;
-		struct zcbor_string _plaintext_3_ID_CRED_I_bstr;
-		struct map _plaintext_3_ID_CRED_I__map;
+		int32_t plaintext_3_ID_CRED_I_int;
+		struct zcbor_string plaintext_3_ID_CRED_I_bstr;
+		struct map plaintext_3_ID_CRED_I_map_m;
 	};
 	enum {
-		_plaintext_3_ID_CRED_I_int,
-		_plaintext_3_ID_CRED_I_bstr,
-		_plaintext_3_ID_CRED_I__map,
-	} _plaintext_3_ID_CRED_I_choice;
-	struct zcbor_string _plaintext_3_Signature_or_MAC_3;
-	struct ead_x_ _plaintext_3_EAD_3;
-	bool _plaintext_3_EAD_3_present;
+		plaintext_3_ID_CRED_I_int_c,
+		plaintext_3_ID_CRED_I_bstr_c,
+		plaintext_3_ID_CRED_I_map_m_c,
+	} plaintext_3_ID_CRED_I_choice;
+	struct zcbor_string plaintext_3_Signature_or_MAC_3;
+	struct EAD_3 plaintext_3_EAD_3_m;
+	bool plaintext_3_EAD_3_m_present;
+};
+
+struct EAD_4 {
+	struct ead_y EAD_4[3];
+	size_t EAD_4_count;
+};
+
+struct plaintext_4 {
+	struct EAD_4 plaintext_4;
+	bool plaintext_4_present;
 };
 
 #ifdef __cplusplus

package/external/libedhoc/backends/cbor/src/backend_cbor_bstr_type_decode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,6 +10,7 @@
 #include <string.h>
 #include "zcbor_decode.h"
 #include "backend_cbor_bstr_type_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"
@@ -21,12 +22,16 @@ static bool decode_byte_string_type_bstr_type(zcbor_state_t *state, struct zcbor
 static bool decode_byte_string_type_bstr_type(
 		zcbor_state_t *state, struct zcbor_string *result)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
 	bool tmp_result = (((zcbor_bstr_decode(state, (&(*result))))));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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;
 }
@@ -40,20 +45,6 @@ int cbor_decode_byte_string_type_bstr_type(
 {
 	zcbor_state_t states[2];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
-
-	bool ret = decode_byte_string_type_bstr_type(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_byte_string_type_bstr_type, sizeof(states) / sizeof(zcbor_state_t), 1);
 }

package/external/libedhoc/backends/cbor/src/backend_cbor_bstr_type_encode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,6 +10,7 @@
 #include <string.h>
 #include "zcbor_encode.h"
 #include "backend_cbor_bstr_type_encode.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"
@@ -21,12 +22,16 @@ static bool encode_byte_string_type_bstr_type(zcbor_state_t *state, const struct
 static bool encode_byte_string_type_bstr_type(
 		zcbor_state_t *state, const struct zcbor_string *input)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
 	bool tmp_result = (((zcbor_bstr_encode(state, (&(*input))))));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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;
 }
@@ -40,20 +45,6 @@ int cbor_encode_byte_string_type_bstr_type(
 {
 	zcbor_state_t states[2];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
-
-	bool ret = encode_byte_string_type_bstr_type(states, input);
-
-	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 *)input, payload_len_out, states,
+		(zcbor_decoder_t *)encode_byte_string_type_bstr_type, sizeof(states) / sizeof(zcbor_state_t), 1);
 }

package/external/libedhoc/backends/cbor/src/backend_cbor_ead_decode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,38 +10,47 @@
 #include <string.h>
 #include "zcbor_decode.h"
 #include "backend_cbor_ead_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"
 #endif
 
-static bool decode_repeated_ead(zcbor_state_t *state, struct ead *result);
-static bool decode_ead(zcbor_state_t *state, struct ead_ *result);
+static bool decode_ead_x(zcbor_state_t *state, struct ead_x *result);
+static bool decode_ead(zcbor_state_t *state, struct ead *result);
 
 
-static bool decode_repeated_ead(
-		zcbor_state_t *state, struct ead *result)
+static bool decode_ead_x(
+		zcbor_state_t *state, struct ead_x *result)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
-	bool tmp_result = (((((zcbor_int32_decode(state, (&(*result)._ead_label))))
-	&& zcbor_present_decode(&((*result)._ead_value_present), (zcbor_decoder_t *)zcbor_bstr_decode, state, (&(*result)._ead_value)))));
+	bool tmp_result = (((((zcbor_int32_decode(state, (&(*result).ead_x_ead_label))))
+	&& ((*result).ead_x_ead_value_present = ((zcbor_bstr_decode(state, (&(*result).ead_x_ead_value)))), 1))));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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;
 }
 
 static bool decode_ead(
-		zcbor_state_t *state, struct ead_ *result)
+		zcbor_state_t *state, struct ead *result)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
-	bool tmp_result = (zcbor_multi_decode(1, 3, &(*result)._ead_count, (zcbor_decoder_t *)decode_repeated_ead, state, (&(*result)._ead), sizeof(struct ead)));
+	bool tmp_result = (zcbor_multi_decode(1, 3, &(*result).ead_count, (zcbor_decoder_t *)decode_ead_x, state, (&(*result).ead), sizeof(struct ead_x)));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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,25 +59,11 @@ static bool decode_ead(
 
 int cbor_decode_ead(
 		const uint8_t *payload, size_t payload_len,
-		struct ead_ *result,
+		struct ead *result,
 		size_t *payload_len_out)
 {
 	zcbor_state_t states[2];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 6);
-
-	bool ret = decode_ead(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_ead, sizeof(states) / sizeof(zcbor_state_t), 6);
 }

package/external/libedhoc/backends/cbor/src/backend_cbor_ead_encode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,38 +10,47 @@
 #include <string.h>
 #include "zcbor_encode.h"
 #include "backend_cbor_ead_encode.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"
 #endif
 
-static bool encode_repeated_ead(zcbor_state_t *state, const struct ead *input);
-static bool encode_ead(zcbor_state_t *state, const struct ead_ *input);
+static bool encode_ead_x(zcbor_state_t *state, const struct ead_x *input);
+static bool encode_ead(zcbor_state_t *state, const struct ead *input);
 
 
-static bool encode_repeated_ead(
-		zcbor_state_t *state, const struct ead *input)
+static bool encode_ead_x(
+		zcbor_state_t *state, const struct ead_x *input)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
-	bool tmp_result = (((((zcbor_int32_encode(state, (&(*input)._ead_label))))
-	&& zcbor_present_encode(&((*input)._ead_value_present), (zcbor_encoder_t *)zcbor_bstr_encode, state, (&(*input)._ead_value)))));
+	bool tmp_result = (((((zcbor_int32_encode(state, (&(*input).ead_x_ead_label))))
+	&& (!(*input).ead_x_ead_value_present || zcbor_bstr_encode(state, (&(*input).ead_x_ead_value))))));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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;
 }
 
 static bool encode_ead(
-		zcbor_state_t *state, const struct ead_ *input)
+		zcbor_state_t *state, const struct ead *input)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 
-	bool tmp_result = (zcbor_multi_encode_minmax(1, 3, &(*input)._ead_count, (zcbor_encoder_t *)encode_repeated_ead, state, (&(*input)._ead), sizeof(struct ead)));
+	bool tmp_result = (zcbor_multi_encode_minmax(1, 3, &(*input).ead_count, (zcbor_encoder_t *)encode_ead_x, state, (&(*input).ead), sizeof(struct ead_x)));
 
-	if (!tmp_result)
-		zcbor_trace();
+	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,25 +59,11 @@ static bool encode_ead(
 
 int cbor_encode_ead(
 		uint8_t *payload, size_t payload_len,
-		const struct ead_ *input,
+		const struct ead *input,
 		size_t *payload_len_out)
 {
 	zcbor_state_t states[2];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 6);
-
-	bool ret = encode_ead(states, input);
-
-	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 *)input, payload_len_out, states,
+		(zcbor_decoder_t *)encode_ead, sizeof(states) / sizeof(zcbor_state_t), 6);
 }

package/external/libedhoc/backends/cbor/src/backend_cbor_enc_structure_decode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,6 +10,7 @@
 #include <string.h>
 #include "zcbor_decode.h"
 #include "backend_cbor_enc_structure_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"
@@ -21,15 +22,19 @@ static bool decode_enc_structure(zcbor_state_t *state, struct enc_structure *res
 static bool decode_enc_structure(
 		zcbor_state_t *state, struct enc_structure *result)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 	struct zcbor_string tmp_str;
 
 	bool tmp_result = (((zcbor_list_start_decode(state) && ((((zcbor_tstr_expect(state, ((tmp_str.value = (uint8_t *)"Encrypt0", tmp_str.len = sizeof("Encrypt0") - 1, &tmp_str)))))
-	&& ((zcbor_bstr_decode(state, (&(*result)._enc_structure_protected))))
-	&& ((zcbor_bstr_decode(state, (&(*result)._enc_structure_external_aad))))) || (zcbor_list_map_end_force_decode(state), false)) && zcbor_list_end_decode(state))));
-
-	if (!tmp_result)
-		zcbor_trace();
+	&& ((zcbor_bstr_decode(state, (&(*result).enc_structure_protected))))
+	&& ((zcbor_bstr_decode(state, (&(*result).enc_structure_external_aad))))) || (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;
 }
@@ -43,20 +48,6 @@ int cbor_decode_enc_structure(
 {
 	zcbor_state_t states[3];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
-
-	bool ret = decode_enc_structure(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_enc_structure, sizeof(states) / sizeof(zcbor_state_t), 1);
 }

package/external/libedhoc/backends/cbor/src/backend_cbor_enc_structure_encode.c

@@ -1,5 +1,5 @@
 /*
- * 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
  */
@@ -10,6 +10,7 @@
 #include <string.h>
 #include "zcbor_encode.h"
 #include "backend_cbor_enc_structure_encode.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"
@@ -21,15 +22,19 @@ static bool encode_enc_structure(zcbor_state_t *state, const struct enc_structur
 static bool encode_enc_structure(
 		zcbor_state_t *state, const struct enc_structure *input)
 {
-	zcbor_print("%s\r\n", __func__);
+	zcbor_log("%s\r\n", __func__);
 	struct zcbor_string tmp_str;
 
 	bool tmp_result = (((zcbor_list_start_encode(state, 3) && ((((zcbor_tstr_encode(state, ((tmp_str.value = (uint8_t *)"Encrypt0", tmp_str.len = sizeof("Encrypt0") - 1, &tmp_str)))))
-	&& ((zcbor_bstr_encode(state, (&(*input)._enc_structure_protected))))
-	&& ((zcbor_bstr_encode(state, (&(*input)._enc_structure_external_aad))))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 3))));
-
-	if (!tmp_result)
-		zcbor_trace();
+	&& ((zcbor_bstr_encode(state, (&(*input).enc_structure_protected))))
+	&& ((zcbor_bstr_encode(state, (&(*input).enc_structure_external_aad))))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 3))));
+
+	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;
 }
@@ -43,20 +48,6 @@ int cbor_encode_enc_structure(
 {
 	zcbor_state_t states[3];
 
-	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
-
-	bool ret = encode_enc_structure(states, input);
-
-	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 *)input, payload_len_out, states,
+		(zcbor_decoder_t *)encode_enc_structure, sizeof(states) / sizeof(zcbor_state_t), 1);
 }