edhoc 1.0.1 → 1.0.3

package/external/libedhoc/externals/mbedtls/tests/src/threading_helpers.c

@@ -0,0 +1,210 @@
+/** Mutex usage verification framework. */
+
+/*
+ *  Copyright The Mbed TLS Contributors
+ *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+ */
+
+#include <test/helpers.h>
+#include <test/macros.h>
+
+#if defined(MBEDTLS_TEST_MUTEX_USAGE)
+
+#include "mbedtls/threading.h"
+
+/** Mutex usage verification framework.
+ *
+ * The mutex usage verification code below aims to detect bad usage of
+ * Mbed TLS's mutex abstraction layer at runtime. Note that this is solely
+ * about the use of the mutex itself, not about checking whether the mutex
+ * correctly protects whatever it is supposed to protect.
+ *
+ * The normal usage of a mutex is:
+ * ```
+ * digraph mutex_states {
+ *   "UNINITIALIZED"; // the initial state
+ *   "IDLE";
+ *   "FREED";
+ *   "LOCKED";
+ *   "UNINITIALIZED" -> "IDLE" [label="init"];
+ *   "FREED" -> "IDLE" [label="init"];
+ *   "IDLE" -> "LOCKED" [label="lock"];
+ *   "LOCKED" -> "IDLE" [label="unlock"];
+ *   "IDLE" -> "FREED" [label="free"];
+ * }
+ * ```
+ *
+ * All bad transitions that can be unambiguously detected are reported.
+ * An attempt to use an uninitialized mutex cannot be detected in general
+ * since the memory content may happen to denote a valid state. For the same
+ * reason, a double init cannot be detected.
+ * All-bits-zero is the state of a freed mutex, which is distinct from an
+ * initialized mutex, so attempting to use zero-initialized memory as a mutex
+ * without calling the init function is detected.
+ *
+ * The framework attempts to detect missing calls to init and free by counting
+ * calls to init and free. If there are more calls to init than free, this
+ * means that a mutex is not being freed somewhere, which is a memory leak
+ * on platforms where a mutex consumes resources other than the
+ * mbedtls_threading_mutex_t object itself. If there are more calls to free
+ * than init, this indicates a missing init, which is likely to be detected
+ * by an attempt to lock the mutex as well. A limitation of this framework is
+ * that it cannot detect scenarios where there is exactly the same number of
+ * calls to init and free but the calls don't match. A bug like this is
+ * unlikely to happen uniformly throughout the whole test suite though.
+ *
+ * If an error is detected, this framework will report what happened and the
+ * test case will be marked as failed. Unfortunately, the error report cannot
+ * indicate the exact location of the problematic call. To locate the error,
+ * use a debugger and set a breakpoint on mbedtls_test_mutex_usage_error().
+ */
+enum value_of_mutex_is_valid_field {
+    /* Potential values for the is_valid field of mbedtls_threading_mutex_t.
+     * Note that MUTEX_FREED must be 0 and MUTEX_IDLE must be 1 for
+     * compatibility with threading_mutex_init_pthread() and
+     * threading_mutex_free_pthread(). MUTEX_LOCKED could be any nonzero
+     * value. */
+    MUTEX_FREED = 0, //!< Set by threading_mutex_free_pthread
+    MUTEX_IDLE = 1, //!< Set by threading_mutex_init_pthread and by our unlock
+    MUTEX_LOCKED = 2, //!< Set by our lock
+};
+
+typedef struct {
+    void (*init)(mbedtls_threading_mutex_t *);
+    void (*free)(mbedtls_threading_mutex_t *);
+    int (*lock)(mbedtls_threading_mutex_t *);
+    int (*unlock)(mbedtls_threading_mutex_t *);
+} mutex_functions_t;
+static mutex_functions_t mutex_functions;
+
+/** The total number of calls to mbedtls_mutex_init(), minus the total number
+ * of calls to mbedtls_mutex_free().
+ *
+ * Reset to 0 after each test case.
+ */
+static int live_mutexes;
+
+static void mbedtls_test_mutex_usage_error(mbedtls_threading_mutex_t *mutex,
+                                           const char *msg)
+{
+    (void) mutex;
+    if (mbedtls_test_info.mutex_usage_error == NULL) {
+        mbedtls_test_info.mutex_usage_error = msg;
+    }
+    mbedtls_fprintf(stdout, "[mutex: %s] ", msg);
+    /* Don't mark the test as failed yet. This way, if the test fails later
+     * for a functional reason, the test framework will report the message
+     * and location for this functional reason. If the test passes,
+     * mbedtls_test_mutex_usage_check() will mark it as failed. */
+}
+
+static void mbedtls_test_wrap_mutex_init(mbedtls_threading_mutex_t *mutex)
+{
+    mutex_functions.init(mutex);
+    if (mutex->is_valid) {
+        ++live_mutexes;
+    }
+}
+
+static void mbedtls_test_wrap_mutex_free(mbedtls_threading_mutex_t *mutex)
+{
+    switch (mutex->is_valid) {
+        case MUTEX_FREED:
+            mbedtls_test_mutex_usage_error(mutex, "free without init or double free");
+            break;
+        case MUTEX_IDLE:
+            /* Do nothing. The underlying free function will reset is_valid
+             * to 0. */
+            break;
+        case MUTEX_LOCKED:
+            mbedtls_test_mutex_usage_error(mutex, "free without unlock");
+            break;
+        default:
+            mbedtls_test_mutex_usage_error(mutex, "corrupted state");
+            break;
+    }
+    if (mutex->is_valid) {
+        --live_mutexes;
+    }
+    mutex_functions.free(mutex);
+}
+
+static int mbedtls_test_wrap_mutex_lock(mbedtls_threading_mutex_t *mutex)
+{
+    int ret = mutex_functions.lock(mutex);
+    switch (mutex->is_valid) {
+        case MUTEX_FREED:
+            mbedtls_test_mutex_usage_error(mutex, "lock without init");
+            break;
+        case MUTEX_IDLE:
+            if (ret == 0) {
+                mutex->is_valid = 2;
+            }
+            break;
+        case MUTEX_LOCKED:
+            mbedtls_test_mutex_usage_error(mutex, "double lock");
+            break;
+        default:
+            mbedtls_test_mutex_usage_error(mutex, "corrupted state");
+            break;
+    }
+    return ret;
+}
+
+static int mbedtls_test_wrap_mutex_unlock(mbedtls_threading_mutex_t *mutex)
+{
+    int ret = mutex_functions.unlock(mutex);
+    switch (mutex->is_valid) {
+        case MUTEX_FREED:
+            mbedtls_test_mutex_usage_error(mutex, "unlock without init");
+            break;
+        case MUTEX_IDLE:
+            mbedtls_test_mutex_usage_error(mutex, "unlock without lock");
+            break;
+        case MUTEX_LOCKED:
+            if (ret == 0) {
+                mutex->is_valid = MUTEX_IDLE;
+            }
+            break;
+        default:
+            mbedtls_test_mutex_usage_error(mutex, "corrupted state");
+            break;
+    }
+    return ret;
+}
+
+void mbedtls_test_mutex_usage_init(void)
+{
+    mutex_functions.init = mbedtls_mutex_init;
+    mutex_functions.free = mbedtls_mutex_free;
+    mutex_functions.lock = mbedtls_mutex_lock;
+    mutex_functions.unlock = mbedtls_mutex_unlock;
+    mbedtls_mutex_init = &mbedtls_test_wrap_mutex_init;
+    mbedtls_mutex_free = &mbedtls_test_wrap_mutex_free;
+    mbedtls_mutex_lock = &mbedtls_test_wrap_mutex_lock;
+    mbedtls_mutex_unlock = &mbedtls_test_wrap_mutex_unlock;
+}
+
+void mbedtls_test_mutex_usage_check(void)
+{
+    if (live_mutexes != 0) {
+        /* A positive number (more init than free) means that a mutex resource
+         * is leaking (on platforms where a mutex consumes more than the
+         * mbedtls_threading_mutex_t object itself). The rare case of a
+         * negative number means a missing init somewhere. */
+        mbedtls_fprintf(stdout, "[mutex: %d leaked] ", live_mutexes);
+        live_mutexes = 0;
+        if (mbedtls_test_info.mutex_usage_error == NULL) {
+            mbedtls_test_info.mutex_usage_error = "missing free";
+        }
+    }
+    if (mbedtls_test_info.mutex_usage_error != NULL &&
+        mbedtls_test_info.result != MBEDTLS_TEST_RESULT_FAILED) {
+        /* Functionally, the test passed. But there was a mutex usage error,
+         * so mark the test as failed after all. */
+        mbedtls_test_fail("Mutex usage error", __LINE__, __FILE__);
+    }
+    mbedtls_test_info.mutex_usage_error = NULL;
+}
+
+#endif /* MBEDTLS_TEST_MUTEX_USAGE */

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

@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZCBOR_COMMON_H__
+#define ZCBOR_COMMON_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include "zcbor_tags.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Convenience type that allows pointing to strings directly inside the payload
+ *  without the need to copy out.
+ */
+struct zcbor_string {
+	const uint8_t *value;
+	size_t len;
+};
+
+
+/** Type representing a string fragment.
+ *
+ * Don't modify any member variables, or subsequent calls may fail.
+**/
+struct zcbor_string_fragment {
+	struct zcbor_string fragment; ///! Location and length of the fragment.
+	size_t offset;                ///! The offset in the full string at which this fragment belongs.
+	size_t total_len;             ///! The total length of the string this fragment is a part of.
+};
+
+
+/** Size to use in struct zcbor_string_fragment when the real size is unknown. */
+#define ZCBOR_STRING_FRAGMENT_UNKNOWN_LENGTH SIZE_MAX
+
+#ifdef ZCBOR_VERBOSE
+#include <zephyr/sys/printk.h>
+#define zcbor_trace() (printk("bytes left: %zu, byte: 0x%x, elem_count: 0x%" PRIxFAST32 ", err: %d, %s:%d\n",\
+	(size_t)state->payload_end - (size_t)state->payload, *state->payload, state->elem_count, \
+	state->constant_state ? state->constant_state->error : 0, __FILE__, __LINE__))
+
+#define zcbor_print_assert(expr, ...) \
+do { \
+	printk("ASSERTION \n  \"" #expr \
+		"\"\nfailed at %s:%d with message:\n  ", \
+		__FILE__, __LINE__); \
+	printk(__VA_ARGS__);\
+} while(0)
+#define zcbor_print(...) printk(__VA_ARGS__)
+#else
+#define zcbor_trace() ((void)state)
+#define zcbor_print_assert(...)
+#define zcbor_print(...)
+#endif
+
+#ifdef ZCBOR_ASSERTS
+#define zcbor_assert(expr, ...) \
+do { \
+	if (!(expr)) { \
+		zcbor_print_assert(expr, __VA_ARGS__); \
+		ZCBOR_FAIL(); \
+	} \
+} while(0)
+#define zcbor_assert_state(expr, ...) \
+do { \
+	if (!(expr)) { \
+		zcbor_print_assert(expr, __VA_ARGS__); \
+		ZCBOR_ERR(ZCBOR_ERR_ASSERTION); \
+	} \
+} while(0)
+#else
+#define zcbor_assert(expr, ...)
+#define zcbor_assert_state(expr, ...)
+#endif
+
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef ZCBOR_ARRAY_SIZE
+#define ZCBOR_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+
+#if SIZE_MAX <= UINT64_MAX
+/** The ZCBOR_SUPPORTS_SIZE_T will be defined if processing of size_t type variables directly
+ * with zcbor_size_ functions is supported.
+**/
+#define ZCBOR_SUPPORTS_SIZE_T
+#else
+#warning "zcbor: Unsupported size_t encoding size"
+#endif
+
+struct zcbor_state_constant;
+
+typedef struct {
+union {
+	uint8_t *payload_mut;
+	uint8_t const *payload; /**< The current place in the payload. Will be
+	                             updated when an element is correctly
+	                             processed. */
+};
+	uint8_t const *payload_bak; /**< Temporary backup of payload. */
+	size_t elem_count; /**< The current element is part of a LIST or a MAP,
+	                        and this keeps count of how many elements are
+	                        expected. This will be checked before processing
+	                        and decremented if the element is correctly
+	                        processed. */
+	uint8_t const *payload_end; /**< The end of the payload. This will be
+	                                 checked against payload before
+	                                 processing each element. */
+	bool indefinite_length_array; /**< Is set to true if the decoder is currently
+	                                   decoding the contents of an indefinite-
+	                                   length array. */
+	bool payload_moved; /**< Is set to true while the state is stored as a backup
+	                         if @ref zcbor_update_state is called, since that function
+	                         updates the payload_end of all backed-up states. */
+	struct zcbor_state_constant *constant_state; /**< The part of the state that is
+	                                                  not backed up and duplicated. */
+} zcbor_state_t;
+
+struct zcbor_state_constant {
+	zcbor_state_t *backup_list;
+	size_t current_backup;
+	size_t num_backups;
+	int error;
+#ifdef ZCBOR_STOP_ON_ERROR
+	bool stop_on_error;
+#endif
+};
+
+/** Function pointer type used with zcbor_multi_decode.
+ *
+ * This type is compatible with all decoding functions here and in the generated
+ * code, except for zcbor_multi_decode.
+ */
+typedef bool(zcbor_encoder_t)(zcbor_state_t *, const void *);
+typedef bool(zcbor_decoder_t)(zcbor_state_t *, void *);
+
+/** Enumeration representing the major types available in CBOR.
+ *
+ * The major type is represented in the 3 first bits of the header byte.
+ */
+typedef enum
+{
+	ZCBOR_MAJOR_TYPE_PINT   = 0, ///! Positive Integer
+	ZCBOR_MAJOR_TYPE_NINT   = 1, ///! Negative Integer
+	ZCBOR_MAJOR_TYPE_BSTR   = 2, ///! Byte String
+	ZCBOR_MAJOR_TYPE_TSTR   = 3, ///! Text String
+	ZCBOR_MAJOR_TYPE_LIST   = 4, ///! List
+	ZCBOR_MAJOR_TYPE_MAP    = 5, ///! Map
+	ZCBOR_MAJOR_TYPE_TAG    = 6, ///! Semantic Tag
+	ZCBOR_MAJOR_TYPE_SIMPLE = 7, ///! Simple values and floats
+} zcbor_major_type_t;
+
+
+/** Convenience macro for failing out of a decoding/encoding function.
+*/
+#define ZCBOR_FAIL() \
+do {\
+	zcbor_trace(); \
+	return false; \
+} while(0)
+
+#define ZCBOR_FAIL_IF(expr) \
+do {\
+	if (expr) { \
+		ZCBOR_FAIL(); \
+	} \
+} while(0)
+
+#define ZCBOR_ERR(err) \
+do { \
+	zcbor_error(state, err); \
+	ZCBOR_FAIL(); \
+} while(0)
+
+#define ZCBOR_ERR_IF(expr, err) \
+do {\
+	if (expr) { \
+		ZCBOR_ERR(err); \
+	} \
+} while(0)
+
+#define ZCBOR_CHECK_PAYLOAD() \
+	ZCBOR_ERR_IF(state->payload >= state->payload_end, ZCBOR_ERR_NO_PAYLOAD)
+
+#ifdef ZCBOR_STOP_ON_ERROR
+#define ZCBOR_CHECK_ERROR()  \
+do { \
+	if (!zcbor_check_error(state)) { \
+		ZCBOR_FAIL(); \
+	} \
+} while(0)
+#else
+#define ZCBOR_CHECK_ERROR()
+#endif
+
+#define ZCBOR_VALUE_IN_HEADER 23 ///! Values below this are encoded directly in the header.
+#define ZCBOR_VALUE_IS_1_BYTE 24 ///! The next 1 byte contains the value.
+#define ZCBOR_VALUE_IS_2_BYTES 25 ///! The next 2 bytes contain the value.
+#define ZCBOR_VALUE_IS_4_BYTES 26 ///! The next 4 bytes contain the value.
+#define ZCBOR_VALUE_IS_8_BYTES 27 ///! The next 8 bytes contain the value.
+#define ZCBOR_VALUE_IS_INDEFINITE_LENGTH 31 ///! The list or map has indefinite length, and will instead be terminated by a 0xFF token.
+
+#define ZCBOR_BOOL_TO_SIMPLE ((uint8_t)20) ///! In CBOR, false/true have the values 20/21
+
+#define ZCBOR_FLAG_RESTORE 1UL ///! Restore from the backup. Overwrite the current state with the state from the backup.
+#define ZCBOR_FLAG_CONSUME 2UL ///! Consume the backup. Remove the backup from the stack of backups.
+#define ZCBOR_FLAG_TRANSFER_PAYLOAD 4UL ///! Keep the pre-restore payload after restoring.
+
+#define ZCBOR_SUCCESS 0
+#define ZCBOR_ERR_NO_BACKUP_MEM 1
+#define ZCBOR_ERR_NO_BACKUP_ACTIVE 2
+#define ZCBOR_ERR_LOW_ELEM_COUNT 3
+#define ZCBOR_ERR_HIGH_ELEM_COUNT 4
+#define ZCBOR_ERR_INT_SIZE 5
+#define ZCBOR_ERR_FLOAT_SIZE 6
+#define ZCBOR_ERR_ADDITIONAL_INVAL 7 ///! > 27
+#define ZCBOR_ERR_NO_PAYLOAD 8
+#define ZCBOR_ERR_PAYLOAD_NOT_CONSUMED 9
+#define ZCBOR_ERR_WRONG_TYPE 10
+#define ZCBOR_ERR_WRONG_VALUE 11
+#define ZCBOR_ERR_WRONG_RANGE 12
+#define ZCBOR_ERR_ITERATIONS 13
+#define ZCBOR_ERR_ASSERTION 14
+#define ZCBOR_ERR_UNKNOWN 31
+
+/** The largest possible elem_count. */
+#ifdef UINT_FAST32_MAX
+#define ZCBOR_MAX_ELEM_COUNT UINT_FAST32_MAX
+#else
+#define ZCBOR_MAX_ELEM_COUNT ((size_t)(-1L))
+#endif
+
+/** Initial value for elem_count for when it just needs to be large. */
+#define ZCBOR_LARGE_ELEM_COUNT (ZCBOR_MAX_ELEM_COUNT - 16)
+
+
+/** Take a backup of the current state. Overwrite the current elem_count. */
+bool zcbor_new_backup(zcbor_state_t *state, size_t new_elem_count);
+
+/** Consult the most recent backup. In doing so, check whether elem_count is
+ *  less than or equal to max_elem_count.
+ *  Also, take action based on the flags (See ZCBOR_FLAG_*).
+ */
+bool zcbor_process_backup(zcbor_state_t *state, uint32_t flags, size_t max_elem_count);
+
+/** Convenience function for starting encoding/decoding of a union.
+ *
+ *  That is, for attempting to encode, or especially decode, multiple options.
+ *  Makes a new backup.
+ */
+bool zcbor_union_start_code(zcbor_state_t *state);
+
+/** Convenience function before encoding/decoding one element of a union.
+ *
+ *  Call this before attempting each option.
+ *  Restores the backup, without consuming it.
+ */
+bool zcbor_union_elem_code(zcbor_state_t *state);
+
+/** Convenience function before encoding/decoding one element of a union.
+ *
+ *  Consumes the backup without restoring it.
+ */
+bool zcbor_union_end_code(zcbor_state_t *state);
+
+/** Initialize a state with backups.
+ *  As long as n_states is more than 1, one of the states in the array is used
+ *  as a struct zcbor_state_constant object.
+ *  If there is no struct zcbor_state_constant (n_states == 1), error codes are
+ *  not available.
+ *  This means that you get a state with (n_states - 2) backups.
+ *  payload, payload_len, and elem_count are used to initialize the first state.
+ *  in the array, which is the state that can be passed to cbor functions.
+ */
+void zcbor_new_state(zcbor_state_t *state_array, size_t n_states,
+		const uint8_t *payload, size_t payload_len, size_t elem_count);
+
+#ifdef ZCBOR_STOP_ON_ERROR
+/** Check stored error and fail if present, but only if stop_on_error is true. */
+static inline bool zcbor_check_error(const zcbor_state_t *state)
+{
+	struct zcbor_state_constant  *cs = state->constant_state;
+	return !(cs && cs->stop_on_error && cs->error);
+}
+#endif
+
+/** Return the current error state, replacing it with SUCCESS. */
+static inline int zcbor_pop_error(zcbor_state_t *state)
+{
+	if (!state->constant_state) {
+		return ZCBOR_SUCCESS;
+	}
+	int err = state->constant_state->error;
+
+	state->constant_state->error = ZCBOR_SUCCESS;
+	return err;
+}
+
+/** Look at current error state without altering it */
+static inline int zcbor_peek_error(const zcbor_state_t *state)
+{
+	if (!state->constant_state) {
+		return ZCBOR_SUCCESS;
+	} else {
+		return state->constant_state->error;
+	}
+}
+
+/** Write the provided error to the error state. */
+static inline void zcbor_error(zcbor_state_t *state, int err)
+{
+#ifdef ZCBOR_STOP_ON_ERROR
+	if (zcbor_check_error(state))
+#endif
+	{
+		if (state->constant_state) {
+			state->constant_state->error = err;
+		}
+	}
+}
+
+/** Whether the current payload is exhausted. */
+static inline bool zcbor_payload_at_end(const zcbor_state_t *state)
+{
+	return (state->payload == state->payload_end);
+}
+
+/** Update the current payload pointer (and payload_end).
+ *
+ *  For use when the payload is divided into multiple chunks.
+ *
+ *  This function also updates all backups to the new payload_end.
+ *  This sets a flag so that @ref zcbor_process_backup fails if a backup is
+ *  processed with the flag @ref ZCBOR_FLAG_RESTORE, but without the flag
+ *  @ref ZCBOR_FLAG_TRANSFER_PAYLOAD since this would cause an invalid state.
+ *
+ *  @param[inout]  state              The current state, will be updated with
+ *                                    the new payload pointer.
+ *  @param[in]     payload            The new payload chunk.
+ *  @param[in]     payload_len        The length of the new payload chunk.
+ */
+void zcbor_update_state(zcbor_state_t *state,
+		const uint8_t *payload, size_t payload_len);
+
+/** Check that the provided fragments are complete and in the right order.
+ *
+ *  If the total length is not known, the total_len can have the value
+ *  @ref ZCBOR_STRING_FRAGMENT_UNKNOWN_LENGTH. If so, all fragments will be
+ *  updated with the actual total length.
+ *
+ *  @param[in]  fragments      An array of string fragments. Cannot be NULL.
+ *  @param[in]  num_fragments  The number of fragments in @p fragments.
+ *
+ *  @retval  true   If the fragments are in the right order, and there are no
+ *                  fragments missing.
+ *  @retval  false  If not all fragments have the same total_len, or gaps are
+ *                  found, or if any fragment value is NULL.
+ */
+bool zcbor_validate_string_fragments(struct zcbor_string_fragment *fragments,
+		size_t num_fragments);
+
+/** Assemble the fragments into a single string.
+ *
+ *  The fragments are copied in the order they appear, without regard for
+ *  offset or total_len. To ensure that the fragments are correct, first
+ *  validate with @ref zcbor_validate_string_fragments.
+ *
+ *  @param[in]     fragments      An array of string fragments. Cannot be NULL.
+ *  @param[in]     num_fragments  The number of fragments in @p fragments.
+ *  @param[out]    result         The buffer to place the assembled string into.
+ *  @param[inout]  result_len     In: The length of the @p result.
+ *                                Out: The length of the assembled string.
+ *
+ *  @retval  true   On success.
+ *  @retval  false  If the assembled string would be larger than the buffer.
+ *                  The buffer might still be written to.
+ */
+bool zcbor_splice_string_fragments(struct zcbor_string_fragment *fragments,
+		size_t num_fragments, uint8_t *result, size_t *result_len);
+
+/** Compare two struct zcbor_string instances.
+ *
+ *  @param[in] str1  A string
+ *  @param[in] str2  A string to compare to @p str1
+ *
+ *  @retval true   if the strings are identical
+ *  @retval false  if length or contents don't match, or one one or both strings is NULL.
+ */
+bool zcbor_compare_strings(const struct zcbor_string *str1,
+		const struct zcbor_string *str2);
+
+/** Calculate the length of a CBOR string, list, or map header.
+ *
+ *  This can be used to find the start of the CBOR object when you have a
+ *  pointer to the start of the contents. The function assumes that the header
+ *  will be the shortest it can be.
+ *
+ *  @param[in] num_elems  The number of elements in the string, list, or map.
+ *
+ *  @return  The length of the header in bytes (1-9).
+ */
+size_t zcbor_header_len(size_t num_elems);
+
+/** Find whether the state is at the end of a list or map.
+ */
+bool zcbor_array_at_end(zcbor_state_t *state);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZCBOR_COMMON_H__ */

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZCBOR_DEBUG_H__
+#define ZCBOR_DEBUG_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include "zcbor_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__attribute__((used))
+static void zcbor_print_compare_lines(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+{
+	for (uint32_t j = 0; j < size; j++) {
+		printk ("%x ", str1[j]);
+	}
+	printk("\r\n");
+	for (uint32_t j = 0; j < size; j++) {
+		printk ("%x ", str2[j]);
+	}
+	printk("\r\n");
+	for (uint32_t j = 0; j < size; j++) {
+		printk ("%x ", str1[j] != str2[j]);
+	}
+	printk("\r\n");
+	printk("\r\n");
+}
+
+__attribute__((used))
+static void zcbor_print_compare_strings(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+{
+	for (uint32_t i = 0; i <= size / 16; i++) {
+		printk("line %d (char %d)\r\n", i, i*16);
+		zcbor_print_compare_lines(&str1[i*16], &str2[i*16],
+			MIN(16, (size - i*16)));
+	}
+	printk("\r\n");
+}
+
+__attribute__((used))
+static void zcbor_print_compare_strings_diff(const uint8_t *str1, const uint8_t *str2, uint32_t size)
+{
+	bool printed = false;
+	for (uint32_t i = 0; i <= size / 16; i++) {
+		if (memcmp(&str1[i*16], &str2[i*16], MIN(16, (size - i*16)) != 0)) {
+			printk("line %d (char %d)\r\n", i, i*16);
+			zcbor_print_compare_lines(&str1[i*16], &str2[i*16],
+				MIN(16, (size - i*16)));
+			printed = true;
+		}
+	}
+	if (printed) {
+		printk("\r\n");
+	}
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZCBOR_DEBUG_H__ */