base.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 <stdbool.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
 
#include "byteorder.h"
 
#include "net/unicoap/constants.h"
#include "net/unicoap/util_macros.h"


 
#ifdef __cplusplus
extern "C" {
#endif
 
/* MARK: - Essentials */
typedef struct {
    uint8_t* data;

    uint16_t size;

    unicoap_option_number_t number;
} unicoap_option_entry_t;

typedef struct {
    /* TODO: OSCORE: read-only due to options stored in two different buffers */

    size_t storage_size;

    size_t storage_capacity;

    unicoap_option_entry_t entries[CONFIG_UNICOAP_OPTIONS_MAX];

    size_t option_count;
} unicoap_options_t;

static inline void unicoap_options_init(unicoap_options_t* options, uint8_t* storage,
                                        size_t capacity)
{
    options->entries->data = storage;
    options->option_count = 0;
    options->storage_size = 0;
    options->storage_capacity = capacity;
}

bool unicoap_options_contains(const unicoap_options_t* options, unicoap_option_number_t number);

static inline void unicoap_options_clear(unicoap_options_t* options)
{
    options->option_count = 0;
    options->storage_size = 0;
}

 
/* MARK: - Allocating option buffers */
#ifndef DOXYGEN
#  define _UNICOAP_OPTIONS_ALLOC(_buf, _name, capacity, _static)    \
    _static uint8_t _buf[capacity];                                 \
    _static unicoap_options_t _name = {                             \
        .entries = { { .data = _buf } },                            \
        .storage_capacity = capacity,                               \
    };
#endif

#define UNICOAP_OPTIONS_ALLOC(name, capacity) \
    _UNICOAP_OPTIONS_ALLOC(_CONCAT3(name, _storage, __LINE__), name, capacity,)

#define UNICOAP_OPTIONS_ALLOC_STATIC(name, capacity) \
    _UNICOAP_OPTIONS_ALLOC(_CONCAT3(name, _storage, __LINE__), name, capacity, static)

#define UNICOAP_OPTIONS_ALLOC_DEFAULT(name) \
    UNICOAP_OPTIONS_ALLOC(name, CONFIG_UNICOAP_OPTIONS_BUFFER_DEFAULT_CAPACITY)

#define UNICOAP_OPTIONS_ALLOC_STATIC_DEFAULT(name) \
    UNICOAP_OPTIONS_ALLOC_STATIC(name, CONFIG_UNICOAP_OPTIONS_BUFFER_DEFAULT_CAPACITY)

 
/* MARK: - Option characteristics */
static inline bool unicoap_option_is_critical(unicoap_option_number_t option_number)
{
    return option_number & 1;
}

static inline bool unicoap_option_is_safe_to_forward(unicoap_option_number_t option_number)
{
    return (option_number & 2) == 0;
}

static inline bool unicoap_option_is_no_cache_key(unicoap_option_number_t option_number)
{
    return ((option_number & 0x1e) == 0x1c);
}

static inline bool unicoap_option_is_cache_key(unicoap_option_number_t option_number)
{
    return ((option_number & 0x1e) != 0x1c);
}

 
/* MARK: - Tools */
const char* unicoap_string_from_option_number(unicoap_option_number_t number);

ssize_t unicoap_options_swap_storage(unicoap_options_t* options, uint8_t* destination,
                                     size_t capacity);

static inline uint8_t* unicoap_options_data(const unicoap_options_t* options)
{
    return options->entries->data;
}

static inline size_t unicoap_options_size(const unicoap_options_t* options)
{
    return options->storage_size;
}

 
/* MARK: - Auxiliary constants */
#if !defined(EBADOPT) || defined(DOXYGEN)
#  define EBADOPT 151
#endif

#if !defined(EPAYLD) || defined(DOXYGEN)
#  define EPAYLD 152
#endif

#define UNICOAP_UINT24_MAX (0xffffff)

#define UNICOAP_UINT24_SIZE (3)

#define UNICOAP_UINT_MAX   (14 + 255 + 0xffff)
 
/* MARK: - Generic Option Methods - */
/* MARK: - Repeatable options */
int unicoap_options_add(unicoap_options_t* options, unicoap_option_number_t number,
                        const uint8_t* value, size_t value_size);

int unicoap_options_add_values_joined(unicoap_options_t* options, unicoap_option_number_t number,
                                      const uint8_t* buffer, size_t size, uint8_t separator);

ssize_t unicoap_options_copy_values_joined(const unicoap_options_t* options,
                                           unicoap_option_number_t number, uint8_t* buffer,
                                           size_t capacity, uint8_t separator);

int unicoap_options_remove_all(unicoap_options_t* options, unicoap_option_number_t number);
 
/* MARK: - Non-repeatable options */
ssize_t unicoap_options_get(const unicoap_options_t* options, unicoap_option_number_t number,
                            const uint8_t** value);

ssize_t unicoap_options_copy_value(const unicoap_options_t* options, unicoap_option_number_t number,
                                   uint8_t* dest, size_t capacity);

int unicoap_options_set(unicoap_options_t* options, unicoap_option_number_t number,
                        const uint8_t* value, size_t value_size);

static inline int unicoap_options_remove(unicoap_options_t* options, unicoap_option_number_t number)
{
    /* reuse unicoap_options_remove_all, helps decrease binary size */
    return unicoap_options_remove_all(options, number);
}

 
/* MARK: - Enumerating options */
typedef struct {
    unicoap_options_t* options;

    size_t index;
} unicoap_options_iterator_t;

static inline void unicoap_options_iterator_init(unicoap_options_iterator_t* iterator,
                                                 unicoap_options_t* options)
{
    assert(iterator);
    assert(options);
    assert(options->entries->data);
    iterator->options = options;
    iterator->index = 0;
}

ssize_t unicoap_options_get_next(unicoap_options_iterator_t* iterator,
                                 unicoap_option_number_t* number, const uint8_t** value);

ssize_t unicoap_options_get_next_by_number(unicoap_options_iterator_t* iterator,
                                           unicoap_option_number_t number, const uint8_t** value);

ssize_t unicoap_options_get_next_query_by_name(unicoap_options_iterator_t* iterator,
                                               unicoap_option_number_t number,
                                               const char* name, size_t length,
                                               const char** value);

static inline
ssize_t unicoap_options_get_next_query_by_name_string(unicoap_options_iterator_t* iterator,
                                               unicoap_option_number_t number, const char* name,
                                               const char** value)
{
    return unicoap_options_get_next_query_by_name(iterator, number, name, strlen(name), value);
}

void unicoap_options_dump_all(const unicoap_options_t* options);

void unicoap_options_print_uri_path(const unicoap_options_t* options);
 
/* MARK: - Strings */
static inline int unicoap_options_set_string(unicoap_options_t* options,
                                             unicoap_option_number_t number, const char* string,
                                             size_t count)
{
    return unicoap_options_set(options, number, (uint8_t*)string,
                               ((count > 0) && string) ? count : strlen(string));
}

static inline int unicoap_options_add_string(unicoap_options_t* options,
                                             unicoap_option_number_t number, const char* string,
                                             size_t count)
{
    return unicoap_options_add(options, number, (uint8_t*)string,
                               ((count > 0) && string) ? count : strlen(string));
}

 
/* MARK: - Unsigned integers */
#ifndef DOXYGEN
ssize_t _unicoap_options_get_variable_uint(const unicoap_options_t* options,
                                           unicoap_option_number_t number, uint32_t* uint,
                                           size_t max_size);
#endif

static inline ssize_t unicoap_options_get_uint32(const unicoap_options_t* options,
                                                 unicoap_option_number_t number, uint32_t* uint)
{
    return _unicoap_options_get_variable_uint(options, number, uint, sizeof(uint32_t));
}

static inline ssize_t unicoap_options_get_uint24(const unicoap_options_t* options,
                                                 unicoap_option_number_t number, uint32_t* uint)
{
    return _unicoap_options_get_variable_uint(options, number, uint, UNICOAP_UINT24_SIZE);
}

static inline ssize_t unicoap_options_get_uint16(const unicoap_options_t* options,
                                                 unicoap_option_number_t number, uint16_t* uint)
{
    uint32_t _uint = 0;
    int res = _unicoap_options_get_variable_uint(options, number, &_uint, sizeof(uint16_t));
    *uint = (uint16_t)_uint;
    return res;
}

static inline ssize_t unicoap_options_get_uint8(const unicoap_options_t* options,
                                                unicoap_option_number_t number, uint8_t* uint)
{
    return unicoap_options_copy_value(options, number, uint, sizeof(uint8_t));
}

int unicoap_options_set_uint(unicoap_options_t* options, unicoap_option_number_t number,
                             uint32_t value);

int unicoap_options_add_uint(unicoap_options_t* options, unicoap_option_number_t number,
                             uint32_t value);
 
 
 
#ifdef __cplusplus
}
#endif