29#ifdef HAVE_SYS_UNISTD_H
30#include <sys/unistd.h>
33#ifdef HAVE_SYS_TYPES_H
36#ifdef HAVE_SYS_SOCKET_H
37#include <sys/socket.h>
39#ifdef HAVE_SYS_IOCTL_H
42#ifdef HAVE_NETINET_IN_H
43#include <netinet/in.h>
45#ifdef HAVE_ARPA_INET_H
51#ifdef COAP_EPOLL_SUPPORT
53#include <sys/timerfd.h>
67#include <lwip/timeouts.h>
68#include <lwip/tcpip.h>
71#ifndef INET6_ADDRSTRLEN
72#define INET6_ADDRSTRLEN 40
76#define min(a,b) ((a) < (b) ? (a) : (b))
92#error FRAC_BITS must be less or equal 8
96#define Q(frac,fval) ((uint16_t)(((1 << (frac)) * fval.integer_part) + \
97 ((1 << (frac)) * fval.fractional_part + 500)/1000))
100#define ACK_RANDOM_FACTOR \
101 Q(FRAC_BITS, session->ack_random_factor)
104#define ACK_TIMEOUT Q(FRAC_BITS, session->ack_timeout)
120 unsigned int result = 0;
169 if (node->
t < q->
t) {
181 }
while (q && q->
t <= node->
t);
244 memset(node, 0,
sizeof(*node));
272#if COAP_CLIENT_SUPPORT
300#if COAP_SERVER_SUPPORT
307 if (session->
context->spsk_setup_data.psk_info.key.length)
308 return &session->
context->spsk_setup_data.psk_info.key;
320 if (session->
context->spsk_setup_data.psk_info.hint.length)
321 return &session->
context->spsk_setup_data.psk_info.hint;
348 memset(&setup_data, 0,
sizeof(setup_data));
354 if (key && key_len > 0) {
378 ctx->spsk_setup_data = *setup_data;
381 return coap_dtls_context_set_spsk(ctx, setup_data);
404 coap_log_err(
"coap_context_set_pki: Wrong version of setup_data\n");
417 const char *ca_dir) {
429 const char *ca_dir) {
462#if COAP_CLIENT_SUPPORT
473 uint64_t rate_limit_ppm) {
474 if (rate_limit_ppm) {
483 size_t max_body_size) {
484 assert(max_body_size == 0 || max_body_size > 1024);
485 if (max_body_size == 0 || max_body_size > 1024) {
492 size_t max_bodies_ram) {
493#if COAP_SERVER_SUPPORT
494 assert(max_bodies_ram == 0 || max_bodies_ram > 1024);
495 if (max_bodies_ram == 0 || max_bodies_ram > 1024) {
496 context->max_bodies_ram = max_bodies_ram;
503 (void)max_bodies_ram;
509 size_t max_token_size) {
520 unsigned int max_idle_sessions) {
531 unsigned int max_handshake_sessions) {
544 unsigned int csm_timeout) {
557 unsigned int csm_timeout_ms) {
558 if (csm_timeout_ms < 10)
560 if (csm_timeout_ms > 10000)
561 csm_timeout_ms = 10000;
572 uint32_t csm_max_message_size) {
573 assert(csm_max_message_size >= 64);
577 csm_max_message_size);
590 unsigned int session_timeout) {
596 unsigned int reconnect_time) {
602 unsigned int reconnect_time,
603 uint8_t retry_count) {
604#if COAP_CLIENT_SUPPORT
605 context->reconnect_time = reconnect_time;
606 context->retry_count = retry_count;
609 (void)reconnect_time;
621#if COAP_SERVER_SUPPORT
622 context->shutdown_no_send_observe = 1;
630#if COAP_EPOLL_SUPPORT
631 return context->epfd;
640#if COAP_EPOLL_SUPPORT
676#if COAP_CLIENT_SUPPORT
685#if COAP_SERVER_SUPPORT
694#if COAP_AF_UNIX_SUPPORT
740#if ! COAP_SERVER_SUPPORT
746 coap_log_warn(
"coap_startup() should be called before any other "
747 "coap_*() functions are called\n");
758#ifdef COAP_EPOLL_SUPPORT
759 c->epfd = epoll_create1(0);
761 coap_log_err(
"coap_new_context: Unable to epoll_create: %s (%d)\n",
767 c->eptimerfd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK);
768 if (c->eptimerfd == -1) {
769 coap_log_err(
"coap_new_context: Unable to timerfd_create: %s (%d)\n",
775 struct epoll_event event;
778 memset(&event, 0,
sizeof(event));
779 event.events = EPOLLIN;
781 event.data.ptr =
NULL;
783 ret = epoll_ctl(c->epfd, EPOLL_CTL_ADD, c->eptimerfd, &event);
806#if COAP_SERVER_SUPPORT
809 if (endpoint ==
NULL) {
817#if defined(WITH_LWIP)
819 if (sys_sem_new(&c->coap_io_timeout_sem, 0) != ERR_OK)
820 coap_log_warn(
"coap_new_context: Failed to set up semaphore\n");
861#if COAP_SERVER_SUPPORT
863 context->context_going_away = 1;
864 if (context->shutdown_no_send_observe)
865 context->observe_no_clear = 1;
866 coap_delete_all_resources(context);
868#if COAP_CLIENT_SUPPORT
870 context->reconnect_time = 0;
877 if (context->timer_configured) {
879 sys_untimeout(coap_io_process_timeout, (
void *)context);
881 context->timer_configured = 0;
885#if COAP_ASYNC_SUPPORT
886 coap_delete_all_async(context);
889#if COAP_SERVER_SUPPORT
893 HASH_ITER(hh, context->cache, cp, ctmp) {
896 if (context->cache_ignore_count) {
900 LL_FOREACH_SAFE(context->endpoint, ep, tmp) {
901 coap_free_endpoint_lkd(ep);
905#if COAP_CLIENT_SUPPORT
913#if COAP_OSCORE_SUPPORT
919#ifdef COAP_EPOLL_SUPPORT
920 if (context->eptimerfd != -1) {
922 struct epoll_event event;
925 ret = epoll_ctl(context->epfd, EPOLL_CTL_DEL, context->eptimerfd, &event);
931 close(context->eptimerfd);
932 context->eptimerfd = -1;
934 if (context->epfd != -1) {
935 close(context->epfd);
939#if COAP_SERVER_SUPPORT
940#if COAP_WITH_OBSERVE_PERSIST
941 coap_persist_cleanup(context);
944#if COAP_PROXY_SUPPORT
945 coap_proxy_cleanup(context);
951#if defined(WITH_LWIP)
953 sys_sem_free(&context->coap_io_timeout_sem);
956#if COAP_THREAD_SAFE && !WITH_LWIP
965#if COAP_SERVER_SUPPORT
973 session->
context->unknown_resource->is_reverse_proxy) {
978 if (proxy_uri || proxy_scheme) {
991 memset(&uri, 0,
sizeof(uri));
1000 resource = session->
context->proxy_uri_resource;
1001 if (uri.
host.
length && resource->proxy_name_count &&
1002 resource->proxy_name_list) {
1005 if (resource->proxy_name_count == 1 &&
1006 resource->proxy_name_list[0]->length == 0) {
1010 for (i = 0; i < resource->proxy_name_count; i++) {
1016 if (i != resource->proxy_name_count) {
1048 switch (opt_iter.
number) {
1069 if (opt_iter.
number & 0x01) {
1071 switch (opt_iter.
number) {
1072#if COAP_Q_BLOCK_SUPPORT
1076 coap_log_debug(
"Critical option '%s' (%d) disabled - not supported\n",
1103#if COAP_OSCORE_SUPPORT
1105 if (ctx->p_osc_ctx || ctx->oscore_find_cb)
1111#if COAP_SERVER_SUPPORT
1112 if ((opt_iter.
number & 0x02) == 0) {
1135 if (opt_iter.
number & 0x02) {
1141 switch (opt_iter.
number) {
1156 coap_log_debug(
"Not Safe option %u cannot be forwarded - dropped\n",
1169 if (last_number == opt_iter.
number) {
1173 if (opt_iter.
number & 0x01) {
1186 pdu->
data -= opt_size;
1199 unsigned char buf[4];
1201 coap_log_debug(
"Option Block2 has invalid set M bit - cleared\n");
1218 last_number = opt_iter.
number;
1268 ssize_t bytes_written = -1;
1276 return bytes_written;
1281 ssize_t bytes_written;
1288#if ! COAP_CLIENT_SUPPORT
1300 coap_log_err(
"Multicast requests cannot be Confirmable (RFC7252 8.1)\n");
1319 return bytes_written;
1395 unsigned int result;
1398#define FP1 Q(FRAC_BITS, ((coap_fixed_point_t){1,0}))
1401#define SHR_FP(val,frac) (((val) + (1 << ((frac) - 1))) >> (frac))
1447 coap_log_debug(
"** %s: mid=0x%04x: added to retransmit queue (%ums)\n",
1457#if COAP_CLIENT_SUPPORT
1478 if (token ==
NULL) {
1483 token->
s[i] = (uint8_t)(i + 1);
1497 lg_crcv = coap_block_new_lg_crcv(session, pdu,
NULL);
1499 LL_PREPEND(session->lg_crcv, lg_crcv);
1515#if COAP_CLIENT_SUPPORT
1517 int timeout_ms = 5000;
1530 while (session->doing_first != 0) {
1549 if (result < timeout_ms) {
1550 timeout_ms -= result;
1552 if (session->doing_first == 1) {
1604#if COAP_CLIENT_SUPPORT
1619#
if COAP_OSCORE_SUPPORT
1620 session->oscore_encryption ||
1625#
if COAP_Q_BLOCK_SUPPORT
1648#if COAP_CLIENT_SUPPORT
1652 int observe_action = -1;
1653 int have_block1 = 0;
1663 coap_log_err(
"coap_send: Invalid PDU code (%d.%02d)\n",
1673#if COAP_CLIENT_SUPPORT
1680 if (session->doing_first) {
1681 unsigned int depth = 0;
1684 LL_FOREACH(session->doing_first_pdu, q_pdu)
1687 coap_log_warn(
"** %s: mid=0x%04x: doing_first queue full (%u) - dropped\n",
1691 LL_APPEND(session->doing_first_pdu, pdu);
1716 session->doing_first = 1;
1718 LL_PREPEND(session->doing_first_pdu, pdu);
1732#if COAP_Q_BLOCK_SUPPORT
1740 session->doing_first = 1;
1742 LL_PREPEND(session->doing_first_pdu, pdu);
1772#if COAP_OSCORE_SUPPORT
1773 if (session->oscore_encryption) {
1774 if (session->recipient_ctx->initial_state == 1 &&
1775 !session->recipient_ctx->silent_server) {
1787 session->doing_first = 1;
1807 const uint8_t *data;
1815 coap_log_debug(
"* Retransmitting PDU with Uri-Path-Abbrev replaced (3)\n");
1833 (block.
m == 1 || block.
bert == 1)) {
1836#if COAP_Q_BLOCK_SUPPORT
1838 (block.
m == 1 || block.
bert == 1)) {
1840 coap_log_warn(
"Block1 and Q-Block1 cannot be in the same request\n");
1855 scratch[0] =
'\000';
1857 size = strlen(scratch);
1858 snprintf(&scratch[size],
sizeof(scratch)-size,
1861 coap_log_debug(
"Token {%s} reused - see https://rfc-editor.org/rfc/rfc9175.html#section-4.2\n",
1873 coap_log_debug(
"coap_send: Using coap_cancel_observe() to do OBSERVE cancellation\n");
1877 ret = coap_cancel_observe_lkd(session, &tmp, pdu->
type);
1894 memset(&block, 0,
sizeof(block));
1897#if COAP_Q_BLOCK_SUPPORT
1898 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK))
1908 (block.
num << 4) | (0 << 3) | block.
szx),
1914 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1922 (block.
num << 4) | (0 << 3) | block.
szx),
1932 (block.
num << 4) | (block.
m << 3) | block.
szx),
1938 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1958#if COAP_Q_BLOCK_SUPPORT
1961 if (block.
num == 0 && block.
m == 0) {
1967 (0 << 4) | (1 << 3) | block.
szx),
1979 if (coap_check_send_need_lg_crcv(session, pdu)) {
1982 if (!session->
lg_xmit && have_block1) {
1987 LL_FOREACH(session->lg_crcv, lg_crcv) {
1990 LL_DELETE(session->lg_crcv, lg_crcv);
1991 coap_block_delete_lg_crcv(session, lg_crcv);
1996 if (have_block1 && session->
lg_xmit) {
1997 LL_FOREACH(session->
lg_xmit, lg_xmit) {
2005 lg_crcv = coap_block_new_lg_crcv(session, pdu, lg_xmit);
2006 if (lg_crcv ==
NULL) {
2017#if COAP_Q_BLOCK_SUPPORT
2020 mid = coap_send_q_block1(session, block, pdu, COAP_SEND_INC_PDU);
2027#if COAP_CLIENT_SUPPORT
2030 LL_PREPEND(session->lg_crcv, lg_crcv);
2032 coap_block_delete_lg_crcv(session, lg_crcv);
2050 addr_str[
sizeof(addr_str)-1] =
'\000';
2052 sizeof(addr_str) - 1)) {
2056 if (addr_str[0] ==
'[') {
2057 cp = strchr(addr_str,
']');
2060 if (memcmp(&addr_str[1],
"::ffff:", 7) == 0) {
2067 cp = strchr(addr_str,
':');
2081 if (hop_limit == 1) {
2083 const uint8_t *data;
2086 data = (
const uint8_t *)
"";
2088 (
int)data_len, (
const char *)data);
2091 }
else if (hop_limit < 1 || hop_limit > 255) {
2120 pdu->
data[data_len] =
'\000';
2121 a_match = strstr((
char *)pdu->
data, cp);
2122 if (a_match && (a_match == (
char *)pdu->
data || a_match[-1] ==
' ') &&
2123 ((
size_t)(a_match - (
char *)pdu->
data + len) == data_len ||
2124 a_match[len] ==
' ')) {
2142 (uint8_t *)&hop_limit);
2146 memmove(pdu->
data + len + 1, pdu->
data,
2148 memcpy(pdu->
data, cp, len);
2149 pdu->
data[len] =
' ';
2161 ssize_t bytes_written;
2163#if ! COAP_SERVER_SUPPORT
2171#if COAP_CLIENT_SUPPORT
2172 if (session->session_failed) {
2174 if (session->session_failed)
2183#if (COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG)
2193 uint32_t timeout_ms;
2205 if (timeout_ms == 0) {
2219#if COAP_PROXY_SUPPORT
2220 if (session->server_list) {
2222 return coap_proxy_local_write(session, pdu);
2235 if (session->
echo) {
2242#if COAP_OSCORE_SUPPORT
2243 if (session->oscore_encryption) {
2254#if !COAP_DISABLE_TCP
2267 coap_log_debug(
"Remote end did not indicate CSM support for Block1 enabled\n");
2270 coap_log_debug(
"Remote end did not indicate CSM support for Block2 enabled\n");
2277 coap_log_debug(
"Remote end did not indicate CSM support for BERT Block1\n");
2281 coap_log_debug(
"Remote end did not indicate CSM support for BERT Block2\n");
2287#if COAP_OSCORE_SUPPORT
2288 if (session->oscore_encryption &&
2295 if (osc_pdu ==
NULL) {
2308#if COAP_SERVER_SUPPORT
2309 if (session->last_resp_pdu != pdu &&
2314 session->last_resp_pdu = pdu;
2323 if (bytes_written < 0) {
2329#if !COAP_DISABLE_TCP
2331 (
size_t)bytes_written < pdu->used_size + pdu->
hdr_size) {
2355 node->
id = pdu->
mid;
2373 coap_pdu_t **response_pdu, uint32_t timeout_ms) {
2394 coap_pdu_t **response_pdu, uint32_t timeout_ms) {
2395#if COAP_CLIENT_SUPPORT
2397 uint32_t rem_timeout = timeout_ms;
2403 uint32_t time_so_far_ms;
2406 assert(request_pdu);
2410 session->resp_pdu =
NULL;
2427 session->doing_send_recv = 1;
2432 if (!session->doing_send_recv)
2440 while (rem_timeout > 0 && session->doing_send_recv && !session->resp_pdu) {
2454 if (time_so_far_ms >= timeout_ms) {
2457 rem_timeout = timeout_ms - time_so_far_ms;
2462 ticks_so_far = now - start;
2464 if (time_so_far_ms >= timeout_ms) {
2467 rem_timeout = timeout_ms - time_so_far_ms;
2474 ticks_so_far = now - start;
2476 ret = time_so_far_ms;
2478 *response_pdu = session->resp_pdu;
2479 session->resp_pdu =
NULL;
2480 if (*response_pdu ==
NULL) {
2490 session->doing_send_recv = 0;
2493 session->resp_pdu =
NULL;
2495 session->req_token =
NULL;
2503 coap_log_warn(
"coap_send_recv: Client mode not supported\n");
2504 *response_pdu =
NULL;
2512 if (!context || !node || !node->
session)
2515#if COAP_CLIENT_SUPPORT
2516 if (node->
session->session_failed) {
2524 ssize_t bytes_written;
2544 node->
t = next_delay;
2555 coap_log_debug(
"** %s: mid=0x%04x: mcast delayed transmission\n",
2558 coap_log_debug(
"** %s: mid=0x%04x: retransmission #%d (next %ums)\n",
2581 if (bytes_written < 0)
2582 return (
int)bytes_written;
2587#if COAP_CLIENT_SUPPORT
2588 if (node->
session->session_failed) {
2589 coap_log_info(
"** %s: mid=0x%04x: deleted due to reconnection issue\n",
2594 coap_log_warn(
"** %s: mid=0x%04x: give up after %d attempts\n",
2596#if COAP_CLIENT_SUPPORT
2600#if COAP_SERVER_SUPPORT
2604 (node->
session->ref_subscriptions || node->
session->ref_proxy_subs)) {
2610 if (node->
session->ref_subscriptions)
2612#if COAP_PROXY_SUPPORT
2614 if (node->
session->ref_proxy_subs)
2616 0, COAP_PROXY_SUBS_TOKEN);
2640#if COAP_CLIENT_SUPPORT
2641 node->
session->doing_send_recv = 0;
2656#if COAP_SERVER_SUPPORT
2658 result = coap_dtls_hello(session, data, data_len);
2669#if COAP_CLIENT_SUPPORT
2698 ssize_t bytes_written;
2701 coap_log_debug(
"** %s: mid=0x%04x: transmitted after delay (1)\n",
2707 if (bytes_written > 0)
2709 if (bytes_written <= 0 ||
2711 if (bytes_written > 0)
2723#if COAP_CONSTRAINED_STACK
2735 packet->
length =
sizeof(payload);
2746 if (bytes_read < 0) {
2747 if (bytes_read == -2) {
2752 }
else if (bytes_read > 0) {
2754#if COAP_CLIENT_SUPPORT
2755 if (session->session_failed) {
2756 session->session_failed = 0;
2765#if !COAP_DISABLE_TCP
2768 ssize_t bytes_read = 0;
2774 if (bytes_read < 0) {
2776 }
else if (bytes_read > 2) {
2798 ssize_t bytes_read = 0;
2806 if (bytes_read > 0) {
2810 retry = bytes_read == (ssize_t)packet->
length;
2811 while (bytes_read > 0) {
2816 size_t n =
min(len, (
size_t)bytes_read);
2841 }
else if (error_opts.
mask) {
2846 coap_log_warn(
"coap_read_session: cannot create error response\n");
2849 coap_log_warn(
"coap_read_session: error sending response\n");
2862 size_t len = hdr_size + tok_ext_bytes - session->
partial_read;
2863 size_t n =
min(len, (
size_t)bytes_read);
2870 hdr_size + tok_ext_bytes);
2919 }
while (bytes_read == 0 && retry);
2926#if COAP_SERVER_SUPPORT
2929 ssize_t bytes_read = -1;
2931#if COAP_CONSTRAINED_STACK
2946 packet->
length =
sizeof(payload);
2952 if (bytes_read < 0) {
2953 if (errno != EAGAIN) {
2956 }
else if (bytes_read > 0) {
2957 coap_session_t *session = coap_endpoint_get_session(endpoint, packet, now);
2979#if !COAP_DISABLE_TCP
2983 coap_session_t *session = coap_new_server_session(ctx, endpoint, extra);
2986 return session !=
NULL;
3000#ifdef COAP_EPOLL_SUPPORT
3003 coap_log_emerg(
"coap_io_do_io() requires libcoap not compiled for using epoll\n");
3008#if COAP_SERVER_SUPPORT
3010 LL_FOREACH_SAFE(ctx->endpoint, ep, tmp) {
3012 coap_read_endpoint(ctx, ep, now);
3014 coap_write_endpoint(ctx, ep, now);
3015#if !COAP_DISABLE_TCP
3017 coap_accept_endpoint(ctx, ep, now,
NULL);
3022#if COAP_CLIENT_SUPPORT
3038#if COAP_CLIENT_SUPPORT
3070#ifndef COAP_EPOLL_SUPPORT
3074 coap_log_emerg(
"coap_io_do_epoll() requires libcoap compiled for using epoll\n");
3081 for (j = 0; j < nevents; j++) {
3086#if COAP_SERVER_SUPPORT
3087 if (sock->endpoint) {
3090 (events[j].events & (EPOLLIN|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
3092 coap_read_endpoint(endpoint->context, endpoint, now);
3096 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
3103 coap_write_endpoint(endpoint->context, endpoint, now);
3106#if !COAP_DISABLE_TCP
3108 (events[j].events & EPOLLIN)) {
3110 coap_accept_endpoint(endpoint->context, endpoint, now,
NULL);
3122#if COAP_CLIENT_SUPPORT
3124 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
3135 (events[j].events & (EPOLLIN|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
3141 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
3153 }
else if (ctx->eptimerfd != -1) {
3162 if (read(ctx->eptimerfd, &count,
sizeof(count)) == -1) {
3175 uint8_t *msg,
size_t msg_len) {
3181#if COAP_SERVER_SUPPORT
3183 coap_session_cid_update_addr(session);
3194 coap_log_debug(
"coap_handle_dgram: UDP version not supported\n");
3212 coap_log_warn(
"coap_handle_dgram: cannot create error response\n");
3215 coap_log_warn(
"coap_handle_dgram: error sending response\n");
3301 if (!queue || !*queue) {
3308 if (session == (*queue)->session && mid == (*queue)->id &&
3311 *queue = (*queue)->
next;
3313 (*queue)->t += (*node)->t;
3326 }
while (q && (session != q->
session || mid != q->
id ||
3351 if (!queue || !*queue)
3356 if (session == (*queue)->session &&
3359 *queue = (*queue)->
next;
3361 (*queue)->t += (*node)->t;
3380 }
while (q && (session != q->
session ||
3484#if COAP_ERROR_PHRASE_LENGTH > 0
3521#if COAP_ERROR_PHRASE_LENGTH > 0
3522 snprintf(buf,
sizeof(buf),
"%s", phrase ? phrase :
"");
3530 snprintf(&buf[len],
sizeof(buf) - len,
"%s%d", first ?
" " :
",",
3536 if (opts->
mask & (1 << i)) {
3538 snprintf(&buf[len],
sizeof(buf) - len,
"%s%d", first ?
" " :
",",
3543 coap_add_data(response, (
size_t)strlen(buf), (
const uint8_t *)buf);
3544 }
else if (opts && opts->
mask) {
3554#if COAP_ERROR_PHRASE_LENGTH > 0
3556 coap_add_data(response, (
size_t)strlen(phrase), (
const uint8_t *)phrase);
3560 coap_add_data(response, (
size_t)strlen(phrase), (
const uint8_t *)phrase);
3568#if COAP_SERVER_SUPPORT
3569#define SZX_TO_BYTES(SZX) ((size_t)(1 << ((SZX) + 4)))
3596 result = coap_print_wellknown_lkd(session->
context, buf, &wkc_len, UINT_MAX, query);
3598 coap_log_warn(
"cannot determine length of /.well-known/core\n");
3608 result = coap_print_wellknown_lkd(session->
context, data_string->
s, &len, 0, query);
3613 assert(len <= (
size_t)wkc_len);
3614 data_string->
length = len;
3634 free_wellknown_response(session, data_string);
3635 }
else if (!coap_add_data_large_response_lkd(resource, session, request,
3638 -1, 0, data_string->
length,
3640 free_wellknown_response,
3642 goto error_released;
3655 free_wellknown_response(session, data_string);
3657 if (response->
code == 0) {
3678 int num_cancelled = 0;
3680#ifndef COAP_SERVER_SUPPORT
3685#if COAP_SERVER_SUPPORT
3689 RESOURCES_ITER(context->resources, r) {
3695 return num_cancelled;
3698#if COAP_SERVER_SUPPORT
3703enum respond_t { RESPONSE_DEFAULT, RESPONSE_DROP, RESPONSE_SEND };
3751static enum respond_t
3756 unsigned int val = 0;
3783 return RESPONSE_SEND;
3785 return RESPONSE_DROP;
3789 return RESPONSE_SEND;
3791 }
else if (resource && session->
context->mcast_per_resource &&
3794 if ((resource->flags &
3797 return RESPONSE_DROP;
3798 }
else if ((resource->flags &
3802 return RESPONSE_DROP;
3803 }
else if ((resource->flags &
3806 return RESPONSE_DROP;
3807 }
else if ((resource->flags &
3810 return RESPONSE_DROP;
3822 return RESPONSE_DROP;
3833 return RESPONSE_DROP;
3835 if ((!resource || session->
context->mcast_per_resource == 0) &&
3837 return RESPONSE_DROP;
3843 return RESPONSE_DEFAULT;
3865 enum respond_t respond = RESPONSE_DEFAULT;
3868 int is_proxy_uri = 0;
3869 int is_proxy_scheme = 0;
3877 int added_block = 0;
3879#if COAP_Q_BLOCK_SUPPORT
3880 int lg_xmit_ctrl = 0;
3882#if COAP_ASYNC_SUPPORT
3886#if COAP_ASYNC_SUPPORT
3887 async = coap_find_async_lkd(session, pdu->
actual_token);
3892 if (async->delay == 0 || async->delay > now) {
3903 if (!(context->unknown_resource && context->unknown_resource->is_reverse_proxy)) {
3912 is_proxy_scheme = 1;
3920 if (is_proxy_scheme || is_proxy_uri) {
3923 if (!context->proxy_uri_resource) {
3926 is_proxy_scheme ?
"Scheme" :
"Uri");
3930 if (((
size_t)pdu->
code - 1 <
3931 (
sizeof(resource->handler) /
sizeof(resource->handler[0]))) &&
3932 !(context->proxy_uri_resource->handler[pdu->
code - 1])) {
3935 is_proxy_scheme ?
"Scheme" :
"Uri",
3951 memset(&uri, 0,
sizeof(uri));
3960 resource = context->proxy_uri_resource;
3961 if (uri.
host.
length && resource->proxy_name_count &&
3962 resource->proxy_name_list) {
3965 if (resource->proxy_name_count == 1 &&
3966 resource->proxy_name_list[0]->length == 0) {
3970 for (i = 0; i < resource->proxy_name_count; i++) {
3976 if (i != resource->proxy_name_count) {
3986 is_proxy_scheme = 0;
3991 assert(resource ==
NULL);
3997 if (hop_limit < 1 || hop_limit > 255) {
4011 if (!is_proxy_uri && !is_proxy_scheme) {
4014 resource = coap_get_resource_from_uri_path_lkd(context, &uri_path_c);
4017 if ((resource ==
NULL) || (resource->is_unknown == 1) ||
4018 (resource->is_proxy_uri == 1)) {
4022 if (resource !=
NULL)
4048 if (is_proxy_uri || is_proxy_scheme) {
4049 resource = context->proxy_uri_resource;
4050 }
else if (context->unknown_resource !=
NULL &&
4052 ((
size_t)pdu->
code - 1 <
4054 (context->unknown_resource->handler[pdu->
code - 1])) {
4055 resource = context->unknown_resource;
4058 resource = &resource_uri_wellknown;
4059 }
else if ((context->unknown_resource !=
NULL) &&
4060 ((
size_t)pdu->
code - 1 <
4062 (context->unknown_resource->handler[pdu->
code - 1])) {
4081 resource = context->unknown_resource;
4094 resource = coap_add_dynamic_resource(session, pdu);
4101 coap_log_debug(
"request for unknown resource '%*.*s', return 4.04\n",
4109 coap_resource_reference_lkd(resource);
4111 if (hop_limit >= 0 &&
4112 (is_proxy_scheme || is_proxy_uri ||
4113 (resource == context->unknown_resource && resource->is_reverse_proxy))) {
4116 if (hop_limit == 1) {
4118 if (resource == context->unknown_resource && resource->is_reverse_proxy) {
4134#if COAP_OSCORE_SUPPORT
4136 coap_log_debug(
"request for OSCORE only resource '%*.*s', return 4.04\n",
4142 if (resource->is_unknown == 0 && resource->is_proxy_uri == 0) {
4152 if ((
size_t)pdu->
code - 1 <
4154 h = resource->handler[pdu->
code - 1];
4170 if (context->mcast_per_resource &&
4190#if COAP_ASYNC_SUPPORT
4221 for (bn = 0; bn <
sizeof(block_nums)/
sizeof(block_nums[0]); bn++) {
4235 if (resource->observable &&
4251 if (coap_handle_request_put_block(context, session, pdu, response,
4253 &added_block, &free_lg_srcv)) {
4259 if (coap_handle_request_send_block(session, pdu, response, resource,
4261#if COAP_Q_BLOCK_SUPPORT
4277 if (block.
num != 0) {
4281#if COAP_Q_BLOCK_SUPPORT
4284 if (block.
num != 0) {
4290 subscription = coap_add_observer(resource, session, &pdu->
actual_token,
4295 coap_touch_observer(context, session, &pdu->
actual_token);
4302 coap_delete_observer_request(resource, session, &pdu->
actual_token, pdu, free_lg_srcv !=
NULL);
4304 coap_log_info(
"observe: unexpected action %d\n", observe_action);
4308#if COAP_WITH_OBSERVE_PERSIST
4310 if (resource == context->unknown_resource) {
4311 context->unknown_pdu = pdu;
4312 context->unknown_session = session;
4314 context->unknown_pdu =
NULL;
4320 if (resource == &resource_uri_wellknown) {
4323 (
int)resource->uri_path->length, (
int)resource->uri_path->length,
4324 resource->uri_path->s);
4325 h(resource, session, pdu, query, response);
4332 (
int)resource->uri_path->length, (
int)resource->uri_path->length,
4333 resource->uri_path->s);
4340 h(resource, session, pdu, query, response),
4348 coap_log_warn(
"handle_request: Invalid PDU response code (%d.%02d)\n",
4350 response->
code & 0x1f);
4351 goto drop_it_no_debug;
4365 coap_log_debug(
"handle_request: response: Invalid Content-Format\n");
4374 coap_add_data(response,
sizeof(
"Not Acceptable")-1, (
const uint8_t *)
"Not Acceptable");
4391 LL_FOREACH(session->lg_srcv, lg_srcv) {
4392 if (lg_srcv == free_lg_srcv) {
4393#if COAP_Q_BLOCK_SUPPORT
4403 coap_ticks(&free_lg_srcv->rec_blocks.last_seen);
4404 if (free_lg_srcv->rec_blocks.last_seen > adjust) {
4405 free_lg_srcv->rec_blocks.last_seen -= adjust;
4407 free_lg_srcv->dont_timeout = 0;
4411 LL_DELETE(session->lg_srcv, free_lg_srcv);
4412 coap_block_delete_lg_srcv(session, free_lg_srcv);
4424 respond = no_response(pdu, response, session, resource);
4425 if (respond != RESPONSE_DROP) {
4426#if (COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG)
4436 coap_delete_observer(resource, session, &pdu->
actual_token);
4446 && (response->
code == 0)) {
4455 (context->mcast_per_resource &&
4459#if COAP_Q_BLOCK_SUPPORT
4464 if (coap_send_q_block2(session, resource, query, pdu->
code, block,
4484 goto drop_it_no_debug;
4488 goto drop_it_no_debug;
4491 node->
id = response->
mid;
4492 node->
pdu = response;
4496 coap_log_debug(
" %s: mid=0x%04x: mcast response delayed for %u.%03u secs\n",
4502 node->
timeout = (
unsigned int)delay;
4520#if COAP_Q_BLOCK_SUPPORT
4540 coap_resource_release_lkd(resource);
4552 coap_resource_release_lkd(resource);
4557#if COAP_CLIENT_SUPPORT
4566#if COAP_PROXY_SUPPORT
4567 if (context->proxy_response_cb) {
4569 coap_proxy_req_t *proxy_req = coap_proxy_map_outgoing_request(session,
4573 if (proxy_req && proxy_req->incoming && !proxy_req->incoming->server_list) {
4574 coap_proxy_process_incoming(session, rcvd, body_data, proxy_req,
4580 if (session->doing_send_recv && session->req_token &&
4583 session->resp_pdu = rcvd;
4590 }
else if (context->response_cb) {
4592 context->response_cb(session,
4651 coap_log_debug(
"Extended Token requested size support not available\n");
4658 lg_crcv = coap_find_lg_crcv(session, rcvd);
4660 LL_DELETE(session->lg_crcv, lg_crcv);
4661 coap_block_delete_lg_crcv(session, lg_crcv);
4667#if COAP_Q_BLOCK_SUPPORT
4669 if (session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK) {
4695 if (!sent && session->lg_crcv)
4696 sent = session->lg_crcv->sent_pdu;
4702 size_t max_age = 60;
4723 node->
id = sent->
mid;
4725 coap_log_debug(
" %s: mid=0x%04x: re-request delayed for %u secs\n",
4728 (
unsigned int)max_age);
4738 if (coap_handle_response_send_block(session, sent, rcvd)) {
4745 if (coap_handle_response_get_block(context, session, sent, rcvd,
4758#if !COAP_DISABLE_TCP
4776 coap_log_warn(
"***%s: Increase timeout in coap_context_set_csm_timeout_ms() to > %d\n",
4791 coap_log_debug(
"* %s: Restricting CSM Max-Message-Size size to %u\n",
4864 coap_log_warn(
"coap_dispatch: cannot create error response\n");
4890 int packet_is_bad = 0;
4891#if COAP_OSCORE_SUPPORT
4895 int is_ext_token_rst = 0;
4896 int oscore_invalid = 0;
4897 int is_local_mcast = 0;
4907 coap_log_info(
"Invalid multicast packet received RFC7252 8.1\n");
4914 coap_log_info(
"coap_dispatch: Received invalid PDU code (%d.%02d)\n",
4928#if COAP_SERVER_SUPPORT
4931 pdu->
mid == session->last_resp_pdu->mid) {
4932#if COAP_OSCORE_SUPPORT
4933 uint8_t oscore_encryption = session->oscore_encryption;
4935 session->oscore_encryption = 0;
4942#if COAP_OSCORE_SUPPORT
4943 session->oscore_encryption = oscore_encryption;
4947#if COAP_OSCORE_SUPPORT
4948 session->oscore_encryption = oscore_encryption;
4957#if COAP_OSCORE_SUPPORT
4966 coap_log_warn(
"coap_dispatch: cannot create error response\n");
4980#if COAP_SERVER_SUPPORT
4989#if COAP_SERVER_SUPPORT
4995 memset(&uri, 0,
sizeof(uri));
4998 resource = context->proxy_uri_resource;
4999 if (uri.
host.
length && resource && resource->proxy_name_count &&
5000 resource->proxy_name_list) {
5002 for (i = 0; i < resource->proxy_name_count; i++) {
5007 if (i == resource->proxy_name_count) {
5015#if COAP_ASYNC_SUPPORT
5031 if (dup_async->delay == 0 || dup_async->delay > now) {
5032 coap_log_info(
"Duplicate request, async response pending\n");
5045 if (session->recipient_ctx ==
NULL ||
5046 (session->recipient_ctx->initial_state == 0 &&
5054 session->oscore_encryption = 1;
5063 session->oscore_encryption &&
5067 coap_log_err(
"received an invalid response to the OSCORE request\n");
5073 switch (pdu->
type) {
5087 if (oscore_invalid ||
5093#if COAP_SERVER_SUPPORT
5102#if COAP_Q_BLOCK_SUPPORT
5104 !(session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK)) {
5105 int doing_q_block = 0;
5108 LL_FOREACH(session->
lg_xmit, lg_xmit) {
5115 if (doing_q_block && lg_xmit) {
5118 memset(&block, 0,
sizeof(block));
5130 coap_send_q_blocks(session, lg_xmit, block,
5131 lg_xmit->
sent_pdu, COAP_SEND_SKIP_PDU);
5135 if (pdu->
code == 0) {
5136#if COAP_CLIENT_SUPPORT
5150 !coap_check_send_need_lg_crcv(session, sent->
pdu) &&
5158 uint64_t token_match =
5162 LL_FOREACH(session->lg_crcv, lg_crcv) {
5173 lg_crcv = coap_block_new_lg_crcv(session, sent->
pdu,
NULL);
5175 LL_PREPEND(session->lg_crcv, lg_crcv);
5202#if COAP_CLIENT_SUPPORT
5203#if COAP_Q_BLOCK_SUPPORT
5205 if (session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK &&
5220 is_ext_token_rst = 1;
5224 if (!is_ping_rst && !is_ext_token_rst)
5241 if (!is_ping_rst && !is_ext_token_rst) {
5245 }
else if (is_ping_rst) {
5254#if COAP_SERVER_SUPPORT
5256 RESOURCES_ITER(context->resources, r) {
5258 LL_FOREACH_SAFE(r->subscribers, obs, tmp) {
5259 if (obs->pdu->mid == pdu->
mid && obs->session == session) {
5262 coap_delete_observer(r, session, &obs->pdu->actual_token);
5272#if COAP_PROXY_SUPPORT
5275 coap_delete_proxy_subscriber(session,
NULL, pdu->
mid, COAP_PROXY_SUBS_MID);
5282 if (oscore_invalid ||
5290 coap_log_warn(
"coap_dispatch: cannot create error response\n");
5312 if (oscore_invalid ||
5321 coap_log_warn(
"coap_dispatch: cannot create error response\n");
5338#if !COAP_DISABLE_TCP
5343#if COAP_SERVER_SUPPORT
5345 handle_request(context, session, pdu, orig_pdu);
5348#if COAP_CLIENT_SUPPORT
5350 handle_response(context, session, sent ? sent->
pdu :
NULL, pdu);
5383 if (packet_is_bad) {
5392#if COAP_OSCORE_SUPPORT
5396#if COAP_SERVER_SUPPORT || COAP_OSCORE_SUPPORT
5407 coap_log_debug(
"***%s: coap_dispatch: PDU dropped, session about to be disconnected\n",
5421#if COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG
5426 return "COAP_EVENT_DTLS_CLOSED";
5428 return "COAP_EVENT_DTLS_CONNECTED";
5430 return "COAP_EVENT_DTLS_RENEGOTIATE";
5432 return "COAP_EVENT_DTLS_ERROR";
5434 return "COAP_EVENT_TCP_CONNECTED";
5436 return "COAP_EVENT_TCP_CLOSED";
5438 return "COAP_EVENT_TCP_FAILED";
5440 return "COAP_EVENT_SESSION_CONNECTED";
5442 return "COAP_EVENT_SESSION_CLOSED";
5444 return "COAP_EVENT_SESSION_FAILED";
5446 return "COAP_EVENT_PARTIAL_BLOCK";
5448 return "COAP_EVENT_XMIT_BLOCK_FAIL";
5450 return "COAP_EVENT_BLOCK_ISSUE";
5452 return "COAP_EVENT_SERVER_SESSION_NEW";
5454 return "COAP_EVENT_SERVER_SESSION_DEL";
5456 return "COAP_EVENT_SERVER_SESSION_CONNECTED";
5458 return "COAP_EVENT_BAD_PACKET";
5460 return "COAP_EVENT_MSG_RETRANSMITTED";
5462 return "COAP_EVENT_FIRST_PDU_FAIL";
5464 return "COAP_EVENT_OSCORE_DECRYPTION_FAILURE";
5466 return "COAP_EVENT_OSCORE_NOT_ENABLED";
5468 return "COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD";
5470 return "COAP_EVENT_OSCORE_NO_SECURITY";
5472 return "COAP_EVENT_OSCORE_INTERNAL_ERROR";
5474 return "COAP_EVENT_OSCORE_DECODE_ERROR";
5476 return "COAP_EVENT_OSCORE_RECIPIENT_CHANGED";
5478 return "COAP_EVENT_WS_PACKET_SIZE";
5480 return "COAP_EVENT_WS_CONNECTED";
5482 return "COAP_EVENT_WS_CLOSED";
5484 return "COAP_EVENT_KEEPALIVE_FAILURE";
5486 return "COAP_EVENT_RECONNECT_FAILED";
5488 return "COAP_EVENT_RECONNECT_SUCCESS";
5490 return "COAP_EVENT_RECONNECT_NO_MORE";
5492 return "COAP_EVENT_RECONNECT_STARTED";
5517#if COAP_PROXY_SUPPORT
5519 coap_proxy_remove_association(session, 0);
5524#if COAP_CLIENT_SUPPORT
5541 session->doing_send_recv = 0;
5610#if COAP_SERVER_SUPPORT
5613 LL_FOREACH(context->endpoint, ep) {
5622#if COAP_CLIENT_SUPPORT
5632#if COAP_SERVER_SUPPORT
5633#if COAP_ASYNC_SUPPORT
5644 if (context->async_state_traversing)
5646 context->async_state_traversing = 1;
5647 LL_FOREACH_SAFE(context->async_state, async, tmp) {
5648 if (async->delay != 0 && !async->session->is_rate_limiting) {
5649 if (async->delay <= now) {
5658 handle_request(context, session, async->pdu,
NULL);
5661 coap_free_async_lkd(session, async);
5664 next_due = async->delay - now;
5670 *tim_rem = next_due;
5671 context->async_state_traversing = 0;
5711#if defined(HAVE_WINSOCK2_H)
5712 WORD wVersionRequested = MAKEWORD(2, 2);
5714 WSAStartup(wVersionRequested, &wsaData);
5723 coap_start_io_process();
5728 coap_io_lwip_init();
5730#if COAP_SERVER_SUPPORT
5732 (
const uint8_t *)
".well-known/core"
5734 memset(&resource_uri_wellknown, 0,
sizeof(resource_uri_wellknown));
5735 resource_uri_wellknown.ref = 1;
5736 resource_uri_wellknown.handler[
COAP_REQUEST_GET-1] = hnd_get_wellknown_lkd;
5738 resource_uri_wellknown.uri_path = &well_known;
5749#if defined(HAVE_WINSOCK2_H)
5751#elif defined(WITH_CONTIKI)
5752 coap_stop_io_process();
5755 coap_io_lwip_cleanup();
5775#if COAP_CLIENT_SUPPORT
5776 context->response_cb = handler;
5786#if COAP_PROXY_SUPPORT
5787 context->proxy_response_cb = handler;
5815 uint32_t dynamic_max) {
5833#if ! defined WITH_CONTIKI && ! defined WITH_LWIP && ! defined RIOT_VERSION && !defined(__ZEPHYR__)
5834#if COAP_SERVER_SUPPORT
5837 const char *ifname) {
5849 const char *group_name,
5850 const char *ifname) {
5851#if COAP_IPV4_SUPPORT
5852 struct ip_mreq mreq4;
5854#if COAP_IPV6_SUPPORT
5855 struct ipv6_mreq mreq6;
5857 struct addrinfo *resmulti =
NULL, hints, *ainfo;
5860#if !defined(ESPIDF_VERSION) && COAP_IPV6_SUPPORT && !defined(HAVE_IF_NAMETOINDEX) && !defined(__QNXNTO__)
5863 int mgroup_setup = 0;
5865 if (single_endpoint) {
5868#if !defined(ESPIDF_VERSION) && COAP_IPV6_SUPPORT && !defined(HAVE_IF_NAMETOINDEX) && !defined(__QNXNTO__)
5869 lookup_endpoint = single_endpoint;
5873 assert(ctx->endpoint);
5876#if !defined(ESPIDF_VERSION) && COAP_IPV6_SUPPORT && !defined(HAVE_IF_NAMETOINDEX) && !defined(__QNXNTO__)
5877 lookup_endpoint = ctx->endpoint;
5882#if COAP_IPV6_SUPPORT
5883 mreq6.ipv6mr_interface = 0;
5885#if COAP_IPV4_SUPPORT
5886 mreq4.imr_interface.s_addr = INADDR_ANY;
5889 memset(&hints, 0,
sizeof(hints));
5890 hints.ai_socktype = SOCK_DGRAM;
5893 result = getaddrinfo(group_name,
NULL, &hints, &resmulti);
5897 "Cannot resolve multicast address: %s\n",
5898 group_name, gai_strerror(result));
5908#if defined(ESPIDF_VERSION)
5909 struct netif *netif;
5911#if COAP_IPV4_SUPPORT
5918 for (ainfo = resmulti; ainfo !=
NULL && !(done_ip4 == 1 && done_ip6 == 1);
5919 ainfo = ainfo->ai_next) {
5920 switch (ainfo->ai_family) {
5921#if COAP_IPV6_SUPPORT
5926#if defined(ESPIDF_VERSION)
5927 netif = netif_find(ifname);
5929 mreq6.ipv6mr_interface = netif_get_index(netif);
5932 "Cannot get IPv4 address: %s\n",
5935 memset(&ifr, 0,
sizeof(ifr));
5936 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
5937 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
5939#ifdef HAVE_IF_NAMETOINDEX
5940 mreq6.ipv6mr_interface = if_nametoindex(ifr.ifr_name);
5941 if (mreq6.ipv6mr_interface == 0) {
5943 "cannot get interface index for '%s'\n",
5946#elif defined(__QNXNTO__)
5948 result = ioctl(lookup_endpoint->sock.fd, SIOCGIFINDEX, &ifr);
5951 "cannot get interface index for '%s': %s\n",
5955 mreq6.ipv6mr_interface = ifr.ifr_ifindex;
5961#if COAP_IPV4_SUPPORT
5966#if defined(ESPIDF_VERSION)
5967 netif = netif_find(ifname);
5969 mreq4.imr_interface.s_addr = netif_ip4_addr(netif)->addr;
5972 "Cannot get IPv4 address: %s\n",
5979 ip4fd = socket(AF_INET, SOCK_DGRAM, 0);
5981 coap_log_err(
"coap_join_mcast_group_intf: %s: socket: %s\n",
5985 memset(&ifr, 0,
sizeof(ifr));
5986 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
5987 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
5988 result = ioctl(ip4fd, SIOCGIFADDR, &ifr);
5991 "Cannot get IPv4 address: %s\n",
5995 mreq4.imr_interface = ((
struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
6016 for (ainfo = resmulti; ainfo !=
NULL; ainfo = ainfo->ai_next) {
6017 for (endpoint = single_endpoint ? single_endpoint : ctx->endpoint;
6019 endpoint = single_endpoint ?
NULL : endpoint->next) {
6025#if COAP_IPV6_SUPPORT
6026 if (ainfo->ai_family == AF_INET6) {
6028 if (endpoint->bind_addr.addr.sa.sa_family == AF_INET6) {
6033 mreq6.ipv6mr_interface =
6034 endpoint->bind_addr.addr.sin6.sin6_scope_id;
6036 mreq6.ipv6mr_interface = 0;
6039 gaddr.
addr.
sin6.sin6_family = AF_INET6;
6040 gaddr.
addr.
sin6.sin6_port = endpoint->bind_addr.addr.sin6.sin6_port;
6041 gaddr.
addr.
sin6.sin6_addr = mreq6.ipv6mr_multiaddr =
6042 ((
struct sockaddr_in6 *)ainfo->ai_addr)->sin6_addr;
6043 result = setsockopt(endpoint->sock.fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
6044 (
char *)&mreq6,
sizeof(mreq6));
6047#if COAP_IPV4_SUPPORT && COAP_IPV6_SUPPORT
6050#if COAP_IPV4_SUPPORT
6051 if (ainfo->ai_family == AF_INET) {
6053 if (endpoint->bind_addr.addr.sa.sa_family == AF_INET) {
6058 mreq4.imr_interface = endpoint->bind_addr.addr.sin.sin_addr;
6060 mreq4.imr_interface.s_addr = INADDR_ANY;
6063 gaddr.
addr.
sin.sin_family = AF_INET;
6064 gaddr.
addr.
sin.sin_port = endpoint->bind_addr.addr.sin.sin_port;
6065 gaddr.
addr.
sin.sin_addr.s_addr = mreq4.imr_multiaddr.s_addr =
6066 ((
struct sockaddr_in *)ainfo->ai_addr)->sin_addr.s_addr;
6067 result = setsockopt(endpoint->sock.fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
6068 (
char *)&mreq4,
sizeof(mreq4));
6076 coap_log_err(
"coap_join_mcast_group_intf: %s: setsockopt: %s\n",
6081 addr_str[
sizeof(addr_str)-1] =
'\000';
6083 sizeof(addr_str) - 1)) {
6095 if (!mgroup_setup) {
6100 freeaddrinfo(resmulti);
6107 const char *group_name,
6108 const char *ifname) {
6111 if (!endpoint || !endpoint->context)
6122 context->mcast_per_resource = 1;
6127#if COAP_CLIENT_SUPPORT
6132#if COAP_IPV4_SUPPORT
6134 if (setsockopt(session->
sock.
fd, IPPROTO_IP, IP_MULTICAST_TTL,
6135 (
const char *)&hops,
sizeof(hops)) < 0) {
6142#if COAP_IPV6_SUPPORT
6144 if (setsockopt(session->
sock.
fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
6145 (
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)
int coap_debug_recv_packet(void)
Check to see whether an incoming packet should be dropped or not.
const char * coap_option_string(coap_pdu_code_t code, coap_option_num_t number)
Returns a textual description of the option name.
void coap_debug_reset(void)
Reset all the defined logging parameters.
struct coap_lg_crcv_t coap_lg_crcv_t
struct coap_endpoint_t coap_endpoint_t
struct coap_async_t coap_async_t
Async Entry information.
struct coap_cache_entry_t coap_cache_entry_t
struct coap_proxy_entry_t coap_proxy_entry_t
Proxy information.
struct coap_subscription_t coap_subscription_t
struct coap_resource_t coap_resource_t
struct coap_lg_srcv_t coap_lg_srcv_t
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_destroy(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)
static int send_recv_terminate
static coap_crit_type_t coap_is_session_proxy(coap_session_t *session, coap_pdu_t *pdu)
static int coap_remove_from_queue_token(coap_queue_t **queue, coap_session_t *session, coap_bin_const_t *token, coap_queue_t **node)
static int check_token_size(coap_session_t *session, const coap_pdu_t *pdu, int is_local_mcast)
#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 prepend_508_ip(coap_session_t *session, coap_pdu_t *pdu)
static unsigned int s_csm_timeout
COAP_STATIC_INLINE coap_queue_t * coap_malloc_node(void)
uint8_t coap_unique_id[8]
#define ACK_RANDOM_FACTOR
creates a Qx.FRAC_BITS from session's 'ack_random_factor'
static void coap_dispatch_pdu(coap_context_t *context, coap_session_t *session, coap_pdu_t *pdu)
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_load_pki_trust_store(coap_context_t *ctx 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...
@ COAP_SIG_OPT_BLOCK_WISE_TRANSFER
@ COAP_SIG_OPT_EXTENDED_TOKEN_LENGTH
@ COAP_SIG_OPT_MAX_MESSAGE_SIZE
@ COAP_OPTION_IF_NONE_MATCH
@ COAP_OPTION_PROXY_SCHEME
@ COAP_OPTION_CONTENT_FORMAT
@ COAP_OPTION_URI_PATH_ABB
#define SESSIONS_ITER_SAFE(e, el, rtmp)
#define SESSIONS_ITER(e, el, rtmp)
void coap_io_do_epoll_lkd(coap_context_t *ctx, struct epoll_event *events, size_t nevents)
Process all the epoll events.
void coap_reset_doing_first(coap_session_t *session)
Reset doing the first packet state when testing for optional functionality.
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_send_recv_lkd(coap_session_t *session, coap_pdu_t *request_pdu, coap_pdu_t **response_pdu, uint32_t timeout_ms)
void coap_io_process_remove_threads_lkd(coap_context_t *context)
Release the coap_io_process() worker threads.
int coap_io_process_lkd(coap_context_t *ctx, uint32_t timeout_ms)
The main I/O processing function.
void coap_call_response_handler(coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd, void *body_free)
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...
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...
#define STATE_TOKEN_BASE(t)
#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.
#define COAP_MAX_DELAY_TICKS
uint64_t coap_ticks_to_rt_us(coap_tick_t t)
Helper function that converts coap ticks to POSIX wallclock time in us.
void coap_prng_init_lkd(unsigned int seed)
Seeds the default random number generation function with the given seed.
int coap_prng_lkd(void *buf, size_t len)
Fills buf with len random bytes using the default pseudo random number generator.
#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_SAFE_REQUEST_HANDLER
Don't lock this resource when calling app call-back handler for requests as handler will not be manip...
#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...
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.
void coap_register_option_lkd(coap_context_t *ctx, coap_option_num_t type)
Registers the option number number with the given context object context.
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.
coap_queue_t * coap_remove_mid_from_delayq(coap_session_t *session, coap_mid_t mid)
This function removes the node with given mid from the delayqueue.
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.
int coap_option_check_critical(coap_session_t *session, coap_pdu_t *pdu, coap_opt_filter_t *unknown, coap_crit_type_t is_proxy)
Verifies that pdu contains no unknown critical options, duplicate options or the options defined as R...
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.
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',...
void coap_add_to_head_delayq(coap_session_t *session, coap_queue_t *node)
This function adds the node to the head of the delayqueue.
void coap_free_context_lkd(coap_context_t *context)
CoAP stack context must be released with coap_free_context_lkd().
int coap_context_load_pki_trust_store_lkd(coap_context_t *ctx)
Load the context's default trusted CAs for a client or server.
coap_mid_t coap_send_internal(coap_session_t *session, coap_pdu_t *pdu, coap_pdu_t *request_pdu)
Sends a CoAP message to given peer.
void * coap_context_set_app_data2_lkd(coap_context_t *context, void *app_data, coap_app_data_free_callback_t callback)
Stores data with the given context, returning the previously stored value or NULL.
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_join_mcast_group_intf_lkd(coap_context_t *ctx, coap_endpoint_t *endpoint, const char *groupname, const char *ifname)
Function interface for joining a multicast group for listening for the currently defined endpoints th...
coap_queue_t * coap_remove_first_from_delayq(coap_session_t *session)
This function removes the first node from the delayqueue.
void coap_add_to_tail_delayq(coap_session_t *session, coap_queue_t *node)
This function adds the node to the tail of the delayqueue.
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.
int coap_remove_from_queue(coap_queue_t **queue, coap_session_t *session, coap_mid_t mid, coap_bin_const_t *token, coap_queue_t **node)
This function removes the element with given mid from the list given list.
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_API int coap_send_recv(coap_session_t *session, coap_pdu_t *request_pdu, coap_pdu_t **response_pdu, uint32_t timeout_ms)
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_max_bodies_ram(coap_context_t *context, size_t max_bodies_ram)
Set the maximum supported total pending bodies that are being received.
void coap_context_rate_limit_ppm(coap_context_t *context, uint64_t rate_limit_ppm)
Set the ratelimit for packets per minute.
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_send_recv_terminate(void)
Terminate any active coap_send_recv() sessions.
coap_resource_t *(* coap_resource_dynamic_create_t)(coap_session_t *session, const coap_pdu_t *request)
Definition of resource dynamic creation handler function.
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_API void * coap_context_set_app_data2(coap_context_t *context, void *app_data, coap_app_data_free_callback_t callback)
Stores data with the given context, returning the previously stored value or NULL.
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...
void coap_register_dynamic_resource_handler(coap_context_t *context, coap_resource_dynamic_create_t dyn_create_handler, uint32_t dynamic_max)
Sets up a handler for calling when an unknown resource is requested.
COAP_API void coap_set_app_data(coap_context_t *context, void *app_data)
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_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 *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 Acknowledge handler that is used as callback in coap_context_t.
void coap_context_set_shutdown_no_observe(coap_context_t *context)
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.
COAP_API void coap_context_set_app_data(coap_context_t *context, void *app_data)
Stores data with the given context.
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_endpoint_join_mcast_group_intf(coap_endpoint_t *endpoint, const char *groupname, const char *ifname)
Function interface for joining a multicast group for listening on a single UDP endpoint.
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 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)
int coap_context_set_cid_tuple_change(coap_context_t *context, uint8_t every)
Set the Connection ID client tuple frequency change for testing CIDs.
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_session_reconnect_time2(coap_context_t *context, unsigned int reconnect_time, uint8_t retry_count)
Set the session reconnect delay time after a working client session has failed.
void coap_context_set_keepalive(coap_context_t *context, unsigned int seconds)
Set the context keepalive timer for sessions.
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.
COAP_API void coap_register_option(coap_context_t *ctx, coap_option_num_t type)
Registers the option number number with the given context object context.
unsigned int coap_context_get_csm_timeout(const coap_context_t *context)
Get the CSM timeout value.
COAP_API int coap_context_load_pki_trust_store(coap_context_t *ctx)
Load the hosts's default trusted CAs for a client or server.
void coap_context_set_session_reconnect_time(coap_context_t *context, unsigned int reconnect_time)
Set the session reconnect delay time after a working client session has failed.
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).
void coap_context_set_max_body_size(coap_context_t *context, size_t max_body_size)
Set the maximum supported body size.
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 *coap_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_set_cid_tuple_change(coap_context_t *context, uint8_t every)
Set the Connection ID client tuple frequency change for testing CIDs.
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.
#define COAP_DTLS_PKI_SETUP_VERSION
Latest PKI setup version.
@ 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.
uint64_t coap_decode_var_bytes8(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_RECONNECT_FAILED
Triggered when a session failed, and a reconnect is going to be attempted.
@ COAP_EVENT_OSCORE_INTERNAL_ERROR
Triggered when there is an OSCORE internal error i.e malloc failed.
@ COAP_EVENT_DTLS_CLOSED
Triggerrd 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_BLOCK_ISSUE
Triggered when a block transfer could not be handled.
@ 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_RECONNECT_STARTED
Triggered when a session starts to reconnect.
@ COAP_EVENT_WS_CLOSED
Triggered when the WebSockets layer is closed.
@ COAP_EVENT_RECONNECT_NO_MORE
Triggered when a session failed, and retry reconnect attempts failed.
@ COAP_EVENT_SESSION_CLOSED
Triggered when TCP layer closes following exchange of CSM information.
@ COAP_EVENT_FIRST_PDU_FAIL
Triggered when the initial app PDU cannot be transmitted.
@ 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_RECIPIENT_CHANGED
Triggered when coap_oscore_session_set_recipient_ctx() replaces the recipient context bound to a sess...
@ 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_SERVER_SESSION_CONNECTED
Called in the CoAP IO loop once a server session is active and (D)TLS (if any) is established.
@ 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_RECONNECT_SUCCESS
Triggered when a session failed, and a reconnect is successful.
@ 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_lock_specific_callback_release(lock, func, failed)
Dummy for no thread-safe code.
#define coap_lock_callback(func)
Dummy for no thread-safe code.
#define coap_lock_init(lock)
Dummy for no thread-safe code.
#define coap_lock_callback_ret(r, func)
Dummy for no thread-safe code.
#define coap_lock_callback_ret_release(r, func, failed)
Dummy for no thread-safe code.
#define coap_lock_unlock()
Dummy for no thread-safe code.
#define coap_lock_check_locked()
Dummy for no thread-safe code.
#define coap_lock_callback_release(func, failed)
Dummy for no thread-safe code.
#define coap_lock_lock(failed)
Dummy for no thread-safe code.
#define coap_log_debug(...)
coap_log_t coap_get_log_level(void)
Get the current logging level.
#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_FILTER_SHORT
The number of option types below 256 that can be stored in an option filter.
#define COAP_OPT_ALL
Pre-defined filter that includes all options.
#define COAP_OPT_FILTER_LONG
The number of option types above 255 that can be stored in an option 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)
coap_pdu_t * coap_pdu_reference_lkd(coap_pdu_t *pdu)
Increment reference counter on a pdu to stop it prematurely getting freed off when coap_delete_pdu() ...
void coap_delete_pdu_lkd(coap_pdu_t *pdu)
Dispose of an CoAP PDU and free off associated storage.
#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.
int coap_pdu_parse_opt(coap_pdu_t *pdu, coap_opt_filter_t *error_opts)
Verify consistency in the given CoAP PDU structure and locate the data.
#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_DEFAULT_MAX_PDU_RX_SIZE
#define COAP_PDU_IS_SIGNALING(pdu)
coap_pdu_t * coap_pdu_duplicate_lkd(const coap_pdu_t *old_pdu, coap_session_t *session, size_t token_length, const uint8_t *token, coap_opt_filter_t *drop_options, coap_bool_t expand_opt_abb)
Duplicate an existing PDU.
int coap_option_check_repeatable(coap_pdu_t *pdu, coap_option_num_t number)
Check whether the option is allowed to be repeated or not.
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
int coap_pdu_parse2(coap_proto_t proto, const uint8_t *data, size_t length, coap_pdu_t *pdu, coap_opt_filter_t *error_opts)
Parses data into the CoAP PDU structure given in result.
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.
COAP_STATIC_INLINE void coap_pdu_release_lkd(coap_pdu_t *pdu)
#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.
const char * coap_response_phrase(unsigned char code)
Returns a human-readable response phrase for the specified CoAP response code.
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_TOKEN_EXT_MAX
#define COAP_RESPONSE_CODE(N)
#define COAP_RESPONSE_CLASS(C)
coap_pdu_code_t
Set of codes available for a PDU.
coap_pdu_type_t
CoAP PDU message type definitions.
int coap_add_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds token of length len to pdu.
int coap_get_data(const coap_pdu_t *pdu, size_t *len, const uint8_t **data)
Retrieves the length and data pointer of specified PDU.
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.
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_INVALID_MID
Indicates an invalid message id.
#define COAP_DEFAULT_URI_WELLKNOWN
well-known resources URI
#define COAP_MEDIATYPE_APPLICATION_LINK_FORMAT
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_register_proxy_response_handler(coap_context_t *context, coap_proxy_response_handler_t handler)
Registers a new message handler that is called whenever a response is received by the proxy logic.
coap_pdu_t *(* coap_proxy_response_handler_t)(coap_session_t *session, const coap_pdu_t *sent, coap_pdu_t *received, coap_cache_key_t *cache_key)
Proxy response handler that is used as callback held in coap_context_t.
#define COAP_NON_RECEIVE_TIMEOUT_TICKS(s)
The NON_RECEIVE_TIMEOUT definition for the session (s).
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)
void coap_session_hold_lkd(coap_session_t *session)
Mark the session as in use for a unit of work (reading and dispatching received data,...
#define COAP_DEFAULT_LEISURE_TICKS(s)
The DEFAULT_LEISURE definition for the session (s).
void coap_handle_nack(coap_session_t *session, coap_pdu_t *sent, const coap_nack_reason_t reason, const coap_mid_t mid)
size_t coap_session_max_pdu_rcv_size(const coap_session_t *session)
Get maximum acceptable receive PDU size.
void coap_session_unhold_lkd(coap_session_t *session)
End a unit of work started by coap_session_hold_lkd().
void coap_read_session(coap_context_t *ctx, coap_session_t *session, coap_tick_t now)
#define COAP_DOING_FIRST_MAX_QUEUE
int coap_session_reconnect(coap_session_t *session)
Close the current session (if not already closed) and reconnect to server (client session only).
void coap_session_server_keepalive_failed(coap_session_t *session)
Clear down a session following a keepalive failure.
#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)
The session is to be disconnected (a send on it has failed, the peer or the (D)TLS layer has closed i...
@ 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)
void(* coap_app_data_free_callback_t)(void *data)
Callback to free off the app data when the entry is being deleted / freed off.
@ COAP_SESSION_TYPE_HELLO
server-side ephemeral session for responding to a client hello
@ COAP_SESSION_TYPE_SERVER
server-side
@ 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_epoll_is_supported(void)
Determine whether epoll is supported or not.
int coap_tls_is_supported(void)
Check whether TLS is available.
int coap_af_unix_is_supported(void)
Check whether socket type AF_UNIX is available.
int coap_ipv6_is_supported(void)
Check whether IPv6 is available.
int coap_threadsafe_is_supported(void)
Determine whether libcoap is threadsafe or not.
int coap_dtls_is_supported(void)
Check whether DTLS is available.
int coap_server_is_supported(void)
Check whether Server code is available.
int coap_client_is_supported(void)
Check whether Client code is available.
int coap_ipv4_is_supported(void)
Check whether IPv4 is available.
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.
void coap_delete_upa_chain(coap_upa_chain_t *chain)
Clean up a UPA chain.
coap_upa_chain_t * coap_upa_server_mapping_chain
coap_upa_chain_t * coap_upa_client_fallback_chain
#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::@307311212233272211314135073342070105261231004120 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 defined
Set if block found.
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.
uint64_t rl_ticks_per_packet
If not 0, rate limit NON to ticks per packet.
coap_app_data_free_callback_t app_cb
call-back to release app_data
coap_pong_handler_t pong_cb
Called when a ping response is received.
coap_nack_handler_t nack_cb
Called when a response issue has occurred.
coap_resource_dynamic_create_t dyn_create_handler
Dynamic resource create handler.
void * app_data
application-specific data
unsigned int ping_timeout
Minimum inactivity time before sending a ping message.
uint32_t dynamic_max
Max number of dynamic resources or 0 is unlimited.
coap_event_handler_t event_cb
Callback function that is used to signal events to the application.
size_t max_body_size
Max supported body size or 0 is unlimited.
coap_opt_filter_t known_options
uint32_t csm_max_message_size
Value for CSM Max-Message-Size.
unsigned int max_handshake_sessions
Maximum number of simultaneous negotiating sessions per endpoint.
coap_ping_handler_t ping_cb
Called when a CoAP ping is received.
uint32_t max_token_size
Largest token size supported RFC8974.
uint32_t csm_timeout_ms
Timeout for waiting for a CSM from the remote side.
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.
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.
uint64_t state_token
state token
uint32_t count
the number of packets sent for payload
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) transmission information.
coap_tick_t last_all_sent
Last time all data sent or 0.
uint8_t blk_size
large block transmission size
union coap_lg_xmit_t::@350064263164163371257164123340306372132367256250 b
int last_block
last acknowledged block number Block1 last transmitted Q-Block2
coap_pdu_t * sent_pdu
The sent pdu with all the data.
uint16_t option
large block transmission CoAP option
uint8_t short_opts[COAP_OPT_FILTER_SHORT]
uint16_t long_opts[COAP_OPT_FILTER_LONG]
Iterator to run through PDU options.
coap_opt_t * next_option
pointer to the unparsed next option
size_t length
remaining length of PDU
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
uint16_t max_opt
highest option number in PDU
uint8_t * token
first byte of token (or extended length bytes prefix), if any, or options
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.
coap_binary_t * data_free
Data to be freed off by coap_delete_pdu().
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_address_t remote
For re-transmission - where the node is going.
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 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 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.
uint32_t ping_failed
Ping failure count.
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 last_resp_mid
The last response mid that has been been processed.
uint8_t is_rate_limiting
Currently NON rate limiting.
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
uint8_t csm_bert_loc_support
CSM TCP BERT blocks supported (local).
coap_addr_tuple_t addr_info
remote/local address info
coap_proto_t proto
protocol used
uint8_t disconnect_pending
Set if a disconnect is deferred until the session is no longer in use.
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_tick_t last_tx
Last time a ratelimited packet is sent.
coap_bin_const_t * psk_hint
If client, this field contains the server provided identity hint.
coap_bin_const_t * last_token
uint8_t no_path_abbrev
Set is remote does not support Uri-Path-Abbrev.
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
uint64_t rl_ticks_per_packet
If not 0, rate limit NON to ticks per packet.
coap_session_type_t type
client or server side socket
coap_context_t * context
session's context
coap_queue_t * delayqueue_tail
tail of delayqueue for O(1) append
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_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
Representation of parsed URI.
coap_str_const_t host
The host part of the URI.