edhoc 1.0.1 → 1.0.2

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

@@ -0,0 +1,141 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_encode.h"
+#include "backend_cbor_id_cred_x_encode.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_id_cred_x_kid(zcbor_state_t *state, const struct id_cred_x_kid_ *input);
+static bool encode_COSE_X509(zcbor_state_t *state, const struct COSE_X509_ *input);
+static bool encode_repeated_id_cred_x_x5chain(zcbor_state_t *state, const struct id_cred_x_x5chain *input);
+static bool encode_COSE_CertHash(zcbor_state_t *state, const struct COSE_CertHash *input);
+static bool encode_repeated_id_cred_x_x5t(zcbor_state_t *state, const struct id_cred_x_x5t *input);
+static bool encode_id_cred_x(zcbor_state_t *state, const struct id_cred_x *input);
+
+
+static bool encode_repeated_id_cred_x_kid(
+		zcbor_state_t *state, const struct id_cred_x_kid_ *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = ((((zcbor_uint32_put(state, (4))))
+	&& (((*input)._id_cred_x_kid_choice == _id_cred_x_kid_int) ? ((zcbor_int32_encode(state, (&(*input)._id_cred_x_kid_int))))
+	: (((*input)._id_cred_x_kid_choice == _id_cred_x_kid_bstr) ? ((zcbor_bstr_encode(state, (&(*input)._id_cred_x_kid_bstr))))
+	: false))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_COSE_X509(
+		zcbor_state_t *state, const struct COSE_X509_ *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((((*input)._COSE_X509_choice == _COSE_X509_bstr) ? ((zcbor_bstr_encode(state, (&(*input)._COSE_X509_bstr))))
+	: (((*input)._COSE_X509_choice == _COSE_X509__certs) ? ((zcbor_list_start_encode(state, 3) && ((zcbor_multi_encode_minmax(2, 3, &(*input)._COSE_X509__certs_certs_count, (zcbor_encoder_t *)zcbor_bstr_encode, state, (&(*input)._COSE_X509__certs_certs), sizeof(struct zcbor_string))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 3)))
+	: false))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_repeated_id_cred_x_x5chain(
+		zcbor_state_t *state, const struct id_cred_x_x5chain *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = ((((zcbor_uint32_put(state, (33))))
+	&& (encode_COSE_X509(state, (&(*input)._id_cred_x_x5chain)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_COSE_CertHash(
+		zcbor_state_t *state, const struct COSE_CertHash *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((zcbor_list_start_encode(state, 2) && ((((((*input)._COSE_CertHash_hashAlg_choice == _COSE_CertHash_hashAlg_int) ? ((zcbor_int32_encode(state, (&(*input)._COSE_CertHash_hashAlg_int))))
+	: (((*input)._COSE_CertHash_hashAlg_choice == _COSE_CertHash_hashAlg_tstr) ? ((zcbor_tstr_encode(state, (&(*input)._COSE_CertHash_hashAlg_tstr))))
+	: false)))
+	&& ((zcbor_bstr_encode(state, (&(*input)._COSE_CertHash_hashValue))))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 2))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_repeated_id_cred_x_x5t(
+		zcbor_state_t *state, const struct id_cred_x_x5t *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = ((((zcbor_uint32_put(state, (34))))
+	&& (encode_COSE_CertHash(state, (&(*input)._id_cred_x_x5t)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_id_cred_x(
+		zcbor_state_t *state, const struct id_cred_x *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((zcbor_map_start_encode(state, 3) && ((zcbor_present_encode(&((*input)._id_cred_x_kid_present), (zcbor_encoder_t *)encode_repeated_id_cred_x_kid, state, (&(*input)._id_cred_x_kid))
+	&& zcbor_present_encode(&((*input)._id_cred_x_x5chain_present), (zcbor_encoder_t *)encode_repeated_id_cred_x_x5chain, state, (&(*input)._id_cred_x_x5chain))
+	&& zcbor_present_encode(&((*input)._id_cred_x_x5t_present), (zcbor_encoder_t *)encode_repeated_id_cred_x_x5t, state, (&(*input)._id_cred_x_x5t))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_map_end_encode(state, 3))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_encode_id_cred_x(
+		uint8_t *payload, size_t payload_len,
+		const struct id_cred_x *input,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[5];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
+
+	bool ret = encode_id_cred_x(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;
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_decode.h"
+#include "backend_cbor_info_decode.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_info(zcbor_state_t *state, struct info *result);
+
+
+static bool decode_info(
+		zcbor_state_t *state, struct info *result)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((((zcbor_int32_decode(state, (&(*result)._info_label))))
+	&& ((zcbor_bstr_decode(state, (&(*result)._info_context))))
+	&& ((zcbor_uint32_decode(state, (&(*result)._info_length)))))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_decode_info(
+		const uint8_t *payload, size_t payload_len,
+		struct info *result,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[2];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 3);
+
+	bool ret = decode_info(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;
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_encode.h"
+#include "backend_cbor_info_encode.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_info(zcbor_state_t *state, const struct info *input);
+
+
+static bool encode_info(
+		zcbor_state_t *state, const struct info *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((((zcbor_int32_encode(state, (&(*input)._info_label))))
+	&& ((zcbor_bstr_encode(state, (&(*input)._info_context))))
+	&& ((zcbor_uint32_encode(state, (&(*input)._info_length)))))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_encode_info(
+		uint8_t *payload, size_t payload_len,
+		const struct info *input,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[2];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 3);
+
+	bool ret = encode_info(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;
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_decode.h"
+#include "backend_cbor_int_type_decode.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_integer_type_int_type(zcbor_state_t *state, int32_t *result);
+
+
+static bool decode_integer_type_int_type(
+		zcbor_state_t *state, int32_t *result)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((zcbor_int32_decode(state, (&(*result))))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_decode_integer_type_int_type(
+		const uint8_t *payload, size_t payload_len,
+		int32_t *result,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[2];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
+
+	bool ret = decode_integer_type_int_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;
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_encode.h"
+#include "backend_cbor_int_type_encode.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_integer_type_int_type(zcbor_state_t *state, const int32_t *input);
+
+
+static bool encode_integer_type_int_type(
+		zcbor_state_t *state, const int32_t *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((zcbor_int32_encode(state, (&(*input))))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_encode_integer_type_int_type(
+		uint8_t *payload, size_t payload_len,
+		const int32_t *input,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[2];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
+
+	bool ret = encode_integer_type_int_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;
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_decode.h"
+#include "backend_cbor_message_1_decode.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_suites(zcbor_state_t *state, struct suites_ *result);
+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_message_1(zcbor_state_t *state, struct message_1 *result);
+
+
+static bool decode_suites(
+		zcbor_state_t *state, struct suites_ *result)
+{
+	zcbor_print("%s\r\n", __func__);
+	bool int_res;
+
+	bool tmp_result = (((zcbor_union_start_code(state) && (int_res = ((((zcbor_list_start_decode(state) && ((zcbor_multi_decode(2, 3, &(*result)._suites__int_int_count, (zcbor_decoder_t *)zcbor_int32_decode, state, (&(*result)._suites__int_int), sizeof(int32_t))) || (zcbor_list_map_end_force_decode(state), false)) && zcbor_list_end_decode(state))) && (((*result)._suites_choice = _suites__int), true))
+	|| (zcbor_union_elem_code(state) && (((zcbor_int32_decode(state, (&(*result)._suites_int)))) && (((*result)._suites_choice = _suites_int), true)))), zcbor_union_end_code(state), int_res))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool decode_repeated_ead(
+		zcbor_state_t *state, struct ead *result)
+{
+	zcbor_print("%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)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool decode_ead(
+		zcbor_state_t *state, struct ead_ *result)
+{
+	zcbor_print("%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)));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool decode_message_1(
+		zcbor_state_t *state, struct message_1 *result)
+{
+	zcbor_print("%s\r\n", __func__);
+	bool int_res;
+
+	bool tmp_result = (((((zcbor_int32_decode(state, (&(*result)._message_1_METHOD))))
+	&& ((decode_suites(state, (&(*result)._message_1_SUITES_I))))
+	&& ((zcbor_bstr_decode(state, (&(*result)._message_1_G_X))))
+	&& ((zcbor_union_start_code(state) && (int_res = ((((zcbor_bstr_decode(state, (&(*result)._message_1_C_I_bstr)))) && (((*result)._message_1_C_I_choice = _message_1_C_I_bstr), true))
+	|| (((zcbor_int32_decode(state, (&(*result)._message_1_C_I_int)))
+	&& ((((*result)._message_1_C_I_int >= -24)
+	&& ((*result)._message_1_C_I_int <= 23)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) && (((*result)._message_1_C_I_choice = _message_1_C_I_int), true))), zcbor_union_end_code(state), int_res)))
+	&& zcbor_present_decode(&((*result)._message_1_EAD_1_present), (zcbor_decoder_t *)decode_ead, state, (&(*result)._message_1_EAD_1)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_decode_message_1(
+		const uint8_t *payload, size_t payload_len,
+		struct message_1 *result,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[4];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 10);
+
+	bool ret = decode_message_1(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;
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_encode.h"
+#include "backend_cbor_message_1_encode.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_suites(zcbor_state_t *state, const struct suites_ *input);
+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_message_1(zcbor_state_t *state, const struct message_1 *input);
+
+
+static bool encode_suites(
+		zcbor_state_t *state, const struct suites_ *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((((*input)._suites_choice == _suites__int) ? ((zcbor_list_start_encode(state, 3) && ((zcbor_multi_encode_minmax(2, 3, &(*input)._suites__int_int_count, (zcbor_encoder_t *)zcbor_int32_encode, state, (&(*input)._suites__int_int), sizeof(int32_t))) || (zcbor_list_map_end_force_encode(state), false)) && zcbor_list_end_encode(state, 3)))
+	: (((*input)._suites_choice == _suites_int) ? ((zcbor_int32_encode(state, (&(*input)._suites_int))))
+	: false))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_repeated_ead(
+		zcbor_state_t *state, const struct ead *input)
+{
+	zcbor_print("%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)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_ead(
+		zcbor_state_t *state, const struct ead_ *input)
+{
+	zcbor_print("%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)));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+static bool encode_message_1(
+		zcbor_state_t *state, const struct message_1 *input)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((((zcbor_int32_encode(state, (&(*input)._message_1_METHOD))))
+	&& ((encode_suites(state, (&(*input)._message_1_SUITES_I))))
+	&& ((zcbor_bstr_encode(state, (&(*input)._message_1_G_X))))
+	&& ((((*input)._message_1_C_I_choice == _message_1_C_I_bstr) ? ((zcbor_bstr_encode(state, (&(*input)._message_1_C_I_bstr))))
+	: (((*input)._message_1_C_I_choice == _message_1_C_I_int) ? (((((*input)._message_1_C_I_int >= -24)
+	&& ((*input)._message_1_C_I_int <= 23)) || (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))
+	&& (zcbor_int32_encode(state, (&(*input)._message_1_C_I_int))))
+	: false)))
+	&& zcbor_present_encode(&((*input)._message_1_EAD_1_present), (zcbor_encoder_t *)encode_ead, state, (&(*input)._message_1_EAD_1)))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_encode_message_1(
+		uint8_t *payload, size_t payload_len,
+		const struct message_1 *input,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[4];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 10);
+
+	bool ret = encode_message_1(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;
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Generated using zcbor version 0.7.0
+ * https://github.com/NordicSemiconductor/zcbor
+ * Generated with a --default-max-qty of 3
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_decode.h"
+#include "backend_cbor_message_2_decode.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_message_2_G_Y_CIPHERTEXT_2(zcbor_state_t *state, struct zcbor_string *result);
+
+
+static bool decode_message_2_G_Y_CIPHERTEXT_2(
+		zcbor_state_t *state, struct zcbor_string *result)
+{
+	zcbor_print("%s\r\n", __func__);
+
+	bool tmp_result = (((zcbor_bstr_decode(state, (&(*result))))));
+
+	if (!tmp_result)
+		zcbor_trace();
+
+	return tmp_result;
+}
+
+
+
+int cbor_decode_message_2_G_Y_CIPHERTEXT_2(
+		const uint8_t *payload, size_t payload_len,
+		struct zcbor_string *result,
+		size_t *payload_len_out)
+{
+	zcbor_state_t states[2];
+
+	zcbor_new_state(states, sizeof(states) / sizeof(zcbor_state_t), payload, payload_len, 1);
+
+	bool ret = decode_message_2_G_Y_CIPHERTEXT_2(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;
+}