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>
67#ifndef INET6_ADDRSTRLEN
68#define INET6_ADDRSTRLEN 40
72#define min(a,b) ((a) < (b) ? (a) : (b))
88#error FRAC_BITS must be less or equal 8
92#define Q(frac,fval) ((uint16_t)(((1 << (frac)) * fval.integer_part) + \
93 ((1 << (frac)) * fval.fractional_part + 500)/1000))
96#define ACK_RANDOM_FACTOR \
97 Q(FRAC_BITS, session->ack_random_factor)
100#define ACK_TIMEOUT Q(FRAC_BITS, session->ack_timeout)
102#if !defined(WITH_LWIP) && !defined(WITH_CONTIKI)
117#include <lwip/memp.h>
119static void coap_retransmittimer_execute(
void *arg);
129 memp_free(MEMP_COAP_NODE, node);
135# define DEBUG DEBUG_PRINT
138#include "net/ip/uip-debug.h"
140#define UIP_IP_BUF ((struct uip_ip_hdr *)&uip_buf[UIP_LLH_LEN])
141#define UIP_UDP_BUF ((struct uip_udp_hdr *)&uip_buf[UIP_LLIPH_LEN])
143void coap_resources_init();
145unsigned char initialized = 0;
148PROCESS(coap_retransmit_process,
"message retransmit process");
163 unsigned int result = 0;
212 if (node->
t < q->
t) {
224 }
while (q && q->
t <= node->
t);
274 memset(node, 0,
sizeof(*node));
302#if COAP_CLIENT_SUPPORT
330#if COAP_SERVER_SUPPORT
363 memset (&setup_data, 0,
sizeof(setup_data));
369 if (key && key_len > 0) {
394 coap_log(
LOG_ERR,
"coap_context_set_pki: Wrong version of setup_data\n");
406 const char *ca_dir) {
419 unsigned int max_idle_sessions) {
430 unsigned int max_handshake_sessions) {
441 unsigned int csm_timeout) {
452 uint32_t csm_max_message_size) {
453 assert(csm_max_message_size >= 64);
464 unsigned int session_timeout) {
474#ifdef COAP_EPOLL_SUPPORT
475 return context->epfd;
487#if ! COAP_SERVER_SUPPORT
506 coap_resources_init();
508 c = &the_coap_context;
514#ifdef COAP_EPOLL_SUPPORT
515 c->epfd = epoll_create1(0);
517 coap_log(
LOG_ERR,
"coap_new_context: Unable to epoll_create: %s (%d)\n",
523 c->eptimerfd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK);
524 if (c->eptimerfd == -1) {
525 coap_log(
LOG_ERR,
"coap_new_context: Unable to timerfd_create: %s (%d)\n",
532 struct epoll_event event;
535 memset(&event, 0,
sizeof(event));
536 event.events = EPOLLIN;
538 event.data.ptr = NULL;
540 ret = epoll_ctl(c->epfd, EPOLL_CTL_ADD, c->eptimerfd, &event);
543 "%s: epoll_ctl ADD failed: %s (%d)\n",
565#if COAP_SERVER_SUPPORT
568 if (endpoint == NULL) {
574#if !defined(WITH_LWIP)
580 process_start(&coap_retransmit_process, (
char *)c);
582 PROCESS_CONTEXT_BEGIN(&coap_retransmit_process);
585 etimer_set(&the_coap_context.retransmit_timer, 0xFFFF);
586 PROCESS_CONTEXT_END(&coap_retransmit_process);
591#if defined(COAP_EPOLL_SUPPORT) || COAP_SERVER_SUPPORT
615#if COAP_SERVER_SUPPORT
624 coap_retransmittimer_restart(context);
630#if COAP_SERVER_SUPPORT
633 HASH_ITER(hh, context->
cache, cp, ctmp) {
642 LL_FOREACH_SAFE(context->
endpoint, ep, tmp) {
647#if COAP_CLIENT_SUPPORT
657#ifdef COAP_EPOLL_SUPPORT
658 if (context->eptimerfd != -1) {
660 struct epoll_event event;
663 ret = epoll_ctl(context->epfd, EPOLL_CTL_DEL, context->eptimerfd, &event);
666 "%s: epoll_ctl DEL failed: %s (%d)\n",
670 close(context->eptimerfd);
671 context->eptimerfd = -1;
673 if (context->epfd != -1) {
674 close(context->epfd);
706 if (opt_iter.
number & 0x01) {
708 switch (opt_iter.
number) {
723#if COAP_SERVER_SUPPORT
724 if ((opt_iter.
number & 0x02) == 0) {
771 ssize_t bytes_written = -1;
773 switch(session->
proto) {
799 return bytes_written;
804 ssize_t bytes_written;
814 bytes_written = coap_socket_send_pdu(sock, session, pdu);
827#if ! COAP_CLIENT_SUPPORT
886 coap_log(
LOG_ERR,
"Multicast requests cannot be Confirmable (RFC7252 8.1)\n");
907 return bytes_written;
960#define FP1 Q(FRAC_BITS, ((coap_fixed_point_t){1,0}))
963#define SHR_FP(val,frac) (((val) + (1 << ((frac) - 1))) >> (frac))
1010 coap_retransmittimer_restart(context);
1021 PROCESS_CONTEXT_BEGIN(&coap_retransmit_process);
1022 etimer_set(&context->retransmit_timer, nextpdu->
t);
1023 PROCESS_CONTEXT_END(&coap_retransmit_process);
1031#ifdef COAP_EPOLL_SUPPORT
1040 const uint8_t *b,
size_t blen) {
1041 return alen == blen && (alen == 0 || memcmp(a, b, alen) == 0);
1049 int timeout_ms = 5000;
1051#include <netif/tapif.h>
1052 struct netif *netif = ip_route(&session->
sock.pcb->local_ip,
1080 result = tapif_select(netif);
1090 sys_check_timeouts();
1094 if (result <= timeout_ms) {
1095 timeout_ms -= result;
1124#if COAP_CLIENT_SUPPORT
1128 int observe_action = -1;
1129 int have_block1 = 0;
1145 (block.
m == 1 || block.
bert == 1))
1153 coap_log(
LOG_DEBUG,
"Token reused - see https://www.rfc-editor.org/rfc/rfc9175.html#section-4.2\n");
1159 memset(&block, 0,
sizeof(block));
1167 if (observe_action != -1 || have_block1 ||
1177 LL_FOREACH(session->
lg_crcv, lg_crcv) {
1192 LL_DELETE(session->
lg_crcv, lg_crcv);
1197 LL_DELETE(session->
lg_crcv, lg_crcv);
1203 if (have_block1 && session->
lg_xmit) {
1204 LL_FOREACH(session->
lg_xmit, lg_xmit) {
1215 if (lg_crcv == NULL) {
1228#if COAP_CLIENT_SUPPORT
1231 LL_PREPEND(session->
lg_crcv, lg_crcv);
1244 ssize_t bytes_written;
1256 addr_str[
sizeof(addr_str)-1] =
'\000';
1258 sizeof(addr_str) - 1)) {
1262 if (addr_str[0] ==
'[') {
1263 cp = strchr(addr_str,
']');
1264 if (cp) *cp =
'\000';
1265 if (memcmp(&addr_str[1],
"::ffff:", 7) == 0) {
1274 cp = strchr(addr_str,
':');
1275 if (cp) *cp =
'\000';
1287 if (hop_limit == 1) {
1293 else if (hop_limit < 1 || hop_limit > 255) {
1307 if (pdu->
data && opt == NULL) {
1320 pdu->
data[data_len] =
'\000';
1321 a_match = strstr((
char*)pdu->
data, cp);
1322 if (a_match && (a_match == (
char*)pdu->
data || a_match[-1] ==
' ') &&
1323 ((
size_t)(a_match - (
char*)pdu->
data + len) == data_len ||
1324 a_match[len] ==
' ')) {
1334 if (pdu->
data == NULL) {
1342 (uint8_t *)&hop_limit);
1347 memmove(pdu->
data + len + 1, pdu->
data,
1349 memcpy(pdu->
data, cp, len);
1350 pdu->
data[len] =
' ';
1358 if (session->
echo) {
1363 session->
echo = NULL;
1370#if !COAP_DISABLE_TCP
1382 "Remote end did not indicate CSM support for Block1 enabled\n");
1386 "Remote end did not indicate CSM support for Block2 enabled\n");
1395 "Remote end did not indicate CSM support for BERT Block1\n");
1400 "Remote end did not indicate CSM support for BERT Block2\n");
1413 if (bytes_written < 0) {
1417#if !COAP_DISABLE_TCP
1419 (
size_t)bytes_written < pdu->used_size + pdu->
hdr_size) {
1443 node->
id = pdu->
mid;
1456 if (!context || !node)
1461 ssize_t bytes_written;
1476 coap_retransmittimer_restart(context);
1502 if (bytes_written < 0)
1503 return (
int)bytes_written;
1515#if COAP_SERVER_SUPPORT
1566#if COAP_SERVER_SUPPORT
1579#if COAP_CLIENT_SUPPORT
1624 ssize_t bytes_written;
1629 switch (session->
proto) {
1631#if !COAP_DISABLE_TCP
1640#if !COAP_DISABLE_TCP
1655 if (bytes_written > 0)
1658 if (bytes_written > 0)
1670#if COAP_CONSTRAINED_STACK
1671 static coap_mutex_t s_static_mutex = COAP_MUTEX_INITIALIZER;
1678#if COAP_CONSTRAINED_STACK
1679 coap_mutex_lock(&s_static_mutex);
1689 if (bytes_read < 0) {
1690 if (bytes_read == -2)
1696 }
else if (bytes_read > 0) {
1704#if !COAP_DISABLE_TCP
1706 ssize_t bytes_read = 0;
1710 uint8_t *buf = packet->
payload;
1711 size_t buf_len =
sizeof(packet->
payload);
1718 if (bytes_read > 0) {
1724 retry = bytes_read == (ssize_t)buf_len;
1725 while (bytes_read > 0) {
1730 size_t n =
min(len, (
size_t)bytes_read);
1738#if COAP_CONSTRAINED_STACK
1739 coap_mutex_unlock(&s_static_mutex);
1742#if COAP_CONSTRAINED_STACK
1743 coap_mutex_lock(&s_static_mutex);
1756 size_t n =
min(len, (
size_t)bytes_read);
1763 if (size > COAP_DEFAULT_MAX_PDU_RX_SIZE) {
1765 "** %s: incoming PDU length too large (%zu > %lu)\n",
1767 size, COAP_DEFAULT_MAX_PDU_RX_SIZE);
1788#if COAP_CONSTRAINED_STACK
1789 coap_mutex_unlock(&s_static_mutex);
1792#if COAP_CONSTRAINED_STACK
1793 coap_mutex_lock(&s_static_mutex);
1814 }
while (bytes_read == 0 && retry);
1819#if COAP_CONSTRAINED_STACK
1820 coap_mutex_unlock(&s_static_mutex);
1824#if COAP_SERVER_SUPPORT
1827 ssize_t bytes_read = -1;
1829#if COAP_CONSTRAINED_STACK
1830 static coap_mutex_t e_static_mutex = COAP_MUTEX_INITIALIZER;
1840#if COAP_CONSTRAINED_STACK
1841 coap_mutex_lock(&e_static_mutex);
1850 if (bytes_read < 0) {
1852 }
else if (bytes_read > 0) {
1862#if COAP_CONSTRAINED_STACK
1863 coap_mutex_unlock(&e_static_mutex);
1882 return session != NULL;
1888#ifdef COAP_EPOLL_SUPPORT
1892 "coap_io_do_io() requires libcoap not compiled for using epoll\n");
1896#if COAP_SERVER_SUPPORT
1898 LL_FOREACH_SAFE(ctx->
endpoint, ep, tmp) {
1900 coap_read_endpoint(ctx, ep, now);
1902 coap_write_endpoint(ctx, ep, now);
1904 coap_accept_endpoint(ctx, ep, now);
1919#if COAP_CLIENT_SUPPORT
1924 coap_connect_session(ctx, s, now);
1944#ifndef COAP_EPOLL_SUPPORT
1949 "coap_io_do_epoll() requires libcoap compiled for using epoll\n");
1955 for(j = 0; j < nevents; j++) {
1960#if COAP_SERVER_SUPPORT
1964 (events[j].events & EPOLLIN)) {
1966 coap_read_endpoint(endpoint->
context, endpoint, now);
1970 (events[j].events & EPOLLOUT)) {
1977 coap_write_endpoint(endpoint->
context, endpoint, now);
1981 (events[j].events & EPOLLIN)) {
1983 coap_accept_endpoint(endpoint->
context, endpoint, now);
1995#if COAP_CLIENT_SUPPORT
1997 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
1999 coap_connect_session(session->
context, session, now);
2008 (events[j].events & (EPOLLIN|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
2014 (events[j].events & (EPOLLOUT|EPOLLERR|EPOLLHUP|EPOLLRDHUP))) {
2027 else if (ctx->eptimerfd != -1) {
2036 if (read(ctx->eptimerfd, &count,
sizeof(count)) == -1) {
2049 uint8_t *msg,
size_t msg_len) {
2088 if (!queue || !*queue)
2093 if (session == (*queue)->session &&
id == (*queue)->id) {
2095 *queue = (*queue)->
next;
2097 (*queue)->
t += (*node)->t;
2099 (*node)->next = NULL;
2110 }
while (q && (session != q->
session ||
id != q->
id));
2167 const uint8_t *token,
size_t token_length) {
2209#if COAP_ERROR_PHRASE_LENGTH > 0
2216 size += strlen(phrase) + 1;
2253 uint16_t delta = opt_iter.
number - opt_num;
2257 }
else if (delta < 269) {
2267 switch (*option & 0x0f) {
2278 opt_num = opt_iter.
number;
2300#if COAP_ERROR_PHRASE_LENGTH > 0
2303 coap_add_data(response, (
size_t)strlen(phrase), (
const uint8_t *)phrase);
2310#if COAP_SERVER_SUPPORT
2317 unsigned char buf[1];
2329#define SZX_TO_BYTES(SZX) ((size_t)(1 << ((SZX) + 4)))
2345 ssize_t wkc_len = get_wkc_len(session->
context, query);
2361 assert (len <= (
size_t)wkc_len);
2362 data_string->
length = len;
2378 ".well-known/core: truncating data length to %zu from %zu\n",
2385 free_wellknown_response(session, data_string);
2389 -1, 0, data_string->
length,
2391 free_wellknown_response,
2393 goto error_released;
2400 free_wellknown_response(session, data_string);
2402 if (response->
code == 0) {
2406 response->
data = NULL;
2424 int num_cancelled = 0;
2433#if COAP_SERVER_SUPPORT
2440 return num_cancelled;
2443#if COAP_SERVER_SUPPORT
2448enum respond_t { RESPONSE_DEFAULT, RESPONSE_DROP, RESPONSE_SEND };
2495static enum respond_t
2500 unsigned int val = 0;
2525 return RESPONSE_SEND;
2528 return RESPONSE_DROP;
2532 return RESPONSE_SEND;
2537 if ((resource->
flags &
2540 return RESPONSE_DROP;
2541 }
else if ((resource->
flags &
2544 if (response->
data == NULL)
2545 return RESPONSE_DROP;
2546 }
else if ((resource->
flags &
2549 return RESPONSE_DROP;
2550 }
else if ((resource->
flags &
2553 return RESPONSE_DROP;
2561 return RESPONSE_DROP;
2572 return RESPONSE_DROP;
2576 return RESPONSE_DROP;
2582 return RESPONSE_DEFAULT;
2602 enum respond_t respond = RESPONSE_DEFAULT;
2605 int is_proxy_uri = 0;
2606 int is_proxy_scheme = 0;
2607 int skip_hop_limit_check = 0;
2609 int send_early_empty_ack = 0;
2614 int added_block = 0;
2615#ifndef WITHOUT_ASYNC
2626#ifndef WITHOUT_ASYNC
2632 if (async->
delay == 0 || async->
delay > now) {
2645 is_proxy_scheme = 1;
2651 if (is_proxy_scheme || is_proxy_uri) {
2657 is_proxy_scheme ?
"Scheme" :
"Uri");
2661 if (((
size_t)pdu->
code - 1 <
2666 is_proxy_scheme ?
"Scheme" :
"Uri",
2683 memset(&uri, 0,
sizeof(uri));
2717 is_proxy_scheme = 0;
2718 skip_hop_limit_check = 1;
2724 if (!skip_hop_limit_check) {
2732 if (hop_limit == 1) {
2737 else if (hop_limit < 1 || hop_limit > 255) {
2754 if (!is_proxy_uri && !is_proxy_scheme) {
2760 if ((resource == NULL) || (resource->
is_unknown == 1) ||
2765 if (resource != NULL)
2786 if (is_proxy_uri || is_proxy_scheme) {
2790 resource = &resource_uri_wellknown;
2792 ((
size_t)pdu->
code - 1 <
2836 if ((
size_t)pdu->
code - 1 <
2857#ifndef WITHOUT_ASYNC
2884 if (block.
num != 0) {
2915 send_early_empty_ack = 1;
2917 if (send_early_empty_ack) {
2922 "Duplicate request with mid=0x%04x - not processed\n",
2924 goto drop_it_no_debug;
2930 resource, uri_path, observe,
2931 query, h, &added_block)) {
2947 h(resource, session, pdu, query, response);
2953 if (send_early_empty_ack &&
2958 if (response->
code == 0) {
2959 goto drop_it_no_debug;
2962 respond = no_response(pdu, response, session, resource);
2963 if (respond != RESPONSE_DROP) {
2982 && (response->
code == 0)) {
3010 node->
id = response->
mid;
3011 node->
pdu = response;
3016 " %s: mid=0x%x: mcast response delayed for %u.%03u secs\n",
3022 node->
timeout = (
unsigned int)delay;
3059#if COAP_CLIENT_SUPPORT
3118#if !COAP_DISABLE_TCP
3189 switch (pdu->
type) {
3203#if COAP_SERVER_SUPPORT
3214 if (pdu->
code == 0) {
3259#if COAP_SERVER_SUPPORT
3264 LL_FOREACH_SAFE(r->subscribers, obs, tmp) {
3296 "coap_dispatch: cannot create error response\n");
3313#if !COAP_DISABLE_TCP
3318#if COAP_SERVER_SUPPORT
3320 handle_request(context, session, pdu);
3323#if COAP_CLIENT_SUPPORT
3325 handle_response(context, session, sent ? sent->
pdu : NULL, pdu);
3377#if COAP_SERVER_SUPPORT
3380 LL_FOREACH(context->
endpoint, ep) {
3389#if COAP_CLIENT_SUPPORT
3399#ifndef WITHOUT_ASYNC
3405 LL_FOREACH_SAFE(context->
async_state, async, tmp) {
3406 if (async->
delay != 0 && async->
delay <= now) {
3408 handle_request(context, async->
session, async->
pdu);
3414 if (next_due == 0 || next_due > async->
delay - now)
3415 next_due = async->
delay - now;
3431#if defined(HAVE_WINSOCK2_H)
3432 WORD wVersionRequested = MAKEWORD(2, 2);
3434 WSAStartup(wVersionRequested, &wsaData);
3443#if COAP_SERVER_SUPPORT
3445 (
const uint8_t *)
".well-known/core" };
3446 memset(&resource_uri_wellknown, 0,
sizeof(resource_uri_wellknown));
3449 resource_uri_wellknown.
uri_path = &well_known;
3454#if defined(HAVE_WINSOCK2_H)
3463#if COAP_CLIENT_SUPPORT
3494#if ! defined WITH_CONTIKI && ! defined WITH_LWIP && ! defined RIOT_VERSION
3495#if COAP_SERVER_SUPPORT
3498 const char *ifname) {
3499 struct ip_mreq mreq4;
3500 struct ipv6_mreq mreq6;
3501 struct addrinfo *resmulti = NULL, hints, *ainfo;
3504 int mgroup_setup = 0;
3512 mreq6.ipv6mr_interface = 0;
3513 mreq4.imr_interface.s_addr = INADDR_ANY;
3515 memset(&hints, 0,
sizeof(hints));
3516 hints.ai_socktype = SOCK_DGRAM;
3519 result = getaddrinfo(group_name, NULL, &hints, &resmulti);
3523 "coap_join_mcast_group_intf: %s: "
3524 "Cannot resolve multicast address: %s\n",
3525 group_name, gai_strerror(result));
3535#if defined(ESPIDF_VERSION)
3536 struct netif *netif;
3543 for (ainfo = resmulti; ainfo != NULL && !(done_ip4 == 1 && done_ip6 == 1);
3544 ainfo = ainfo->ai_next) {
3545 switch (ainfo->ai_family) {
3550#if defined(ESPIDF_VERSION)
3551 netif = netif_find(ifname);
3553 mreq6.ipv6mr_interface = netif_get_index(netif);
3556 "coap_join_mcast_group_intf: %s: "
3557 "Cannot get IPv4 address: %s\n",
3560 memset (&ifr, 0,
sizeof(ifr));
3561 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
3562 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
3564#ifdef HAVE_IF_NAMETOINDEX
3565 mreq6.ipv6mr_interface = if_nametoindex(ifr.ifr_name);
3566 if (mreq6.ipv6mr_interface == 0) {
3568 "cannot get interface index for '%s'\n",
3575 "cannot get interface index for '%s': %s\n",
3580 mreq6.ipv6mr_interface = ifr.ifr_ifindex;
3589#if defined(ESPIDF_VERSION)
3590 netif = netif_find(ifname);
3592 mreq4.imr_interface.s_addr = netif_ip4_addr(netif)->addr;
3595 "coap_join_mcast_group_intf: %s: "
3596 "Cannot get IPv4 address: %s\n",
3603 ip4fd = socket(AF_INET, SOCK_DGRAM, 0);
3606 "coap_join_mcast_group_intf: %s: socket: %s\n",
3610 memset (&ifr, 0,
sizeof(ifr));
3611 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
3612 ifr.ifr_name[IFNAMSIZ - 1] =
'\000';
3613 result = ioctl(ip4fd, SIOCGIFADDR, &ifr);
3616 "coap_join_mcast_group_intf: %s: "
3617 "Cannot get IPv4 address: %s\n",
3622 mreq4.imr_interface = ((
struct sockaddr_in*)&ifr.ifr_addr)->sin_addr;
3635 for (ainfo = resmulti; ainfo != NULL; ainfo = ainfo->ai_next) {
3636 LL_FOREACH(ctx->
endpoint, endpoint) {
3642 if (ainfo->ai_family == AF_INET6) {
3649 mreq6.ipv6mr_interface =
3653 mreq6.ipv6mr_interface = 0;
3656 gaddr.
addr.
sin6.sin6_family = AF_INET6;
3658 gaddr.
addr.
sin6.sin6_addr = mreq6.ipv6mr_multiaddr =
3659 ((
struct sockaddr_in6 *)ainfo->ai_addr)->sin6_addr;
3660 result = setsockopt(endpoint->
sock.
fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
3661 (
char *)&mreq6,
sizeof(mreq6));
3663 else if (ainfo->ai_family == AF_INET) {
3673 mreq4.imr_interface.s_addr = INADDR_ANY;
3676 gaddr.
addr.
sin.sin_family = AF_INET;
3678 gaddr.
addr.
sin.sin_addr.s_addr = mreq4.imr_multiaddr.s_addr =
3679 ((
struct sockaddr_in *)ainfo->ai_addr)->sin_addr.s_addr;
3680 result = setsockopt(endpoint->
sock.
fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
3681 (
char *)&mreq4,
sizeof(mreq4));
3689 "coap_join_mcast_group_intf: %s: setsockopt: %s\n",
3695 addr_str[
sizeof(addr_str)-1] =
'\000';
3697 sizeof(addr_str) - 1)) {
3709 if (!mgroup_setup) {
3714 freeaddrinfo(resmulti);
3726#if COAP_CLIENT_SUPPORT
3732 if (setsockopt(session->
sock.
fd, IPPROTO_IP, IP_MULTICAST_TTL,
3733 (
const char *)&hops,
sizeof(hops)) < 0) {
3740 if (setsockopt(session->
sock.
fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
3741 (
const char *)&hops,
sizeof(hops)) < 0) {
3779PROCESS_THREAD(coap_retransmit_process, ev, data) {
3789 if (ev == PROCESS_EVENT_TIMER) {
3790 if (etimer_expired(&the_coap_context.retransmit_timer)) {
3795 while (nextpdu && nextpdu->
t <= now) {
3801 etimer_set(&the_coap_context.retransmit_timer,
3802 nextpdu ? nextpdu->
t - now : 0xFFFF);
3804 if (etimer_expired(&the_coap_context.notify_timer)) {
3806 etimer_reset(&the_coap_context.notify_timer);
3831static void coap_retransmittimer_execute(
void *arg) {
3837 ctx->timer_configured = 0;
3844 while (nextinqueue != NULL) {
3845 if (nextinqueue->
t > elapsed) {
3846 nextinqueue->
t -= elapsed;
3849 elapsed -= nextinqueue->
t;
3857 coap_retransmittimer_restart(ctx);
3863 if (ctx->timer_configured) {
3864 printf(
"clearing\n");
3865 sys_untimeout(coap_retransmittimer_execute, (
void*)ctx);
3866 ctx->timer_configured = 0;
3888 printf(
"scheduling for %d ticks\n", delay);
3889 sys_timeout(delay, coap_retransmittimer_execute, (
void*)ctx);
3890 ctx->timer_configured = 1;
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.
COAP_STATIC_INLINE void coap_address_copy(coap_address_t *dst, const coap_address_t *src)
Pulls together all the internal only header files.
ssize_t coap_socket_read(coap_socket_t *sock, uint8_t *data, size_t data_len)
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.
ssize_t coap_network_read(coap_socket_t *sock, coap_packet_t *packet)
Function interface for reading data.
ssize_t coap_network_send(coap_socket_t *sock, const coap_session_t *session, const uint8_t *data, size_t datalen)
Function interface for data transmission.
#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
void coap_update_epoll_timer(coap_context_t *context, coap_tick_t delay)
Update the epoll timer fd as to when it is to trigger.
#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)
#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
#define COAP_SOCKET_EMPTY
coap_socket_flags_t values
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_send(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
ssize_t coap_tls_read(coap_session_t *session COAP_UNUSED, uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
int coap_dtls_receive(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
ssize_t coap_tls_write(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)
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...
unsigned int coap_io_prepare_epoll(coap_context_t *ctx, coap_tick_t now)
Any now timed out delayed packet is transmitted, along with any packets associated with requested obs...
void coap_io_do_epoll(coap_context_t *ctx, struct epoll_event *events, size_t nevents)
Process all the epoll events.
int coap_io_process(coap_context_t *ctx, uint32_t timeout_ms)
The main I/O processing function.
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)
coap_lg_crcv_t * coap_block_new_lg_crcv(coap_session_t *session, coap_pdu_t *pdu)
int coap_handle_response_send_block(coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd)
void coap_check_code_lg_xmit(coap_session_t *session, coap_pdu_t *response, coap_resource_t *resource, coap_string_t *query, coap_pdu_code_t request_method)
The function checks that the code in a newly formed lg_xmit created by coap_add_data_large_response()...
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)
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, coap_string_t *query, coap_method_handler_t h, int *added_block)
#define COAP_OPT_BLOCK_SZX(opt)
Returns the value of the SZX-field of a Block option opt.
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.
int coap_add_data_large_response(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.
#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_ticks(coap_tick_t *t)
Sets t to the internal time with COAP_TICKS_PER_SECOND resolution.
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.
coap_tick_t coap_check_async(coap_context_t *context, coap_tick_t now)
Checks if there are any pending Async requests - if so, send them off.
void coap_delete_all_async(coap_context_t *context)
Removes and frees off all of the async entries for the given context.
void coap_free_async(coap_session_t *session, coap_async_t *s)
Releases the memory that was allocated by coap_register_async() for the object async.
coap_async_t * coap_find_async(coap_session_t *session, coap_bin_const_t token)
Retrieves the object identified by token from the list of asynchronous transactions that are register...
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.
coap_print_status_t coap_print_wellknown(coap_context_t *, unsigned char *, size_t *, size_t, const coap_string_t *)
void coap_delete_all_resources(coap_context_t *context)
Deletes all resources from given context and frees their storage.
#define RESOURCES_ITER(r, tmp)
coap_resource_t * coap_get_resource_from_uri_path(coap_context_t *context, coap_str_const_t *uri_path)
Returns the resource identified by the unique string uri_path.
#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...
#define COAP_RESOURCE_FLAGS_LIB_DIS_MCAST_SUPPRESS_5_XX
Disable libcoap library suppressing 5.xx multicast responses (overridden by RFC7969 No-Response optio...
void(* coap_method_handler_t)(coap_resource_t *, coap_session_t *, const coap_pdu_t *, const coap_string_t *, coap_pdu_t *)
Definition of message handler function.
#define COAP_PRINT_STATUS_ERROR
#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...
unsigned int coap_adjust_basetime(coap_context_t *ctx, coap_tick_t now)
Set sendqueue_basetime in the given context object ctx to now.
void coap_delete_all(coap_queue_t *queue)
Removes all items from given queue and frees the allocated storage.
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.
int coap_delete_node(coap_queue_t *node)
Destroys specified node.
coap_queue_t * coap_peek_next(coap_context_t *context)
Returns the next pdu to send without removing from sendqeue.
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_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',...
coap_mid_t coap_retransmit(coap_context_t *context, coap_queue_t *node)
Handles retransmissions of confirmable messages.
void coap_cancel_all_messages(coap_context_t *context, coap_session_t *session, const uint8_t *token, size_t token_length)
Cancels all outstanding messages for session session that have the specified token.
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_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.
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.
void coap_context_set_session_timeout(coap_context_t *context, unsigned int session_timeout)
Set the session timeout value.
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.
unsigned int coap_context_get_max_handshake_sessions(const coap_context_t *context)
Get the session timeout value.
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.
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.
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.
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_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_free_context(coap_context_t *context)
CoAP stack context must be released with coap_free_context().
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_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.
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.
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.
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.
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.
COAP_STATIC_INLINE 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.
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).
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_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.
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_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.
void coap_register_option(coap_context_t *ctx, uint16_t type)
Registers the option type type with the given context object ctx.
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_get_app_data(const coap_context_t *ctx)
Returns any application-specific data that has been stored with context using the function coap_set_a...
void coap_context_set_max_idle_sessions(coap_context_t *context, unsigned int max_idle_sessions)
Set the maximum idle sessions count.
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)
Stores data with the given CoAP context.
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.
coap_mid_t coap_send(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
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(coap_context_t *context, unsigned int csm_timeout)
Set the CSM timeout value.
@ COAP_RESPONSE_FAIL
Response not liked - send CoAP RST packet.
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.
void * coap_dtls_new_client_session(coap_session_t *coap_session)
Create a new client-side session.
void * coap_tls_new_client_session(coap_session_t *coap_session, int *connected)
Create a new TLS client-side session.
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_TCP_FAILED
Triggered when TCP layer fails for some reason.
@ COAP_EVENT_DTLS_CONNECTED
Triggered when (D)TLS session connected.
@ COAP_EVENT_TCP_CONNECTED
Triggered when TCP layer connects.
@ COAP_EVENT_DTLS_ERROR
Triggered when (D)TLS error occurs.
coap_log_t coap_get_log_level(void)
Get the current logging level.
void coap_show_pdu(coap_log_t level, const coap_pdu_t *pdu)
Display the contents of the specified pdu.
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(level,...)
Logging function.
#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.
#define COAP_PDU_IS_RESPONSE(pdu)
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_update_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Updates token in pdu with length len and 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_PDU_IS_SIGNALING(pdu)
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.
size_t coap_pdu_encode_header(coap_pdu_t *pdu, coap_proto_t proto)
Compose the protocol specific header for the specified PDU.
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_PROXY_SCHEME
#define COAP_DEFAULT_PORT
#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_OPTION_IF_NONE_MATCH
#define COAP_OPTION_URI_PATH
#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_SIGNALING_OPTION_CUSTODY
#define COAPS_DEFAULT_PORT
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_bin_const_t coap_pdu_get_token(const coap_pdu_t *pdu)
Gets the token associated with pdu.
@ 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
coap_session_t * coap_new_server_session(coap_context_t *ctx, coap_endpoint_t *ep)
Creates a new server session for the specified endpoint.
ssize_t coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu, coap_queue_t *node)
void coap_session_send_csm(coap_session_t *session)
Notify session transport has just connected and CSM exchange can now start.
#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.
ssize_t coap_session_send(coap_session_t *session, const uint8_t *data, size_t datalen)
Function interface for datagram data transmission.
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_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.
ssize_t coap_session_write(coap_session_t *session, const uint8_t *data, size_t datalen)
Function interface for stream data transmission.
void coap_free_endpoint(coap_endpoint_t *ep)
void coap_session_set_mtu(coap_session_t *session, unsigned mtu)
Set the session MTU.
size_t coap_session_max_pdu_size(const coap_session_t *session)
Get maximum acceptable PDU size.
coap_endpoint_t * coap_new_endpoint(coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto)
Create a new endpoint for communicating with peers.
#define COAP_PROTO_NOT_RELIABLE(p)
#define COAP_PROTO_RELIABLE(p)
void coap_session_release(coap_session_t *session)
Decrement reference counter on a session.
void coap_session_disconnected(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
coap_session_t * coap_session_reference(coap_session_t *session)
Increment reference counter on a session.
@ COAP_SESSION_TYPE_HELLO
server-side ephemeral session for responding to a client hello
@ COAP_SESSION_TYPE_CLIENT
client-side
@ COAP_SESSION_STATE_HANDSHAKE
@ COAP_SESSION_STATE_ESTABLISHED
@ COAP_SESSION_STATE_NONE
@ COAP_SESSION_STATE_CONNECTING
void coap_delete_bin_const(coap_bin_const_t *s)
Deletes the given const binary data and releases any memory 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...
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
#define COAP_SET_STR(st, l, v)
#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(coap_resource_t *resource, coap_session_t *session, const coap_binary_t *token)
Removes any subscription for observer from resource and releases the allocated storage.
coap_subscription_t * coap_add_observer(coap_resource_t *resource, coap_session_t *session, const coap_binary_t *token, const coap_pdu_t *pdu)
Adds the specified peer as observer for resource.
void coap_check_notify(coap_context_t *context)
Checks all known resources to see if they are dirty and then notifies subscribed observers.
void coap_handle_failed_notify(coap_context_t *context, coap_session_t *session, const coap_binary_t *token)
Handles a failed observe notify.
void coap_touch_observer(coap_context_t *context, coap_session_t *session, const coap_binary_t *token)
Flags that data is ready to be sent to observers.
int coap_socket_connect_tcp1(coap_socket_t *sock, const coap_address_t *local_if, const coap_address_t *server, int default_port, coap_address_t *local_addr, coap_address_t *remote_addr)
Create a new TCP socket and initiate the connection.
int coap_socket_connect_tcp2(coap_socket_t *sock, coap_address_t *local_addr, coap_address_t *remote_addr)
Complete the TCP Connection.
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_STATIC_INLINE void coap_free(void *object)
Wrapper function to coap_free_type() for backwards compatibility.
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().
#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)
COAP_STATIC_INLINE int token_match(const uint8_t *a, size_t alen, const uint8_t *b, size_t blen)
#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 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 void coap_read_session(coap_context_t *ctx, coap_session_t *session, coap_tick_t now)
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'
#define COAP_RESOURCE_CHECK_TIME
The interval in seconds to check if resources have changed.
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_session_t * session
transaction session
coap_pdu_t * pdu
copy of request pdu
coap_tick_t delay
When to delay to before triggering the response 0 indicates never trigger.
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 m
1 if more blocks follow, 0 otherwise
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
unsigned int csm_timeout
Timeout for waiting for a CSM from the remote side.
void * app
application-specific data
coap_async_t * async_state
list of asynchronous message ids
coap_session_t * sessions
client sessions
coap_nack_handler_t nack_handler
unsigned int ping_timeout
Minimum inactivity time before sending a ping message.
coap_resource_t * resources
hash table or list of known resources
ssize_t(* network_send)(coap_socket_t *sock, const coap_session_t *session, const uint8_t *data, size_t datalen)
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
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.
coap_response_handler_t response_handler
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
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.
ssize_t(* network_read)(coap_socket_t *sock, coap_packet_t *packet)
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
Structure to hold large body (many blocks) client receive information.
uint8_t initial
If set, has not been used yet.
uint64_t state_token
state token
coap_binary_t * app_token
app requesting PDU token
uint8_t observe_set
Set if this is an observe receive PDU.
Structure to hold large body (many blocks) transmission information.
union coap_lg_xmit_t::@1 b
coap_pdu_t pdu
skeletal PDU
Iterator to run through PDU options.
coap_option_num_t number
decoded option number
coap_addr_tuple_t addr_info
local and remote addresses
unsigned char payload[COAP_RXBUFFER_SIZE]
payload
uint8_t * token
first byte of token, 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 token_length
length of Token
uint8_t hdr_size
actual size used for protocol-specific header (0 until header is encoded)
uint8_t * data
first byte of payload, if any
coap_mid_t mid
message id, if any, in regular host byte order
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_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
coap_bin_const_t * psk_key
If client, this field contains the current pre-shared key for server; When this field is NULL,...
coap_endpoint_t * endpoint
session's endpoint
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
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 relationaship with peer
uint8_t csm_bert_rem_support
CSM TCP BERT blocks supported (remote)
uint8_t block_mode
Zero or more COAP_BLOCK_ or'd options.
uint8_t read_header[8]
storage space for header of incoming message header
coap_addr_tuple_t addr_info
key: remote/local address info
coap_proto_t proto
protocol used
unsigned ref
reference count from queues
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
coap_mid_t last_ping_mid
the last keepalive message id that was used in this session
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_endpoint_t * endpoint
coap_socket_flags_t flags
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
host part of the URI