private.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024-2026 Carl Seifert
 * SPDX-FileCopyrightText: 2024-2026 TU Dresden
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#include <stdint.h>
#include <alloca.h>
 
#include "mutex.h"
#include "bitfield.h"
#include "architecture.h"
#include "random.h"
 
#include "net/unicoap.h"
 
#include "private/state.h"
#include "private/packet.h"
#include "private/messaging.h"


 
#ifdef __cplusplus
extern "C" {
#endif
 
/* MARK: - Debugging */
#define UNICOAP_DEBUG_PREFIX "coap"
 
#ifndef DOXYGEN
#  define _UNICOAP_NEED_HAVE "(need %" PRIuSIZE ", have %" PRIuSIZE ")"
#endif
 
#ifndef DOXYGEN
#  define _UNICOAP_PREFIX_DEBUG(category, ...) DEBUG(UNICOAP_DEBUG_PREFIX category ": " __VA_ARGS__)
#  define UNICOAP_DEBUG(...)                   _UNICOAP_PREFIX_DEBUG("", __VA_ARGS__)
#  define _OPTIONS_DEBUG(...)                   _UNICOAP_PREFIX_DEBUG(".options", __VA_ARGS__)
#  define _MESSAGING_DEBUG(...)                 _UNICOAP_PREFIX_DEBUG(".messaging", __VA_ARGS__)
#  define _STATE_DEBUG(...)                     _UNICOAP_PREFIX_DEBUG(".state", __VA_ARGS__)
#  define _STATE_EVENT_DEBUG(...)               _UNICOAP_PREFIX_DEBUG(".state.sched", __VA_ARGS__)
#  define _STATE_NOTIF_DEBUG(...)               _UNICOAP_PREFIX_DEBUG(".state.notif", __VA_ARGS__)
#  define _TRANSPORT_DEBUG(...)                 _UNICOAP_PREFIX_DEBUG(".transport", __VA_ARGS__)
#  define _SERVER_DEBUG(...)                    _UNICOAP_PREFIX_DEBUG(".server", __VA_ARGS__)
#  define _CLIENT_DEBUG(...)                    _UNICOAP_PREFIX_DEBUG(".client", __VA_ARGS__)
#  define _URI_DEBUG(...)                       _UNICOAP_PREFIX_DEBUG(".uri", __VA_ARGS__)
#  define API_WARNING(message)                 "WARNING: " message "\n"
#  define API_ERROR(message)                   "ERROR: " message "\n"
#  define API_MISUSE(message)                  "API MISUSE: " message "\n"
#  define INTERNAL_ERROR(message)              "BUG: " message "\n"
#  define FIXIT(message)                       "+++ FIXIT: " message "\n"
#endif
 
#if ENABLE_DEBUG
#  define DEBUG_ENDPOINT(endpoint) unicoap_print_endpoint(endpoint)
#  define DEBUG_FLAGS(flags, role) unicoap_print_flags(flags, role)
#else
#  define DEBUG_ENDPOINT(endpoint) (void)endpoint
#  define DEBUG_FLAGS(flags, role) \
      (void)flags;                 \
      (void)role
#endif
 
#ifndef DOXYGEN
#  if IS_ACTIVE(CONFIG_UNICOAP_ASSIST)
#    include <stdio.h>
#  endif
#  define unicoap_assist(...)                     \
      do {                                        \
          if (IS_ACTIVE(CONFIG_UNICOAP_ASSIST) || IS_ACTIVE(CONFIG_UNICOAP_DEBUG_LOGGING)) { \
              printf(__VA_ARGS__);                \
          }                                       \
      } while (0)
#endif

void unicoap_assist_emit_diagnostic_missing_driver(unicoap_proto_t proto);
 
/* MARK: - Thread */
#define UNICOAP_THREAD_IDENTIFIER "unicoap"

void unicoap_state_lock(void);

void unicoap_state_unlock(void);

extern kernel_pid_t _unicoap_pid;
 
/* MARK: - State and initialization */
typedef struct {
    mutex_t lock;
 
#if IS_USED(MODULE_UNICOAP_SERVER) || defined(DOXYGEN)
    unicoap_listener_t* listeners;
#endif
 
#if UNICOAP_HAVE_CLIENT_STATE
    unicoap_client_memo_t client_memos[CONFIG_UNICOAP_CLIENT_MEMOS_CAPACITY];
#endif
 
    /* TODO: Client and advanced server features: Exchange-layer state objects */
} unicoap_state_t;

static inline void unicoap_set_listeners(unicoap_state_t* state, unicoap_listener_t* listeners) {
#if IS_USED(MODULE_UNICOAP_SERVER)
    state->listeners = listeners;
#else
    (void)state;
    (void)listeners;
#endif
}

static inline unicoap_listener_t* unicoap_get_listeners(unicoap_state_t* state) {
#if IS_USED(MODULE_UNICOAP_SERVER)
    return state->listeners;
#else
    (void)state;
    return NULL;
#endif
}

int unicoap_init_udp(event_queue_t* queue);

int unicoap_deinit_udp(event_queue_t* queue);

int unicoap_init_dtls(event_queue_t* queue);

int unicoap_deinit_dtls(event_queue_t* queue);

int unicoap_init_slipmux(event_queue_t* queue);

int unicoap_deinit_slipmux(event_queue_t* queue);

int unicoap_init_rfc7252_common(event_queue_t* queue);

int unicoap_deinit_rfc7252_common(event_queue_t* queue);
 
/* MARK: unicoap_driver_extension_point */
 
/* MARK: - Private Server Utils */
int unicoap_resource_find(const unicoap_packet_t* packet, const unicoap_resource_t** resource_ptr,
                          const unicoap_listener_t** listener_ptr);

int unicoap_resource_match_request_default(const unicoap_listener_t* listener,
                                           const unicoap_resource_t** resource_ptr,
                                           const unicoap_message_t* request,
                                           const unicoap_endpoint_t* endpoint);

int unicoap_resource_handle_well_known_core(unicoap_message_t* message, const unicoap_aux_t* aux,
                                            unicoap_request_context_t* ctx, void* arg);
 
/* MARK: - Private message and option helpers */
#ifndef DOXYGEN
#  define _UNICOAP_OPTIONS_ALLOCA(_buf, _name, capacity, _static) \
    uint8_t* _buf = alloca(capacity);                             \
    unicoap_options_t* _name = alloca(sizeof(unicoap_options_t)); \
    memset(_name, 0, sizeof(unicoap_options_t));                  \
    (_name)->entries->data = _buf;                                \
    (_name)->storage_capacity = capacity;
#endif

#define UNICOAP_OPTIONS_ALLOCA(name, capacity) \
    _UNICOAP_OPTIONS_ALLOCA(_CONCAT3(name, _storage, __LINE__), name, capacity,)

 
/* MARK: - Other Utils */

#define UNICOAP_DECL_RECEIVER_STORAGE \
    uint8_t unicoap_receiver_buffer[CONFIG_UNICOAP_PDU_SIZE_MAX]

#define UNICOAP_DECL_RECEIVER_STORAGE_EXTERN extern UNICOAP_DECL_RECEIVER_STORAGE

static inline bool unicoap_transport_truncate_received(size_t* chunk_size, size_t received)
{
    /* cannot use sizeof() here, because we want this function to be inlinable,
     * extern decl would affect transport.c, too */
    if (received + *chunk_size > CONFIG_UNICOAP_PDU_SIZE_MAX) {
        /* Limit chunk size to remaining available storage capacity */
        _TRANSPORT_DEBUG("truncated\n");
        _TRANSPORT_DEBUG("warning: recv storage too small, need at least %" PRIdSIZE "\n",
                        received + *chunk_size);
        *chunk_size = CONFIG_UNICOAP_PDU_SIZE_MAX - received;
        return true;
    }
    return false;
}

 
#ifndef DOXYGEN
static inline void __debug_hex(const uint8_t* buffer, size_t size)
{
    for (size_t i = 0; i < size; i += 1) {
        printf("%02X", buffer[i]);
    }
}
 
#  define _UNICOAP_DEBUG_HEX(bytes, size) \
      do {                                \
          if (ENABLE_DEBUG) {             \
              __debug_hex(bytes, size);   \
          }                               \
      } while (0)
#endif
 
#ifdef __cplusplus
}
#endif