coap_client_tcp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Nordic Semiconductor ASA
 * Copyright (c) 2026 Ellenby Technologies Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_NET_COAP_CLIENT_TCP_H_
#define ZEPHYR_INCLUDE_NET_COAP_CLIENT_TCP_H_


 
#include <zephyr/net/coap.h>
#include <zephyr/net/coap_client.h>
#include <zephyr/kernel.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define MAX_COAP_TCP_MSG_LEN (CONFIG_COAP_CLIENT_MESSAGE_HEADER_SIZE + \
                              CONFIG_COAP_CLIENT_MESSAGE_SIZE)

typedef void (*coap_client_tcp_response_cb_t)(const struct coap_client_response_data *data,
                                              void *user_data);

typedef int (*coap_client_tcp_payload_cb_t)(size_t offset, const uint8_t **payload,
                                            size_t *len, bool *last_block,
                                            void *user_data);

typedef int (*coap_client_tcp_socket_config_cb_t)(int fd, void *user_data);
 
/* Forward declaration for event callback */
struct coap_client_tcp;

enum coap_client_tcp_event {
        COAP_CLIENT_TCP_EVENT_CSM_UPDATED,
        COAP_CLIENT_TCP_EVENT_PONG_RECEIVED,
        COAP_CLIENT_TCP_EVENT_RELEASE,
        COAP_CLIENT_TCP_EVENT_ABORT,
};

union coap_client_tcp_event_data {
        struct {
                const char *alt_addr;
                uint32_t hold_off_sec;
        } release;
        struct {
                uint16_t bad_csm_option;
        } abort;
};

typedef void (*coap_client_tcp_event_cb_t)(
        struct coap_client_tcp *client,
        enum coap_client_tcp_event event,
        const union coap_client_tcp_event_data *data,
        void *user_data);

struct coap_client_tcp_option {
        uint16_t code;
#if defined(CONFIG_COAP_EXTENDED_OPTIONS_LEN)
        uint16_t len;
        uint8_t value[CONFIG_COAP_EXTENDED_OPTIONS_LEN_VALUE];
#else
        uint8_t len;
        uint8_t value[MAX_COAP_CLIENT_OPTION_LEN];
#endif
};

#define MAX_TCP_PATH_SIZE (CONFIG_COAP_CLIENT_MAX_PATH_LENGTH + 1)
#define MAX_TCP_EXTRA_OPTIONS CONFIG_COAP_CLIENT_MAX_EXTRA_OPTIONS

struct coap_client_tcp_request {
        enum coap_method method;                      
        char path[MAX_TCP_PATH_SIZE];                 
        enum coap_content_format fmt;                 
        const uint8_t *payload;                       
        size_t len;                                   
        coap_client_tcp_payload_cb_t payload_cb;      
        coap_client_tcp_response_cb_t cb;             
        struct coap_client_tcp_option
                options[MAX_TCP_EXTRA_OPTIONS];       
        uint8_t num_options;                          
        void *user_data;                              
};

struct coap_client_tcp_internal_request {
        uint8_t request_token[COAP_TOKEN_MAX_LEN];
        uint32_t offset;
        uint8_t request_tkl;
        bool request_ongoing;
        atomic_t in_callback;
        struct coap_block_context recv_blk_ctx;
        struct coap_block_context send_blk_ctx;
        struct coap_client_tcp_request coap_request;
        struct coap_packet request;
        uint8_t request_tag[COAP_TOKEN_MAX_LEN];
        uint8_t send_buf[MAX_COAP_TCP_MSG_LEN];
 
        /* TCP-specific timeout handling (no retransmission) */
        int64_t tcp_t0;
        uint32_t tcp_timeout_ms;
 
        /* For blockwise transfers */
        uint32_t last_payload_len;
 
        /* For GETs with observe option set */
        bool is_observe;
};
 
struct coap_client_tcp {
        int fd;
        struct k_mutex lock;
        uint8_t recv_buf[MAX_COAP_TCP_MSG_LEN];
        size_t recv_offset; /* Bytes received so far into recv_buf */
        struct coap_client_tcp_internal_request requests[CONFIG_COAP_CLIENT_MAX_REQUESTS];
        struct coap_option echo_option;
        bool send_echo;
 
        /* Max block/message size from CSM negotiation */
        uint32_t max_block_size;
 
        /* Blockwise transfer capability (negotiated via CSM BWT option) */
        bool blockwise_enabled;
 
        /* Ping/Pong tracking */
        bool ping_pending;
        int64_t ping_t0;
 
        /* Event callback for Release/Abort signals */
        coap_client_tcp_event_cb_t event_cb;
        void *event_cb_user_data;
 
        coap_client_tcp_socket_config_cb_t socket_config_cb;
        void *socket_config_cb_user_data;
};

int coap_client_tcp_init(struct coap_client_tcp *client, const char *info);

int coap_client_tcp_connect(struct coap_client_tcp *client,
                            const struct net_sockaddr *addr,
                            net_socklen_t addrlen, int proto);

int coap_client_tcp_close(struct coap_client_tcp *client);

int coap_client_tcp_req(struct coap_client_tcp *client,
                        struct coap_client_tcp_request *req);

int coap_client_tcp_csm_req(struct coap_client_tcp *client,
                            uint32_t max_block_size,
                            coap_client_tcp_response_cb_t cb,
                            void *user_data);

void coap_client_tcp_cancel_requests(struct coap_client_tcp *client);

void coap_client_tcp_cancel_and_reset_all(struct coap_client_tcp *client);

struct coap_client_tcp_option coap_client_tcp_option_initial_block2(struct coap_client_tcp *client);

bool coap_client_tcp_has_ongoing_exchange(struct coap_client_tcp *client);

int coap_client_tcp_ping(struct coap_client_tcp *client);

int coap_client_tcp_release(struct coap_client_tcp *client,
                            const char *alt_addr, uint32_t hold_off_sec);

void coap_client_tcp_set_event_cb(struct coap_client_tcp *client,
                                  coap_client_tcp_event_cb_t cb,
                                  void *user_data);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NET_COAP_CLIENT_TCP_H_ */