state.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 <stdlib.h>
#include "ztimer.h"
#include "random.h"
#include "event.h"
#include "container.h"
 
#include "net/unicoap/server.h"
 
#include "private/packet.h"
 
#ifdef __cplusplus
extern "C" {
#endif


 
/* MARK: - Event Scheduling */

typedef struct {
    event_t super;

    ztimer_t ztimer;
 
#if DEVELHELP || defined (DOXYGEN)
    const char* name;
#endif
} unicoap_scheduled_event_t;

static inline const char* unicoap_scheduled_event_name(unicoap_scheduled_event_t* event) {
    (void)event;
#if DEVELHELP
    return event->name;
#else
    return NULL;
#endif
}

static inline unicoap_scheduled_event_t* unicoap_scheduled_event_of_event(event_t* event) {
    return container_of(event, unicoap_scheduled_event_t, super);
}

#define UNICOAP_CLOCK ZTIMER_MSEC

typedef void (*unicoap_event_callback_t)(unicoap_scheduled_event_t* event);

void unicoap_event_schedule(unicoap_scheduled_event_t* event, unicoap_event_callback_t callback,
                            uint32_t duration, const char* name);

void unicoap_event_reschedule(unicoap_scheduled_event_t* event, uint32_t duration);
void unicoap_event_cancel(unicoap_scheduled_event_t* event);
 
/* MARK: - Common state */

#define UNICOAP_HAVE_MESSAGING_STATE \
    IS_USED(MODULE_UNICOAP_DRIVER_RFC7252_COMMON)
/* MARK: unicoap_driver_extension_point */

#define UNICOAP_HAVE_CLIENT_STATE \
    IS_USED(MODULE_UNICOAP_CLIENT) && CONFIG_UNICOAP_CLIENT_MEMOS_CAPACITY > 0

typedef struct {
    struct {
        unicoap_scheduled_event_t timeout;
    } exchange;

    union {
#if UNICOAP_HAVE_MESSAGING_STATE || defined(DOXYGEN)

        void* state;
#endif
    } messaging;

    unicoap_endpoint_t endpoint;
} unicoap_memo_t;

static inline void* unicoap_memo_messaging_state(unicoap_memo_t* memo) {
    (void)memo;
#if UNICOAP_HAVE_MESSAGING_STATE
    return memo->messaging.state;
#else
    return NULL;
#endif
}

static inline unicoap_memo_t* unicoap_memo_of_timeout(unicoap_scheduled_event_t* timeout) {
    return container_of(timeout, unicoap_memo_t, exchange.timeout);
}

static inline unicoap_memo_t* unicoap_memo_of_event(event_t* event) {
    return unicoap_memo_of_timeout(unicoap_scheduled_event_of_event(event));
}

 
/* MARK: - Layered notification system */
typedef int unicoap_layer_notification_t;

#define UNICOAP_LAYER_NOTIFICATION_ASYNC_FAILURE (~(~0U >> 1))

static inline int unicoap_layer_notification_async_failure_to_errno(unicoap_layer_notification_t type) {
    assert(type & UNICOAP_LAYER_NOTIFICATION_ASYNC_FAILURE);
    assert(type < 0);
    return type;
}

static inline unicoap_layer_notification_t unicoap_layer_notification_async_failure_from_errno(int error) {
    return -abs(error);
}

#define UNICOAP_LAYER_NOTIFICATION_STATE_RELEASE (0)

#define UNICOAP_LAYER_NOTIFICATION_STATE_ALLOC (1)

void unicoap_messaging_notify(void* state, unicoap_layer_notification_t type,
                              void* arg, unicoap_proto_t proto);

void unicoap_exchange_notify(void* state, unicoap_layer_notification_t type, void* arg);

void unicoap_exchange_notify_all(const unicoap_endpoint_t* endpoint, unicoap_layer_notification_t type, void* arg);
 
/* MARK: - Client state */
typedef union {
    unicoap_response_callback_t response;
    void* _any;
} unicoap_callback_t;

static inline bool unicoap_callback_is_present(const unicoap_callback_t callback) {
    /* Per ISO-C, union members all start at the same address, hence checking if
     the first member is NULL is fine as long as the second member also is a pointer.
     Both are function pointers. Global reasoning says we're fine here. */
    return callback._any != NULL;
}

typedef struct {
    unicoap_memo_t super;

    unicoap_callback_t callback;

    void* callback_arg;

    uint8_t token[CONFIG_UNICOAP_GENERATED_TOKEN_LENGTH];
 
#if IS_USED(MODULE_UNICOAP_CLIENT_CANCELLATION)
    uint16_t reference_id;
#endif

    unicoap_request_flags_t flags;
} unicoap_client_memo_t;

static inline unicoap_client_memo_t* unicoap_client_memo_of_super(unicoap_memo_t* memo) {
    return container_of(memo, unicoap_client_memo_t, super);
}

static inline unicoap_client_memo_t* unicoap_client_memo_of_event(event_t* event) {
    return unicoap_client_memo_of_super(unicoap_memo_of_event(event));
}

static inline unicoap_client_memo_t* unicoap_client_memo_of_timeout(unicoap_scheduled_event_t* timeout) {
    return unicoap_client_memo_of_super(unicoap_memo_of_timeout(timeout));
}

int unicoap_client_callback_success(unicoap_client_memo_t* memo, const unicoap_packet_t* packet,
                                    unicoap_block_option_t block);

void unicoap_client_callback_failure(unicoap_client_memo_t* memo, int error);

unicoap_client_memo_t* unicoap_client_memo_create(const unicoap_endpoint_t* endpoint);

unicoap_client_memo_t* unicoap_client_memo_find_token(const unicoap_endpoint_t* endpoint,
                                                  const uint8_t* token, size_t token_length);
 

unicoap_client_memo_t* unicoap_client_memo_find_refno(int refno);

int unicoap_client_memo_assign_refno(unicoap_client_memo_t* memo);

void unicoap_client_memo_free(unicoap_client_memo_t* memo, int error);
 
#ifdef __cplusplus
}
#endif