coap.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Intel Corporation
 * Copyright (c) 2021 Nordic Semiconductor
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_COAP_H_
#define ZEPHYR_INCLUDE_NET_COAP_H_
 
#include <zephyr/types.h>
#include <stddef.h>
#include <stdbool.h>
#include <net/net_ip.h>
 
#include <sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum coap_option_num {
        COAP_OPTION_IF_MATCH = 1,
        COAP_OPTION_URI_HOST = 3,
        COAP_OPTION_ETAG = 4,
        COAP_OPTION_IF_NONE_MATCH = 5,
        COAP_OPTION_OBSERVE = 6,
        COAP_OPTION_URI_PORT = 7,
        COAP_OPTION_LOCATION_PATH = 8,
        COAP_OPTION_URI_PATH = 11,
        COAP_OPTION_CONTENT_FORMAT = 12,
        COAP_OPTION_MAX_AGE = 14,
        COAP_OPTION_URI_QUERY = 15,
        COAP_OPTION_ACCEPT = 17,
        COAP_OPTION_LOCATION_QUERY = 20,
        COAP_OPTION_BLOCK2 = 23,
        COAP_OPTION_BLOCK1 = 27,
        COAP_OPTION_SIZE2 = 28,
        COAP_OPTION_PROXY_URI = 35,
        COAP_OPTION_PROXY_SCHEME = 39,
        COAP_OPTION_SIZE1 = 60,
};
 
enum coap_method {
        COAP_METHOD_GET = 1,
        COAP_METHOD_POST = 2,
        COAP_METHOD_PUT = 3,
        COAP_METHOD_DELETE = 4,
};
 
#define COAP_REQUEST_MASK 0x07
 
#define COAP_VERSION_1 1U
 
enum coap_msgtype {
        COAP_TYPE_CON = 0,
        COAP_TYPE_NON_CON = 1,
        COAP_TYPE_ACK = 2,
        COAP_TYPE_RESET = 3
};
 
#define coap_make_response_code(class, det) ((class << 5) | (det))
 
enum coap_response_code {
        COAP_RESPONSE_CODE_OK = coap_make_response_code(2, 0),
        COAP_RESPONSE_CODE_CREATED = coap_make_response_code(2, 1),
        COAP_RESPONSE_CODE_DELETED = coap_make_response_code(2, 2),
        COAP_RESPONSE_CODE_VALID = coap_make_response_code(2, 3),
        COAP_RESPONSE_CODE_CHANGED = coap_make_response_code(2, 4),
        COAP_RESPONSE_CODE_CONTENT = coap_make_response_code(2, 5),
        COAP_RESPONSE_CODE_CONTINUE = coap_make_response_code(2, 31),
        COAP_RESPONSE_CODE_BAD_REQUEST = coap_make_response_code(4, 0),
        COAP_RESPONSE_CODE_UNAUTHORIZED = coap_make_response_code(4, 1),
        COAP_RESPONSE_CODE_BAD_OPTION = coap_make_response_code(4, 2),
        COAP_RESPONSE_CODE_FORBIDDEN = coap_make_response_code(4, 3),
        COAP_RESPONSE_CODE_NOT_FOUND = coap_make_response_code(4, 4),
        COAP_RESPONSE_CODE_NOT_ALLOWED = coap_make_response_code(4, 5),
        COAP_RESPONSE_CODE_NOT_ACCEPTABLE = coap_make_response_code(4, 6),
        COAP_RESPONSE_CODE_INCOMPLETE = coap_make_response_code(4, 8),
        COAP_RESPONSE_CODE_PRECONDITION_FAILED = coap_make_response_code(4, 12),
        COAP_RESPONSE_CODE_REQUEST_TOO_LARGE = coap_make_response_code(4, 13),
        COAP_RESPONSE_CODE_UNSUPPORTED_CONTENT_FORMAT =
                                                coap_make_response_code(4, 15),
        COAP_RESPONSE_CODE_INTERNAL_ERROR = coap_make_response_code(5, 0),
        COAP_RESPONSE_CODE_NOT_IMPLEMENTED = coap_make_response_code(5, 1),
        COAP_RESPONSE_CODE_BAD_GATEWAY = coap_make_response_code(5, 2),
        COAP_RESPONSE_CODE_SERVICE_UNAVAILABLE = coap_make_response_code(5, 3),
        COAP_RESPONSE_CODE_GATEWAY_TIMEOUT = coap_make_response_code(5, 4),
        COAP_RESPONSE_CODE_PROXYING_NOT_SUPPORTED =
                                                coap_make_response_code(5, 5)
};
 
#define COAP_CODE_EMPTY (0)
 
#define COAP_TOKEN_MAX_LEN 8UL
 
enum coap_content_format {
        COAP_CONTENT_FORMAT_TEXT_PLAIN = 0, /* charset=urf-8 */
        COAP_CONTENT_FORMAT_APP_LINK_FORMAT = 40,
        COAP_CONTENT_FORMAT_APP_XML = 41,
        COAP_CONTENT_FORMAT_APP_OCTET_STREAM = 42,
        COAP_CONTENT_FORMAT_APP_EXI = 47,
        COAP_CONTENT_FORMAT_APP_JSON = 50,
        COAP_CONTENT_FORMAT_APP_CBOR = 60,
};
 
/* block option helper */
#define GET_BLOCK_NUM(v)        ((v) >> 4)
#define GET_BLOCK_SIZE(v)       (((v) & 0x7))
#define GET_MORE(v)             (!!((v) & 0x08))
 
struct coap_observer;
struct coap_packet;
struct coap_pending;
struct coap_reply;
struct coap_resource;
 
typedef int (*coap_method_t)(struct coap_resource *resource,
                             struct coap_packet *request,
                             struct sockaddr *addr, socklen_t addr_len);
 
typedef void (*coap_notify_t)(struct coap_resource *resource,
                              struct coap_observer *observer);
 
struct coap_resource {
        coap_method_t get, post, put, del;
        coap_notify_t notify;
        const char * const *path;
        void *user_data;
        sys_slist_t observers;
        int age;
};
 
struct coap_observer {
        sys_snode_t list;
        struct sockaddr addr;
        uint8_t token[8];
        uint8_t tkl;
};
 
struct coap_packet {
        uint8_t *data; /* User allocated buffer */
        uint16_t offset; /* CoAP lib maintains offset while adding data */
        uint16_t max_len; /* Max CoAP packet data length */
        uint8_t hdr_len; /* CoAP header length */
        uint16_t opt_len; /* Total options length (delta + len + value) */
        uint16_t delta; /* Used for delta calculation in CoAP packet */
#if defined(CONFIG_COAP_KEEP_USER_DATA)
        void *user_data; /* Application specific user data */
#endif
};
 
struct coap_option {
        uint16_t delta;
#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[12];
#endif
};
 
typedef int (*coap_reply_t)(const struct coap_packet *response,
                            struct coap_reply *reply,
                            const struct sockaddr *from);
 
#define COAP_DEFAULT_MAX_RETRANSMIT 4
#define COAP_DEFAULT_ACK_RANDOM_FACTOR 1.5
 
struct coap_pending {
        struct sockaddr addr;
        uint32_t t0;
        uint32_t timeout;
        uint16_t id;
        uint8_t *data;
        uint16_t len;
        uint8_t retries;
};
 
struct coap_reply {
        coap_reply_t reply;
        void *user_data;
        int age;
        uint16_t id;
        uint8_t token[8];
        uint8_t tkl;
};
 
uint8_t coap_header_get_version(const struct coap_packet *cpkt);
 
uint8_t coap_header_get_type(const struct coap_packet *cpkt);
 
uint8_t coap_header_get_token(const struct coap_packet *cpkt, uint8_t *token);
 
uint8_t coap_header_get_code(const struct coap_packet *cpkt);
 
uint16_t coap_header_get_id(const struct coap_packet *cpkt);
 
const uint8_t *coap_packet_get_payload(const struct coap_packet *cpkt,
                                       uint16_t *len);
 
int coap_packet_parse(struct coap_packet *cpkt, uint8_t *data, uint16_t len,
                      struct coap_option *options, uint8_t opt_num);
 
int coap_packet_init(struct coap_packet *cpkt, uint8_t *data, uint16_t max_len,
                     uint8_t ver, uint8_t type, uint8_t token_len,
                     const uint8_t *token, uint8_t code, uint16_t id);
 
int coap_ack_init(struct coap_packet *cpkt, const struct coap_packet *req,
                  uint8_t *data, uint16_t max_len, uint8_t code);
 
uint8_t *coap_next_token(void);
 
uint16_t coap_next_id(void);
 
int coap_find_options(const struct coap_packet *cpkt, uint16_t code,
                      struct coap_option *options, uint16_t veclen);
 
int coap_packet_append_option(struct coap_packet *cpkt, uint16_t code,
                              const uint8_t *value, uint16_t len);
 
unsigned int coap_option_value_to_int(const struct coap_option *option);
 
int coap_append_option_int(struct coap_packet *cpkt, uint16_t code,
                           unsigned int val);
 
int coap_packet_append_payload_marker(struct coap_packet *cpkt);
 
int coap_packet_append_payload(struct coap_packet *cpkt, const uint8_t *payload,
                               uint16_t payload_len);
 
int coap_handle_request(struct coap_packet *cpkt,
                        struct coap_resource *resources,
                        struct coap_option *options,
                        uint8_t opt_num,
                        struct sockaddr *addr, socklen_t addr_len);
 
enum coap_block_size {
        COAP_BLOCK_16,
        COAP_BLOCK_32,
        COAP_BLOCK_64,
        COAP_BLOCK_128,
        COAP_BLOCK_256,
        COAP_BLOCK_512,
        COAP_BLOCK_1024,
};
 
static inline uint16_t coap_block_size_to_bytes(
        enum coap_block_size block_size)
{
        return (1 << (block_size + 4));
}
 
struct coap_block_context {
        size_t total_size;
        size_t current;
        enum coap_block_size block_size;
};
 
int coap_block_transfer_init(struct coap_block_context *ctx,
                             enum coap_block_size block_size,
                             size_t total_size);
 
int coap_append_block1_option(struct coap_packet *cpkt,
                              struct coap_block_context *ctx);
 
int coap_append_block2_option(struct coap_packet *cpkt,
                              struct coap_block_context *ctx);
 
int coap_append_size1_option(struct coap_packet *cpkt,
                             struct coap_block_context *ctx);
 
int coap_append_size2_option(struct coap_packet *cpkt,
                             struct coap_block_context *ctx);
 
int coap_get_option_int(const struct coap_packet *cpkt, uint16_t code);
 
int coap_update_from_block(const struct coap_packet *cpkt,
                           struct coap_block_context *ctx);
 
size_t coap_next_block(const struct coap_packet *cpkt,
                       struct coap_block_context *ctx);
 
void coap_observer_init(struct coap_observer *observer,
                        const struct coap_packet *request,
                        const struct sockaddr *addr);
 
bool coap_register_observer(struct coap_resource *resource,
                            struct coap_observer *observer);
 
void coap_remove_observer(struct coap_resource *resource,
                          struct coap_observer *observer);
 
struct coap_observer *coap_find_observer_by_addr(
        struct coap_observer *observers, size_t len,
        const struct sockaddr *addr);
 
struct coap_observer *coap_observer_next_unused(
        struct coap_observer *observers, size_t len);
 
void coap_reply_init(struct coap_reply *reply,
                     const struct coap_packet *request);
 
int coap_pending_init(struct coap_pending *pending,
                      const struct coap_packet *request,
                      const struct sockaddr *addr,
                      uint8_t retries);
 
struct coap_pending *coap_pending_next_unused(
        struct coap_pending *pendings, size_t len);
 
struct coap_reply *coap_reply_next_unused(
        struct coap_reply *replies, size_t len);
 
struct coap_pending *coap_pending_received(
        const struct coap_packet *response,
        struct coap_pending *pendings, size_t len);
 
struct coap_reply *coap_response_received(
        const struct coap_packet *response,
        const struct sockaddr *from,
        struct coap_reply *replies, size_t len);
 
struct coap_pending *coap_pending_next_to_expire(
        struct coap_pending *pendings, size_t len);
 
bool coap_pending_cycle(struct coap_pending *pending);
 
void coap_pending_clear(struct coap_pending *pending);
 
void coap_pendings_clear(struct coap_pending *pendings, size_t len);
 
void coap_reply_clear(struct coap_reply *reply);
 
void coap_replies_clear(struct coap_reply *replies, size_t len);
 
int coap_resource_notify(struct coap_resource *resource);
 
bool coap_request_is_observe(const struct coap_packet *request);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_COAP_H_ */