constants.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2025 Carl Seifert
 * Copyright (C) 2024-2025 TU Dresden
 * Copyright (C) 2018 Freie Universität Berlin
 *
 * 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 "macros/utils.h"
 
#include "net/unicoap/config.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* MARK: - CoAP PDUs */
typedef enum {
    UNICOAP_COAP_VERSION_1 = 1
} unicoap_protocol_version_t;
 
#define UNICOAP_PAYLOAD_MARKER           (0xFF)
 
#define UNICOAP_ETAG_LENGTH_MAX          (8)
 
#define UNICOAP_TOKEN_LENGTH_FIXED_WIDTH 4
/* MARK: - RFC 7252 message types */
#define UNICOAP_RFC7252_MESSAGE_TYPE_FIXED_WIDTH 3
 
typedef enum {
    UNICOAP_TYPE_CON = 0,
 
    UNICOAP_TYPE_NON = 1,
 
    UNICOAP_TYPE_ACK = 2,
 
    UNICOAP_TYPE_RST = 3
} __attribute__((__packed__)) unicoap_rfc7252_message_type_t;
/* MARK: - Message codes */
#define UNICOAP_CODE_EMPTY (0)
 
/* This function is needed by this header, yet public use is discouraged. */
#ifndef DOXYGEN
#  define UNICOAP_CODE(suffix, detail) ((CONCAT(UNICOAP_CODE_CLASS_, suffix) << 5) | detail)
#endif
 
typedef enum {
    UNICOAP_CODE_CLASS_REQUEST = 0,
 
    UNICOAP_CODE_CLASS_RESPONSE_SUCCESS = 2,
 
    UNICOAP_CODE_CLASS_RESPONSE_CLIENT_FAILURE = 4,
 
    UNICOAP_CODE_CLASS_RESPONSE_SERVER_FAILURE = 5,
 
    UNICOAP_CODE_CLASS_SIGNAL = 7,
} __attribute__((__packed__)) unicoap_code_class_t;
 
typedef enum {
    UNICOAP_METHOD_GET = 1,
 
    UNICOAP_METHOD_POST = 2,
 
    UNICOAP_METHOD_PUT = 3,
 
    UNICOAP_METHOD_DELETE = 4,
 
    UNICOAP_METHOD_FETCH = 5,
 
    UNICOAP_METHOD_PATCH = 6,
 
    UNICOAP_METHOD_IPATCH = 7,
} __attribute__((__packed__)) unicoap_method_t;
 
/* We want to allow casting the code field in the pdu to this enum.
 * This enum is used in a union in unicoap_message_t.
 * The static_asserts in this header guarantee usage of these enums is safe in a union
 * with an uint8_t code field. */
static_assert(sizeof(unicoap_method_t) == sizeof(uint8_t),
              "Method enum is too wide, please file an issue.");
 
typedef enum {
    UNICOAP_SIGNAL_CAPABILITIES_SETTINGS = 1,
 
    UNICOAP_SIGNAL_PING = 2,
 
    UNICOAP_SIGNAL_PONG = 3,
 
    UNICOAP_SIGNAL_RELEASE = 4,
 
    UNICOAP_SIGNAL_ABORT = 5,
} __attribute__((__packed__)) unicoap_signal_t;
 
static_assert(sizeof(unicoap_signal_t) == sizeof(uint8_t),
              "Signal enum is too wide, please file an issue.");
 
typedef enum {
    UNICOAP_STATUS_CREATED = UNICOAP_CODE(RESPONSE_SUCCESS, 1),
 
    UNICOAP_STATUS_DELETED = UNICOAP_CODE(RESPONSE_SUCCESS, 2),
 
    UNICOAP_STATUS_VALID = UNICOAP_CODE(RESPONSE_SUCCESS, 3),
 
    UNICOAP_STATUS_CHANGED = UNICOAP_CODE(RESPONSE_SUCCESS, 4),
 
    UNICOAP_STATUS_CONTENT = UNICOAP_CODE(RESPONSE_SUCCESS, 5),
 
    UNICOAP_STATUS_CONTINUE = UNICOAP_CODE(RESPONSE_SUCCESS, 31),
 
    UNICOAP_STATUS_BAD_REQUEST = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 0),
 
    UNICOAP_STATUS_UNAUTHORIZED = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 1),
 
    UNICOAP_STATUS_BAD_OPTION = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 2),
 
    UNICOAP_STATUS_FORBIDDEN = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 3),
 
    UNICOAP_STATUS_PATH_NOT_FOUND = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 4),
 
    UNICOAP_STATUS_METHOD_NOT_ALLOWED = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 5),
 
    UNICOAP_STATUS_NOT_ACCEPTABLE = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 6),
 
    UNICOAP_STATUS_REQUEST_ENTITY_INCOMPLETE = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 8),
 
    UNICOAP_STATUS_CONFLICT = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 9),
 
    UNICOAP_STATUS_PRECONDITION_FAILED = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 12),
 
    UNICOAP_STATUS_REQUEST_ENTITY_TOO_LARGE = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 13),
 
    UNICOAP_STATUS_UNSUPPORTED_CONTENT_FORMAT = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 15),
 
    UNICOAP_STATUS_UNPROCESSABLE_ENTITY = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 22),
 
    UNICOAP_STATUS_TOO_MANY_REQUESTS = UNICOAP_CODE(RESPONSE_CLIENT_FAILURE, 29),
 
    UNICOAP_STATUS_INTERNAL_SERVER_ERROR = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 0),
 
    UNICOAP_STATUS_NOT_IMPLEMENTED = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 1),
 
    UNICOAP_STATUS_BAD_GATEWAY = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 2),
 
    UNICOAP_STATUS_SERVICE_UNAVAILABLE = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 3),
 
    UNICOAP_STATUS_GATEWAY_TIMEOUT = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 4),
 
    UNICOAP_STATUS_PROXYING_NOT_SUPPORTED = UNICOAP_CODE(RESPONSE_SERVER_FAILURE, 5),
} __attribute__((__packed__)) unicoap_status_t;
 
static_assert(sizeof(unicoap_status_t) == sizeof(uint8_t),
              "Status enum is too wide, please file an issue.");
/* MARK: - Option numbers */
typedef enum {
    UNICOAP_OPTION_IF_MATCH = 1,
 
    UNICOAP_OPTION_URI_HOST = 3,
 
    UNICOAP_OPTION_ETAG = 4,
 
    UNICOAP_OPTION_IF_NONE_MATCH = 5,
 
    UNICOAP_OPTION_OBSERVE = 6,
 
    UNICOAP_OPTION_URI_PORT = 7,
 
    UNICOAP_OPTION_LOCATION_PATH = 8,
 
    UNICOAP_OPTION_OSCORE = 9,
 
    UNICOAP_OPTION_URI_PATH = 11,
 
    UNICOAP_OPTION_CONTENT_FORMAT = 12,
 
    UNICOAP_OPTION_MAX_AGE = 14,
 
    UNICOAP_OPTION_URI_QUERY = 15,
 
    UNICOAP_OPTION_HOP_LIMIT = 16,
 
    UNICOAP_OPTION_ACCEPT = 17,
 
    UNICOAP_OPTION_Q_BLOCK1 = 19,
 
    UNICOAP_OPTION_LOCATION_QUERY = 20,
 
    UNICOAP_OPTION_EDHOC = 21,
 
    UNICOAP_OPTION_BLOCK2 = 23,
 
    UNICOAP_OPTION_BLOCK1 = 27,
 
    UNICOAP_OPTION_SIZE2 = 28,
 
    UNICOAP_OPTION_Q_BLOCK2 = 31,
 
    UNICOAP_OPTION_PROXY_URI = 35,
 
    UNICOAP_OPTION_PROXY_SCHEME = 39,
 
    UNICOAP_OPTION_SIZE1 = 60,
 
    UNICOAP_OPTION_ECHO = 252,
 
    UNICOAP_OPTION_NO_RESPONSE = 258,
 
    UNICOAP_OPTION_REQUEST_TAG = 292,
 
    UNICOAP_SIGNALING_CSM_OPTION_MAX_MESSAGE_SIZE = 2,
 
    UNICOAP_SIGNALING_CSM_OPTION_BLOCKWISE_TRANSFER = 4,
 
    UNICOAP_SIGNALING_PING_PONG_OPTION_CUSTODY = 2,
 
    UNICOAP_SIGNALING_RELEASE_OPTION_ALTERNATIVE_ADDRESS = 2,
 
    UNICOAP_SIGNALING_RELEASE_OPTION_HOLD_OFF = 4,
 
    UNICOAP_SIGNALING_ABORT_OPTION_BAD_CSM = 2,
} __attribute__((__packed__)) unicoap_option_number_t;
 
static_assert(sizeof(unicoap_option_number_t) == sizeof(uint16_t),
              "unicoap_option_number_t has unexpected size");
/* MARK: - Content-Format values */
/* Please see the generator in iana/contenttype.js */
typedef enum {
    UNICOAP_FORMAT_TEXT = 0,
 
    UNICOAP_FORMAT_COSE_ENCRYPT0 = 16,
 
    UNICOAP_FORMAT_COSE_MAC0 = 17,
 
    UNICOAP_FORMAT_COSE_SIGN1 = 18,
 
    UNICOAP_FORMAT_ACE_CBOR = 19,
 
    UNICOAP_FORMAT_IMAGE_GIF = 21,
 
    UNICOAP_FORMAT_IMAGE_JPEG = 22,
 
    UNICOAP_FORMAT_IMAGE_PNG = 23,
 
    UNICOAP_FORMAT_LINK = 40,
 
    UNICOAP_FORMAT_XML = 41,
 
    UNICOAP_FORMAT_OCTET_STREAM = 42,
 
    UNICOAP_FORMAT_EXI = 47,
 
    UNICOAP_FORMAT_JSON = 50,
 
    UNICOAP_FORMAT_JSON_PATCH_JSON = 51,
 
    UNICOAP_FORMAT_MERGE_PATCH_JSON = 52,
 
    UNICOAP_FORMAT_CBOR = 60,
 
    UNICOAP_FORMAT_CWT = 61,
 
    UNICOAP_FORMAT_MULTIPART_CORE = 62,
 
    UNICOAP_FORMAT_CBOR_SEQ = 63,
 
    UNICOAP_FORMAT_EDHOC_CBOR_SEQ = 64,
 
    UNICOAP_FORMAT_CID_EDHOC_CBOR_SEQ = 65,
 
    UNICOAP_FORMAT_COSE_ENCRYPT = 96,
 
    UNICOAP_FORMAT_COSE_MAC = 97,
 
    UNICOAP_FORMAT_COSE_SIGN = 98,
 
    UNICOAP_FORMAT_COSE_KEY = 101,
 
    UNICOAP_FORMAT_COSE_KEY_SET = 102,
 
    UNICOAP_FORMAT_SENML_JSON = 110,
 
    UNICOAP_FORMAT_SENSML_JSON = 111,
 
    UNICOAP_FORMAT_SENML_CBOR = 112,
 
    UNICOAP_FORMAT_SENSML_CBOR = 113,
 
    UNICOAP_FORMAT_SENML_EXI = 114,
 
    UNICOAP_FORMAT_SENSML_EXI = 115,
 
    UNICOAP_FORMAT_YANG_DATA_CBOR_SID = 140,
 
    UNICOAP_FORMAT_COAP_GROUP_JSON = 256,
 
    UNICOAP_FORMAT_CONCISE_PROBLEM_DETAILS_CBOR = 257,
 
    UNICOAP_FORMAT_SWID_CBOR = 258,
 
    UNICOAP_FORMAT_PKIXCMP = 259,
 
    UNICOAP_FORMAT_YANG_SID_JSON = 260,
 
    UNICOAP_FORMAT_ACE_GROUPCOMM_CBOR = 261,
 
    UNICOAP_FORMAT_ACE_TRL_CBOR = 262,
 
    UNICOAP_FORMAT_EAT_CWT = 263,
 
    UNICOAP_FORMAT_EAT_JWT = 264,
 
    UNICOAP_FORMAT_EAT_BUN_CBOR = 265,
 
    UNICOAP_FORMAT_EAT_BUN_JSON = 266,
 
    UNICOAP_FORMAT_EAT_UCS_CBOR = 267,
 
    UNICOAP_FORMAT_EAT_UCS_JSON = 268,
 
    UNICOAP_FORMAT_COAP_EAP = 269,
 
    UNICOAP_FORMAT_DOTS_CBOR = 271,
 
    UNICOAP_FORMAT_MISSING_BLOCKS_CBOR_SEQ = 272,
 
    UNICOAP_FORMAT_PKCS7_MIME_SERVER_GENERATED_KEY = 280,
 
    UNICOAP_FORMAT_PKCS7_MIME_CERTS_ONLY = 281,
 
    UNICOAP_FORMAT_PKCS8 = 284,
 
    UNICOAP_FORMAT_CSRATTRS = 285,
 
    UNICOAP_FORMAT_PKCS10 = 286,
 
    UNICOAP_FORMAT_PKIX_CERT = 287,
 
    UNICOAP_FORMAT_AIF_CBOR = 290,
 
    UNICOAP_FORMAT_AIF_JSON = 291,
 
    UNICOAP_FORMAT_SENML_XML = 310,
 
    UNICOAP_FORMAT_SENSML_XML = 311,
 
    UNICOAP_FORMAT_SENML_ETCH_JSON = 320,
 
    UNICOAP_FORMAT_SENML_ETCH_CBOR = 322,
 
    UNICOAP_FORMAT_YANG_DATA_CBOR = 340,
 
    UNICOAP_FORMAT_YANG_DATA_CBOR_NAME = 341,
 
    UNICOAP_FORMAT_TD_JSON = 432,
 
    UNICOAP_FORMAT_TM_JSON = 433,
 
    UNICOAP_FORMAT_SDF_JSON = 434,
 
    UNICOAP_FORMAT_UCCS_CBOR = 601,
 
    UNICOAP_FORMAT_OCF_CBOR = 10000,
 
    UNICOAP_FORMAT_OSCORE = 10001,
 
    UNICOAP_FORMAT_JAVASCRIPT = 10002,
 
    UNICOAP_FORMAT_EAT_CWT_PSA_TFM = 10003,
 
    UNICOAP_FORMAT_EAT_CWT_PSA_LEGACY = 10004,
 
    UNICOAP_FORMAT_EAT_CWT_INTEL = 10005,
 
    UNICOAP_FORMAT_TOC_CBOR = 10570,
 
    UNICOAP_FORMAT_CE_CBOR = 10571,
 
    UNICOAP_FORMAT_TOC_CBOR_INTEL = 10572,
 
    UNICOAP_FORMAT_CE_CBOR_INTEL = 10573,
 
    UNICOAP_FORMAT_JSON_DEFLATE = 11050,
 
    UNICOAP_FORMAT_CBOR_DEFLATE = 11060,
 
    UNICOAP_FORMAT_OMA_LWM2M_TLV = 11542,
 
    UNICOAP_FORMAT_OMA_LWM2M_JSON = 11543,
 
    UNICOAP_FORMAT_OMA_LWM2M_CBOR = 11544,
 
    UNICOAP_FORMAT_TEXT_ZSTD = 12000,
 
    UNICOAP_FORMAT_XML_ZSTD = 12041,
 
    UNICOAP_FORMAT_JSON_ZSTD = 12050,
 
    UNICOAP_FORMAT_TEXT_CSS = 20000,
 
    UNICOAP_FORMAT_IMAGE_SVG_XML = 30000,
} __attribute__((__packed__)) unicoap_content_format_t;
#ifdef __cplusplus
}
#endif