options.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2025 Carl Seifert
 * Copyright (C) 2024-2025 TU Dresden
 *
 * This file is subject to the terms and conditions of the GNU Lesser General
 * Public License v2.1. See the file LICENSE in the top level directory for
 * more details.
 */
 
#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,
                                               const char** value);

void unicoap_options_dump_all(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);
 
/* MARK: - Predefined Options - */

 
/* MARK: - Uri-Host */

static inline ssize_t unicoap_options_get_uri_host(const unicoap_options_t* options,
                                                   const char** host)
{
    return unicoap_options_get(options, UNICOAP_OPTION_URI_HOST, (const uint8_t**)host);
}

static inline ssize_t unicoap_options_set_uri_host(unicoap_options_t* options, char* host,
                                                   size_t length)
{
    assert(length > 0 && length <= 255);
    return unicoap_options_set(options, UNICOAP_OPTION_URI_HOST, (uint8_t*)host, length);
}

static inline ssize_t unicoap_options_set_uri_host_string(unicoap_options_t* options, char* host)
{
    return unicoap_options_set_uri_host(options, host, strlen(host));
}

static inline int unicoap_options_remove_uri_host(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_URI_HOST);
}
 /* Uri-Host */
 
/* MARK: - If-None-Match */

static inline bool unicoap_options_get_if_none_match(const unicoap_options_t* options)
{
    return unicoap_options_contains(options, UNICOAP_OPTION_IF_NONE_MATCH);
}

static inline ssize_t unicoap_options_set_if_none_match(unicoap_options_t* options, bool value)
{
    if (value) {
        return unicoap_options_remove(options, UNICOAP_OPTION_IF_NONE_MATCH);
    }
    else {
        return unicoap_options_set(options, UNICOAP_OPTION_IF_NONE_MATCH, NULL, 0);
    }
}
 /* If-None-Match */
 
/* MARK: - Uri-Port */

static inline ssize_t unicoap_options_get_uri_port(const unicoap_options_t* options, uint16_t* port)
{
    return unicoap_options_get_uint16(options, UNICOAP_OPTION_URI_PORT, port);
}

static inline ssize_t unicoap_options_set_uri_port(unicoap_options_t* options, uint16_t port)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_URI_PORT, (uint32_t)port);
}

static inline int unicoap_options_remove_uri_port(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_URI_PORT);
}
 /* Uri-Port */
 
/* MARK: - Content-Format */

static inline ssize_t unicoap_options_get_content_format(const unicoap_options_t* options,
                                                         unicoap_content_format_t* format)
{
    return unicoap_options_get_uint16(options, UNICOAP_OPTION_CONTENT_FORMAT, (uint16_t*)format);
}

static inline ssize_t unicoap_options_set_content_format(unicoap_options_t* options,
                                                         unicoap_content_format_t format)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_CONTENT_FORMAT, (uint32_t)format);
}

static inline int unicoap_options_remove_content_format(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_CONTENT_FORMAT);
}
 /* Content-Format */
 
/* MARK: - Max-Age */

static inline ssize_t unicoap_options_get_max_age(const unicoap_options_t* options, uint32_t* age)
{
    return unicoap_options_get_uint32(options, UNICOAP_OPTION_MAX_AGE, age);
}

static inline ssize_t unicoap_options_set_max_age(unicoap_options_t* options, uint32_t age)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_MAX_AGE, age);
}

static inline int unicoap_options_remove_max_age(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_MAX_AGE);
}
 /* Max-Age */
 
/* MARK: - Accept */

static inline ssize_t unicoap_options_get_accept(const unicoap_options_t* options,
                                                 unicoap_content_format_t* format)
{
    return unicoap_options_get_uint16(options, UNICOAP_OPTION_ACCEPT, (uint16_t*)format);
}

static inline ssize_t unicoap_options_set_accept(unicoap_options_t* options,
                                                 unicoap_content_format_t format)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_ACCEPT, (uint32_t)format);
}

static inline int unicoap_options_remove_accept(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_ACCEPT);
}
 /* Accept */
 
/* MARK: - Proxy-Scheme */

static inline ssize_t unicoap_options_get_proxy_scheme(const unicoap_options_t* options,
                                                       const char** scheme)
{
    return unicoap_options_get(options, UNICOAP_OPTION_PROXY_SCHEME, (const uint8_t**)scheme);
}

static inline ssize_t unicoap_options_set_proxy_scheme(unicoap_options_t* options, char* scheme,
                                                       size_t length)
{
    return unicoap_options_set(options, UNICOAP_OPTION_PROXY_SCHEME, (uint8_t*)scheme, length);
}

static inline ssize_t unicoap_options_set_proxy_scheme_string(unicoap_options_t* options,
                                                              char* scheme)
{
    return unicoap_options_set_proxy_scheme(options, scheme, strlen(scheme));
}

static inline int unicoap_options_remove_proxy_scheme(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_PROXY_SCHEME);
}
 /* Proxy-Scheme */
 
/* MARK: - Proxy-Uri */

static inline ssize_t unicoap_options_get_proxy_uri(const unicoap_options_t* options,
                                                    const char** uri)
{
    return unicoap_options_get(options, UNICOAP_OPTION_PROXY_URI, (const uint8_t**)uri);
}

static inline ssize_t unicoap_options_set_proxy_uri(unicoap_options_t* options, char* uri,
                                                    size_t length)
{
    assert(length > 0 && length <= 1034);
    return unicoap_options_set(options, UNICOAP_OPTION_PROXY_URI, (uint8_t*)uri, length);
}

static inline ssize_t unicoap_options_set_proxy_uri_string(unicoap_options_t* options, char* uri)
{
    return unicoap_options_set_proxy_uri(options, uri, strlen(uri));
}

static inline int unicoap_options_remove_proxy_uri(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_PROXY_URI);
}
 /* Proxy-Uri */
 
/* MARK: - No-Response */

static inline ssize_t unicoap_options_get_no_response(const unicoap_options_t* options,
                                                      uint8_t* value)
{
    return unicoap_options_get_uint8(options, UNICOAP_OPTION_NO_RESPONSE, value);
}

static inline ssize_t unicoap_options_set_no_response(unicoap_options_t* options, uint8_t value)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_NO_RESPONSE, (uint32_t)value);
}

static inline int unicoap_options_remove_no_response(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_NO_RESPONSE);
}
 /* No-Response */
 
/* MARK: - If-Match */

static inline ssize_t unicoap_options_get_first_if_match(const unicoap_options_t* options,
                                                         const uint8_t** value)
{
    return unicoap_options_get(options, UNICOAP_OPTION_IF_MATCH, value);
}

static inline ssize_t unicoap_options_get_next_if_match(unicoap_options_iterator_t* iterator,
                                                        const uint8_t** value)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_IF_MATCH, value);
}

static inline ssize_t unicoap_options_add_if_match(unicoap_options_t* options, uint8_t* value,
                                                   size_t size)
{
    assert(size <= 8);
    return unicoap_options_add(options, UNICOAP_OPTION_IF_MATCH, value, size);
}

static inline int unicoap_options_remove_all_if_match(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_IF_MATCH);
}
 /* If-Match */
 
/* MARK: - ETag */

static inline ssize_t unicoap_options_get_first_etag(const unicoap_options_t* options,
                                                     const uint8_t** etag)
{
    return unicoap_options_get(options, UNICOAP_OPTION_ETAG, etag);
}

static inline ssize_t unicoap_options_get_next_etag(unicoap_options_iterator_t* iterator,
                                                    const uint8_t** etag)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_ETAG, etag);
}

static inline ssize_t unicoap_options_add_etag(unicoap_options_t* options, uint8_t* etag,
                                               size_t size)
{
    assert(size > 0 && size <= 8);
    return unicoap_options_add(options, UNICOAP_OPTION_ETAG, etag, size);
}

static inline int unicoap_options_remove_etags(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_ETAG);
}
 /* ETag */
 
/* MARK: - Location-Path */

static inline ssize_t
unicoap_options_get_first_location_path_component(const unicoap_options_t* options,
                                                  const char** component)
{
    return unicoap_options_get(options, UNICOAP_OPTION_LOCATION_PATH, (const uint8_t**)component);
}

static inline ssize_t
unicoap_options_get_next_location_path_component(unicoap_options_iterator_t* iterator,
                                                 const char** component)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_LOCATION_PATH,
                                              (const uint8_t**)component);
}

static inline ssize_t unicoap_options_copy_location_path(const unicoap_options_t* options,
                                                         char* path, size_t capacity)
{
    assert(capacity > 0);
    *path = '/';
    path += 1;
    capacity -= 1;
    int res = unicoap_options_copy_values_joined(options, UNICOAP_OPTION_LOCATION_PATH,
                                                 (uint8_t*)path, capacity, '/');
    return res < 0 ? res : res + 1;
}

static inline ssize_t unicoap_options_add_location_path_component(unicoap_options_t* options,
                                                                  char* component, size_t length)
{
    return unicoap_options_add(options, UNICOAP_OPTION_LOCATION_PATH, (uint8_t*)component, length);
}

static inline ssize_t unicoap_options_add_location_path_component_string(unicoap_options_t* options,
                                                                         char* component)
{
    return unicoap_options_add_location_path_component(options, component, strlen(component));
}

static inline ssize_t unicoap_options_add_location_path(unicoap_options_t* options, char* path,
                                                        size_t length)
{
    return unicoap_options_add_values_joined(options, UNICOAP_OPTION_LOCATION_PATH, (uint8_t*)path,
                                             length, '/');
}

static inline ssize_t unicoap_options_add_location_path_string(unicoap_options_t* options,
                                                               char* path)
{
    return unicoap_options_add_location_path(options, path, strlen(path));
}

static inline int unicoap_options_remove_location_path(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_LOCATION_PATH);
}
 /* Location-Path */
 
/* MARK: - Uri-Path */

static inline ssize_t unicoap_options_get_first_uri_path_component(const unicoap_options_t* options,
                                                                   const char** component)
{
    return unicoap_options_get(options, UNICOAP_OPTION_URI_PATH, (const uint8_t**)component);
}

static inline ssize_t
unicoap_options_get_next_uri_path_component(unicoap_options_iterator_t* iterator,
                                            const char** component)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_URI_PATH,
                                              (const uint8_t**)component);
}

static inline ssize_t unicoap_options_copy_uri_path(const unicoap_options_t* options, char* path,
                                                    size_t capacity)
{
    assert(capacity > 0);
    *path = '/';
    path += 1;
    capacity -= 1;
    int res = unicoap_options_copy_values_joined(options, UNICOAP_OPTION_URI_PATH, (uint8_t*)path,
                                                 capacity, '/');
    return res < 0 ? res : res + 1;
}

static inline ssize_t unicoap_options_add_uri_path_component(unicoap_options_t* options,
                                                             char* component, size_t length)
{
    assert(length <= 255);
    return unicoap_options_add(options, UNICOAP_OPTION_URI_PATH, (uint8_t*)component, length);
}

static inline ssize_t unicoap_options_add_uri_path_component_string(unicoap_options_t* options,
                                                                    char* component)
{
    return unicoap_options_add_uri_path_component(options, component, strlen(component));
}

static inline ssize_t unicoap_options_add_uri_path(unicoap_options_t* options, char* path,
                                                   size_t length)
{
    return unicoap_options_add_values_joined(options, UNICOAP_OPTION_URI_PATH, (uint8_t*)path,
                                             length, '/');
}

static inline ssize_t unicoap_options_add_uri_path_string(unicoap_options_t* options, char* path)
{
    return unicoap_options_add_uri_path(options, path, strlen(path));
}

static inline int unicoap_options_remove_uri_path(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_URI_PATH);
}
 /* Uri-Path */
 
/* MARK: - Uri-Query */

static inline ssize_t unicoap_options_get_first_uri_query(const unicoap_options_t* options,
                                                          const char** query)
{
    return unicoap_options_get(options, UNICOAP_OPTION_URI_QUERY, (const uint8_t**)query);
}

static inline ssize_t unicoap_options_get_next_uri_query(unicoap_options_iterator_t* iterator,
                                                         const char** query)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_URI_QUERY,
                                              (const uint8_t**)query);
}

static inline ssize_t
unicoap_options_get_next_uri_query_by_name(unicoap_options_iterator_t* iterator, const char* name,
                                           const char** value)
{
    return unicoap_options_get_next_query_by_name(iterator, UNICOAP_OPTION_URI_QUERY, name, value);
}

static inline ssize_t unicoap_options_get_first_uri_query_by_name(unicoap_options_t* options,
                                                                  const char* name,
                                                                  const char** value)
{
    unicoap_options_iterator_t iterator;
    unicoap_options_iterator_init(&iterator, options);
    return unicoap_options_get_next_uri_query_by_name(&iterator, name, value);
}

static inline ssize_t unicoap_options_copy_uri_queries(const unicoap_options_t* options,
                                                       char* queries, size_t capacity)
{
    return unicoap_options_copy_values_joined(options, UNICOAP_OPTION_URI_QUERY, (uint8_t*)queries,
                                              capacity, '&');
}

static inline ssize_t unicoap_options_add_uri_query(unicoap_options_t* options, char* query,
                                                    size_t length)
{
    assert(length <= 255);
    return unicoap_options_add(options, UNICOAP_OPTION_URI_QUERY, (uint8_t*)query, length);
}

static inline ssize_t unicoap_options_add_uri_query_string(unicoap_options_t* options, char* query)
{
    return unicoap_options_add_uri_query(options, query, strlen(query));
}

static inline ssize_t unicoap_options_add_uri_queries(unicoap_options_t* options, char* queries,
                                                      size_t length)
{
    return unicoap_options_add_values_joined(options, UNICOAP_OPTION_URI_QUERY, (uint8_t*)queries,
                                             length, '&');
}

static inline ssize_t unicoap_options_add_uri_queries_string(unicoap_options_t* options,
                                                             char* queries)
{
    return unicoap_options_add_uri_queries(options, queries, strlen(queries));
}

static inline int unicoap_options_remove_uri_queries(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_URI_QUERY);
}
 /* Uri-Query */
 
/* MARK: - Location-Query */

static inline ssize_t unicoap_options_get_first_location_query(const unicoap_options_t* options,
                                                               const char** query)
{
    return unicoap_options_get(options, UNICOAP_OPTION_LOCATION_QUERY, (const uint8_t**)query);
}

static inline ssize_t unicoap_options_get_next_location_query(unicoap_options_iterator_t* iterator,
                                                              const char** query)
{
    return unicoap_options_get_next_by_number(iterator, UNICOAP_OPTION_LOCATION_QUERY,
                                              (const uint8_t**)query);
}

static inline ssize_t
unicoap_options_get_next_location_query_by_name(unicoap_options_iterator_t* iterator,
                                                const char* name, const char** value)
{
    return unicoap_options_get_next_query_by_name(iterator, UNICOAP_OPTION_LOCATION_QUERY, name,
                                                  value);
}

static inline ssize_t unicoap_options_get_first_location_query_by_name(unicoap_options_t* options,
                                                                       const char* name,
                                                                       const char** value)
{
    unicoap_options_iterator_t iterator;
    unicoap_options_iterator_init(&iterator, options);
    return unicoap_options_get_next_location_query_by_name(&iterator, name, value);
}

static inline ssize_t unicoap_options_copy_location_queries(const unicoap_options_t* options,
                                                            char* queries, size_t capacity)
{
    return unicoap_options_copy_values_joined(options, UNICOAP_OPTION_LOCATION_QUERY,
                                              (uint8_t*)queries, capacity, '&');
}

static inline ssize_t unicoap_options_add_location_query(unicoap_options_t* options, char* query,
                                                         size_t length)
{
    assert(length <= 255);
    return unicoap_options_add(options, UNICOAP_OPTION_LOCATION_QUERY, (uint8_t*)query, length);
}

static inline ssize_t unicoap_options_add_location_query_string(unicoap_options_t* options,
                                                                char* query)
{
    return unicoap_options_add_location_query(options, query, strlen(query));
}

static inline ssize_t unicoap_options_add_location_queries(unicoap_options_t* options,
                                                           char* queries, size_t length)
{
    return unicoap_options_add_values_joined(options, UNICOAP_OPTION_LOCATION_QUERY,
                                             (uint8_t*)queries, length, '&');
}

static inline ssize_t unicoap_options_add_location_queries_string(unicoap_options_t* options,
                                                                  char* queries)
{
    return unicoap_options_add_location_queries(options, queries, strlen(queries));
}

static inline int unicoap_options_remove_location_queries(unicoap_options_t* options)
{
    return unicoap_options_remove_all(options, UNICOAP_OPTION_LOCATION_QUERY);
}
 /* Location-Query */
 
/* MARK: - Observe */

#define UNICOAP_OBSERVE_OPTION_REGISTER   (0)

#define UNICOAP_OBSERVE_OPTION_DEREGISTER (1)

static inline ssize_t unicoap_options_get_observe(const unicoap_options_t* options,
                                                  uint32_t* observe)
{
    return unicoap_options_get_uint24(options, UNICOAP_OPTION_OBSERVE, observe);
}

static inline ssize_t unicoap_options_set_observe(unicoap_options_t* options, uint32_t observe)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_OBSERVE, observe);
}

static inline int unicoap_options_remove_observe(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_OBSERVE);
}

int unicoap_options_set_observe_generated(unicoap_options_t* options);
 /* Observe */
 
/* MARK: - Block-wise Transfers */

#define UNICOAP_BLOCK_OPTION_NONE (0x0f000000)

typedef uint32_t unicoap_block_option_t;

static inline ssize_t unicoap_options_get_block(const unicoap_options_t* options,
                                                unicoap_option_number_t number,
                                                unicoap_block_option_t* block)
{
    return unicoap_options_get_uint24(options, number, block);
}

static inline int unicoap_options_set_block(unicoap_options_t* options,
                                            unicoap_option_number_t number,
                                            unicoap_block_option_t block)
{
    assert(block <= UNICOAP_UINT24_MAX);
    return unicoap_options_set_uint(options, number, block);
}

static inline ssize_t unicoap_options_get_block1(const unicoap_options_t* options,
                                                 unicoap_block_option_t* block)
{
    return unicoap_options_get_block(options, UNICOAP_OPTION_BLOCK1, block);
}

static inline ssize_t unicoap_options_set_block1(unicoap_options_t* options,
                                                 unicoap_block_option_t block)
{
    return unicoap_options_set_block(options, UNICOAP_OPTION_BLOCK1, block);
}

static inline int unicoap_options_remove_block1(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_BLOCK1);
}

static inline ssize_t unicoap_options_get_block2(const unicoap_options_t* options,
                                                 unicoap_block_option_t* block)
{
    return unicoap_options_get_block(options, UNICOAP_OPTION_BLOCK2, block);
}

static inline ssize_t unicoap_options_set_block2(unicoap_options_t* options,
                                                 unicoap_block_option_t block)
{
    return unicoap_options_set_block(options, UNICOAP_OPTION_BLOCK2, block);
}

static inline int unicoap_options_remove_block2(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_BLOCK2);
}

static inline ssize_t unicoap_options_get_size1(const unicoap_options_t* options, uint32_t* size)
{
    return unicoap_options_get_uint32(options, UNICOAP_OPTION_SIZE1, size);
}

static inline ssize_t unicoap_options_set_size1(unicoap_options_t* options, uint32_t size)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_SIZE1, size);
}

static inline int unicoap_options_remove_size1(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_SIZE1);
}

static inline ssize_t unicoap_options_get_size2(const unicoap_options_t* options, uint32_t* size)
{
    return unicoap_options_get_uint32(options, UNICOAP_OPTION_SIZE2, size);
}

static inline ssize_t unicoap_options_set_size2(unicoap_options_t* options, uint32_t size)
{
    return unicoap_options_set_uint(options, UNICOAP_OPTION_SIZE2, size);
}

static inline int unicoap_options_remove_size2(unicoap_options_t* options)
{
    return unicoap_options_remove(options, UNICOAP_OPTION_SIZE2);
}
 /* Block-wise Transfers */

 
#ifdef __cplusplus
}
#endif