edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/mbedtls/library/mps_reader.h

@@ -1,366 +0,0 @@
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-/**
- * \file mps_reader.h
- *
- * \brief This file defines reader objects, which together with their
- *        sibling writer objects form the basis for the communication
- *        between the various layers of the Mbed TLS messaging stack,
- *        as well as the communication between the messaging stack and
- *        the (D)TLS handshake protocol implementation.
- *
- * Readers provide a means of transferring incoming data from
- * a 'producer' providing it in chunks of arbitrary size, to
- * a 'consumer' which fetches and processes it in chunks of
- * again arbitrary, and potentially different, size.
- *
- * Readers can thus be seen as datagram-to-stream converters,
- * and they abstract away the following two tasks from the user:
- * 1. The pointer arithmetic of stepping through a producer-
- *    provided chunk in smaller chunks.
- * 2. The merging of incoming data chunks in case the
- *    consumer requests data in larger chunks than what the
- *    producer provides.
- *
- * The basic abstract flow of operation is the following:
- * - Initially, the reader is in 'producing mode'.
- * - The producer hands an incoming data buffer to the reader,
- *   moving it from 'producing' to 'consuming' mode.
- * - The consumer subsequently fetches and processes the buffer
- *   content. Once that's done -- or partially done and a consumer's
- *   request can't be fulfilled -- the producer revokes the reader's
- *   access to the incoming data buffer, putting the reader back to
- *   producing mode.
- * - The producer subsequently gathers more incoming data and hands
- *   it to the reader until it switches back to consuming mode
- *   if enough data is available for the last consumer request to
- *   be satisfiable.
- * - Repeat the above.
- *
- * The abstract states of the reader from the producer's and
- * consumer's perspective are as follows:
- *
- * - From the perspective of the consumer, the state of the
- *   reader consists of the following:
- *   - A byte stream representing (concatenation of) the data
- *     received through calls to mbedtls_mps_reader_get(),
- *   - A marker within that byte stream indicating which data
- *     can be considered processed, and hence need not be retained,
- *     when the reader is passed back to the producer via
- *     mbedtls_mps_reader_reclaim().
- *     The marker is set via mbedtls_mps_reader_commit()
- *     which places it at the end of the current byte stream.
- *   The consumer need not be aware of the distinction between consumer
- *   and producer mode, because it only interfaces with the reader
- *   when the latter is in consuming mode.
- *
- * - From the perspective of the producer, the reader's state is one of:
- *   - Attached: The reader is in consuming mode.
- *   - Unset: No incoming data buffer is currently managed by the reader,
- *            and all previously handed incoming data buffers have been
- *            fully processed. More data needs to be fed into the reader
- *            via mbedtls_mps_reader_feed().
- *
- *   - Accumulating: No incoming data buffer is currently managed by the
- *                   reader, but some data from the previous incoming data
- *                   buffer hasn't been processed yet and is internally
- *                   held back.
- *   The Attached state belongs to consuming mode, while the Unset and
- *   Accumulating states belong to producing mode.
- *
- * Transitioning from the Unset or Accumulating state to Attached is
- * done via successful calls to mbedtls_mps_reader_feed(), while
- * transitioning from Attached to either Unset or Accumulating (depending
- * on what has been processed) is done via mbedtls_mps_reader_reclaim().
- *
- * The following diagram depicts the producer-state progression:
- *
- *        +------------------+             reclaim
- *        |      Unset       +<-------------------------------------+       get
- *        +--------|---------+                                      |   +------+
- *                 |                                                |   |      |
- *                 |                                                |   |      |
- *                 |                feed                  +---------+---+--+   |
- *                 +-------------------------------------->                <---+
- *                                                        |    Attached    |
- *                 +-------------------------------------->                <---+
- *                 |     feed, enough data available      +---------+---+--+   |
- *                 |     to serve previous consumer request         |   |      |
- *                 |                                                |   |      |
- *        +--------+---------+                                      |   +------+
- *   +---->   Accumulating   |<-------------------------------------+    commit
- *   |    +---+--------------+      reclaim, previous read request
- *   |        |                        couldn't be fulfilled
- *   |        |
- *   +--------+
- *     feed, need more data to serve
- *     previous consumer request
- *                                         |
- *                                         |
- *               producing mode            |           consuming mode
- *                                         |
- *
- */
-
-#ifndef MBEDTLS_READER_H
-#define MBEDTLS_READER_H
-
-#include <stdio.h>
-
-#include "mps_common.h"
-#include "mps_error.h"
-
-struct mbedtls_mps_reader;
-typedef struct mbedtls_mps_reader mbedtls_mps_reader;
-
-/*
- * Structure definitions
- */
-
-struct mbedtls_mps_reader {
-    unsigned char *frag;  /*!< The fragment of incoming data managed by
-                           *   the reader; it is provided to the reader
-                           *   through mbedtls_mps_reader_feed(). The reader
-                           *   does not own the fragment and does not
-                           *   perform any allocation operations on it,
-                           *   but does have read and write access to it.
-                           *
-                           *   The reader is in consuming mode if
-                           *   and only if \c frag is not \c NULL.          */
-    mbedtls_mps_stored_size_t frag_len;
-    /*!< The length of the current fragment.
-     *   Must be 0 if \c frag == \c NULL.             */
-    mbedtls_mps_stored_size_t commit;
-    /*!< The offset of the last commit, relative
-     *   to the first byte in the fragment, if
-     *   no accumulator is present. If an accumulator
-     *   is present, it is viewed as a prefix to the
-     *   current fragment, and this variable contains
-     *   an offset from the beginning of the accumulator.
-     *
-     *   This is only used when the reader is in
-     *   consuming mode, i.e. \c frag != \c NULL;
-     *   otherwise, its value is \c 0.                */
-    mbedtls_mps_stored_size_t end;
-    /*!< The offset of the end of the last chunk
-     *   passed to the user through a call to
-     *   mbedtls_mps_reader_get(), relative to the first
-     *   byte in the fragment, if no accumulator is
-     *   present. If an accumulator is present, it is
-     *   viewed as a prefix to the current fragment, and
-     *   this variable contains an offset from the
-     *   beginning of the accumulator.
-     *
-     *   This is only used when the reader is in
-     *   consuming mode, i.e. \c frag != \c NULL;
-     *   otherwise, its value is \c 0.                */
-    mbedtls_mps_stored_size_t pending;
-    /*!< The amount of incoming data missing on the
-     *   last call to mbedtls_mps_reader_get().
-     *   In particular, it is \c 0 if the last call
-     *   was successful.
-     *   If a reader is reclaimed after an
-     *   unsuccessful call to mbedtls_mps_reader_get(),
-     *   this variable is used to have the reader
-     *   remember how much data should be accumulated
-     *   so that the call to mbedtls_mps_reader_get()
-     *   succeeds next time.
-     *   This is only used when the reader is in
-     *   consuming mode, i.e. \c frag != \c NULL;
-     *   otherwise, its value is \c 0.                */
-
-    /* The accumulator is only needed if we need to be able to pause
-     * the reader. A few bytes could be saved by moving this to a
-     * separate struct and using a pointer here. */
-
-    unsigned char *acc;   /*!< The accumulator is used to gather incoming
-                           *   data if a read-request via mbedtls_mps_reader_get()
-                           *   cannot be served from the current fragment.   */
-    mbedtls_mps_stored_size_t acc_len;
-    /*!< The total size of the accumulator.           */
-    mbedtls_mps_stored_size_t acc_available;
-    /*!< The number of bytes currently gathered in
-     *   the accumulator. This is both used in
-     *   producing and in consuming mode:
-     *   While producing, it is increased until
-     *   it reaches the value of \c acc_remaining below.
-     *   While consuming, it is used to judge if a
-     *   get request can be served from the
-     *   accumulator or not.
-     *   Must not be larger than \c acc_len.           */
-    union {
-        mbedtls_mps_stored_size_t acc_remaining;
-        /*!< This indicates the amount of data still
-         *   to be gathered in the accumulator. It is
-         *   only used in producing mode.
-         *   Must be at most acc_len - acc_available.  */
-        mbedtls_mps_stored_size_t frag_offset;
-        /*!< If an accumulator is present and in use, this
-         *   field indicates the offset of the current
-         *   fragment from the beginning of the
-         *   accumulator. If no accumulator is present
-         *   or the accumulator is not in use, this is \c 0.
-         *   It is only used in consuming mode.
-         *   Must not be larger than \c acc_available. */
-    } acc_share;
-};
-
-/*
- * API organization:
- * A reader object is usually prepared and maintained
- * by some lower layer and passed for usage to an upper
- * layer, and the API naturally splits according to which
- * layer is supposed to use the respective functions.
- */
-
-/*
- * Maintenance API (Lower layer)
- */
-
-/**
- * \brief           Initialize a reader object
- *
- * \param reader    The reader to be initialized.
- * \param acc       The buffer to be used as a temporary accumulator
- *                  in case get requests through mbedtls_mps_reader_get()
- *                  exceed the buffer provided by mbedtls_mps_reader_feed().
- *                  This buffer is owned by the caller and exclusive use
- *                  for reading and writing is given to the reader for the
- *                  duration of the reader's lifetime. It is thus the caller's
- *                  responsibility to maintain (and not touch) the buffer for
- *                  the lifetime of the reader, and to properly zeroize and
- *                  free the memory after the reader has been destroyed.
- * \param acc_len   The size in Bytes of \p acc.
- *
- * \return          \c 0 on success.
- * \return          A negative \c MBEDTLS_ERR_READER_XXX error code on failure.
- */
-int mbedtls_mps_reader_init(mbedtls_mps_reader *reader,
-                            unsigned char *acc,
-                            mbedtls_mps_size_t acc_len);
-
-/**
- * \brief           Free a reader object
- *
- * \param reader    The reader to be freed.
- *
- * \return          \c 0 on success.
- * \return          A negative \c MBEDTLS_ERR_READER_XXX error code on failure.
- */
-int mbedtls_mps_reader_free(mbedtls_mps_reader *reader);
-
-/**
- * \brief           Pass chunk of data for the reader to manage.
- *
- * \param reader    The reader context to use. The reader must be
- *                  in producing mode.
- * \param buf       The buffer to be managed by the reader.
- * \param buflen    The size in Bytes of \p buffer.
- *
- * \return          \c 0 on success. In this case, the reader will be
- *                  moved to consuming mode and obtains read access
- *                  of \p buf until mbedtls_mps_reader_reclaim()
- *                  is called. It is the responsibility of the caller
- *                  to ensure that the \p buf persists and is not changed
- *                  between successful calls to mbedtls_mps_reader_feed()
- *                  and mbedtls_mps_reader_reclaim().
- * \return          \c MBEDTLS_ERR_MPS_READER_NEED_MORE if more input data is
- *                  required to fulfill a previous request to mbedtls_mps_reader_get().
- *                  In this case, the reader remains in producing mode and
- *                  takes no ownership of the provided buffer (an internal copy
- *                  is made instead).
- * \return          Another negative \c MBEDTLS_ERR_READER_XXX error code on
- *                  different kinds of failures.
- */
-int mbedtls_mps_reader_feed(mbedtls_mps_reader *reader,
-                            unsigned char *buf,
-                            mbedtls_mps_size_t buflen);
-
-/**
- * \brief           Reclaim reader's access to the current input buffer.
- *
- * \param reader    The reader context to use. The reader must be
- *                  in consuming mode.
- * \param paused    If not \c NULL, the integer at address \p paused will be
- *                  modified to indicate whether the reader has been paused
- *                  (value \c 1) or not (value \c 0). Pausing happens if there
- *                  is uncommitted data and a previous request to
- *                  mbedtls_mps_reader_get() has exceeded the bounds of the
- *                  input buffer.
- *
- * \return          \c 0 on success.
- * \return          A negative \c MBEDTLS_ERR_READER_XXX error code on failure.
- */
-int mbedtls_mps_reader_reclaim(mbedtls_mps_reader *reader,
-                               int *paused);
-
-/*
- * Usage API (Upper layer)
- */
-
-/**
- * \brief           Request data from the reader.
- *
- * \param reader    The reader context to use. The reader must
- *                  be in consuming mode.
- * \param desired   The desired amount of data to be read, in Bytes.
- * \param buffer    The address to store the buffer pointer in.
- *                  This must not be \c NULL.
- * \param buflen    The address to store the actual buffer
- *                  length in, or \c NULL.
- *
- * \return          \c 0 on success. In this case, \c *buf holds the
- *                  address of a buffer of size \c *buflen
- *                  (if \c buflen != \c NULL) or \c desired
- *                  (if \c buflen == \c NULL). The user has read access
- *                  to the buffer and guarantee of stability of the data
- *                  until the next call to mbedtls_mps_reader_reclaim().
- * \return          #MBEDTLS_ERR_MPS_READER_OUT_OF_DATA if there is not enough
- *                  data available to serve the get request. In this case, the
- *                  reader remains intact and in consuming mode, and the consumer
- *                  should retry the call after a successful cycle of
- *                  mbedtls_mps_reader_reclaim() and mbedtls_mps_reader_feed().
- *                  If, after such a cycle, the consumer requests a different
- *                  amount of data, the result is implementation-defined;
- *                  progress is guaranteed only if the same amount of data
- *                  is requested after a mbedtls_mps_reader_reclaim() and
- *                  mbedtls_mps_reader_feed() cycle.
- * \return          Another negative \c MBEDTLS_ERR_READER_XXX error
- *                  code for different kinds of failure.
- *
- * \note            Passing \c NULL as \p buflen is a convenient way to
- *                  indicate that fragmentation is not tolerated.
- *                  It's functionally equivalent to passing a valid
- *                  address as buflen and checking \c *buflen == \c desired
- *                  afterwards.
- */
-int mbedtls_mps_reader_get(mbedtls_mps_reader *reader,
-                           mbedtls_mps_size_t desired,
-                           unsigned char **buffer,
-                           mbedtls_mps_size_t *buflen);
-
-/**
- * \brief         Mark data obtained from mbedtls_mps_reader_get() as processed.
- *
- *                This call indicates that all data received from prior calls to
- *                mbedtls_mps_reader_get() has been or will have been
- *                processed when mbedtls_mps_reader_reclaim() is called,
- *                and thus need not be backed up.
- *
- *                This function has no user observable effect until
- *                mbedtls_mps_reader_reclaim() is called. In particular,
- *                buffers received from mbedtls_mps_reader_get() remain
- *                valid until mbedtls_mps_reader_reclaim() is called.
- *
- * \param reader  The reader context to use.
- *
- * \return        \c 0 on success.
- * \return        A negative \c MBEDTLS_ERR_READER_XXX error code on failure.
- *
- */
-int mbedtls_mps_reader_commit(mbedtls_mps_reader *reader);
-
-#endif /* MBEDTLS_READER_H */

package/external/libedhoc/externals/mbedtls/library/mps_trace.c

@@ -1,112 +0,0 @@
-/*
- *  Message Processing Stack, Trace module
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-#include "common.h"
-
-#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
-
-#include "mps_common.h"
-
-#if defined(MBEDTLS_MPS_ENABLE_TRACE)
-
-#include "mps_trace.h"
-#include <stdarg.h>
-
-static int trace_depth = 0;
-
-#define color_default  "\x1B[0m"
-#define color_red      "\x1B[1;31m"
-#define color_green    "\x1B[1;32m"
-#define color_yellow   "\x1B[1;33m"
-#define color_blue     "\x1B[1;34m"
-#define color_magenta  "\x1B[1;35m"
-#define color_cyan     "\x1B[1;36m"
-#define color_white    "\x1B[1;37m"
-
-static char const *colors[] =
-{
-    color_default,
-    color_green,
-    color_yellow,
-    color_magenta,
-    color_cyan,
-    color_blue,
-    color_white
-};
-
-#define MPS_TRACE_BUF_SIZE 100
-
-void mbedtls_mps_trace_print_msg(int id, int line, const char *format, ...)
-{
-    int ret;
-    char str[MPS_TRACE_BUF_SIZE];
-    va_list argp;
-    va_start(argp, format);
-    ret = mbedtls_vsnprintf(str, MPS_TRACE_BUF_SIZE, format, argp);
-    va_end(argp);
-
-    if (ret >= 0 && ret < MPS_TRACE_BUF_SIZE) {
-        str[ret] = '\0';
-        mbedtls_printf("[%d|L%d]: %s\n", id, line, str);
-    }
-}
-
-int mbedtls_mps_trace_get_depth()
-{
-    return trace_depth;
-}
-void mbedtls_mps_trace_dec_depth()
-{
-    trace_depth--;
-}
-void mbedtls_mps_trace_inc_depth()
-{
-    trace_depth++;
-}
-
-void mbedtls_mps_trace_color(int id)
-{
-    if (id > (int) (sizeof(colors) / sizeof(*colors))) {
-        return;
-    }
-    printf("%s", colors[id]);
-}
-
-void mbedtls_mps_trace_indent(int level, mbedtls_mps_trace_type ty)
-{
-    if (level > 0) {
-        while (--level) {
-            printf("|  ");
-        }
-
-        printf("|  ");
-    }
-
-    switch (ty) {
-        case MBEDTLS_MPS_TRACE_TYPE_COMMENT:
-            mbedtls_printf("@ ");
-            break;
-
-        case MBEDTLS_MPS_TRACE_TYPE_CALL:
-            mbedtls_printf("+--> ");
-            break;
-
-        case MBEDTLS_MPS_TRACE_TYPE_ERROR:
-            mbedtls_printf("E ");
-            break;
-
-        case MBEDTLS_MPS_TRACE_TYPE_RETURN:
-            mbedtls_printf("< ");
-            break;
-
-        default:
-            break;
-    }
-}
-
-#endif /* MBEDTLS_MPS_ENABLE_TRACE */
-#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */

package/external/libedhoc/externals/mbedtls/library/mps_trace.h

@@ -1,154 +0,0 @@
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-/**
- * \file mps_trace.h
- *
- * \brief Tracing module for MPS
- */
-
-#ifndef MBEDTLS_MPS_MBEDTLS_MPS_TRACE_H
-#define MBEDTLS_MPS_MBEDTLS_MPS_TRACE_H
-
-#include "common.h"
-#include "mps_common.h"
-#include "mps_trace.h"
-
-#include "mbedtls/platform.h"
-
-#if defined(MBEDTLS_MPS_ENABLE_TRACE)
-
-/*
- * Adapt this to enable/disable tracing output
- * from the various layers of the MPS.
- */
-
-#define MBEDTLS_MPS_TRACE_ENABLE_LAYER_1
-#define MBEDTLS_MPS_TRACE_ENABLE_LAYER_2
-#define MBEDTLS_MPS_TRACE_ENABLE_LAYER_3
-#define MBEDTLS_MPS_TRACE_ENABLE_LAYER_4
-#define MBEDTLS_MPS_TRACE_ENABLE_READER
-#define MBEDTLS_MPS_TRACE_ENABLE_WRITER
-
-/*
- * To use the existing trace module, only change
- * MBEDTLS_MPS_TRACE_ENABLE_XXX above, but don't modify the
- * rest of this file.
- */
-
-typedef enum {
-    MBEDTLS_MPS_TRACE_TYPE_COMMENT,
-    MBEDTLS_MPS_TRACE_TYPE_CALL,
-    MBEDTLS_MPS_TRACE_TYPE_ERROR,
-    MBEDTLS_MPS_TRACE_TYPE_RETURN
-} mbedtls_mps_trace_type;
-
-#define MBEDTLS_MPS_TRACE_BIT_LAYER_1 1
-#define MBEDTLS_MPS_TRACE_BIT_LAYER_2 2
-#define MBEDTLS_MPS_TRACE_BIT_LAYER_3 3
-#define MBEDTLS_MPS_TRACE_BIT_LAYER_4 4
-#define MBEDTLS_MPS_TRACE_BIT_WRITER  5
-#define MBEDTLS_MPS_TRACE_BIT_READER  6
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_LAYER_1)
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_1 (1u << MBEDTLS_MPS_TRACE_BIT_LAYER_1)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_1 0
-#endif
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_LAYER_2)
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_2 (1u << MBEDTLS_MPS_TRACE_BIT_LAYER_2)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_2 0
-#endif
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_LAYER_3)
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_3 (1u << MBEDTLS_MPS_TRACE_BIT_LAYER_3)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_3 0
-#endif
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_LAYER_4)
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_4 (1u << MBEDTLS_MPS_TRACE_BIT_LAYER_4)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_LAYER_4 0
-#endif
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_READER)
-#define MBEDTLS_MPS_TRACE_MASK_READER (1u << MBEDTLS_MPS_TRACE_BIT_READER)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_READER 0
-#endif
-
-#if defined(MBEDTLS_MPS_TRACE_ENABLE_WRITER)
-#define MBEDTLS_MPS_TRACE_MASK_WRITER (1u << MBEDTLS_MPS_TRACE_BIT_WRITER)
-#else
-#define MBEDTLS_MPS_TRACE_MASK_WRITER 0
-#endif
-
-#define MBEDTLS_MPS_TRACE_MASK (MBEDTLS_MPS_TRACE_MASK_LAYER_1 |       \
-                                MBEDTLS_MPS_TRACE_MASK_LAYER_2 |       \
-                                MBEDTLS_MPS_TRACE_MASK_LAYER_3 |       \
-                                MBEDTLS_MPS_TRACE_MASK_LAYER_4 |       \
-                                MBEDTLS_MPS_TRACE_MASK_READER  |       \
-                                MBEDTLS_MPS_TRACE_MASK_WRITER)
-
-/* We have to avoid globals because E-ACSL chokes on them...
- * Wrap everything in stub functions. */
-int  mbedtls_mps_trace_get_depth(void);
-void mbedtls_mps_trace_inc_depth(void);
-void mbedtls_mps_trace_dec_depth(void);
-
-void mbedtls_mps_trace_color(int id);
-void mbedtls_mps_trace_indent(int level, mbedtls_mps_trace_type ty);
-
-void mbedtls_mps_trace_print_msg(int id, int line, const char *format, ...);
-
-#define MBEDTLS_MPS_TRACE(type, ...)                                              \
-    do {                                                                            \
-        if (!(MBEDTLS_MPS_TRACE_MASK & (1u << mbedtls_mps_trace_id)))         \
-        break;                                                                  \
-        mbedtls_mps_trace_indent(mbedtls_mps_trace_get_depth(), type);            \
-        mbedtls_mps_trace_color(mbedtls_mps_trace_id);                            \
-        mbedtls_mps_trace_print_msg(mbedtls_mps_trace_id, __LINE__, __VA_ARGS__); \
-        mbedtls_mps_trace_color(0);                                               \
-    } while (0)
-
-#define MBEDTLS_MPS_TRACE_INIT(...)                                         \
-    do {                                                                      \
-        if (!(MBEDTLS_MPS_TRACE_MASK & (1u << mbedtls_mps_trace_id)))   \
-        break;                                                            \
-        MBEDTLS_MPS_TRACE(MBEDTLS_MPS_TRACE_TYPE_CALL, __VA_ARGS__);        \
-        mbedtls_mps_trace_inc_depth();                                        \
-    } while (0)
-
-#define MBEDTLS_MPS_TRACE_END(val)                                        \
-    do {                                                                    \
-        if (!(MBEDTLS_MPS_TRACE_MASK & (1u << mbedtls_mps_trace_id))) \
-        break;                                                          \
-        MBEDTLS_MPS_TRACE(MBEDTLS_MPS_TRACE_TYPE_RETURN, "%d (-%#04x)",    \
-                          (int) (val), -((unsigned) (val)));                           \
-        mbedtls_mps_trace_dec_depth();                                      \
-    } while (0)
-
-#define MBEDTLS_MPS_TRACE_RETURN(val)         \
-    do {                                        \
-        /* Breaks tail recursion. */            \
-        int ret__ = val;                        \
-        MBEDTLS_MPS_TRACE_END(ret__);         \
-        return ret__;                        \
-    } while (0)
-
-#else /* MBEDTLS_MPS_TRACE */
-
-#define MBEDTLS_MPS_TRACE(type, ...) do { } while (0)
-#define MBEDTLS_MPS_TRACE_INIT(...)  do { } while (0)
-#define MBEDTLS_MPS_TRACE_END          do { } while (0)
-
-#define MBEDTLS_MPS_TRACE_RETURN(val) return val;
-
-#endif /* MBEDTLS_MPS_TRACE */
-
-#endif /* MBEDTLS_MPS_MBEDTLS_MPS_TRACE_H */