27#ifdef HAVE_SYS_UNISTD_H
28#include <sys/unistd.h>
31#ifdef HAVE_SYS_TYPES_H
34#ifdef HAVE_SYS_SOCKET_H
35#include <sys/socket.h>
37#ifdef HAVE_SYS_IOCTL_H
40#ifdef HAVE_NETINET_IN_H
41#include <netinet/in.h>
43#ifdef HAVE_ARPA_INET_H
49#ifdef COAP_EPOLL_SUPPORT
51#include <sys/timerfd.h>
64#include <lwip/timeouts.h>
65#include <lwip/tcpip.h>
68#ifndef INET6_ADDRSTRLEN
69#define INET6_ADDRSTRLEN 40
73#define min(a,b) ((a) < (b) ? (a) : (b))
89#error FRAC_BITS must be less or equal 8
93#define Q(frac,fval) ((uint16_t)(((1 << (frac)) * fval.integer_part) + \
94 ((1 << (frac)) * fval.fractional_part + 500)/1000))
97#define ACK_RANDOM_FACTOR \
98 Q(FRAC_BITS, session->ack_random_factor)
101#define ACK_TIMEOUT Q(FRAC_BITS, session->ack_timeout)
116#include <lwip/memp.h>
125 memp_free(MEMP_COAP_NODE, node);
131 unsigned int result = 0;
180 if (node->
t < q->
t) {
192 }
while (q && q->
t <= node->
t);
264 memset(node, 0,
sizeof(*node));
292#if COAP_CLIENT_SUPPORT
320#if COAP_SERVER_SUPPORT
368 memset(&setup_data, 0,
sizeof(setup_data));
374 if (key && key_len > 0) {
424 coap_log_err(
"coap_context_set_pki: Wrong version of setup_data\n");
437 const char *ca_dir) {
449 const char *ca_dir) {
463 size_t max_token_size) {
471 unsigned int max_idle_sessions) {
482 unsigned int max_handshake_sessions) {
495 unsigned int csm_timeout) {
508 unsigned int csm_timeout_ms) {
509 if (csm_timeout_ms < 10)
511 if (csm_timeout_ms > 10000)
512 csm_timeout_ms = 10000;
523 uint32_t csm_max_message_size) {
524 assert(csm_max_message_size >= 64);
535 unsigned int session_timeout) {
546#ifdef COAP_EPOLL_SUPPORT
547 return context->epfd;
557 context->
app = app_data;
570#if ! COAP_SERVER_SUPPORT
576 coap_log_warn(
"coap_startup() should be called before any other "
577 "coap_*() functions are called\n");
589#ifdef COAP_EPOLL_SUPPORT
590 c->epfd = epoll_create1(0);
592 coap_log_err(
"coap_new_context: Unable to epoll_create: %s (%d)\n",
598 c->eptimerfd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK);
599 if (c->eptimerfd == -1) {
600 coap_log_err(
"coap_new_context: Unable to timerfd_create: %s (%d)\n",
606 struct epoll_event event;
609 memset(&event, 0,
sizeof(event));
610 event.events = EPOLLIN;
612 event.data.ptr = NULL;
614 ret = epoll_ctl(c->epfd, EPOLL_CTL_ADD, c->eptimerfd, &event);
638#if COAP_SERVER_SUPPORT
641 if (endpoint == NULL) {
652#if defined(COAP_EPOLL_SUPPORT) || COAP_SERVER_SUPPORT
690#if COAP_SERVER_SUPPORT
699 if (context->timer_configured) {
701 sys_untimeout(coap_io_process_timeout, (
void *)context);
703 context->timer_configured = 0;
707#if COAP_ASYNC_SUPPORT
708 coap_delete_all_async(context);
711#if COAP_OSCORE_SUPPORT
715#if COAP_SERVER_SUPPORT
718 HASH_ITER(hh, context->
cache, cp, ctmp) {
727 LL_FOREACH_SAFE(context->
endpoint, ep, tmp) {
732#if COAP_CLIENT_SUPPORT
742#ifdef COAP_EPOLL_SUPPORT
743 if (context->eptimerfd != -1) {
745 struct epoll_event event;
748 ret = epoll_ctl(context->epfd, EPOLL_CTL_DEL, context->eptimerfd, &event);
754 close(context->eptimerfd);
755 context->eptimerfd = -1;
757 if (context->epfd != -1) {
758 close(context->epfd);
762#if COAP_SERVER_SUPPORT
763#if COAP_WITH_OBSERVE_PERSIST
784 if (opt_iter.
number & 0x01) {
786 switch (opt_iter.
number) {
787#if COAP_Q_BLOCK_SUPPORT
812#if COAP_OSCORE_SUPPORT
819#if COAP_SERVER_SUPPORT
820 if ((opt_iter.
number & 0x02) == 0) {
846 if (last_number == opt_iter.
number) {
862 unsigned char buf[4];
864 coap_log_debug(
"Option Block2 has invalid set M bit - cleared\n");
881 last_number = opt_iter.
number;
929 ssize_t bytes_written = -1;
937 return bytes_written;
942 ssize_t bytes_written;
945#if ! COAP_CLIENT_SUPPORT
957 coap_log_err(
"Multicast requests cannot be Confirmable (RFC7252 8.1)\n");
976 return bytes_written;
1051 unsigned int result;
1054#define FP1 Q(FRAC_BITS, ((coap_fixed_point_t){1,0}))
1057#define SHR_FP(val,frac) (((val) + (1 << ((frac) - 1))) >> (frac))
1102 coap_log_debug(
"** %s: mid=0x%04x: added to retransmit queue (%ums)\n",
1112#if COAP_CLIENT_SUPPORT
1132 if (token == NULL) {
1137 token->
s[i] = (uint8_t)(i + 1);
1154#if COAP_CLIENT_SUPPORT
1156 int timeout_ms = 5000;
1189 if (result < timeout_ms) {
1190 timeout_ms -= result;
1257#if COAP_CLIENT_SUPPORT
1261 int observe_action = -1;
1262 int have_block1 = 0;
1272 coap_log_err(
"coap_send: Invalid PDU code (%d.%02d)\n",
1278#if COAP_CLIENT_SUPPORT
1331#if COAP_OSCORE_SUPPORT
1332 if (session->oscore_encryption) {
1333 if (session->recipient_ctx->initial_state == 1) {
1363 (block.
m == 1 || block.
bert == 1)) {
1366#if COAP_Q_BLOCK_SUPPORT
1368 (block.
m == 1 || block.
bert == 1)) {
1370 coap_log_warn(
"Block1 and Q-Block1 cannot be in the same request\n");
1380 coap_log_debug(
"Token reused - see https://rfc-editor.org/rfc/rfc9175.html#section-4.2\n");
1390 coap_log_debug(
"coap_send: Using coap_cancel_observe() to do OBSERVE cancellation\n");
1411 memset(&block, 0,
sizeof(block));
1414#if COAP_Q_BLOCK_SUPPORT
1431#if COAP_Q_BLOCK_SUPPORT
1432 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK))
1442 (block.
num << 4) | (0 << 3) | block.
szx),
1448 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1456 (block.
num << 4) | (0 << 3) | block.
szx),
1466 (block.
num << 4) | (block.
m << 3) | block.
szx),
1472 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1492#if COAP_Q_BLOCK_SUPPORT
1495 if (block.
num == 0 && block.
m == 0) {
1501 (0 << 4) | (1 << 3) | block.
szx),
1513 if (observe_action != -1 || have_block1 ||
1514#
if COAP_OSCORE_SUPPORT
1515 session->oscore_encryption ||
1521 if (!session->
lg_xmit && have_block1) {
1526 LL_FOREACH(session->
lg_crcv, lg_crcv) {
1529 LL_DELETE(session->
lg_crcv, lg_crcv);
1535 if (have_block1 && session->
lg_xmit) {
1536 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1545 if (lg_crcv == NULL) {
1556#if COAP_Q_BLOCK_SUPPORT
1559 mid = coap_send_q_block1(session, block, pdu, COAP_SEND_INC_PDU);
1566#if COAP_CLIENT_SUPPORT
1569 LL_PREPEND(session->
lg_crcv, lg_crcv);
1585 ssize_t bytes_written;
1598 addr_str[
sizeof(addr_str)-1] =
'\000';
1600 sizeof(addr_str) - 1)) {
1604 if (addr_str[0] ==
'[') {
1605 cp = strchr(addr_str,
']');
1608 if (memcmp(&addr_str[1],
"::ffff:", 7) == 0) {
1615 cp = strchr(addr_str,
':');
1629 if (hop_limit == 1) {
1634 }
else if (hop_limit < 1 || hop_limit > 255) {
1636 coap_log_warn(
"Proxy return has bad hop limit count '%zu'\n",
1648 if (pdu->
data && opt == NULL) {
1661 pdu->
data[data_len] =
'\000';
1662 a_match = strstr((
char *)pdu->
data, cp);
1663 if (a_match && (a_match == (
char *)pdu->
data || a_match[-1] ==
' ') &&
1664 ((
size_t)(a_match - (
char *)pdu->
data + len) == data_len ||
1665 a_match[len] ==
' ')) {
1675 if (pdu->
data == NULL) {
1683 (uint8_t *)&hop_limit);
1687 memmove(pdu->
data + len + 1, pdu->
data,
1689 memcpy(pdu->
data, cp, len);
1690 pdu->
data[len] =
' ';
1698 if (session->
echo) {
1703 session->
echo = NULL;
1705#if COAP_OSCORE_SUPPORT
1706 if (session->oscore_encryption) {
1717#if !COAP_DISABLE_TCP
1728 coap_log_debug(
"Remote end did not indicate CSM support for Block1 enabled\n");
1731 coap_log_debug(
"Remote end did not indicate CSM support for Block2 enabled\n");
1738 coap_log_debug(
"Remote end did not indicate CSM support for BERT Block1\n");
1742 coap_log_debug(
"Remote end did not indicate CSM support for BERT Block2\n");
1748#if COAP_OSCORE_SUPPORT
1749 if (session->oscore_encryption &&
1755 if (osc_pdu == NULL) {
1770 if (bytes_written < 0) {
1774#if !COAP_DISABLE_TCP
1776 (
size_t)bytes_written < pdu->used_size + pdu->
hdr_size) {
1800 node->
id = pdu->
mid;
1813 if (!context || !node)
1818 ssize_t bytes_written;
1837 node->
t = next_delay;
1846 coap_log_debug(
"** %s: mid=0x%04x: mcast delayed transmission\n",
1849 coap_log_debug(
"** %s: mid=0x%04x: retransmission #%d (next %ums)\n",
1870 if (bytes_written < 0)
1871 return (
int)bytes_written;
1877 coap_log_warn(
"** %s: mid=0x%04x: give up after %d attempts\n",
1880#if COAP_SERVER_SUPPORT
1922#if COAP_SERVER_SUPPORT
1935#if COAP_CLIENT_SUPPORT
1961 ssize_t bytes_written;
1969 if (bytes_written > 0)
1971 if (bytes_written <= 0 ||
1973 if (bytes_written > 0)
1985#if COAP_CONSTRAINED_STACK
1995#if COAP_CONSTRAINED_STACK
2001 packet->
length =
sizeof(payload);
2009 if (bytes_read < 0) {
2010 if (bytes_read == -2)
2013 }
else if (bytes_read > 0) {
2018#if !COAP_DISABLE_TCP
2021 ssize_t bytes_read = 0;
2027 if (bytes_read < 0) {
2029 }
else if (bytes_read > 2) {
2036#if COAP_CONSTRAINED_STACK
2046#if COAP_CONSTRAINED_STACK
2052#if COAP_CONSTRAINED_STACK
2060 ssize_t bytes_read = 0;
2068 if (bytes_read > 0) {
2072 retry = bytes_read == (ssize_t)packet->
length;
2073 while (bytes_read > 0) {
2078 size_t n =
min(len, (
size_t)bytes_read);
2086#if COAP_CONSTRAINED_STACK
2090#if COAP_CONSTRAINED_STACK
2106 size_t len = hdr_size + tok_ext_bytes - session->
partial_read;
2107 size_t n =
min(len, (
size_t)bytes_read);
2113 hdr_size + tok_ext_bytes);
2114 if (size > COAP_DEFAULT_MAX_PDU_RX_SIZE) {
2115 coap_log_warn(
"** %s: incoming PDU length too large (%zu > %lu)\n",
2117 size, COAP_DEFAULT_MAX_PDU_RX_SIZE);
2138#if COAP_CONSTRAINED_STACK
2142#if COAP_CONSTRAINED_STACK
2164 }
while (bytes_read == 0 && retry);
2169#if COAP_CONSTRAINED_STACK
2174#if COAP_SERVER_SUPPORT
2177 ssize_t bytes_read = -1;
2179#if COAP_CONSTRAINED_STACK
2192#if COAP_CONSTRAINED_STACK
2198 packet->
length =
sizeof(payload);
2204 if (bytes_read < 0) {
2205 if (errno != EAGAIN) {
2208 }
else if (bytes_read > 0) {
2218#if COAP_CONSTRAINED_STACK
2232#if !COAP_DISABLE_TCP
2239 return session != NULL;
2253#ifdef COAP_EPOLL_SUPPORT
2256 coap_log_emerg(
"coap_io_do_io() requires libcoap not compiled for using epoll\n");
2261#if COAP_SERVER_SUPPORT
2263 LL_FOREACH_SAFE(ctx->
endpoint, ep, tmp) {
2265 coap_read_endpoint(ctx, ep, now);
2267 coap_write_endpoint(ctx, ep, now);
2268#if !COAP_DISABLE_TCP
2270 coap_accept_endpoint(ctx, ep, now, NULL);
2286#if COAP_CLIENT_SUPPORT
2318#ifndef COAP_EPOLL_SUPPORT
2322 coap_log_emerg(
"coap_io_do_epoll() requires libcoap compiled for using epoll\n");
2329 for (j = 0; j < nevents; j++) {
2334#if COAP_SERVER_SUPPORT
2338 (events[j].events & EPOLLIN)) {
2340 coap_read_endpoint(endpoint->
context, endpoint, now);
2344 (events[j].events & EPOLLOUT)) {
2351 coap_write_endpoint(endpoint->
context, endpoint, now);
2354#if !COAP_DISABLE_TCP
2356 (events[j].events & EPOLLIN)) {
2358 coap_accept_endpoint(endpoint->
context, endpoint, now, NULL);
2370#if COAP_CLIENT_SUPPORT
2372 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
2383 (events[j].events & (EPOLLIN|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
2389 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
2401 }
else if (ctx->eptimerfd != -1) {
2410 if (read(ctx->eptimerfd, &count,
sizeof(count)) == -1) {
2423 uint8_t *msg,
size_t msg_len) {
2437 coap_log_debug(
"coap_handle_dgram: UDP version not supported\n");
2471 if (!queue || !*queue)
2476 if (session == (*queue)->session &&
id == (*queue)->id) {
2478 *queue = (*queue)->
next;
2480 (*queue)->
t += (*node)->t;
2482 (*node)->next = NULL;
2493 }
while (q && (session != q->
session ||
id != q->
id));
2597#if COAP_ERROR_PHRASE_LENGTH > 0
2604 size += strlen(phrase) + 1;
2639 uint16_t delta = opt_iter.
number - opt_num;
2643 }
else if (delta < 269) {
2653 switch (*option & 0x0f) {
2664 opt_num = opt_iter.
number;
2686#if COAP_ERROR_PHRASE_LENGTH > 0
2689 coap_add_data(response, (
size_t)strlen(phrase), (
const uint8_t *)phrase);
2696#if COAP_SERVER_SUPPORT
2697#define SZX_TO_BYTES(SZX) ((size_t)(1 << ((SZX) + 4)))
2726 coap_log_warn(
"cannot determine length of /.well-known/core\n");
2741 assert(len <= (
size_t)wkc_len);
2742 data_string->
length = len;
2755 coap_log_debug(
".well-known/core: truncating data length to %zu from %zu\n",
2762 free_wellknown_response(session, data_string);
2766 -1, 0, data_string->
length,
2768 free_wellknown_response,
2770 goto error_released;
2783 free_wellknown_response(session, data_string);
2785 if (response->
code == 0) {
2789 response->
data = NULL;
2806 int num_cancelled = 0;
2808#ifndef COAP_SERVER_SUPPORT
2813#if COAP_SERVER_SUPPORT
2823 return num_cancelled;
2826#if COAP_SERVER_SUPPORT
2831enum respond_t { RESPONSE_DEFAULT, RESPONSE_DROP, RESPONSE_SEND };
2878static enum respond_t
2883 unsigned int val = 0;
2909 response->
data = NULL;
2910 return RESPONSE_SEND;
2912 return RESPONSE_DROP;
2916 return RESPONSE_SEND;
2921 if ((resource->
flags &
2924 return RESPONSE_DROP;
2925 }
else if ((resource->
flags &
2928 if (response->
data == NULL)
2929 return RESPONSE_DROP;
2930 }
else if ((resource->
flags &
2933 return RESPONSE_DROP;
2934 }
else if ((resource->
flags &
2937 return RESPONSE_DROP;
2944 return RESPONSE_DROP;
2955 return RESPONSE_DROP;
2959 return RESPONSE_DROP;
2965 return RESPONSE_DEFAULT;
2986 enum respond_t respond = RESPONSE_DEFAULT;
2989 int is_proxy_uri = 0;
2990 int is_proxy_scheme = 0;
2991 int skip_hop_limit_check = 0;
2993 int send_early_empty_ack = 0;
2999 int added_block = 0;
3001#if COAP_Q_BLOCK_SUPPORT
3002 int lg_xmit_ctrl = 0;
3004#if COAP_ASYNC_SUPPORT
3010 coap_log_info(
"Invalid multicast packet received RFC7252 8.1\n");
3014#if COAP_ASYNC_SUPPORT
3015 async = coap_find_async_lkd(session, pdu->
actual_token);
3020 if (async->delay == 0 || async->delay > now) {
3039 is_proxy_scheme = 1;
3046 if (is_proxy_scheme || is_proxy_uri) {
3052 is_proxy_scheme ?
"Scheme" :
"Uri");
3056 if (((
size_t)pdu->
code - 1 <
3061 is_proxy_scheme ?
"Scheme" :
"Uri",
3062 pdu->code/100, pdu->code%100);
3077 memset(&uri, 0,
sizeof(uri));
3111 is_proxy_scheme = 0;
3112 skip_hop_limit_check = 1;
3118 if (!skip_hop_limit_check) {
3126 if (hop_limit == 1) {
3130 }
else if (hop_limit < 1 || hop_limit > 255) {
3147 if (!is_proxy_uri && !is_proxy_scheme) {
3153 if ((resource == NULL) || (resource->
is_unknown == 1) ||
3158 if (resource != NULL)
3184 if (is_proxy_uri || is_proxy_scheme) {
3188 ((
size_t)pdu->
code - 1 <
3194 resource = &resource_uri_wellknown;
3196 ((
size_t)pdu->
code - 1 <
3231 coap_log_debug(
"request for unknown resource '%*.*s', return 4.04\n",
3239#if COAP_OSCORE_SUPPORT
3241 coap_log_debug(
"request for OSCORE only resource '%*.*s', return 4.04\n",
3257 if ((
size_t)pdu->
code - 1 <
3289#if COAP_ASYNC_SUPPORT
3324 resource, uri_path, observe,
3325 &added_block, &free_lg_srcv)) {
3333#if COAP_Q_BLOCK_SUPPORT
3349 if (block.
num != 0) {
3353#if COAP_Q_BLOCK_SUPPORT
3356 if (block.
num != 0) {
3376 coap_log_info(
"observe: unexpected action %d\n", observe_action);
3385 send_early_empty_ack = 1;
3387 if (send_early_empty_ack) {
3391 coap_log_debug(
"Duplicate request with mid=0x%04x - not processed\n",
3393 goto drop_it_no_debug;
3397#if COAP_WITH_OBSERVE_PERSIST
3400 context->unknown_pdu = pdu;
3401 context->unknown_session = session;
3403 context->unknown_pdu = NULL;
3409 if (resource == &resource_uri_wellknown) {
3414 h(resource, session, pdu, query, response);
3420 h(resource, session, pdu, query, response),
3427 coap_log_warn(
"handle_request: Invalid PDU response code (%d.%02d)\n",
3429 response->
code & 0x1f);
3430 goto drop_it_no_debug;
3442 LL_DELETE(session->
lg_srcv, free_lg_srcv);
3452 if (send_early_empty_ack &&
3457 if (response->
code == 0) {
3458 goto drop_it_no_debug;
3461 respond = no_response(pdu, response, session, resource);
3462 if (respond != RESPONSE_DROP) {
3463#if (COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG)
3483 && (response->
code == 0)) {
3488 response->
data = NULL;
3496#if COAP_Q_BLOCK_SUPPORT
3501 if (coap_send_q_block2(session, resource, query, pdu->
code, block,
3522 goto drop_it_no_debug;
3526 goto drop_it_no_debug;
3529 node->
id = response->
mid;
3530 node->
pdu = response;
3534 coap_log_debug(
" %s: mid=0x%04x: mcast response delayed for %u.%03u secs\n",
3540 node->
timeout = (
unsigned int)delay;
3554#if COAP_Q_BLOCK_SUPPORT
3570#if COAP_Q_BLOCK_SUPPORT || COAP_THREAD_SAFE
3587#if COAP_CLIENT_SUPPORT
3629 coap_log_debug(
"Extended Token requested size support not available\n");
3638#if COAP_Q_BLOCK_SUPPORT
3640 if (session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK &&
3702#if !COAP_DISABLE_TCP
3720 coap_log_warn(
"***%s: Increase timeout in coap_context_set_csm_timeout_ms() to > %d\n",
3791 coap_log_warn(
"coap_dispatch: cannot create error response\n");
3816 int packet_is_bad = 0;
3817#if COAP_OSCORE_SUPPORT
3821 int is_ext_token_rst;
3828 coap_log_info(
"coap_dispatch: Received invalid PDU code (%d.%02d)\n",
3842#if COAP_OSCORE_SUPPORT
3854 coap_log_warn(
"coap_dispatch: cannot create error response\n");
3868#if COAP_SERVER_SUPPORT
3877#if COAP_SERVER_SUPPORT
3883 memset(&uri, 0,
sizeof(uri));
3906 if (session->recipient_ctx == NULL ||
3907 session->recipient_ctx->initial_state == 0) {
3913 session->oscore_encryption = 1;
3922 switch (pdu->
type) {
3938#if COAP_SERVER_SUPPORT
3947 if (pdu->
code == 0) {
3948#if COAP_Q_BLOCK_SUPPORT
3959#if COAP_CLIENT_SUPPORT
3961 coap_send_q_block1(session, block, sent->
pdu,
3962 COAP_SEND_SKIP_PDU);
3965 coap_send_q_blocks(session, sent->
pdu->
lg_xmit, block,
3966 sent->
pdu, COAP_SEND_SKIP_PDU);
3993#if COAP_Q_BLOCK_SUPPORT
3995 if (session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK &&
4003 is_ext_token_rst = 0;
4010 is_ext_token_rst = 1;
4013 if (!is_ping_rst && !is_ext_token_rst)
4029 if (!is_ping_rst && !is_ext_token_rst) {
4036 }
else if (is_ping_rst) {
4045#if COAP_SERVER_SUPPORT
4049 LL_FOREACH_SAFE(r->subscribers, obs, tmp) {
4095 coap_log_warn(
"coap_dispatch: cannot create error response\n");
4115#if !COAP_DISABLE_TCP
4120#if COAP_SERVER_SUPPORT
4122 handle_request(context, session, pdu);
4125#if COAP_CLIENT_SUPPORT
4127 handle_response(context, session, sent ? sent->
pdu : NULL, pdu);
4161 if (packet_is_bad) {
4174#if COAP_OSCORE_SUPPORT
4179#if COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG
4184 return "COAP_EVENT_DTLS_CLOSED";
4186 return "COAP_EVENT_DTLS_CONNECTED";
4188 return "COAP_EVENT_DTLS_RENEGOTIATE";
4190 return "COAP_EVENT_DTLS_ERROR";
4192 return "COAP_EVENT_TCP_CONNECTED";
4194 return "COAP_EVENT_TCP_CLOSED";
4196 return "COAP_EVENT_TCP_FAILED";
4198 return "COAP_EVENT_SESSION_CONNECTED";
4200 return "COAP_EVENT_SESSION_CLOSED";
4202 return "COAP_EVENT_SESSION_FAILED";
4204 return "COAP_EVENT_PARTIAL_BLOCK";
4206 return "COAP_EVENT_XMIT_BLOCK_FAIL";
4208 return "COAP_EVENT_SERVER_SESSION_NEW";
4210 return "COAP_EVENT_SERVER_SESSION_DEL";
4212 return "COAP_EVENT_BAD_PACKET";
4214 return "COAP_EVENT_MSG_RETRANSMITTED";
4216 return "COAP_EVENT_OSCORE_DECRYPTION_FAILURE";
4218 return "COAP_EVENT_OSCORE_NOT_ENABLED";
4220 return "COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD";
4222 return "COAP_EVENT_OSCORE_NO_SECURITY";
4224 return "COAP_EVENT_OSCORE_INTERNAL_ERROR";
4226 return "COAP_EVENT_OSCORE_DECODE_ERROR";
4228 return "COAP_EVENT_WS_PACKET_SIZE";
4230 return "COAP_EVENT_WS_CONNECTED";
4232 return "COAP_EVENT_WS_CLOSED";
4234 return "COAP_EVENT_KEEPALIVE_FAILURE";
4284#if COAP_SERVER_SUPPORT
4287 LL_FOREACH(context->
endpoint, ep) {
4296#if COAP_CLIENT_SUPPORT
4306#if COAP_SERVER_SUPPORT
4307#if COAP_ASYNC_SUPPORT
4313 LL_FOREACH_SAFE(context->async_state, async, tmp) {
4314 if (async->delay != 0 && async->delay <= now) {
4316 handle_request(context, async->session, async->pdu);
4319 coap_free_async_lkd(async->session, async);
4321 if (next_due == 0 || next_due > async->delay - now)
4322 next_due = async->delay - now;
4332#if COAP_CONSTRAINED_STACK
4352#if COAP_CONSTRAINED_STACK
4361#if defined(HAVE_WINSOCK2_H)
4362 WORD wVersionRequested = MAKEWORD(2, 2);
4364 WSAStartup(wVersionRequested, &wsaData);
4373 coap_start_io_process();
4377#if COAP_SERVER_SUPPORT
4379 (
const uint8_t *)
".well-known/core"
4381 memset(&resource_uri_wellknown, 0,
sizeof(resource_uri_wellknown));
4384 resource_uri_wellknown.
uri_path = &well_known;
4390#if defined(HAVE_WINSOCK2_H)
4392#elif defined(WITH_CONTIKI)
4393 coap_stop_io_process();
4397#if COAP_CONSTRAINED_STACK
4412#if COAP_CLIENT_SUPPORT
4450#if ! defined WITH_CONTIKI && ! defined WITH_LWIP && ! defined RIOT_VERSION
4451#if COAP_SERVER_SUPPORT
4454 const char *ifname) {
4465 const char *ifname) {
4466#if COAP_IPV4_SUPPORT
4467 struct ip_mreq mreq4;
4469#if COAP_IPV6_SUPPORT
4470 struct ipv6_mreq mreq6;
4472 struct addrinfo *resmulti = NULL, hints, *ainfo;
4475 int mgroup_setup = 0;
4483#if COAP_IPV6_SUPPORT
4484 mreq6.ipv6mr_interface = 0;
4486#if COAP_IPV4_SUPPORT
4487 mreq4.imr_interface.s_addr = INADDR_ANY;
4490 memset(&hints, 0,
sizeof(hints));
4491 hints.ai_socktype = SOCK_DGRAM;
4494 result = getaddrinfo(group_name, NULL, &hints, &resmulti);
4498 "Cannot resolve multicast address: %s\n",
4499 group_name, gai_strerror(result));
4509#if defined(ESPIDF_VERSION)
4510 struct netif *netif;
4512#if COAP_IPV4_SUPPORT
4519 for (ainfo = resmulti; ainfo != NULL && !(done_ip4 == 1 && done_ip6 == 1);
4520 ainfo = ainfo->ai_next) {
4521 switch (ainfo->ai_family) {
4522#if COAP_IPV6_SUPPORT
4527#if defined(ESPIDF_VERSION)
4528 netif = netif_find(ifname);
4530 mreq6.ipv6mr_interface = netif_get_index(netif);
4533 "Cannot get IPv4 address: %s\n",
4536 memset(&ifr, 0,
sizeof(ifr));
4537 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
4538 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
4540#ifdef HAVE_IF_NAMETOINDEX
4541 mreq6.ipv6mr_interface = if_nametoindex(ifr.ifr_name);
4542 if (mreq6.ipv6mr_interface == 0) {
4544 "cannot get interface index for '%s'\n",
4547#elif defined(__QNXNTO__)
4552 "cannot get interface index for '%s': %s\n",
4556 mreq6.ipv6mr_interface = ifr.ifr_ifindex;
4562#if COAP_IPV4_SUPPORT
4567#if defined(ESPIDF_VERSION)
4568 netif = netif_find(ifname);
4570 mreq4.imr_interface.s_addr = netif_ip4_addr(netif)->addr;
4573 "Cannot get IPv4 address: %s\n",
4580 ip4fd = socket(AF_INET, SOCK_DGRAM, 0);
4582 coap_log_err(
"coap_join_mcast_group_intf: %s: socket: %s\n",
4586 memset(&ifr, 0,
sizeof(ifr));
4587 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
4588 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
4589 result = ioctl(ip4fd, SIOCGIFADDR, &ifr);
4592 "Cannot get IPv4 address: %s\n",
4596 mreq4.imr_interface = ((
struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
4610 for (ainfo = resmulti; ainfo != NULL; ainfo = ainfo->ai_next) {
4611 LL_FOREACH(ctx->
endpoint, endpoint) {
4617#if COAP_IPV6_SUPPORT
4618 if (ainfo->ai_family == AF_INET6) {
4625 mreq6.ipv6mr_interface =
4628 mreq6.ipv6mr_interface = 0;
4631 gaddr.
addr.
sin6.sin6_family = AF_INET6;
4633 gaddr.
addr.
sin6.sin6_addr = mreq6.ipv6mr_multiaddr =
4634 ((
struct sockaddr_in6 *)ainfo->ai_addr)->sin6_addr;
4635 result = setsockopt(endpoint->
sock.
fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
4636 (
char *)&mreq6,
sizeof(mreq6));
4639#if COAP_IPV4_SUPPORT && COAP_IPV6_SUPPORT
4642#if COAP_IPV4_SUPPORT
4643 if (ainfo->ai_family == AF_INET) {
4652 mreq4.imr_interface.s_addr = INADDR_ANY;
4655 gaddr.
addr.
sin.sin_family = AF_INET;
4657 gaddr.
addr.
sin.sin_addr.s_addr = mreq4.imr_multiaddr.s_addr =
4658 ((
struct sockaddr_in *)ainfo->ai_addr)->sin_addr.s_addr;
4659 result = setsockopt(endpoint->
sock.
fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4660 (
char *)&mreq4,
sizeof(mreq4));
4668 coap_log_err(
"coap_join_mcast_group_intf: %s: setsockopt: %s\n",
4673 addr_str[
sizeof(addr_str)-1] =
'\000';
4675 sizeof(addr_str) - 1)) {
4687 if (!mgroup_setup) {
4692 freeaddrinfo(resmulti);
4704#if COAP_CLIENT_SUPPORT
4709#if COAP_IPV4_SUPPORT
4711 if (setsockopt(session->
sock.
fd, IPPROTO_IP, IP_MULTICAST_TTL,
4712 (
const char *)&hops,
sizeof(hops)) < 0) {
4719#if COAP_IPV6_SUPPORT
4721 if (setsockopt(session->
sock.
fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
4722 (
const char *)&hops,
sizeof(hops)) < 0) {
void coap_address_init(coap_address_t *addr)
Resets the given coap_address_t object addr to its default values.
int coap_is_mcast(const coap_address_t *a)
Checks if given address a denotes a multicast address.
void coap_address_copy(coap_address_t *dst, const coap_address_t *src)
void coap_debug_reset(void)
Reset all the defined logging parameters.
struct coap_async_t coap_async_t
Async Entry information.
const char * coap_socket_strerror(void)
void coap_packet_get_memmapped(coap_packet_t *packet, unsigned char **address, size_t *length)
Given a packet, set msg and msg_len to an address and length of the packet's data in memory.
void coap_update_io_timer(coap_context_t *context, coap_tick_t delay)
Update when to continue with I/O processing, unless packets come in in the meantime.
#define COAP_RXBUFFER_SIZE
#define COAP_SOCKET_ERROR
@ COAP_NACK_NOT_DELIVERABLE
@ COAP_NACK_TOO_MANY_RETRIES
#define COAP_SOCKET_MULTICAST
socket is used for multicast communication
#define COAP_SOCKET_WANT_ACCEPT
non blocking server socket is waiting for accept
#define COAP_SOCKET_NOT_EMPTY
the socket is not empty
#define COAP_SOCKET_CAN_WRITE
non blocking socket can now write without blocking
#define COAP_SOCKET_BOUND
the socket is bound
#define COAP_SOCKET_WANT_READ
non blocking socket is waiting for reading
#define COAP_SOCKET_CAN_ACCEPT
non blocking server socket can now accept without blocking
#define COAP_SOCKET_WANT_WRITE
non blocking socket is waiting for writing
#define COAP_SOCKET_CAN_CONNECT
non blocking client socket can now connect without blocking
void coap_epoll_ctl_mod(coap_socket_t *sock, uint32_t events, const char *func)
Epoll specific function to modify the state of events that epoll is tracking on the appropriate file ...
#define COAP_SOCKET_WANT_CONNECT
non blocking client socket is waiting for connect
#define COAP_SOCKET_CAN_READ
non blocking socket can now read without blocking
#define COAP_SOCKET_CONNECTED
the socket is connected
Library specific build wrapper for coap_internal.h.
void coap_dump_memory_type_counts(coap_log_t level)
Dumps the current usage of malloc'd memory types.
void coap_memory_init(void)
Initializes libcoap's memory management.
void * coap_malloc_type(coap_memory_tag_t type, size_t size)
Allocates a chunk of size bytes and returns a pointer to the newly allocated memory.
void coap_free_type(coap_memory_tag_t type, void *p)
Releases the memory that was allocated by coap_malloc_type().
CoAP mutex mechanism wrapper.
#define coap_mutex_init(a)
#define coap_mutex_unlock(a)
#define coap_mutex_destroy(a)
#define coap_mutex_lock(a)
#define FRAC_BITS
The number of bits for the fractional part of ACK_TIMEOUT and ACK_RANDOM_FACTOR.
static ssize_t coap_send_pdu(coap_session_t *session, coap_pdu_t *pdu, coap_queue_t *node)
#define MAX_BITS
The maximum number of bits for fixed point integers that are used for retransmission time calculation...
#define ACK_TIMEOUT
creates a Qx.FRAC_BITS from session's 'ack_timeout'
static const char * coap_event_name(coap_event_t event)
static int coap_cancel(coap_context_t *context, const coap_queue_t *sent)
This function cancels outstanding messages for the session and token specified in sent.
static int coap_handle_dgram_for_proto(coap_context_t *ctx, coap_session_t *session, coap_packet_t *packet)
static void coap_write_session(coap_context_t *ctx, coap_session_t *session, coap_tick_t now)
COAP_STATIC_INLINE void coap_free_node(coap_queue_t *node)
#define SHR_FP(val, frac)
static void handle_signaling(coap_context_t *context, coap_session_t *session, coap_pdu_t *pdu)
static int check_token_size(coap_session_t *session, const coap_pdu_t *pdu)
static unsigned int s_csm_timeout
COAP_STATIC_INLINE coap_queue_t * coap_malloc_node(void)
#define ACK_RANDOM_FACTOR
creates a Qx.FRAC_BITS from session's 'ack_random_factor'
int coap_dtls_context_set_pki(coap_context_t *ctx COAP_UNUSED, const coap_dtls_pki_t *setup_data COAP_UNUSED, const coap_dtls_role_t role COAP_UNUSED)
int coap_dtls_receive(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
int coap_dtls_context_set_pki_root_cas(coap_context_t *ctx COAP_UNUSED, const char *ca_file COAP_UNUSED, const char *ca_path COAP_UNUSED)
void coap_dtls_free_context(void *handle COAP_UNUSED)
void * coap_dtls_new_context(coap_context_t *coap_context COAP_UNUSED)
uint16_t coap_option_num_t
uint8_t coap_opt_t
Use byte-oriented access methods here because sliding a complex struct coap_opt_t over the data buffe...
#define SESSIONS_ITER_SAFE(e, el, rtmp)
#define SESSIONS_ITER(e, el, rtmp)
#define coap_lock_callback_ret_release(r, c, func, failed)
#define coap_lock_callback_release(c, func, failed)
#define coap_lock_unlock(c)
#define coap_lock_lock(c, failed)
#define coap_lock_callback(c, func)
#define coap_lock_check_locked(c)
#define coap_lock_being_freed(c, failed)
#define coap_lock_init(c)
#define coap_lock_callback_ret(r, c, func)
void coap_io_do_epoll_lkd(coap_context_t *ctx, struct epoll_event *events, size_t nevents)
Process all the epoll events.
coap_mid_t coap_send_rst_lkd(coap_session_t *session, const coap_pdu_t *request)
Sends an RST message with code 0 for the specified request to dst.
coap_mid_t coap_send_message_type_lkd(coap_session_t *session, const coap_pdu_t *request, coap_pdu_type_t type)
Helper function to create and send a message with type (usually ACK or RST).
coap_mid_t coap_send_error_lkd(coap_session_t *session, const coap_pdu_t *request, coap_pdu_code_t code, coap_opt_filter_t *opts)
Sends an error response with code code for request request to dst.
void coap_io_do_io_lkd(coap_context_t *ctx, coap_tick_t now)
Processes any outstanding read, write, accept or connect I/O as indicated in the coap_socket_t struct...
int coap_io_process_lkd(coap_context_t *ctx, uint32_t timeout_ms)
The main I/O processing function.
unsigned int coap_io_prepare_epoll_lkd(coap_context_t *ctx, coap_tick_t now)
Any now timed out delayed packet is transmitted, along with any packets associated with requested obs...
coap_mid_t coap_send_lkd(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
coap_mid_t coap_send_ack_lkd(coap_session_t *session, const coap_pdu_t *request)
Sends an ACK message with code 0 for the specified request to dst.
COAP_API void coap_io_do_epoll(coap_context_t *ctx, struct epoll_event *events, size_t nevents)
Process all the epoll events.
COAP_API void coap_io_do_io(coap_context_t *ctx, coap_tick_t now)
Processes any outstanding read, write, accept or connect I/O as indicated in the coap_socket_t struct...
int coap_add_data_large_response_lkd(coap_resource_t *resource, coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_string_t *query, uint16_t media_type, int maxage, uint64_t etag, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr)
Associates given data with the response pdu that is passed as fourth parameter.
void coap_block_delete_lg_srcv(coap_session_t *session, coap_lg_srcv_t *lg_srcv)
void coap_block_delete_lg_crcv(coap_session_t *session, coap_lg_crcv_t *lg_crcv)
int coap_handle_response_get_block(coap_context_t *context, coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd, coap_recurse_t recursive)
void coap_check_code_lg_xmit(const coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_resource_t *resource, const coap_string_t *query)
The function checks that the code in a newly formed lg_xmit created by coap_add_data_large_response_l...
int coap_handle_response_send_block(coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd)
void coap_check_update_token(coap_session_t *session, coap_pdu_t *pdu)
The function checks if the token needs to be updated before PDU is presented to the application (only...
int coap_handle_request_put_block(coap_context_t *context, coap_session_t *session, coap_pdu_t *pdu, coap_pdu_t *response, coap_resource_t *resource, coap_string_t *uri_path, coap_opt_t *observe, int *added_block, coap_lg_srcv_t **free_lg_srcv)
coap_lg_crcv_t * coap_block_new_lg_crcv(coap_session_t *session, coap_pdu_t *pdu, coap_lg_xmit_t *lg_xmit)
int coap_handle_request_send_block(coap_session_t *session, coap_pdu_t *pdu, coap_pdu_t *response, coap_resource_t *resource, coap_string_t *query)
#define COAP_OPT_BLOCK_SZX(opt)
Returns the value of the SZX-field of a Block option opt.
#define COAP_BLOCK_TRY_Q_BLOCK
#define COAP_BLOCK_SINGLE_BODY
int coap_get_block_b(const coap_session_t *session, const coap_pdu_t *pdu, coap_option_num_t number, coap_block_b_t *block)
Initializes block from pdu.
#define COAP_BLOCK_NO_PREEMPTIVE_RTAG
#define COAP_BLOCK_USE_LIBCOAP
void coap_delete_cache_entry(coap_context_t *context, coap_cache_entry_t *cache_entry)
Remove a cache-entry from the hash list and free off all the appropriate contents apart from app_data...
int64_t coap_tick_diff_t
This data type is used to represent the difference between two clock_tick_t values.
void coap_clock_init(void)
Initializes the internal clock.
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
#define COAP_TICKS_PER_SECOND
Use ms resolution on POSIX systems.
uint64_t coap_ticks_to_rt_us(coap_tick_t t)
Helper function that converts coap ticks to POSIX wallclock time in us.
int coap_prng(void *buf, size_t len)
Fills buf with len random bytes using the default pseudo random number generator.
void coap_prng_init(unsigned int seed)
Seeds the default random number generation function with the given seed.
void coap_delete_all_resources(coap_context_t *context)
Deletes all resources from given context and frees their storage.
coap_print_status_t coap_print_wellknown_lkd(coap_context_t *context, unsigned char *buf, size_t *buflen, size_t offset, const coap_string_t *query_filter)
Prints the names of all known resources for context to buf.
coap_resource_t * coap_get_resource_from_uri_path_lkd(coap_context_t *context, coap_str_const_t *uri_path)
Returns the resource identified by the unique string uri_path.
#define RESOURCES_ITER(r, tmp)
#define COAP_RESOURCE_HANDLE_WELLKNOWN_CORE
Define this when invoking coap_resource_unknown_init2() if .well-known/core is to be passed to the un...
#define COAP_RESOURCE_FLAGS_HAS_MCAST_SUPPORT
This resource has support for multicast requests.
#define COAP_RESOURCE_FLAGS_LIB_DIS_MCAST_SUPPRESS_4_XX
Disable libcoap library suppressing 4.xx multicast responses (overridden by RFC7969 No-Response optio...
#define COAP_RESOURCE_FLAGS_LIB_DIS_MCAST_DELAYS
Disable libcoap library from adding in delays to multicast requests before releasing the response bac...
void(* coap_method_handler_t)(coap_resource_t *resource, coap_session_t *session, const coap_pdu_t *request, const coap_string_t *query, coap_pdu_t *response)
Definition of message handler function.
#define COAP_RESOURCE_FLAGS_OSCORE_ONLY
Define this resource as an OSCORE enabled access only.
#define COAP_RESOURCE_FLAGS_LIB_DIS_MCAST_SUPPRESS_5_XX
Disable libcoap library suppressing 5.xx multicast responses (overridden by RFC7969 No-Response optio...
uint32_t coap_print_status_t
Status word to encode the result of conditional print or copy operations such as coap_print_link().
#define COAP_PRINT_STATUS_ERROR
#define COAP_RESOURCE_FLAGS_FORCE_SINGLE_BODY
Force all large traffic to this resource to be presented as a single body to the request handler.
#define COAP_RESOURCE_FLAGS_LIB_ENA_MCAST_SUPPRESS_2_05
Enable libcoap library suppression of 205 multicast responses that are empty (overridden by RFC7969 N...
#define COAP_RESOURCE_FLAGS_LIB_ENA_MCAST_SUPPRESS_2_XX
Enable libcoap library suppressing 2.xx multicast responses (overridden by RFC7969 No-Response option...
void coap_register_option_lkd(coap_context_t *ctx, uint16_t type)
Registers the option type type with the given context object ctx.
int coap_handle_event_lkd(coap_context_t *context, coap_event_t event, coap_session_t *session)
Invokes the event handler of context for the given event and data.
uint16_t coap_new_message_id_lkd(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
unsigned int coap_adjust_basetime(coap_context_t *ctx, coap_tick_t now)
Set sendqueue_basetime in the given context object ctx to now.
int coap_delete_node_lkd(coap_queue_t *node)
Destroys specified node.
void coap_delete_all(coap_queue_t *queue)
Removes all items from given queue and frees the allocated storage.
int coap_context_set_psk2_lkd(coap_context_t *context, coap_dtls_spsk_t *setup_data)
Set the context's default PSK hint and/or key for a server.
int coap_remove_from_queue(coap_queue_t **queue, coap_session_t *session, coap_mid_t id, coap_queue_t **node)
This function removes the element with given id from the list given list.
coap_queue_t * coap_peek_next(coap_context_t *context)
Returns the next pdu to send without removing from sendqeue.
COAP_API int coap_delete_node(coap_queue_t *node)
Destroys specified node.
int coap_client_delay_first(coap_session_t *session)
Delay the sending of the first client request until some other negotiation has completed.
int coap_context_set_psk_lkd(coap_context_t *context, const char *hint, const uint8_t *key, size_t key_len)
Set the context's default PSK hint and/or key for a server.
coap_queue_t * coap_pop_next(coap_context_t *context)
Returns the next pdu to send and removes it from the sendqeue.
void coap_dispatch(coap_context_t *context, coap_session_t *session, coap_pdu_t *pdu)
Dispatches the PDUs from the receive queue in given context.
coap_mid_t coap_send_internal(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
int coap_insert_node(coap_queue_t **queue, coap_queue_t *node)
Adds node to given queue, ordered by variable t in node.
unsigned int coap_calc_timeout(coap_session_t *session, unsigned char r)
Calculates the initial timeout based on the session CoAP transmission parameters 'ack_timeout',...
int coap_join_mcast_group_intf_lkd(coap_context_t *ctx, const char *groupname, const char *ifname)
Function interface for joining a multicast group for listening for the currently defined endpoints th...
void coap_free_context_lkd(coap_context_t *context)
CoAP stack context must be released with coap_free_context_lkd().
int coap_can_exit_lkd(coap_context_t *context)
Returns 1 if there are no messages to send or to dispatch in the context's queues.
coap_mid_t coap_retransmit(coap_context_t *context, coap_queue_t *node)
Handles retransmissions of confirmable messages.
int coap_check_code_class(coap_session_t *session, coap_pdu_t *pdu)
Check whether the pdu contains a valid code class.
int coap_context_set_pki_root_cas_lkd(coap_context_t *ctx, const char *ca_file, const char *ca_dir)
Set the context's default Root CA information for a client or server.
int coap_option_check_critical(coap_session_t *session, coap_pdu_t *pdu, coap_opt_filter_t *unknown)
Verifies that pdu contains no unknown critical options.
coap_mid_t coap_wait_ack(coap_context_t *context, coap_session_t *session, coap_queue_t *node)
coap_queue_t * coap_new_node(void)
Creates a new node suitable for adding to the CoAP sendqueue.
void coap_cancel_session_messages(coap_context_t *context, coap_session_t *session, coap_nack_reason_t reason)
Cancels all outstanding messages for session session.
int coap_context_set_pki_lkd(coap_context_t *context, const coap_dtls_pki_t *setup_data)
Set the context's default PKI information for a server.
int coap_handle_dgram(coap_context_t *ctx, coap_session_t *session, uint8_t *msg, size_t msg_len)
Parses and interprets a CoAP datagram with context ctx.
void coap_cancel_all_messages(coap_context_t *context, coap_session_t *session, coap_bin_const_t *token)
Cancels all outstanding messages for session session that have the specified token.
void coap_context_set_session_timeout(coap_context_t *context, unsigned int session_timeout)
Set the session timeout value.
unsigned int coap_context_get_max_handshake_sessions(const coap_context_t *context)
Get the session timeout value.
COAP_API int coap_join_mcast_group_intf(coap_context_t *ctx, const char *groupname, const char *ifname)
Function interface for joining a multicast group for listening for the currently defined endpoints th...
void(* coap_pong_handler_t)(coap_session_t *session, const coap_pdu_t *received, const coap_mid_t mid)
Received Pong handler that is used as callback in coap_context_t.
unsigned int coap_context_get_max_idle_sessions(const coap_context_t *context)
Get the maximum idle sessions count.
coap_context_t * coap_new_context(const coap_address_t *listen_addr)
Creates a new coap_context_t object that will hold the CoAP stack status.
COAP_API coap_mid_t coap_send(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
COAP_API int coap_context_set_pki(coap_context_t *context, const coap_dtls_pki_t *setup_data)
Set the context's default PKI information for a server.
void coap_mcast_per_resource(coap_context_t *context)
Function interface to enable processing mcast requests on a per resource basis.
coap_response_t(* coap_response_handler_t)(coap_session_t *session, const coap_pdu_t *sent, const coap_pdu_t *received, const coap_mid_t mid)
Response handler that is used as callback in coap_context_t.
COAP_API coap_mid_t coap_send_error(coap_session_t *session, const coap_pdu_t *request, coap_pdu_code_t code, coap_opt_filter_t *opts)
Sends an error response with code code for request request to dst.
void coap_context_set_csm_max_message_size(coap_context_t *context, uint32_t csm_max_message_size)
Set the CSM max session size value.
void coap_context_set_csm_timeout(coap_context_t *context, unsigned int csm_timeout)
Set the CSM timeout value.
void coap_register_response_handler(coap_context_t *context, coap_response_handler_t handler)
Registers a new message handler that is called whenever a response is received.
coap_pdu_t * coap_new_error_response(const coap_pdu_t *request, coap_pdu_code_t code, coap_opt_filter_t *opts)
Creates a new ACK PDU with specified error code.
void coap_context_set_max_handshake_sessions(coap_context_t *context, unsigned int max_handshake_sessions)
Set the maximum number of sessions in (D)TLS handshake value.
int coap_context_get_coap_fd(const coap_context_t *context)
Get the libcoap internal file descriptor for using in an application's select() or returned as an eve...
int coap_mcast_set_hops(coap_session_t *session, size_t hops)
Function interface for defining the hop count (ttl) for sending multicast traffic.
void coap_context_set_app_data(coap_context_t *context, void *app_data)
Stores data with the given context.
void(* coap_ping_handler_t)(coap_session_t *session, const coap_pdu_t *received, const coap_mid_t mid)
Received Ping handler that is used as callback in coap_context_t.
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
COAP_API void coap_free_context(coap_context_t *context)
CoAP stack context must be released with coap_free_context().
void(* coap_nack_handler_t)(coap_session_t *session, const coap_pdu_t *sent, const coap_nack_reason_t reason, const coap_mid_t mid)
Negative Acknowedge handler that is used as callback in coap_context_t.
void * coap_context_get_app_data(const coap_context_t *context)
Returns any application-specific data that has been stored with context using the function coap_conte...
COAP_API int coap_context_set_pki_root_cas(coap_context_t *ctx, const char *ca_file, const char *ca_dir)
Set the context's default Root CA information for a client or server.
uint32_t coap_context_get_csm_max_message_size(const coap_context_t *context)
Get the CSM max session size value.
unsigned int coap_context_get_session_timeout(const coap_context_t *context)
Get the session timeout value.
COAP_API int coap_context_set_psk(coap_context_t *context, const char *hint, const uint8_t *key, size_t key_len)
Set the context's default PSK hint and/or key for a server.
COAP_API void coap_register_option(coap_context_t *ctx, uint16_t type)
Registers the option type type with the given context object ctx.
COAP_API coap_mid_t coap_send_ack(coap_session_t *session, const coap_pdu_t *request)
Sends an ACK message with code 0 for the specified request to dst.
unsigned int coap_context_get_csm_timeout_ms(const coap_context_t *context)
Get the CSM timeout value.
void coap_register_ping_handler(coap_context_t *context, coap_ping_handler_t handler)
Registers a new message handler that is called whenever a CoAP Ping message is received.
COAP_API int coap_context_set_psk2(coap_context_t *context, coap_dtls_spsk_t *setup_data)
Set the context's default PSK hint and/or key for a server.
void * coap_get_app_data(const coap_context_t *ctx)
void coap_context_set_max_idle_sessions(coap_context_t *context, unsigned int max_idle_sessions)
Set the maximum idle sessions count.
COAP_API coap_mid_t coap_send_message_type(coap_session_t *session, const coap_pdu_t *request, coap_pdu_type_t type)
Helper function to create and send a message with type (usually ACK or RST).
COAP_API coap_mid_t coap_send_rst(coap_session_t *session, const coap_pdu_t *request)
Sends an RST message with code 0 for the specified request to dst.
void coap_context_set_keepalive(coap_context_t *context, unsigned int seconds)
Set the context keepalive timer for sessions.
void coap_set_app_data(coap_context_t *ctx, void *app_data)
COAP_API int coap_can_exit(coap_context_t *context)
Returns 1 if there are no messages to send or to dispatch in the context's queues.
unsigned int coap_context_get_csm_timeout(const coap_context_t *context)
Get the CSM timeout value.
void coap_register_pong_handler(coap_context_t *context, coap_pong_handler_t handler)
Registers a new message handler that is called whenever a CoAP Pong message is received.
void coap_context_set_max_token_size(coap_context_t *context, size_t max_token_size)
Set the maximum token size (RFC8974).
COAP_API int coap_handle_event(coap_context_t *context, coap_event_t event, coap_session_t *session)
Invokes the event handler of context for the given event and data.
void coap_register_nack_handler(coap_context_t *context, coap_nack_handler_t handler)
Registers a new message handler that is called whenever a confirmable message (request or response) i...
void coap_context_set_csm_timeout_ms(coap_context_t *context, unsigned int csm_timeout_ms)
Set the CSM timeout value.
@ COAP_RESPONSE_FAIL
Response not liked - send CoAP RST packet.
@ COAP_RESPONSE_OK
Response is fine.
const coap_bin_const_t * coap_get_session_client_psk_identity(const coap_session_t *session)
Get the current client's PSK identity.
void coap_dtls_startup(void)
Initialize the underlying (D)TLS Library layer.
coap_session_t * coap_session_new_dtls_session(coap_session_t *session, coap_tick_t now)
Create a new DTLS session for the session.
int coap_dtls_hello(coap_session_t *coap_session, const uint8_t *data, size_t data_len)
Handling client HELLO messages from a new candiate peer.
int coap_dtls_context_set_spsk(coap_context_t *coap_context, coap_dtls_spsk_t *setup_data)
Set the DTLS context's default server PSK information.
void coap_dtls_shutdown(void)
Close down the underlying (D)TLS Library layer.
const coap_bin_const_t * coap_get_session_client_psk_key(const coap_session_t *coap_session)
Get the current client's PSK key.
const coap_bin_const_t * coap_get_session_server_psk_key(const coap_session_t *coap_session)
Get the current server's PSK key.
const coap_bin_const_t * coap_get_session_server_psk_hint(const coap_session_t *coap_session)
Get the current server's PSK identity hint.
int coap_tls_is_supported(void)
Check whether TLS is available.
#define COAP_DTLS_PKI_SETUP_VERSION
Latest PKI setup version.
int coap_dtls_is_supported(void)
Check whether DTLS is available.
@ COAP_DTLS_ROLE_SERVER
Internal function invoked for server.
unsigned int coap_encode_var_safe(uint8_t *buf, size_t length, unsigned int val)
Encodes multiple-length byte sequences.
unsigned int coap_decode_var_bytes(const uint8_t *buf, size_t len)
Decodes multiple-length byte sequences.
unsigned int coap_encode_var_safe8(uint8_t *buf, size_t length, uint64_t val)
Encodes multiple-length byte sequences.
coap_event_t
Scalar type to represent different events, e.g.
@ COAP_EVENT_OSCORE_DECODE_ERROR
Triggered when there is an OSCORE decode of OSCORE option failure.
@ COAP_EVENT_SESSION_CONNECTED
Triggered when TCP layer completes exchange of CSM information.
@ COAP_EVENT_OSCORE_INTERNAL_ERROR
Triggered when there is an OSCORE internal error i.e malloc failed.
@ COAP_EVENT_DTLS_CLOSED
Triggerred when (D)TLS session closed.
@ COAP_EVENT_TCP_FAILED
Triggered when TCP layer fails for some reason.
@ COAP_EVENT_WS_CONNECTED
Triggered when the WebSockets layer is up.
@ COAP_EVENT_DTLS_CONNECTED
Triggered when (D)TLS session connected.
@ COAP_EVENT_SESSION_FAILED
Triggered when TCP layer fails following exchange of CSM information.
@ COAP_EVENT_PARTIAL_BLOCK
Triggered when not all of a large body has been received.
@ COAP_EVENT_XMIT_BLOCK_FAIL
Triggered when not all of a large body has been transmitted.
@ COAP_EVENT_SERVER_SESSION_NEW
Called in the CoAP IO loop if a new server-side session is created due to an incoming connection.
@ COAP_EVENT_OSCORE_NOT_ENABLED
Triggered when trying to use OSCORE to decrypt, but it is not enabled.
@ COAP_EVENT_WS_CLOSED
Triggered when the WebSockets layer is closed.
@ COAP_EVENT_SESSION_CLOSED
Triggered when TCP layer closes following exchange of CSM information.
@ COAP_EVENT_SERVER_SESSION_DEL
Called in the CoAP IO loop if a server session is deleted (e.g., due to inactivity or because the max...
@ COAP_EVENT_OSCORE_NO_SECURITY
Triggered when there is no OSCORE security definition found.
@ COAP_EVENT_DTLS_RENEGOTIATE
Triggered when (D)TLS session renegotiated.
@ COAP_EVENT_BAD_PACKET
Triggered when badly formatted packet received.
@ COAP_EVENT_MSG_RETRANSMITTED
Triggered when a message is retransmitted.
@ COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD
Triggered when there is no OSCORE encrypted payload provided.
@ COAP_EVENT_TCP_CLOSED
Triggered when TCP layer is closed.
@ COAP_EVENT_WS_PACKET_SIZE
Triggered when there is an oversize WebSockets packet.
@ COAP_EVENT_TCP_CONNECTED
Triggered when TCP layer connects.
@ COAP_EVENT_OSCORE_DECRYPTION_FAILURE
Triggered when there is an OSCORE decryption failure.
@ COAP_EVENT_KEEPALIVE_FAILURE
Triggered when no response to a keep alive (ping) packet.
@ COAP_EVENT_DTLS_ERROR
Triggered when (D)TLS error occurs.
#define coap_log_debug(...)
#define coap_log_alert(...)
void coap_show_pdu(coap_log_t level, const coap_pdu_t *pdu)
Display the contents of the specified pdu.
#define coap_log_emerg(...)
size_t coap_print_addr(const coap_address_t *addr, unsigned char *buf, size_t len)
Print the address into the defined buffer.
const char * coap_endpoint_str(const coap_endpoint_t *endpoint)
Get endpoint description.
const char * coap_session_str(const coap_session_t *session)
Get session description.
#define coap_log_info(...)
#define coap_log_warn(...)
#define coap_log_err(...)
int coap_netif_strm_connect2(coap_session_t *session)
Layer function interface for Netif stream connect (tcp).
ssize_t coap_netif_dgrm_read(coap_session_t *session, coap_packet_t *packet)
Function interface for layer data datagram receiving for sessions.
ssize_t coap_netif_dgrm_read_ep(coap_endpoint_t *endpoint, coap_packet_t *packet)
Function interface for layer data datagram receiving for endpoints.
int coap_netif_available(coap_session_t *session)
Function interface to check whether netif for session is still available.
#define COAP_OBSERVE_CANCEL
The value COAP_OBSERVE_CANCEL in a GET/FETCH request option COAP_OPTION_OBSERVE indicates that the ob...
#define COAP_OBSERVE_ESTABLISH
The value COAP_OBSERVE_ESTABLISH in a GET/FETCH request option COAP_OPTION_OBSERVE indicates a new ob...
coap_opt_t * coap_option_next(coap_opt_iterator_t *oi)
Updates the iterator oi to point to the next option.
uint32_t coap_opt_length(const coap_opt_t *opt)
Returns the length of the given option.
coap_opt_iterator_t * coap_option_iterator_init(const coap_pdu_t *pdu, coap_opt_iterator_t *oi, const coap_opt_filter_t *filter)
Initializes the given option iterator oi to point to the beginning of the pdu's option list.
#define COAP_OPT_ALL
Pre-defined filter that includes all options.
int coap_option_filter_unset(coap_opt_filter_t *filter, coap_option_num_t option)
Clears the corresponding entry for number in filter.
void coap_option_filter_clear(coap_opt_filter_t *filter)
Clears filter filter.
coap_opt_t * coap_check_option(const coap_pdu_t *pdu, coap_option_num_t number, coap_opt_iterator_t *oi)
Retrieves the first option of number number from pdu.
const uint8_t * coap_opt_value(const coap_opt_t *opt)
Returns a pointer to the value of the given option.
int coap_option_filter_get(coap_opt_filter_t *filter, coap_option_num_t option)
Checks if number is contained in filter.
int coap_option_filter_set(coap_opt_filter_t *filter, coap_option_num_t option)
Sets the corresponding entry for number in filter.
coap_pdu_t * coap_oscore_new_pdu_encrypted_lkd(coap_session_t *session, coap_pdu_t *pdu, coap_bin_const_t *kid_context, oscore_partial_iv_t send_partial_iv)
Encrypts the specified pdu when OSCORE encryption is required on session.
struct coap_pdu_t * coap_oscore_decrypt_pdu(coap_session_t *session, coap_pdu_t *pdu)
Decrypts the OSCORE-encrypted parts of pdu when OSCORE is used.
int coap_rebuild_pdu_for_proxy(coap_pdu_t *pdu)
Convert PDU to use Proxy-Scheme option if Proxy-Uri option is present.
void coap_delete_all_oscore(coap_context_t *context)
Cleanup all allocated OSCORE information.
#define COAP_PDU_IS_RESPONSE(pdu)
#define COAP_TOKEN_EXT_2B_TKL
size_t coap_insert_option(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Inserts option of given number in the pdu with the appropriate data.
int coap_remove_option(coap_pdu_t *pdu, coap_option_num_t number)
Removes (first) option of given number from the pdu.
#define COAP_DROPPED_RESPONSE
Indicates that a response is suppressed.
int coap_pdu_parse_header(coap_pdu_t *pdu, coap_proto_t proto)
Decode the protocol specific header for the specified PDU.
size_t coap_pdu_parse_header_size(coap_proto_t proto, const uint8_t *data)
Interprets data to determine the number of bytes in the header.
#define COAP_PDU_IS_EMPTY(pdu)
#define COAP_PDU_IS_SIGNALING(pdu)
int coap_option_check_repeatable(coap_option_num_t number)
Check whether the option is allowed to be repeated or not.
int coap_pdu_parse_opt(coap_pdu_t *pdu)
Verify consistency in the given CoAP PDU structure and locate the data.
size_t coap_update_option(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Updates existing first option of given number in the pdu with the new data.
#define COAP_TOKEN_EXT_1B_TKL
size_t coap_pdu_encode_header(coap_pdu_t *pdu, coap_proto_t proto)
Compose the protocol specific header for the specified PDU.
#define COAP_DEFAULT_VERSION
size_t coap_pdu_parse_size(coap_proto_t proto, const uint8_t *data, size_t length)
Parses data to extract the message size.
int coap_pdu_resize(coap_pdu_t *pdu, size_t new_size)
Dynamically grows the size of pdu to new_size.
#define COAP_PDU_IS_REQUEST(pdu)
size_t coap_add_option_internal(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Adds option of given number to pdu that is passed as first parameter.
#define COAP_OPTION_HOP_LIMIT
#define COAP_OPTION_NORESPONSE
#define COAP_OPTION_URI_HOST
#define COAP_OPTION_IF_MATCH
#define COAP_OPTION_BLOCK2
const char * coap_response_phrase(unsigned char code)
Returns a human-readable response phrase for the specified CoAP response code.
#define COAP_OPTION_CONTENT_FORMAT
#define COAP_OPTION_BLOCK1
#define COAP_OPTION_Q_BLOCK1
#define COAP_OPTION_PROXY_SCHEME
#define COAP_OPTION_URI_QUERY
void coap_delete_pdu(coap_pdu_t *pdu)
Dispose of an CoAP PDU and frees associated storage.
int coap_mid_t
coap_mid_t is used to store the CoAP Message ID of a CoAP PDU.
#define COAP_TOKEN_DEFAULT_MAX
#define COAP_OPTION_IF_NONE_MATCH
#define COAP_TOKEN_EXT_MAX
#define COAP_OPTION_URI_PATH
#define COAP_SIGNALING_OPTION_EXTENDED_TOKEN_LENGTH
#define COAP_RESPONSE_CODE(N)
#define COAP_RESPONSE_CLASS(C)
coap_pdu_code_t
Set of codes available for a PDU.
#define COAP_OPTION_OSCORE
coap_pdu_type_t
CoAP PDU message type definitions.
#define COAP_SIGNALING_OPTION_BLOCK_WISE_TRANSFER
int coap_add_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds token of length len to pdu.
#define COAP_OPTION_Q_BLOCK2
#define COAP_SIGNALING_OPTION_CUSTODY
int coap_pdu_parse(coap_proto_t proto, const uint8_t *data, size_t length, coap_pdu_t *pdu)
Parses data into the CoAP PDU structure given in result.
#define COAP_OPTION_URI_PORT
coap_pdu_t * coap_pdu_init(coap_pdu_type_t type, coap_pdu_code_t code, coap_mid_t mid, size_t size)
Creates a new CoAP PDU with at least enough storage space for the given size maximum message size.
#define COAP_OPTION_ACCEPT
#define COAP_INVALID_MID
Indicates an invalid message id.
#define COAP_OPTION_PROXY_URI
#define COAP_OPTION_OBSERVE
#define COAP_DEFAULT_URI_WELLKNOWN
well-known resources URI
#define COAP_MEDIATYPE_APPLICATION_LINK_FORMAT
#define COAP_SIGNALING_OPTION_MAX_MESSAGE_SIZE
int coap_add_data(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds given data to the pdu that is passed as first parameter.
@ COAP_SIGNALING_CODE_ABORT
@ COAP_SIGNALING_CODE_CSM
@ COAP_SIGNALING_CODE_PING
@ COAP_REQUEST_CODE_DELETE
@ COAP_SIGNALING_CODE_PONG
@ COAP_SIGNALING_CODE_RELEASE
@ COAP_REQUEST_CODE_FETCH
void coap_connect_session(coap_session_t *session, coap_tick_t now)
ssize_t coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu, coap_queue_t *node)
#define COAP_DEFAULT_LEISURE_TICKS(s)
The DEFAULT_LEISURE definition for the session (s).
size_t coap_session_max_pdu_rcv_size(const coap_session_t *session)
Get maximum acceptable receive PDU size.
coap_session_t * coap_endpoint_get_session(coap_endpoint_t *endpoint, const coap_packet_t *packet, coap_tick_t now)
Lookup the server session for the packet received on an endpoint, or create a new one.
void coap_free_endpoint_lkd(coap_endpoint_t *endpoint)
Release an endpoint and all the structures associated with it.
void coap_read_session(coap_context_t *ctx, coap_session_t *session, coap_tick_t now)
#define COAP_MAX_PAYLOADS(s)
void coap_session_connected(coap_session_t *session)
Notify session that it has just connected or reconnected.
ssize_t coap_session_send_pdu(coap_session_t *session, coap_pdu_t *pdu)
Send a pdu according to the session's protocol.
size_t coap_session_max_pdu_size_lkd(const coap_session_t *session)
Get maximum acceptable PDU size.
void coap_session_release_lkd(coap_session_t *session)
Decrement reference counter on a session.
coap_session_t * coap_session_reference_lkd(coap_session_t *session)
Increment reference counter on a session.
void coap_session_disconnected_lkd(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
coap_endpoint_t * coap_new_endpoint_lkd(coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto)
Create a new endpoint for communicating with peers.
coap_session_t * coap_new_server_session(coap_context_t *ctx, coap_endpoint_t *ep, void *extra)
Creates a new server session for the specified endpoint.
@ COAP_EXT_T_NOT_CHECKED
Not checked.
@ COAP_EXT_T_CHECKING
Token size check request sent.
@ COAP_EXT_T_CHECKED
Token size valid.
void coap_session_set_mtu(coap_session_t *session, unsigned mtu)
Set the session MTU.
coap_session_state_t
coap_session_state_t values
#define COAP_PROTO_NOT_RELIABLE(p)
#define COAP_PROTO_RELIABLE(p)
@ COAP_SESSION_TYPE_HELLO
server-side ephemeral session for responding to a client hello
@ COAP_SESSION_TYPE_CLIENT
client-side
@ COAP_SESSION_STATE_ESTABLISHED
@ COAP_SESSION_STATE_NONE
void coap_delete_bin_const(coap_bin_const_t *s)
Deletes the given const binary data and releases any memory allocated.
coap_binary_t * coap_new_binary(size_t size)
Returns a new binary object with at least size bytes storage allocated.
coap_bin_const_t * coap_new_bin_const(const uint8_t *data, size_t size)
Take the specified byte array (text) and create a coap_bin_const_t * Returns a new const binary objec...
void coap_delete_binary(coap_binary_t *s)
Deletes the given coap_binary_t object and releases any memory allocated.
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
#define coap_string_equal(string1, string2)
Compares the two strings for equality.
coap_string_t * coap_new_string(size_t size)
Returns a new string object with at least size+1 bytes storage allocated.
void coap_delete_string(coap_string_t *s)
Deletes the given string and releases any memory allocated.
int coap_delete_observer_request(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token, coap_pdu_t *request)
Removes any subscription for session observer from resource and releases the allocated storage.
void coap_persist_cleanup(coap_context_t *context)
Close down persist tracking, releasing any memory used.
int coap_delete_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token)
Removes any subscription for session observer from resource and releases the allocated storage.
int coap_cancel_observe_lkd(coap_session_t *session, coap_binary_t *token, coap_pdu_type_t message_type)
Cancel an observe that is being tracked by the client large receive logic.
void coap_handle_failed_notify(coap_context_t *context, coap_session_t *session, const coap_bin_const_t *token)
Handles a failed observe notify.
coap_subscription_t * coap_add_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token, const coap_pdu_t *pdu)
Adds the specified peer as observer for resource.
void coap_touch_observer(coap_context_t *context, coap_session_t *session, const coap_bin_const_t *token)
Flags that data is ready to be sent to observers.
coap_string_t * coap_get_uri_path(const coap_pdu_t *request)
Extract uri_path string from request PDU.
int coap_split_proxy_uri(const uint8_t *str_var, size_t len, coap_uri_t *uri)
Parses a given string into URI components.
coap_string_t * coap_get_query(const coap_pdu_t *request)
Extract query string from request PDU according to escape rules in 6.5.8.
#define COAP_STATIC_INLINE
coap_address_t remote
remote address and port
coap_address_t local
local address and port
Multi-purpose address abstraction.
union coap_address_t::@0 addr
CoAP binary data definition with const data.
size_t length
length of binary data
const uint8_t * s
read-only binary data
CoAP binary data definition.
size_t length
length of binary data
Structure of Block options with BERT support.
unsigned int num
block number
unsigned int bert
Operating as BERT.
unsigned int aszx
block size (0-7 including BERT
unsigned int m
1 if more blocks follow, 0 otherwise
unsigned int szx
block size (0-6)
The CoAP stack's global state is stored in a coap_context_t object.
coap_tick_t sendqueue_basetime
The time stamp in the first element of the sendqeue is relative to sendqueue_basetime.
coap_pong_handler_t pong_handler
Called when a ping response is received.
void * app
application-specific data
coap_session_t * sessions
client sessions
coap_nack_handler_t nack_handler
Called when a response issue has occurred.
unsigned int ping_timeout
Minimum inactivity time before sending a ping message.
coap_resource_t * resources
hash table or list of known resources
uint16_t * cache_ignore_options
CoAP options to ignore when creating a cache-key.
coap_opt_filter_t known_options
coap_ping_handler_t ping_handler
Called when a CoAP ping is received.
uint32_t csm_max_message_size
Value for CSM Max-Message-Size.
size_t cache_ignore_count
The number of CoAP options to ignore when creating a cache-key.
unsigned int max_handshake_sessions
Maximum number of simultaneous negotating sessions per endpoint.
uint32_t max_token_size
Largest token size supported RFC8974.
coap_response_handler_t response_handler
Called when a response is received.
coap_cache_entry_t * cache
CoAP cache-entry cache.
uint8_t mcast_per_resource
Mcast controlled on a per resource basis.
coap_endpoint_t * endpoint
the endpoints used for listening
uint32_t csm_timeout_ms
Timeout for waiting for a CSM from the remote side.
coap_event_handler_t handle_event
Callback function that is used to signal events to the application.
unsigned int session_timeout
Number of seconds of inactivity after which an unused session will be closed.
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
coap_resource_t * proxy_uri_resource
can be used for handling proxy URI resources
coap_dtls_spsk_t spsk_setup_data
Contains the initial PSK server setup data.
coap_resource_t * unknown_resource
can be used for handling unknown resources
unsigned int max_idle_sessions
Maximum number of simultaneous unused sessions per endpoint.
coap_bin_const_t identity
coap_dtls_cpsk_info_t psk_info
Client PSK definition.
The structure used for defining the PKI setup data to be used.
The structure used for defining the Server PSK setup data to be used.
coap_dtls_spsk_info_t psk_info
Server PSK definition.
Abstraction of virtual endpoint that can be attached to coap_context_t.
coap_context_t * context
endpoint's context
coap_session_t * sessions
hash table or list of active sessions
coap_address_t bind_addr
local interface address
coap_socket_t sock
socket object for the interface, if any
coap_proto_t proto
protocol used on this interface
uint64_t state_token
state token
coap_binary_t * app_token
original PDU token
coap_layer_write_t l_write
coap_layer_establish_t l_establish
Structure to hold large body (many blocks) client receive information.
uint64_t state_token
state token
coap_binary_t * app_token
app requesting PDU token
Structure to hold large body (many blocks) server receive information.
Structure to hold large body (many blocks) transmission information.
union coap_lg_xmit_t::@1 b
coap_pdu_t pdu
skeletal PDU
uint16_t option
large block transmisson CoAP option
Iterator to run through PDU options.
coap_option_num_t number
decoded option number
size_t length
length of payload
coap_addr_tuple_t addr_info
local and remote addresses
unsigned char * payload
payload
uint8_t * token
first byte of token (or extended length bytes prefix), if any, or options
coap_lg_xmit_t * lg_xmit
Holds ptr to lg_xmit if sending a set of blocks.
size_t max_size
maximum size for token, options and payload, or zero for variable size pdu
coap_pdu_code_t code
request method (value 1–31) or response code (value 64-255)
uint8_t hdr_size
actual size used for protocol-specific header (0 until header is encoded)
coap_bin_const_t actual_token
Actual token in pdu.
uint8_t * data
first byte of payload, if any
coap_mid_t mid
message id, if any, in regular host byte order
uint32_t e_token_length
length of Token space (includes leading extended bytes
size_t used_size
used bytes of storage for token, options and payload
uint8_t crit_opt
Set if unknown critical option for proxy.
size_t alloc_size
allocated storage for token, options and payload
coap_session_t * session
Session responsible for PDU or NULL.
coap_pdu_type_t type
message type
coap_session_t * session
the CoAP session
coap_pdu_t * pdu
the CoAP PDU to send
unsigned int timeout
the randomized timeout value
uint8_t is_mcast
Set if this is a queued mcast response.
struct coap_queue_t * next
coap_mid_t id
CoAP message id.
coap_tick_t t
when to send PDU for the next time
unsigned char retransmit_cnt
retransmission counter, will be removed when zero
Abstraction of resource that can be attached to coap_context_t.
coap_str_const_t ** proxy_name_list
Array valid names this host is known by (proxy support)
coap_str_const_t * uri_path
Request URI Path for this resource.
unsigned int observe
The next value for the Observe option.
coap_method_handler_t handler[7]
Used to store handlers for the seven coap methods GET, POST, PUT, DELETE, FETCH, PATCH and IPATCH.
unsigned int is_proxy_uri
resource created for proxy URI handler
unsigned int is_unknown
resource created for unknown handler
unsigned int observable
can be observed
size_t proxy_name_count
Count of valid names this host is known by (proxy support)
int flags
zero or more COAP_RESOURCE_FLAGS_* or'd together
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
coap_lg_xmit_t * lg_xmit
list of large transmissions
volatile uint8_t max_token_checked
Check for max token size coap_ext_token_check_t.
uint8_t csm_not_seen
Set if timeout waiting for CSM.
coap_bin_const_t * psk_key
If client, this field contains the current pre-shared key for server; When this field is NULL,...
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
uint8_t doing_first
Set if doing client's first request.
uint8_t delay_recursive
Set if in coap_client_delay_first()
coap_socket_t sock
socket object for the session, if any
coap_pdu_t * partial_pdu
incomplete incoming pdu
uint32_t max_token_size
Largest token size supported RFC8974.
coap_bin_const_t * psk_identity
If client, this field contains the current identity for server; When this field is NULL,...
coap_session_state_t state
current state of relationship with peer
uint8_t csm_bert_rem_support
CSM TCP BERT blocks supported (remote)
coap_mid_t remote_test_mid
mid used for checking remote support
uint8_t read_header[8]
storage space for header of incoming message header
coap_addr_tuple_t addr_info
remote/local address info
coap_proto_t proto
protocol used
unsigned ref
reference count from queues
coap_response_t last_con_handler_res
The result of calling the response handler of the last CON.
coap_bin_const_t * psk_hint
If client, this field contains the server provided identity hint.
coap_bin_const_t * last_token
coap_dtls_cpsk_t cpsk_setup_data
client provided PSK initial setup data
size_t mtu
path or CSM mtu (xmt)
size_t partial_read
if > 0 indicates number of bytes already read for an incoming message
void * tls
security parameters
uint16_t max_retransmit
maximum re-transmit count (default 4)
uint8_t csm_block_supported
CSM TCP blocks supported.
uint8_t proxy_session
Set if this is an ongoing proxy session.
uint8_t con_active
Active CON request sent.
coap_queue_t * delayqueue
list of delayed messages waiting to be sent
uint32_t tx_rtag
Next Request-Tag number to use.
coap_mid_t last_ping_mid
the last keepalive message id that was used in this session
coap_lg_srcv_t * lg_srcv
Server list of expected large receives.
coap_lg_crcv_t * lg_crcv
Client list of expected large receives.
coap_mid_t last_con_mid
The last CON mid that has been been processed.
coap_session_type_t type
client or server side socket
coap_mid_t last_ack_mid
The last ACK mid that has been been processed.
coap_context_t * context
session's context
size_t partial_write
if > 0 indicates number of bytes already written from the pdu at the head of sendqueue
coap_bin_const_t * echo
last token used to make a request
coap_layer_func_t lfunc[COAP_LAYER_LAST]
Layer functions to use.
coap_session_t * session
Used to determine session owner.
coap_endpoint_t * endpoint
Used by the epoll logic for a listening endpoint.
coap_address_t mcast_addr
remote address and port (multicast track)
coap_socket_flags_t flags
1 or more of COAP_SOCKET* flag values
CoAP string data definition with const data.
const uint8_t * s
read-only string data
size_t length
length of string
CoAP string data definition.
size_t length
length of string
Number of notifications that may be sent non-confirmable before a confirmable message is sent to dete...
struct coap_session_t * session
subscriber session
coap_pdu_t * pdu
cache_key to identify requester
Representation of parsed URI.
coap_str_const_t host
The host part of the URI.