libcoap 4.3.5-develop-79a0414
Loading...
Searching...
No Matches
coap_session.c
Go to the documentation of this file.
1/* coap_session.c -- Session management for libcoap
2 *
3 * Copyright (C) 2017 Jean-Claue Michelou <jcm@spinetix.com>
4 * Copyright (C) 2022-2025 Jon Shallow <supjps-libcoap@jpshallow.com>
5 *
6 * SPDX-License-Identifier: BSD-2-Clause
7 *
8 * This file is part of the CoAP library libcoap. Please see
9 * README for terms of use.
10 */
11
18
19#ifndef COAP_SESSION_C_
20#define COAP_SESSION_C_
21
22#include <stdio.h>
23
24#ifdef COAP_EPOLL_SUPPORT
25#include <sys/epoll.h>
26#include <sys/timerfd.h>
27#endif /* COAP_EPOLL_SUPPORT */
28
32 uint32_t fr = fp1.fractional_part * fp2.fractional_part;
33
34 res.integer_part = fp1.integer_part * fp2.integer_part + fr/1000;
35 res.fractional_part = fr % 1000;
36 return res;
37}
38
42 uint32_t fr = fp1.fractional_part * u2;
43
44 res.integer_part = fp1.integer_part * u2 + fr/1000;
45 res.fractional_part = fr % 1000;
46 return res;
47}
48
52 uint32_t fr = fp1.fractional_part + fp2.fractional_part;
53
54 res.integer_part = fp1.integer_part + fp2.integer_part + fr/1000;
55 res.fractional_part = fr % 1000;
56 return res;
57}
58
61 coap_fixed_point_t res = fp1;
62
63 res.integer_part += u2;
64 return res;
65}
66
69 coap_fixed_point_t res = fp1;
70
71 res.integer_part -= u2;
72 return res;
73}
74
78 uint32_t num = (fp1.integer_part * 1000 + fp1.fractional_part) / u2;
79
80 res.integer_part = num / 1000;
81 res.fractional_part = num % 1000;
82 return res;
83}
84
85#if COAP_Q_BLOCK_SUPPORT
89 uint8_t ran;
90
91 coap_prng_lkd(&ran, sizeof(ran));
93 res = coap_multi_fixed_uint(res, ran);
94 res = coap_div_fixed_uint(res, 0xff);
95 res = coap_add_fixed_fixed(COAP_NON_TIMEOUT(session), res);
96 return res;
97}
98
104
105 return ticks;
106}
107
108/*
109 * Save away derived Congestion Control parameters for speed of access.
110 * They will get updated whenever a component variable is updated.
111 */
112
113/*
114 * NON_PROBING_WAIT = NON_TIMEOUT * ((2 ** NON_MAX_RETRANSMIT) - 1) *
115 * ACK_RANDOM_FACTOR + (2 * MAX_LATENCY) + NON_TIMEOUT_RANDOM
116 *
117 * Do not include NON_TIMEOUT_RANDOM as that changes
118 */
119static void
120coap_session_fix_non_probing_wait_base(coap_session_t *s) {
122
124 ((1 << (COAP_NON_MAX_RETRANSMIT(s) + 1)) -1));
128}
129
130/*
131 * NON_PARTIAL_TIMEOUT = NON_TIMEOUT * ((2 ** NON_MAX_RETRANSMIT) - 1) *
132 * ACK_RANDOM_FACTOR + (2 * MAX_LATENCY) + NON_TIMEOUT
133 */
134static void
135coap_session_fix_non_partial_timeout(coap_session_t *s) {
137
139 ((1 << (COAP_NON_MAX_RETRANSMIT(s) + 1)) -1));
144}
145#endif /* COAP_Q_BLOCK_SUPPORT */
146
147void
149 if (value.integer_part > 0 && value.fractional_part < 1000) {
150 session->ack_timeout = value;
151 coap_log_debug("***%s: session ack_timeout set to %u.%03u\n",
152 coap_session_str(session), session->ack_timeout.integer_part,
154 }
155}
156
157void
159 coap_fixed_point_t value) {
160 if (value.integer_part > 0 && value.fractional_part < 1000) {
161 session->ack_random_factor = value;
162 coap_log_debug("***%s: session ack_random_factor set to %u.%03u\n",
165#if COAP_Q_BLOCK_SUPPORT
166 coap_session_fix_non_probing_wait_base(session);
167 coap_session_fix_non_partial_timeout(session);
168#endif /* COAP_Q_BLOCK_SUPPORT */
169 }
170 return;
171}
172
173void
175 if (value > 0) {
176 session->max_retransmit = value;
177 coap_log_debug("***%s: session max_retransmit set to %u\n",
178 coap_session_str(session), session->max_retransmit);
179 }
180}
181
182void
183coap_session_set_nstart(coap_session_t *session, uint16_t value) {
184 if (value > 0) {
185 session->nstart = value;
186 coap_log_debug("***%s: session nstart set to %u\n",
187 coap_session_str(session), session->nstart);
188 }
189}
190
191void
193 coap_fixed_point_t value) {
194 if (value.integer_part > 0 && value.fractional_part < 1000) {
195 session->default_leisure = value;
196 coap_log_debug("***%s: session default_leisure set to %u.%03u\n",
199 }
200}
201
202void
204 if (value > 0) {
205 session->probing_rate = value;
206 coap_log_debug("***%s: session probing_rate set to %" PRIu32 "\n",
207 coap_session_str(session), session->probing_rate);
208 }
209}
210
211void
213#if COAP_Q_BLOCK_SUPPORT
214 if (value > 0) {
215 session->max_payloads = value;
216 coap_log_debug("***%s: session max_payloads set to %u\n",
217 coap_session_str(session), session->max_payloads);
218 coap_session_fix_non_probing_wait_base(session);
219 coap_session_fix_non_partial_timeout(session);
220 }
221#else /* ! COAP_Q_BLOCK_SUPPORT */
222 (void)session;
223 (void)value;
224#endif /* ! COAP_Q_BLOCK_SUPPORT */
225}
226
227void
229#if COAP_Q_BLOCK_SUPPORT
230 if (value > 0) {
231 session->non_max_retransmit = value;
232 coap_log_debug("***%s: session non_max_retransmit set to %u\n",
233 coap_session_str(session), session->non_max_retransmit);
234 coap_session_fix_non_probing_wait_base(session);
235 coap_session_fix_non_partial_timeout(session);
236 }
237#else /* ! COAP_Q_BLOCK_SUPPORT */
238 (void)session;
239 (void)value;
240#endif /* ! COAP_Q_BLOCK_SUPPORT */
241}
242
243void
245 coap_fixed_point_t value) {
246#if COAP_Q_BLOCK_SUPPORT
247 if (value.integer_part > 0 && value.fractional_part < 1000) {
248 session->non_timeout = value;
249 coap_log_debug("***%s: session non_timeout set to %u.%03u\n",
250 coap_session_str(session), session->non_timeout.integer_part,
251 session->non_timeout.fractional_part);
252 coap_session_fix_non_probing_wait_base(session);
253 coap_session_fix_non_partial_timeout(session);
254 }
255#else /* ! COAP_Q_BLOCK_SUPPORT */
256 (void)session;
257 (void)value;
258#endif /* ! COAP_Q_BLOCK_SUPPORT */
259}
260
261void
263 coap_fixed_point_t value) {
264#if COAP_Q_BLOCK_SUPPORT
265 if (value.integer_part > 0 && value.fractional_part < 1000)
266 session->non_receive_timeout = value;
267 coap_log_debug("***%s: session non_receive_timeout set to %u.%03u\n",
268 coap_session_str(session),
269 session->non_receive_timeout.integer_part,
270 session->non_receive_timeout.fractional_part);
271#else /* ! COAP_Q_BLOCK_SUPPORT */
272 (void)session;
273 (void)value;
274#endif /* ! COAP_Q_BLOCK_SUPPORT */
275}
276
279 return session->ack_timeout;
280}
281
284 return session->ack_random_factor;
285}
286
287uint16_t
289 return session->max_retransmit;
290}
291
292uint16_t
294 return session->nstart;
295}
296
299 return session->default_leisure;
300}
301
302uint32_t
304 return session->probing_rate;
305}
306
307uint16_t
309#if COAP_Q_BLOCK_SUPPORT
310 return session->max_payloads;
311#else /* ! COAP_Q_BLOCK_SUPPORT */
312 (void)session;
314#endif /* ! COAP_Q_BLOCK_SUPPORT */
315}
316
317uint16_t
319#if COAP_Q_BLOCK_SUPPORT
320 return session->non_max_retransmit;
321#else /* ! COAP_Q_BLOCK_SUPPORT */
322 (void)session;
324#endif /* ! COAP_Q_BLOCK_SUPPORT */
325}
326
329#if COAP_Q_BLOCK_SUPPORT
330 return session->non_timeout;
331#else /* ! COAP_Q_BLOCK_SUPPORT */
332 (void)session;
334#endif /* ! COAP_Q_BLOCK_SUPPORT */
335}
336
339#if COAP_Q_BLOCK_SUPPORT
340 return session->non_receive_timeout;
341#else /* ! COAP_Q_BLOCK_SUPPORT */
342 (void)session;
344#endif /* ! COAP_Q_BLOCK_SUPPORT */
345}
346
349 coap_lock_lock(return NULL);
352 return session;
353}
354
357 ++session->ref;
358 return session;
359}
360
361COAP_API void
363 if (session) {
364#if COAP_THREAD_SAFE
365 coap_context_t *context = session->context;
366 (void)context;
367#endif /* COAP_THREAD_SAFE */
368
369 coap_lock_lock(return);
372 }
373}
374
375void
377 if (session) {
379#ifndef __COVERITY__
380 assert(session->ref > 0);
381 if (session->ref > 0)
382 --session->ref;
383 if (session->ref == 0 && session->type == COAP_SESSION_TYPE_CLIENT)
384 coap_session_free(session);
385#else /* __COVERITY__ */
386 /* Coverity scan is fooled by the reference counter leading to
387 * false positives for USE_AFTER_FREE. */
388 --session->ref;
389 __coverity_negative_sink__(session->ref);
390 /* Indicate that resources are released properly. */
391 if (session->ref == 0 && session->type == COAP_SESSION_TYPE_CLIENT) {
392 __coverity_free__(session);
393 }
394#endif /* __COVERITY__ */
395 }
396}
397
398COAP_API void
399coap_session_set_app_data(coap_session_t *session, void *app_data) {
400 assert(session);
401 coap_lock_lock(return);
402 coap_session_set_app_data2_lkd(session, app_data, NULL);
404}
405
406void *
408 assert(session);
409 return session->app_data;
410}
411
412COAP_API void *
415 void *old_data;
416
417 coap_lock_lock(return NULL);
418 old_data = coap_session_set_app_data2_lkd(session, app_data, callback);
420 return old_data;
421}
422
423void *
426 void *old_data = session->app_data;
427
428 session->app_data = app_data;
429 session->app_cb = app_data ? callback : NULL;
430 return old_data;
431}
432
433static coap_session_t *
435 const coap_addr_hash_t *addr_hash,
436 const coap_address_t *local_addr,
437 const coap_address_t *remote_addr, int ifindex,
438 coap_context_t *context, coap_endpoint_t *endpoint) {
440 sizeof(coap_session_t));
441#if ! COAP_SERVER_SUPPORT
442 (void)endpoint;
443#endif /* ! COAP_SERVER_SUPPORT */
444 if (!session)
445 return NULL;
446 memset(session, 0, sizeof(*session));
447 session->proto = proto;
448 session->type = type;
449 if (addr_hash)
450 memcpy(&session->addr_hash, addr_hash, sizeof(session->addr_hash));
451 else
452 memset(&session->addr_hash, 0, sizeof(session->addr_hash));
453 if (local_addr) {
454 coap_address_copy(&session->addr_info.local, local_addr);
455#if COAP_CLIENT_SUPPORT
456 coap_address_copy(&session->local_reconnect, local_addr);
457#endif /* COAP_CLIENT_SUPPORT */
458 } else {
460#if COAP_CLIENT_SUPPORT
462#endif /* COAP_CLIENT_SUPPORT */
463 }
464 if (remote_addr)
465 coap_address_copy(&session->addr_info.remote, remote_addr);
466 else
468 session->ifindex = ifindex;
469 session->context = context;
470#if COAP_SERVER_SUPPORT
471 session->endpoint = endpoint;
472 if (endpoint)
473 session->mtu = endpoint->default_mtu;
474 else
475#endif /* COAP_SERVER_SUPPORT */
477 session->block_mode = context->block_mode;
478 if (proto == COAP_PROTO_DTLS) {
479 session->tls_overhead = 29;
480 if (session->tls_overhead >= session->mtu) {
481 session->tls_overhead = session->mtu;
482 coap_log_err("DTLS overhead exceeds MTU\n");
483 }
484 }
488 session->nstart = COAP_DEFAULT_NSTART;
491#if COAP_Q_BLOCK_SUPPORT
492 session->max_payloads = COAP_DEFAULT_MAX_PAYLOADS;
493 session->non_max_retransmit = COAP_DEFAULT_NON_MAX_RETRANSMIT;
494 session->non_timeout = COAP_DEFAULT_NON_TIMEOUT;
495 session->non_receive_timeout = COAP_DEFAULT_NON_RECEIVE_TIMEOUT;
496 coap_session_fix_non_probing_wait_base(session);
497 coap_session_fix_non_partial_timeout(session);
498#endif /* COAP_Q_BLOCK_SUPPORT */
499 session->dtls_event = -1;
504 session->max_token_size = context->max_token_size; /* RFC8974 */
505 if (session->type != COAP_SESSION_TYPE_CLIENT)
507
508 /* Randomly initialize */
509 /* TCP/TLS have no notion of mid */
510 if (COAP_PROTO_NOT_RELIABLE(session->proto))
511 coap_prng_lkd((unsigned char *)&session->tx_mid, sizeof(session->tx_mid));
512 coap_prng_lkd((unsigned char *)&session->tx_rtag, sizeof(session->tx_rtag));
513
514 return session;
515}
516
517void
519 coap_queue_t *q, *tmp;
520 coap_lg_xmit_t *lq, *ltmp;
521
522#if COAP_PROXY_SUPPORT
523 if (session->ref_proxy_subs)
524 coap_delete_proxy_subscriber(session, NULL, 0, COAP_PROXY_SUBS_ALL);
525#endif /* COAP_PROXY_SUPPORT */
526#if COAP_CLIENT_SUPPORT
527 coap_lg_crcv_t *lg_crcv, *etmp;
528
529 /* Need to do this before (D)TLS and socket is closed down */
530 LL_FOREACH_SAFE(session->lg_crcv, lg_crcv, etmp) {
531 if (lg_crcv->observe_set && session->no_observe_cancel == 0) {
532 /* Need to close down observe */
533 if (coap_cancel_observe_lkd(session, lg_crcv->app_token, COAP_MESSAGE_NON)) {
534 /* Need to delete node we set up for NON */
535 coap_queue_t *queue = session->context->sendqueue;
536
537 while (queue) {
538 if (queue->session == session) {
540 break;
541 }
542 queue = queue->next;
543 }
544 }
545 }
546 /* In case coap_cancel_observe_lkd() failure, which could clear down lg_crcv */
547 if (!session->lg_crcv)
548 break;
549 LL_DELETE(session->lg_crcv, lg_crcv);
550 coap_block_delete_lg_crcv(session, lg_crcv);
551 }
552#endif /* COAP_CLIENT_SUPPORT */
553
554 LL_FOREACH_SAFE(session->delayqueue, q, tmp) {
555 if (q->pdu->type==COAP_MESSAGE_CON) {
556 coap_handle_nack(session, q->pdu,
557 session->proto == COAP_PROTO_DTLS ?
559 q->id);
560 }
562 }
563 if (session->partial_pdu)
565 if (session->sock.lfunc[COAP_LAYER_SESSION].l_close)
566 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
567 if (session->psk_identity)
569 if (session->psk_key)
571 if (session->psk_hint)
573
574#if COAP_SERVER_SUPPORT
575 coap_cache_entry_t *cp, *ctmp;
576 HASH_ITER(hh, session->context->cache, cp, ctmp) {
577 /* cp->session is NULL if not session based */
578 if (cp->session == session) {
579 coap_delete_cache_entry(session->context, cp);
580 }
581 }
582#endif /* COAP_PROXY_SUPPORT */
583 LL_FOREACH_SAFE(session->lg_xmit, lq, ltmp) {
584 LL_DELETE(session->lg_xmit, lq);
585 coap_block_delete_lg_xmit(session, lq);
586 }
587#if COAP_SERVER_SUPPORT
588 coap_lg_srcv_t *sq, *stmp;
589
590 LL_FOREACH_SAFE(session->lg_srcv, sq, stmp) {
591 LL_DELETE(session->lg_srcv, sq);
592 coap_block_delete_lg_srcv(session, sq);
593 }
594#endif /* COAP_SERVER_SUPPORT */
595#if COAP_OSCORE_SUPPORT
597#endif /* COAP_OSCORE_SUPPORT */
598#if COAP_WS_SUPPORT
599 coap_free_type(COAP_STRING, session->ws);
600 coap_delete_str_const(session->ws_host);
601#endif /* COAP_WS_SUPPORT */
602}
603
604void
606 if (!session)
607 return;
609 assert(session->ref == 0);
610 if (session->ref)
611 return;
612 /* Make sure nothing gets deleted under our feet */
614 coap_session_mfree(session);
615#if COAP_SERVER_SUPPORT
617 if (session->endpoint) {
618 if (session->endpoint->sessions)
619 SESSIONS_DELETE(session->endpoint->sessions, session);
620 } else
621#endif /* COAP_SERVER_SUPPORT */
622#if COAP_CLIENT_SUPPORT
623 if (session->context) {
624 if (session->context->sessions)
625 SESSIONS_DELETE(session->context->sessions, session);
626 }
628#endif /* COAP_CLIENT_SUPPORT */
630 coap_delete_bin_const(session->echo);
631#if COAP_SERVER_SUPPORT
633#endif /* COAP_SERVER_SUPPORT */
634
635 if (session->app_cb) {
636 session->app_cb(session->app_data);
637 }
638 coap_log_debug("***%s: session %p: closed\n", coap_session_str(session),
639 (void *)session);
640 assert(session->ref == 1);
642}
643
644#if COAP_SERVER_SUPPORT
645void
647 int i;
648
651 coap_cancel_all_messages(session->context, session, NULL);
652 RESOURCES_ITER(session->context->resources, r) {
653 /* In case code is broken somewhere */
654 for (i = 0; i < 1000; i++) {
655 if (!coap_delete_observer(r, session, NULL))
656 break;
657 }
658 }
659 if (session->context->unknown_resource) {
660 /* In case code is broken somewhere */
661 for (i = 0; i < 1000; i++) {
662 if (!coap_delete_observer(session->context->unknown_resource, session, NULL))
663 break;
664 }
665 }
666 if (session->context->proxy_uri_resource) {
667 /* In case code is broken somewhere */
668 for (i = 0; i < 1000; i++) {
669 if (!coap_delete_observer(session->context->proxy_uri_resource, session, NULL))
670 break;
671 }
672 }
673 while (session->delayqueue) {
674 coap_queue_t *q = session->delayqueue;
675
676 session->delayqueue = q->next;
678 }
679 /* Force session to go away */
682
684}
685#endif /* COAP_SERVER_SUPPORT */
686
687static size_t
689 size_t max_with_header) {
690#if COAP_DISABLE_TCP
691 (void)session;
692 return max_with_header > COAP_PDU_MAX_UDP_HEADER_SIZE
693 ? max_with_header - COAP_PDU_MAX_UDP_HEADER_SIZE
694 : 0;
695#else /* !COAP_DISABLE_TCP */
696 if (COAP_PROTO_NOT_RELIABLE(session->proto))
697 return max_with_header > COAP_PDU_MAX_UDP_HEADER_SIZE
698 ? max_with_header - COAP_PDU_MAX_UDP_HEADER_SIZE
699 : 0;
700 /* we must assume there is no token to be on the safe side */
701 if (max_with_header <= 2)
702 return 0;
703 else if (max_with_header <= COAP_MAX_MESSAGE_SIZE_TCP0 + 2)
704 return max_with_header - 2;
705 else if (max_with_header <= COAP_MAX_MESSAGE_SIZE_TCP8 + 3)
706 return max_with_header - 3;
707 else if (max_with_header <= COAP_MAX_MESSAGE_SIZE_TCP16 + 4)
708 return max_with_header - 4;
709 else
710 return max_with_header - COAP_PDU_MAX_TCP_HEADER_SIZE;
711#endif /* !COAP_DISABLE_TCP */
712}
713
714size_t
716 if (session->csm_rcv_mtu)
718 (size_t)(session->csm_rcv_mtu));
719
721 (size_t)(session->mtu - session->tls_overhead));
722}
723
724COAP_API size_t
726 size_t size;
727 coap_session_t *session_rw;
728
729 /*
730 * Need to do this to not get a compiler warning about const parameters
731 * but need to maintain source code backward compatibility
732 */
733 memcpy(&session_rw, &session, sizeof(session_rw));
734 coap_lock_lock(return 0);
735 size = coap_session_max_pdu_size_lkd(session_rw);
737 return size;
738}
739
740size_t
742 size_t max_with_header;
743
745#if COAP_CLIENT_SUPPORT
746 /*
747 * Delay if session->doing_first is set.
748 * E.g. Reliable and CSM not in yet for checking block support
749 */
750 coap_session_t *session_rw;
751
752 /*
753 * Need to do this to not get a compiler warning about const parameters
754 * but need to maintain source code backward compatibility
755 */
756 memcpy(&session_rw, &session, sizeof(session_rw));
757 if (coap_client_delay_first(session_rw) == 0) {
758 coap_log_debug("coap_client_delay_first: timeout\n");
759 /* Have to go with the defaults */
760 }
761#endif /* COAP_CLIENT_SUPPORT */
762
763 max_with_header = (size_t)(session->mtu - session->tls_overhead);
764
765 return coap_session_max_pdu_size_internal(session, max_with_header);
766}
767
768void
769coap_session_set_mtu(coap_session_t *session, unsigned mtu) {
770 if (mtu > COAP_DEFAULT_MAX_PDU_RX_SIZE) {
771 mtu = COAP_DEFAULT_MAX_PDU_RX_SIZE;
772 coap_log_debug("* %s: Restricting MTU size to %u\n",
773 coap_session_str(session), mtu);
774 }
775 if (mtu < 64)
776 mtu = 64;
777 session->mtu = mtu;
778 if (session->tls_overhead >= session->mtu) {
779 session->tls_overhead = session->mtu;
780 coap_log_err("DTLS overhead exceeds MTU\n");
781 }
782}
783
784ssize_t
786 coap_queue_t *node) {
787 if (node) {
788 coap_queue_t *removed = NULL;
789 coap_remove_from_queue(&session->context->sendqueue, session, node->id, &removed);
790 assert(removed == node);
792 node->session = NULL;
793 node->t = 0;
794 } else {
795 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
796 coap_queue_t *q = NULL;
797 /* Check same mid is not getting re-used in violation of RFC7252 */
798 LL_FOREACH(session->delayqueue, q) {
799 if (q->id == pdu->mid) {
800 coap_log_err("** %s: mid=0x%04x: already in-use - dropped\n",
801 coap_session_str(session), pdu->mid);
802 return COAP_INVALID_MID;
803 }
804 }
805 }
806 node = coap_new_node();
807 if (node == NULL)
808 return COAP_INVALID_MID;
809 node->id = pdu->mid;
810 node->pdu = pdu;
811 if (pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
812 uint8_t r;
813 coap_prng_lkd(&r, sizeof(r));
814 /* add timeout in range [ACK_TIMEOUT...ACK_TIMEOUT * ACK_RANDOM_FACTOR] */
815 node->timeout = coap_calc_timeout(session, r);
816 }
817 coap_address_copy(&node->remote, &session->addr_info.remote);
818 }
819 LL_APPEND(session->delayqueue, node);
820 coap_log_debug("** %s: mid=0x%04x: delayed\n",
821 coap_session_str(session), node->id);
822 return COAP_PDU_DELAYED;
823}
824
825#if !COAP_DISABLE_TCP
826void
828 coap_pdu_t *pdu;
829 uint8_t buf[4];
830 assert(COAP_PROTO_RELIABLE(session->proto));
831 coap_log_debug("***%s: sending CSM\n", coap_session_str(session));
832 session->state = COAP_SESSION_STATE_CSM;
833 session->partial_write = 0;
834 if (session->mtu == 0)
835 coap_session_set_mtu(session, COAP_DEFAULT_MTU); /* base value */
837 if (pdu == NULL
839 coap_encode_var_safe(buf, sizeof(buf),
840 session->context->csm_max_message_size), buf) == 0
842 coap_encode_var_safe(buf, sizeof(buf),
843 0), buf) == 0
844 || (session->max_token_size > COAP_TOKEN_DEFAULT_MAX &&
847 coap_encode_var_safe(buf, sizeof(buf),
848 session->max_token_size),
849 buf) == 0)
850 || coap_pdu_encode_header(pdu, session->proto) == 0
851 ) {
853 } else {
854 ssize_t bytes_written;
855
856 pdu->session = session;
857 bytes_written = coap_session_send_pdu(session, pdu);
858 if (bytes_written != (ssize_t)pdu->used_size + pdu->hdr_size) {
860 } else {
861 session->csm_rcv_mtu = session->context->csm_max_message_size;
862 if (session->csm_rcv_mtu > COAP_BERT_BASE)
863 session->csm_bert_loc_support = 1;
864 else
865 session->csm_bert_loc_support = 0;
866 }
867 }
868 if (pdu)
870}
871#endif /* !COAP_DISABLE_TCP */
872
875 coap_mid_t mid;
876
878 mid = coap_session_send_ping_lkd(session);
879 if (mid != COAP_INVALID_MID) {
880 coap_tick_t now;
881
882 coap_ticks(&now);
883 session->last_ping_mid = mid;
884 session->last_rx_tx = now;
885 session->last_ping = now;
886 }
888 return mid;
889}
890
893 coap_pdu_t *ping = NULL;
894
896 if (session->state != COAP_SESSION_STATE_ESTABLISHED ||
897 session->con_active)
898 return COAP_INVALID_MID;
899 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
900 uint16_t mid = coap_new_message_id_lkd(session);
901 ping = coap_pdu_init(COAP_MESSAGE_CON, 0, mid, 0);
902 }
903#if !COAP_DISABLE_TCP
904 else {
906 }
907#endif /* !COAP_DISABLE_TCP */
908 if (!ping)
909 return COAP_INVALID_MID;
910 return coap_send_internal(session, ping, NULL);
911}
912
913void
915 if (session->state != COAP_SESSION_STATE_ESTABLISHED) {
916 coap_log_debug("***%s: session connected\n",
917 coap_session_str(session));
918 if (session->state == COAP_SESSION_STATE_CSM) {
920#if COAP_CLIENT_SUPPORT
922#endif /* COAP_CLIENT_SUPPORT */
923 if (session->doing_first)
924 session->doing_first = 0;
925 }
926 }
927
929 session->partial_write = 0;
930
931 if (session->proto==COAP_PROTO_DTLS) {
932 session->tls_overhead = coap_dtls_get_overhead(session);
933 if (session->tls_overhead >= session->mtu) {
934 session->tls_overhead = session->mtu;
935 coap_log_err("DTLS overhead exceeds MTU\n");
936 }
937 }
938
939 while (session->delayqueue && session->state == COAP_SESSION_STATE_ESTABLISHED) {
940 ssize_t bytes_written;
941 coap_queue_t *q = session->delayqueue;
942 coap_address_t remote;
943
944 if (q->pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
945 if (session->con_active >= COAP_NSTART(session))
946 break;
947 session->con_active++;
948 }
949 /* Take entry off the queue */
950 session->delayqueue = q->next;
951 q->next = NULL;
952
953 coap_address_copy(&remote, &session->addr_info.remote);
955 coap_log_debug("** %s: mid=0x%04x: transmitted after delay (2)\n",
956 coap_session_str(session), (int)q->pdu->mid);
957 bytes_written = coap_session_send_pdu(session, q->pdu);
958 if (q->pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
959 if (coap_wait_ack(session->context, session, q) >= 0)
960 q = NULL;
961 }
962 coap_address_copy(&session->addr_info.remote, &remote);
963 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
964 if (q)
966 if (bytes_written < 0)
967 break;
968 } else if (q) {
969 if (bytes_written <= 0 || (size_t)bytes_written < q->pdu->used_size + q->pdu->hdr_size) {
970 q->next = session->delayqueue;
971 session->delayqueue = q;
972 if (bytes_written > 0)
973 session->partial_write = (size_t)bytes_written;
974 break;
975 } else {
977 }
978 }
979 }
980}
981
982#if COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG
983static const char *
985 switch (reason) {
987 return "COAP_NACK_TOO_MANY_RETRIES";
989 return "COAP_NACK_NOT_DELIVERABLE";
990 case COAP_NACK_RST:
991 return "COAP_NACK_RST";
993 return "COAP_NACK_TLS_FAILED";
995 return "COAP_NACK_ICMP_ISSUE";
997 return "COAP_NACK_BAD_RESPONSE";
999 return "COAP_NACK_TLS_LAYER_FAILED";
1001 return "COAP_NACK_WS_LAYER_FAILED";
1003 return "COAP_NACK_WS_FAILED";
1004 default:
1005 return "???";
1006 }
1007}
1008#endif /* COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_DEBUG */
1009
1010void
1012 coap_pdu_t *sent,
1013 const coap_nack_reason_t reason,
1014 const coap_mid_t mid) {
1015 if (session->context->nack_handler) {
1016 coap_bin_const_t token = {0, NULL};
1017
1018 if (sent) {
1019 coap_check_update_token(session, sent);
1020 token = sent->actual_token;
1021 }
1022 coap_lock_callback(session->context->nack_handler(session, sent, reason, mid));
1023 if (sent) {
1024 coap_update_token(sent, token.length, token.s);
1025 }
1026 }
1027#if COAP_CLIENT_SUPPORT
1028 if (reason != COAP_NACK_ICMP_ISSUE) {
1029 session->doing_send_recv = 0;
1030 }
1031#endif /* COAP_CLIENT_SUPPORT */
1032}
1033
1034COAP_API void
1040
1041void
1043#if !COAP_DISABLE_TCP
1044 coap_session_state_t state = session->state;
1045#endif /* !COAP_DISABLE_TCP */
1046 coap_lg_xmit_t *lq, *ltmp;
1047#if COAP_SERVER_SUPPORT
1048 coap_lg_srcv_t *sq, *stmp;
1049#endif /* COAP_SERVER_SUPPORT */
1050#if COAP_CLIENT_SUPPORT
1051 coap_lg_crcv_t *cq, *etmp;
1052#endif /* COAP_CLIENT_SUPPORT */
1053 int sent_nack = 0;
1054 coap_queue_t *q;
1055
1057#if COAP_CLIENT_SUPPORT
1058 coap_session_failed(session);
1059#endif /* COAP_CLIENT_SUPPORT */
1060
1061 q = session->context->sendqueue;
1062 while (q) {
1063 if (q->session == session) {
1064 /* Take the first one */
1065 coap_handle_nack(session, q->pdu, reason, q->id);
1066 sent_nack = 1;
1067 break;
1068 }
1069 q = q->next;
1070 }
1071
1072 if (reason != COAP_NACK_ICMP_ISSUE) {
1073 while (session->delayqueue) {
1074 q = session->delayqueue;
1075 session->delayqueue = q->next;
1076 q->next = NULL;
1077 coap_log_debug("** %s: mid=0x%04x: not transmitted after disconnect\n",
1078 coap_session_str(session), q->id);
1079 if (q->pdu->type == COAP_MESSAGE_CON) {
1080 coap_handle_nack(session, q->pdu, reason, q->id);
1081 sent_nack = 1;
1082 }
1083
1084#if COAP_CLIENT_SUPPORT
1085 session->doing_send_recv = 0;
1086#endif /* COAP_CLIENT_SUPPORT */
1088 }
1089 }
1090#if COAP_CLIENT_SUPPORT
1091 if (!sent_nack && session->lg_crcv) {
1092 /* Take the first one */
1093 coap_handle_nack(session, session->lg_crcv->sent_pdu, reason,
1094 session->lg_crcv->sent_pdu->mid);
1095 sent_nack = 1;
1096 }
1097#endif /* COAP_CLIENT_SUPPORT */
1098 if (!sent_nack) {
1099 /* Unable to determine which request disconnection was for */
1100 coap_handle_nack(session, NULL, reason, 0);
1101 }
1102 if (reason == COAP_NACK_ICMP_ISSUE) {
1103 coap_log_debug("***%s: session ICMP issue (%s)\n",
1104 coap_session_str(session), coap_nack_name(reason));
1105 return;
1106 }
1107 coap_log_debug("***%s: session disconnected (%s)\n",
1108 coap_session_str(session), coap_nack_name(reason));
1109#if COAP_SERVER_SUPPORT
1110 coap_delete_observers(session->context, session);
1111#endif /* COAP_SERVER_SUPPORT */
1112
1113 if (session->proto == COAP_PROTO_UDP)
1115 else
1116 session->state = COAP_SESSION_STATE_NONE;
1117
1118 session->con_active = 0;
1119
1120 if (session->partial_pdu) {
1122 session->partial_pdu = NULL;
1123 }
1124 session->partial_read = 0;
1125
1126 /* Not done if nack handler called above */
1127 while (session->delayqueue) {
1128 q = session->delayqueue;
1129 session->delayqueue = q->next;
1130 q->next = NULL;
1131 coap_log_debug("** %s: mid=0x%04x: not transmitted after disconnect\n",
1132 coap_session_str(session), q->id);
1133#if COAP_CLIENT_SUPPORT
1134 session->doing_send_recv = 0;
1135#endif /* COAP_CLIENT_SUPPORT */
1137 }
1138
1139#if COAP_CLIENT_SUPPORT
1140 if (!session->session_failed) {
1141 /* Need to do this before (D)TLS and socket is closed down */
1142 LL_FOREACH_SAFE(session->lg_crcv, cq, etmp) {
1143 LL_DELETE(session->lg_crcv, cq);
1144 coap_block_delete_lg_crcv(session, cq);
1145 }
1146 }
1147#endif /* COAP_CLIENT_SUPPORT */
1148 LL_FOREACH_SAFE(session->lg_xmit, lq, ltmp) {
1149 LL_DELETE(session->lg_xmit, lq);
1150 coap_block_delete_lg_xmit(session, lq);
1151 }
1152#if COAP_SERVER_SUPPORT
1153 LL_FOREACH_SAFE(session->lg_srcv, sq, stmp) {
1154 LL_DELETE(session->lg_srcv, sq);
1155 coap_block_delete_lg_srcv(session, sq);
1156 }
1157#endif /* COAP_SERVER_SUPPORT */
1158 coap_cancel_session_messages(session->context, session, reason);
1159
1160#if !COAP_DISABLE_TCP
1161 if (COAP_PROTO_RELIABLE(session->proto)) {
1162 if (coap_netif_available(session)) {
1166 }
1167#if COAP_CLIENT_SUPPORT
1168 if (state != COAP_SESSION_STATE_NONE && !session->session_failed) {
1172 }
1173#endif /* COAP_CLIENT_SUPPORT */
1174 if (session->doing_first)
1175 session->doing_first = 0;
1176 }
1177#endif /* !COAP_DISABLE_TCP */
1178 if (session->sock.lfunc[COAP_LAYER_SESSION].l_close)
1179 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
1180}
1181
1182#if COAP_CLIENT_SUPPORT
1183void
1185 if (session->context->reconnect_time &&
1187 session->type == COAP_SESSION_TYPE_CLIENT) {
1188 if (session->sock.lfunc[COAP_LAYER_SESSION].l_close)
1189 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
1190 session->session_failed = 1;
1191 coap_ticks(&session->last_rx_tx);
1192 }
1193}
1194#endif /* COAP_CLIENT_SUPPORT */
1195
1196#if COAP_SERVER_SUPPORT
1197static void
1198coap_make_addr_hash(coap_addr_hash_t *addr_hash, coap_proto_t proto,
1199 const coap_addr_tuple_t *addr_info) {
1200 memset(addr_hash, 0, sizeof(coap_addr_hash_t));
1201 coap_address_copy(&addr_hash->remote, &addr_info->remote);
1202 addr_hash->lport = coap_address_get_port(&addr_info->local);
1203 addr_hash->proto = proto;
1204}
1205
1208 const coap_packet_t *packet, coap_tick_t now) {
1209 coap_session_t *session;
1210 coap_session_t *rtmp;
1211 unsigned int num_idle = 0;
1212 unsigned int num_hs = 0;
1213 coap_session_t *oldest = NULL;
1214 coap_session_t *oldest_hs = NULL;
1215 coap_addr_hash_t addr_hash;
1216
1217 coap_make_addr_hash(&addr_hash, endpoint->proto, &packet->addr_info);
1218 SESSIONS_FIND(endpoint->sessions, addr_hash, session);
1219 if (session) {
1220 /* Maybe mcast or unicast IP address which is not in the hash */
1221 coap_address_copy(&session->addr_info.local, &packet->addr_info.local);
1222 session->ifindex = packet->ifindex;
1223 session->last_rx_tx = now;
1224 return session;
1225 }
1226
1227#if COAP_CLIENT_SUPPORT
1228 SESSIONS_FIND(endpoint->context->sessions, addr_hash, session);
1229 if (session) {
1230 /* Maybe mcast or unicast IP address which is not in the hash */
1231 coap_address_copy(&session->addr_info.local, &packet->addr_info.local);
1232 session->ifindex = packet->ifindex;
1233 session->last_rx_tx = now;
1234 return session;
1235 }
1236
1237 if (coap_is_mcast(&packet->addr_info.local)) {
1238 /* Check if this a proxy client packet we sent on another socket */
1239 SESSIONS_ITER(endpoint->context->sessions, session, rtmp) {
1240 if (coap_address_equals(&session->addr_info.remote, &packet->addr_info.local) &&
1243 /* Drop looped back packet to stop recursion / confusion */
1244 return NULL;
1245 }
1246 }
1247 }
1248#endif /* COAP_CLIENT_SUPPORT */
1249 SESSIONS_ITER(endpoint->sessions, session, rtmp) {
1250 if (session->ref == 0 && session->delayqueue == NULL) {
1251 if (session->type == COAP_SESSION_TYPE_SERVER) {
1252 ++num_idle;
1253 if (oldest==NULL || session->last_rx_tx < oldest->last_rx_tx)
1254 oldest = session;
1255
1256 if (session->state == COAP_SESSION_STATE_HANDSHAKE) {
1257 ++num_hs;
1258 /* See if this is a partial (D)TLS session set up
1259 which needs to be cleared down to prevent DOS */
1260 if ((session->last_rx_tx + COAP_PARTIAL_SESSION_TIMEOUT_TICKS) < now) {
1261 if (oldest_hs == NULL ||
1262 session->last_rx_tx < oldest_hs->last_rx_tx)
1263 oldest_hs = session;
1264 }
1265 }
1266 } else if (session->type == COAP_SESSION_TYPE_HELLO) {
1267 ++num_hs;
1268 /* See if this is a partial (D)TLS session set up for Client Hello
1269 which needs to be cleared down to prevent DOS */
1270 if ((session->last_rx_tx + COAP_PARTIAL_SESSION_TIMEOUT_TICKS) < now) {
1271 if (oldest_hs == NULL ||
1272 session->last_rx_tx < oldest_hs->last_rx_tx)
1273 oldest_hs = session;
1274 }
1275 }
1276 }
1277 }
1278
1279 if (endpoint->context->max_idle_sessions > 0 &&
1280 num_idle >= endpoint->context->max_idle_sessions) {
1282 coap_session_free(oldest);
1283 } else if (oldest_hs) {
1284 coap_log_warn("***%s: Incomplete session timed out\n",
1285 coap_session_str(oldest_hs));
1287 coap_session_free(oldest_hs);
1288 }
1289
1290 if (num_hs > (endpoint->context->max_handshake_sessions ?
1291 endpoint->context->max_handshake_sessions :
1293 /* Maxed out on number of sessions in (D)TLS negotiation state */
1294 coap_log_debug("Oustanding sessions in COAP_SESSION_STATE_HANDSHAKE too "
1295 "large. New request ignored\n");
1296 return NULL;
1297 }
1298
1299 if (endpoint->proto == COAP_PROTO_DTLS) {
1300 /*
1301 * Need to check that this actually is a Client Hello before wasting
1302 * time allocating and then freeing off session.
1303 */
1304
1305 /*
1306 * Generic header structure of the DTLS record layer.
1307 * typedef struct __attribute__((__packed__)) {
1308 * uint8_t content_type; content type of the included message
1309 * uint16_t version; Protocol version
1310 * uint16_t epoch; counter for cipher state changes
1311 * uint8_t sequence_number[6]; sequence number
1312 * uint16_t length; length of the following fragment
1313 * uint8_t handshake; If content_type == DTLS_CT_HANDSHAKE
1314 * } dtls_record_handshake_t;
1315 */
1316#define OFF_CONTENT_TYPE 0 /* offset of content_type in dtls_record_handshake_t */
1317#define DTLS_CT_ALERT 21 /* Content Type Alert */
1318#define DTLS_CT_HANDSHAKE 22 /* Content Type Handshake */
1319#define OFF_HANDSHAKE_TYPE 13 /* offset of handshake in dtls_record_handshake_t */
1320#define DTLS_HT_CLIENT_HELLO 1 /* Client Hello handshake type */
1321#define DTLS_CT_CID 25 /* Content Type Connection ID */
1322#define OFF_CID 11 /* offset of CID in dtls_record_handshake_t */
1323#define OFF_CID_DTLS13 1 /* offset of CID in DTLS1.3 Unified Header */
1324
1325 const uint8_t *payload = (const uint8_t *)packet->payload;
1326 size_t length = packet->length;
1327 if (length < (OFF_HANDSHAKE_TYPE + 1)) {
1328 coap_log_debug("coap_dtls_hello: ContentType %d Short Packet (%zu < %d) dropped\n",
1329 payload[OFF_CONTENT_TYPE], length,
1330 OFF_HANDSHAKE_TYPE + 1);
1331 return NULL;
1332 }
1333 if ((payload[OFF_CONTENT_TYPE] & 0x30) == 0x30 ||
1334 payload[OFF_CONTENT_TYPE] == DTLS_CT_CID) {
1335 /* Client may have changed its IP address */
1336 int changed = 0;
1337
1338 SESSIONS_ITER(endpoint->sessions, session, rtmp) {
1339 if (session->client_cid) {
1340 if ((session->is_dtls13 && (payload[OFF_CONTENT_TYPE] & 0x30) == 0x30 &&
1341 memcmp(session->client_cid->s, &payload[OFF_CID_DTLS13],
1342 session->client_cid->length) == 0) ||
1343 (!session->is_dtls13 && payload[OFF_CONTENT_TYPE] == DTLS_CT_CID &&
1344 memcmp(session->client_cid->s, &payload[OFF_CID],
1345 session->client_cid->length) == 0)) {
1346 /* Updating IP address */
1347 coap_log_info("***%s: CID: Old Client Session\n", coap_session_str(session));
1348 SESSIONS_DELETE(endpoint->sessions, session);
1349 session->addr_info = packet->addr_info;
1350 memcpy(&session->addr_hash, &addr_hash, sizeof(session->addr_hash));
1351 SESSIONS_ADD(endpoint->sessions, session);
1352 coap_log_info("***%s: CID: New Client Session\n", coap_session_str(session));
1353 return session;
1354 }
1355 }
1356 }
1357 if (!changed) {
1358 coap_log_debug("coap_dtls_hello: ContentType Connection-IS dropped\n");
1359 return NULL;
1360 }
1361 } else if (payload[OFF_CONTENT_TYPE] != DTLS_CT_HANDSHAKE ||
1362 payload[OFF_HANDSHAKE_TYPE] != DTLS_HT_CLIENT_HELLO) {
1363 /* only log if not a late alert */
1364 if (payload[OFF_CONTENT_TYPE] != DTLS_CT_ALERT)
1365 coap_log_debug("coap_dtls_hello: ContentType %d Handshake %d dropped\n",
1366 payload[OFF_CONTENT_TYPE],
1367 payload[OFF_HANDSHAKE_TYPE]);
1368 return NULL;
1369 }
1370 }
1371
1373 &addr_hash, &packet->addr_info.local,
1374 &packet->addr_info.remote,
1375 packet->ifindex, endpoint->context, endpoint);
1376 if (session) {
1377 session->last_rx_tx = now;
1378 memcpy(session->sock.lfunc, endpoint->sock.lfunc,
1379 sizeof(session->sock.lfunc));
1380 if (endpoint->proto == COAP_PROTO_UDP)
1382 else if (endpoint->proto == COAP_PROTO_DTLS) {
1383 session->type = COAP_SESSION_TYPE_HELLO;
1384 }
1385 SESSIONS_ADD(endpoint->sessions, session);
1386 coap_log_debug("***%s: session %p: new incoming session\n",
1387 coap_session_str(session), (void *)session);
1389 }
1390 return session;
1391}
1392
1395 coap_tick_t now) {
1396 if (session) {
1397 session->last_rx_tx = now;
1398 session->type = COAP_SESSION_TYPE_SERVER;
1399 coap_dtls_establish(session);
1400 }
1401 return session;
1402}
1403#endif /* COAP_SERVER_SUPPORT */
1404
1405#if COAP_CLIENT_SUPPORT
1406static coap_session_t *
1407coap_session_create_client(coap_context_t *ctx,
1408 const coap_address_t *local_if,
1409 const coap_address_t *server,
1410 coap_proto_t proto) {
1411 coap_session_t *session = NULL;
1412 int default_port = COAP_DEFAULT_PORT;
1413
1414 assert(server);
1415
1416 switch (proto) {
1417 case COAP_PROTO_UDP:
1418 default_port = COAP_DEFAULT_PORT;
1419 break;
1420 case COAP_PROTO_DTLS:
1421 if (!coap_dtls_is_supported()) {
1422 coap_log_crit("coap_new_client_session*: DTLS not supported\n");
1423 return NULL;
1424 }
1425 default_port = COAPS_DEFAULT_PORT;
1426 break;
1427 case COAP_PROTO_TCP:
1428 if (!coap_tcp_is_supported()) {
1429 coap_log_crit("coap_new_client_session*: TCP not supported\n");
1430 return NULL;
1431 }
1432 default_port = COAP_DEFAULT_PORT;
1433 break;
1434 case COAP_PROTO_TLS:
1435 if (!coap_tls_is_supported()) {
1436 coap_log_crit("coap_new_client_session*: TLS not supported\n");
1437 return NULL;
1438 }
1439 default_port = COAPS_DEFAULT_PORT;
1440 break;
1441 case COAP_PROTO_WS:
1442 if (!coap_ws_is_supported()) {
1443 coap_log_crit("coap_new_client_session*: WS not supported\n");
1444 return NULL;
1445 }
1446 default_port = 80;
1447 break;
1448 case COAP_PROTO_WSS:
1449 if (!coap_wss_is_supported()) {
1450 coap_log_crit("coap_new_client_session*: WSS not supported\n");
1451 return NULL;
1452 }
1453 default_port = 443;
1454 break;
1455 case COAP_PROTO_NONE:
1456 case COAP_PROTO_LAST:
1457 default:
1458 assert(0);
1459 return NULL;
1460 }
1461 session = coap_make_session(proto, COAP_SESSION_TYPE_CLIENT, NULL,
1462 local_if, server, 0, ctx, NULL);
1463 if (!session)
1464 goto error;
1465
1467 session->sock.session = session;
1468 memcpy(&session->sock.lfunc, coap_layers_coap[proto],
1469 sizeof(session->sock.lfunc));
1470
1471 if (COAP_PROTO_NOT_RELIABLE(proto)) {
1472 coap_session_t *s, *rtmp;
1473 if (!coap_netif_dgrm_connect(session, local_if, server, default_port)) {
1474 goto error;
1475 }
1476 /* Check that this is not a duplicate 4-tuple */
1477 SESSIONS_ITER_SAFE(ctx->sessions, s, rtmp) {
1480 &s->addr_info.local) &&
1482 &s->addr_info.remote)) {
1483 coap_log_warn("***%s: session %p: duplicate - already exists\n",
1484 coap_session_str(session), (void *)session);
1485 goto error;
1486 }
1487 }
1488#ifdef WITH_CONTIKI
1489 session->sock.context = ctx;
1490#endif /* WITH_CONTIKI */
1491#if !COAP_DISABLE_TCP
1492 } else if (COAP_PROTO_RELIABLE(proto)) {
1493 if (!coap_netif_strm_connect1(session, local_if, server, default_port)) {
1494 goto error;
1495 }
1496#endif /* !COAP_DISABLE_TCP */
1497 }
1498
1499 session->sock.session = session;
1500#ifdef COAP_EPOLL_SUPPORT
1501 coap_epoll_ctl_add(&session->sock,
1502 EPOLLIN |
1503 ((session->sock.flags & COAP_SOCKET_WANT_CONNECT) ?
1504 EPOLLOUT : 0),
1505 __func__);
1506#endif /* COAP_EPOLL_SUPPORT */
1507
1509 if (local_if)
1510 session->sock.flags |= COAP_SOCKET_BOUND;
1511#if COAP_SERVER_SUPPORT
1512 if (ctx->proxy_uri_resource)
1513 session->proxy_session = 1;
1514#endif /* COAP_SERVER_SUPPORT */
1515 SESSIONS_ADD(ctx->sessions, session);
1516 return session;
1517
1518error:
1519 /*
1520 * Need to add in the session as coap_session_release_lkd()
1521 * will call SESSIONS_DELETE in coap_session_free().
1522 */
1523 if (session)
1524 SESSIONS_ADD(ctx->sessions, session);
1525 coap_session_release_lkd(session);
1526 return NULL;
1527}
1528
1529static void
1530coap_session_check_connect(coap_session_t *session) {
1531 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
1532 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
1533 }
1534#if !COAP_DISABLE_TCP
1535 if (COAP_PROTO_RELIABLE(session->proto)) {
1536 if (session->sock.flags & COAP_SOCKET_WANT_CONNECT) {
1538 if (session->type == COAP_SESSION_TYPE_CLIENT) {
1539 session->doing_first = 1;
1540 }
1541 } else {
1542 /* Initial connect worked immediately */
1543 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
1544 }
1545 }
1546#endif /* !COAP_DISABLE_TCP */
1547 coap_ticks(&session->last_rx_tx);
1548}
1549#endif /* COAP_CLIENT_SUPPORT */
1550
1551void
1553 if (COAP_PROTO_NOT_RELIABLE(session->proto))
1554 coap_session_connected(session);
1555#if !COAP_DISABLE_TCP
1556 if (COAP_PROTO_RELIABLE(session->proto))
1557 coap_session_send_csm(session);
1558#endif /* !COAP_DISABLE_TCP */
1559}
1560
1561#if COAP_CLIENT_SUPPORT
1562int
1564 int default_port = COAP_DEFAULT_PORT;
1565
1566 if (session->sock.lfunc[COAP_LAYER_SESSION].l_close && !session->session_failed)
1567 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
1568
1569 switch (session->proto) {
1570 case COAP_PROTO_UDP:
1571 default_port = COAP_DEFAULT_PORT;
1572 break;
1573 case COAP_PROTO_DTLS:
1574 default_port = COAPS_DEFAULT_PORT;
1575 break;
1576 case COAP_PROTO_TCP:
1577 default_port = COAP_DEFAULT_PORT;
1578 break;
1579 case COAP_PROTO_TLS:
1580 default_port = COAPS_DEFAULT_PORT;
1581 break;
1582 case COAP_PROTO_WS:
1583 default_port = 80;
1584 break;
1585 case COAP_PROTO_WSS:
1586 default_port = 443;
1587 break;
1588 case COAP_PROTO_NONE:
1589 case COAP_PROTO_LAST:
1590 default:
1591 assert(0);
1592 return 0;
1593 }
1594 session->sock.session = session;
1595 coap_log_debug("***%s: trying to reconnect\n", coap_session_str(session));
1596 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
1597 session->state = COAP_SESSION_STATE_NONE;
1598 if (!coap_netif_dgrm_connect(session, &session->local_reconnect, &session->addr_info.remote,
1599 default_port)) {
1600 goto error;
1601 }
1603#ifdef WITH_CONTIKI
1604 session->sock.context = session->context;
1605#endif /* WITH_CONTIKI */
1606#if !COAP_DISABLE_TCP
1607 } else if (COAP_PROTO_RELIABLE(session->proto)) {
1608 if (!coap_netif_strm_connect1(session, &session->local_reconnect, &session->addr_info.remote,
1609 default_port)) {
1610 goto error;
1611 }
1612#endif /* !COAP_DISABLE_TCP */
1613 } else {
1614 goto error;
1615 }
1616#ifdef COAP_EPOLL_SUPPORT
1617 coap_epoll_ctl_add(&session->sock,
1618 EPOLLIN |
1619 ((session->sock.flags & COAP_SOCKET_WANT_CONNECT) ?
1620 EPOLLOUT : 0),
1621 __func__);
1622#endif /* COAP_EPOLL_SUPPORT */
1623
1625 session->sock.flags |= COAP_SOCKET_BOUND;
1626 coap_session_check_connect(session);
1627 return 1;
1628error:
1629 return 0;
1630}
1631
1632void
1634 coap_lg_crcv_t *lg_crcv, *etmp;
1635
1636 if (!session->session_failed)
1637 return;
1638 coap_log_debug("***%s: session re-established\n",
1639 coap_session_str(session));
1640 session->session_failed = 0;
1641 LL_FOREACH_SAFE(session->lg_crcv, lg_crcv, etmp) {
1643 coap_send_internal(session, lg_crcv->sent_pdu, NULL);
1644 }
1645}
1646
1649 const coap_address_t *local_if,
1650 const coap_address_t *server,
1651 coap_proto_t proto) {
1652 coap_session_t *session;
1653
1654 coap_lock_lock(return NULL);
1655 session = coap_new_client_session_lkd(ctx, local_if, server, proto);
1657 return session;
1658}
1659
1662 const coap_address_t *local_if,
1663 const coap_address_t *server,
1664 coap_proto_t proto) {
1665 coap_session_t *session;
1666
1668 session = coap_session_create_client(ctx, local_if, server,
1669 proto);
1670 if (session) {
1671 coap_log_debug("***%s: session %p: created outgoing session\n",
1672 coap_session_str(session), (void *)session);
1673 coap_session_check_connect(session);
1674 }
1675 return session;
1676}
1677
1680 const coap_address_t *local_if,
1681 const coap_address_t *server,
1682 coap_proto_t proto, const char *identity,
1683 const uint8_t *key, unsigned key_len) {
1684 coap_session_t *session;
1685
1686 coap_lock_lock(return NULL);
1687 session = coap_new_client_session_psk_lkd(ctx, local_if, server, proto, identity, key, key_len);
1689 return session;
1690}
1691
1694 const coap_address_t *local_if,
1695 const coap_address_t *server,
1696 coap_proto_t proto, const char *identity,
1697 const uint8_t *key, unsigned key_len) {
1698 coap_dtls_cpsk_t setup_data;
1699
1701 memset(&setup_data, 0, sizeof(setup_data));
1703
1704 if (identity) {
1705 setup_data.psk_info.identity.s = (const uint8_t *)identity;
1706 setup_data.psk_info.identity.length = strlen(identity);
1707 }
1708
1709 if (key && key_len > 0) {
1710 setup_data.psk_info.key.s = key;
1711 setup_data.psk_info.key.length = key_len;
1712 }
1713
1714 return coap_new_client_session_psk2_lkd(ctx, local_if, server,
1715 proto, &setup_data);
1716}
1717
1718/*
1719 * Check the validity of the SNI to send to the server.
1720 *
1721 * https://datatracker.ietf.org/doc/html/rfc6066#section-3
1722 * Literal IPv4 and IPv6 addresses are not permitted in "HostName".
1723 */
1724static void
1725coap_sanitize_client_sni(char **client_sni) {
1726 char *cp;
1727
1728 if (*client_sni == NULL)
1729 return;
1730
1731 cp = *client_sni;
1732 switch (*cp) {
1733 case '0':
1734 case '1':
1735 case '2':
1736 case '3':
1737 case '4':
1738 case '5':
1739 case '6':
1740 case '7':
1741 case '8':
1742 case '9':
1743 case 'a':
1744 case 'b':
1745 case 'c':
1746 case 'd':
1747 case 'e':
1748 case 'f':
1749 case 'A':
1750 case 'B':
1751 case 'C':
1752 case 'D':
1753 case 'E':
1754 case 'F':
1755 case ':':
1756 break;
1757 case '\000':
1758 /* Empty entry invalid */
1759 *client_sni = NULL;
1760 return;
1761 default:
1762 /* Does not start with a hex digit or : - not literal IP. */
1763 return;
1764 }
1765 /* Check for IPv4 */
1766 while (*cp) {
1767 switch (*cp) {
1768 case '0':
1769 case '1':
1770 case '2':
1771 case '3':
1772 case '4':
1773 case '5':
1774 case '6':
1775 case '7':
1776 case '8':
1777 case '9':
1778 case '.':
1779 break;
1780 default:
1781 /* Not of format nnn.nnn.nnn.nnn. Could be IPv6 */
1782 goto check_ipv6;
1783 }
1784 cp++;
1785 }
1786 /* IPv4 address - not allowed. */
1787 *client_sni = NULL;
1788 return;
1789
1790check_ipv6:
1791 /* Check for IPv6 */
1792 cp = *client_sni;
1793 while (*cp) {
1794 switch (*cp) {
1795 case '0':
1796 case '1':
1797 case '2':
1798 case '3':
1799 case '4':
1800 case '5':
1801 case '6':
1802 case '7':
1803 case '8':
1804 case '9':
1805 case 'a':
1806 case 'b':
1807 case 'c':
1808 case 'd':
1809 case 'e':
1810 case 'f':
1811 case 'A':
1812 case 'B':
1813 case 'C':
1814 case 'D':
1815 case 'E':
1816 case 'F':
1817 case ':':
1818 break;
1819 case '%':
1820 /* Start of i/f specification, Previous is IPv6 */
1821 *client_sni = NULL;
1822 return;
1823 default:
1824 /* Not of format xx:xx::xx. */
1825 return;
1826 }
1827 cp++;
1828 }
1829 *client_sni = NULL;
1830 return;
1831}
1832
1835 const coap_address_t *local_if,
1836 const coap_address_t *server,
1837 coap_proto_t proto,
1838 coap_dtls_cpsk_t *setup_data) {
1839 coap_session_t *session;
1840
1841 coap_lock_lock(return NULL);
1842 session = coap_new_client_session_psk2_lkd(ctx, local_if, server, proto, setup_data);
1844 return session;
1845}
1846
1849 const coap_address_t *local_if,
1850 const coap_address_t *server,
1851 coap_proto_t proto,
1852 coap_dtls_cpsk_t *setup_data) {
1853 coap_session_t *session;
1854
1856 session = coap_session_create_client(ctx, local_if, server, proto);
1857
1858 if (!session || !setup_data)
1859 return NULL;
1860
1861 session->cpsk_setup_data = *setup_data;
1862 if (setup_data->psk_info.identity.s) {
1863 session->psk_identity =
1865 setup_data->psk_info.identity.length);
1866 if (!session->psk_identity) {
1867 coap_log_warn("Cannot store session Identity (PSK)\n");
1868 coap_session_release_lkd(session);
1869 return NULL;
1870 }
1872 coap_log_warn("Identity (PSK) not defined\n");
1873 coap_session_release_lkd(session);
1874 return NULL;
1875 }
1876
1877 if (setup_data->psk_info.key.s && setup_data->psk_info.key.length > 0) {
1878 session->psk_key = coap_new_bin_const(setup_data->psk_info.key.s,
1879 setup_data->psk_info.key.length);
1880 if (!session->psk_key) {
1881 coap_log_warn("Cannot store session pre-shared key (PSK)\n");
1882 coap_session_release_lkd(session);
1883 return NULL;
1884 }
1886 coap_log_warn("Pre-shared key (PSK) not defined\n");
1887 coap_session_release_lkd(session);
1888 return NULL;
1889 }
1890
1891 coap_sanitize_client_sni(&session->cpsk_setup_data.client_sni);
1892
1894 if (!coap_dtls_context_set_cpsk(ctx, &session->cpsk_setup_data)) {
1895 coap_session_release_lkd(session);
1896 return NULL;
1897 }
1898 }
1899 coap_log_debug("***%s: new outgoing session\n",
1900 coap_session_str(session));
1901 coap_session_check_connect(session);
1902 return session;
1903}
1904#endif /* COAP_CLIENT_SUPPORT */
1905
1906int
1908 const coap_bin_const_t *psk_hint
1909 ) {
1910 /* We may be refreshing the hint with the same hint */
1911 coap_bin_const_t *old_psk_hint = session->psk_hint;
1912
1913 if (psk_hint && psk_hint->s) {
1914 if (session->psk_hint) {
1915 if (coap_binary_equal(session->psk_hint, psk_hint))
1916 return 1;
1917 }
1918 session->psk_hint = coap_new_bin_const(psk_hint->s,
1919 psk_hint->length);
1920 if (!session->psk_hint) {
1921 coap_log_err("No memory to store identity hint (PSK)\n");
1922 if (old_psk_hint)
1923 coap_delete_bin_const(old_psk_hint);
1924 return 0;
1925 }
1926 } else {
1927 session->psk_hint = NULL;
1928 }
1929 if (old_psk_hint)
1930 coap_delete_bin_const(old_psk_hint);
1931
1932 return 1;
1933}
1934
1935int
1937 const coap_bin_const_t *psk_key
1938 ) {
1939 /* We may be refreshing the key with the same key */
1940 coap_bin_const_t *old_psk_key = session->psk_key;
1941
1942 if (psk_key && psk_key->s) {
1943 if (session->psk_key) {
1944 if (coap_binary_equal(session->psk_key, psk_key))
1945 return 1;
1946 }
1947 session->psk_key = coap_new_bin_const(psk_key->s, psk_key->length);
1948 if (!session->psk_key) {
1949 coap_log_err("No memory to store pre-shared key (PSK)\n");
1950 if (old_psk_key)
1951 coap_delete_bin_const(old_psk_key);
1952 return 0;
1953 }
1954 } else {
1955 session->psk_key = NULL;
1956 }
1957 if (old_psk_key)
1958 coap_delete_bin_const(old_psk_key);
1959
1960 return 1;
1961}
1962
1963int
1965 const coap_bin_const_t *psk_identity
1966 ) {
1967 /* We may be refreshing the identity with the same identity */
1968 coap_bin_const_t *old_psk_identity = session->psk_identity;
1969
1970 if (psk_identity && psk_identity->s) {
1971 if (session->psk_identity) {
1972 if (coap_binary_equal(session->psk_identity, psk_identity))
1973 return 1;
1974 }
1975 session->psk_identity = coap_new_bin_const(psk_identity->s,
1976 psk_identity->length);
1977 if (!session->psk_identity) {
1978 coap_log_err("No memory to store pre-shared key identity (PSK)\n");
1979 if (old_psk_identity)
1980 coap_delete_bin_const(old_psk_identity);
1981 return 0;
1982 }
1983 } else {
1984 session->psk_identity = NULL;
1985 }
1986 if (old_psk_identity)
1987 coap_delete_bin_const(old_psk_identity);
1988
1989 return 1;
1990}
1991
1992#if COAP_SERVER_SUPPORT
1993const coap_bin_const_t *
1995 if (session)
1996 return session->psk_hint;
1997 return NULL;
1998}
1999#endif /* COAP_SERVER_SUPPORT */
2000
2001const coap_bin_const_t *
2003 const coap_bin_const_t *psk_identity = NULL;
2004 if (session) {
2005 psk_identity = session->psk_identity;
2006 if (psk_identity == NULL) {
2007 psk_identity = &session->cpsk_setup_data.psk_info.identity;
2008 }
2009 }
2010 return psk_identity;
2011}
2012
2013const coap_bin_const_t *
2015 if (session)
2016 return session->psk_key;
2017 return NULL;
2018}
2019
2020#if COAP_CLIENT_SUPPORT
2023 const coap_address_t *local_if,
2024 const coap_address_t *server,
2025 coap_proto_t proto,
2026 coap_dtls_pki_t *setup_data) {
2027 coap_session_t *session;
2028
2029 coap_lock_lock(return NULL);
2030 session = coap_new_client_session_pki_lkd(ctx, local_if, server, proto, setup_data);
2032 return session;
2033}
2034
2037 const coap_address_t *local_if,
2038 const coap_address_t *server,
2039 coap_proto_t proto,
2040 coap_dtls_pki_t *setup_data) {
2041 coap_session_t *session;
2042 coap_dtls_pki_t l_setup_data;
2043
2044 if (!setup_data)
2045 return NULL;
2046 if (setup_data->version != COAP_DTLS_PKI_SETUP_VERSION) {
2047 coap_log_err("coap_new_client_session_pki: Wrong version of setup_data\n");
2048 return NULL;
2049 }
2050
2052 l_setup_data = *setup_data;
2053 coap_sanitize_client_sni(&l_setup_data.client_sni);
2054
2055 session = coap_session_create_client(ctx, local_if, server, proto);
2056
2057 if (!session) {
2058 return NULL;
2059 }
2060
2062 /* we know that setup_data is not NULL */
2063 if (!coap_dtls_context_set_pki(ctx, &l_setup_data, COAP_DTLS_ROLE_CLIENT)) {
2064 coap_session_release_lkd(session);
2065 return NULL;
2066 }
2067 }
2068 coap_log_debug("***%s: new outgoing session\n",
2069 coap_session_str(session));
2070 coap_session_check_connect(session);
2071 return session;
2072}
2073#endif /* ! COAP_CLIENT_SUPPORT */
2074
2075#if COAP_SERVER_SUPPORT
2076#if !COAP_DISABLE_TCP
2079 coap_session_t *session;
2080 coap_tick_t now;
2081
2083 NULL, NULL, NULL, 0, ctx, ep);
2084 if (!session)
2085 goto error;
2086
2087 memcpy(session->sock.lfunc, ep->sock.lfunc, sizeof(session->sock.lfunc));
2088 if (!coap_netif_strm_accept(ep, session, extra))
2089 goto error;
2090
2091 coap_make_addr_hash(&session->addr_hash, session->proto, &session->addr_info);
2092
2093#ifdef COAP_EPOLL_SUPPORT
2094 session->sock.session = session;
2095 coap_epoll_ctl_add(&session->sock,
2096 EPOLLIN,
2097 __func__);
2098#endif /* COAP_EPOLL_SUPPORT */
2099 SESSIONS_ADD(ep->sessions, session);
2100 if (session) {
2101 coap_ticks(&now);
2102 session->last_rx_tx = now;
2103 coap_log_debug("***%s: session %p: new incoming session\n",
2104 coap_session_str(session), (void *)session);
2108 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
2109 }
2110 return session;
2111
2112error:
2113 /*
2114 * Need to add in the session as coap_session_release_lkd()
2115 * will call SESSIONS_DELETE in coap_session_free().
2116 */
2117 if (session) {
2118 SESSIONS_ADD(ep->sessions, session);
2119 coap_session_free(session);
2120 }
2121 return NULL;
2122}
2123#endif /* !COAP_DISABLE_TCP */
2124#endif /* COAP_SERVER_SUPPORT */
2125
2126void
2128 const uint8_t *data) {
2129 session->tx_token = coap_decode_var_bytes8(data, len);
2130 /*
2131 * Decrement as when first used by coap_session_new_token() it will
2132 * get incremented
2133 */
2134 session->tx_token--;
2135}
2136
2137void
2139 uint8_t *data) {
2140 *len = coap_encode_var_safe8(data,
2141 sizeof(session->tx_token), ++session->tx_token);
2142}
2143
2144COAP_API uint16_t
2146 uint16_t mid;
2147
2148 coap_lock_lock(return 0);
2149 mid = coap_new_message_id_lkd(session);
2151 return mid;
2152}
2153
2154uint16_t
2157 if (COAP_PROTO_NOT_RELIABLE(session->proto))
2158 return ++session->tx_mid;
2159 /* TCP/TLS have no notion of mid */
2160 return 0;
2161}
2162
2163const coap_address_t *
2165 if (session)
2166 return &session->addr_info.remote;
2167 return NULL;
2168}
2169
2170const coap_address_t *
2172 if (session)
2173 return &session->addr_info.local;
2174 return NULL;
2175}
2176
2177const coap_address_t *
2179#if COAP_CLIENT_SUPPORT
2180 if (session && session->type == COAP_SESSION_TYPE_CLIENT &&
2181 session->sock.flags & COAP_SOCKET_MULTICAST)
2182 return &session->sock.mcast_addr;
2183#else /* ! COAP_CLIENT_SUPPORT */
2184 (void)session;
2185#endif /* ! COAP_CLIENT_SUPPORT */
2186 return NULL;
2187}
2188
2191 if (session)
2192 return session->context;
2193 return NULL;
2194}
2195
2198 if (session)
2199 return session->proto;
2200 return 0;
2201}
2202
2205 if (session)
2206 return session->type;
2207 return 0;
2208}
2209
2210COAP_API int
2212 int ret;
2213
2214 coap_lock_lock(return 0);
2215 ret = coap_session_set_type_client_lkd(session, 1);
2217 return ret;
2218}
2219
2220int
2222#if COAP_CLIENT_SUPPORT && COAP_SERVER_SUPPORT
2223 if (session && session->type == COAP_SESSION_TYPE_SERVER) {
2225 session->type = COAP_SESSION_TYPE_CLIENT;
2226 if (session->endpoint) {
2227 SESSIONS_DELETE(session->endpoint->sessions, session);
2228 SESSIONS_ADD(session->context->sessions, session);
2229 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
2230 session->sock = session->endpoint->sock;
2231 session->sock.flags |= COAP_SOCKET_SLAVE;
2232 session->sock.flags &= ~COAP_SOCKET_CAN_READ;
2233 session->sock.flags &= ~COAP_SOCKET_WANT_READ;
2234 }
2235 session->endpoint = NULL;
2236 }
2237 if (report_changed) {
2238 coap_log_debug("***%s: session now is type Client\n",
2239 coap_session_str(session));
2240 }
2241 return 1;
2242 }
2243#else /* ! COAP_CLIENT_SUPPORT || ! COAP_SERVER_SUPPORT */
2244 (void)session;
2245 (void)report_changed;
2246#endif /* ! COAP_CLIENT_SUPPORT || ! COAP_SERVER_SUPPORT */
2247 return 0;
2248}
2249
2250COAP_API int
2252 int ret;
2253
2254 coap_lock_lock(return 0);
2255 ret = coap_session_set_type_server_lkd(session);
2257 return ret;
2258}
2259
2260int
2262#if COAP_CLIENT_SUPPORT && COAP_SERVER_SUPPORT
2263 if (session && session->type == COAP_SESSION_TYPE_CLIENT) {
2264 coap_endpoint_t *ep;
2265 coap_mid_t mid;
2266 coap_pdu_t *ping = NULL;
2267
2268 LL_FOREACH(session->context->endpoint, ep) {
2269 if (session->proto == ep->proto)
2270 break;
2271 }
2272 if (!ep) {
2273 /* Need a dummy endpoint to 'hang' off as this is now a server */
2274 ep = coap_malloc_endpoint();
2275 if (!ep) {
2276 coap_log_warn("coap_new_endpoint: malloc");
2277 return 0;
2278 }
2279
2280 memset(ep, 0, sizeof(coap_endpoint_t));
2281 ep->context = session->context;
2282 ep->proto = session->proto;
2283 ep->sock.endpoint = ep;
2284 memcpy(&ep->sock.lfunc, coap_layers_coap[session->proto], sizeof(ep->sock.lfunc));
2285
2287 LL_PREPEND(session->context->endpoint, ep);
2288 }
2289 /* Need to use coap_send_lkd() here to get traffic flowing */
2290 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
2292 }
2293#if !COAP_DISABLE_TCP
2294 else {
2296 }
2297#endif /* !COAP_DISABLE_TCP */
2298 if (!ping) {
2299 session->type = COAP_SESSION_TYPE_SERVER;
2300 return 0;
2301 }
2302 mid = coap_send_lkd(session, ping);
2303 if (mid != COAP_INVALID_MID) {
2304 coap_tick_t now;
2305
2306 coap_ticks(&now);
2307 session->last_ping_mid = mid;
2308 session->last_rx_tx = now;
2309 session->last_ping = now;
2310 }
2311 if (session->context) {
2312 if (session->context->sessions) {
2313 SESSIONS_DELETE(session->context->sessions, session);
2314 }
2315 }
2316 SESSIONS_ADD(ep->sessions, session);
2317 session->endpoint = ep;
2318 session->type = COAP_SESSION_TYPE_SERVER;
2319 coap_session_release_lkd(session);
2320 coap_log_debug("***%s: session now is type Server\n",
2321 coap_session_str(session));
2322 return 1;
2323 }
2324#else /* ! COAP_CLIENT_SUPPORT || ! COAP_SERVER_SUPPORT */
2325 (void)session;
2326#endif /* ! COAP_CLIENT_SUPPORT || ! COAP_SERVER_SUPPORT */
2327 return 0;
2328}
2329
2332 if (session)
2333 return session->state;
2334 return 0;
2335}
2336
2339#if COAP_SERVER_SUPPORT
2340 if (session)
2341 return session->endpoint;
2342#else /* ! COAP_SERVER_SUPPORT */
2343 (void)session;
2344#endif /* ! COAP_SERVER_SUPPORT */
2345 return 0;
2346}
2347
2348int
2350 if (session)
2351 return session->ifindex;
2352 return -1;
2353}
2354
2355void *
2357 coap_tls_library_t *tls_lib) {
2358 if (session)
2359 return coap_dtls_get_tls(session, tls_lib);
2360 return NULL;
2361}
2362
2363static const char *
2365 switch (proto) {
2366 case COAP_PROTO_UDP:
2367 return "UDP ";
2368 case COAP_PROTO_DTLS:
2369 return "DTLS";
2370 case COAP_PROTO_TCP:
2371 return "TCP ";
2372 case COAP_PROTO_TLS:
2373 return "TLS ";
2374 case COAP_PROTO_WS:
2375 return "WS ";
2376 case COAP_PROTO_WSS:
2377 return "WSS ";
2378 case COAP_PROTO_NONE:
2379 case COAP_PROTO_LAST:
2380 default:
2381 return "????" ;
2382 break;
2383 }
2384 return NULL;
2385}
2386
2387#if COAP_SERVER_SUPPORT
2389coap_new_endpoint(coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto) {
2390 coap_endpoint_t *endpoint;
2391
2392 coap_lock_lock(return NULL);
2393 endpoint = coap_new_endpoint_lkd(context, listen_addr, proto);
2395 return endpoint;
2396}
2397
2399coap_new_endpoint_lkd(coap_context_t *context, const coap_address_t *listen_addr,
2400 coap_proto_t proto) {
2401 coap_endpoint_t *ep = NULL;
2402
2403 if (!context || !listen_addr) {
2404 coap_log_debug("coap_new_endpoint: Both context and listen_addr need to be defined\n");
2405 return NULL;
2406 }
2407
2409
2410 switch (proto) {
2411 case COAP_PROTO_UDP:
2412 break;
2413 case COAP_PROTO_DTLS:
2414 if (!coap_dtls_is_supported()) {
2415 coap_log_warn("coap_new_endpoint: DTLS not supported\n");
2416 return NULL;
2417 }
2418 break;
2419 case COAP_PROTO_TLS:
2420 if (!coap_tls_is_supported()) {
2421 coap_log_warn("coap_new_endpoint: TLS not supported\n");
2422 return NULL;
2423 }
2424 break;
2425 case COAP_PROTO_TCP:
2426 if (!coap_tcp_is_supported()) {
2427 coap_log_warn("coap_new_endpoint: TCP not supported\n");
2428 return NULL;
2429 }
2430 break;
2431 case COAP_PROTO_WS:
2432 if (!coap_ws_is_supported()) {
2433 coap_log_warn("coap_new_endpoint: WS not supported\n");
2434 return NULL;
2435 }
2436 break;
2437 case COAP_PROTO_WSS:
2438 if (!coap_wss_is_supported()) {
2439 coap_log_warn("coap_new_endpoint: WSS not supported\n");
2440 return NULL;
2441 }
2442 break;
2443 case COAP_PROTO_NONE:
2444 case COAP_PROTO_LAST:
2445 default:
2446 coap_log_crit("coap_new_endpoint: Unsupported protocol %d\n", proto);
2447 return NULL;
2448 }
2449
2450 if (proto == COAP_PROTO_DTLS || proto == COAP_PROTO_TLS ||
2451 proto == COAP_PROTO_WSS) {
2453 coap_log_info("coap_new_endpoint: one of coap_context_set_psk() or "
2454 "coap_context_set_pki() not called\n");
2455 return NULL;
2456 }
2457 }
2458 ep = coap_malloc_endpoint();
2459 if (!ep) {
2460 coap_log_warn("coap_new_endpoint: malloc");
2461 return NULL;
2462 }
2463
2464 memset(ep, 0, sizeof(coap_endpoint_t));
2465 ep->context = context;
2466 ep->proto = proto;
2467 ep->sock.endpoint = ep;
2468 memcpy(&ep->sock.lfunc, coap_layers_coap[proto], sizeof(ep->sock.lfunc));
2469
2470 if (COAP_PROTO_NOT_RELIABLE(proto)) {
2471 if (!coap_netif_dgrm_listen(ep, listen_addr))
2472 goto error;
2473#ifdef WITH_CONTIKI
2474 ep->sock.context = context;
2475#endif /* WITH_CONTIKI */
2476#if !COAP_DISABLE_TCP
2477 } else if (COAP_PROTO_RELIABLE(proto)) {
2478 if (!coap_netif_strm_listen(ep, listen_addr))
2479 goto error;
2480#endif /* !COAP_DISABLE_TCP */
2481 } else {
2482 coap_log_crit("coap_new_endpoint: Protocol type not supported %d\n", proto);
2483 goto error;
2484 }
2485
2487#ifndef INET6_ADDRSTRLEN
2488#define INET6_ADDRSTRLEN 40
2489#endif
2490 unsigned char addr_str[INET6_ADDRSTRLEN + 8];
2491
2492 if (coap_print_addr(&ep->bind_addr, addr_str, INET6_ADDRSTRLEN + 8)) {
2493 coap_log_debug("created %s endpoint %s\n", coap_proto_name(ep->proto),
2494 addr_str);
2495 }
2496 }
2497
2499
2500#ifdef COAP_EPOLL_SUPPORT
2501 ep->sock.endpoint = ep;
2503 EPOLLIN,
2504 __func__);
2505#endif /* COAP_EPOLL_SUPPORT */
2506
2507 LL_PREPEND(context->endpoint, ep);
2508 return ep;
2509
2510error:
2512 return NULL;
2513}
2514
2515void
2517 ep->default_mtu = (uint16_t)mtu;
2518}
2519
2520COAP_API void
2522 if (ep) {
2523 coap_context_t *context = ep->context;
2524 if (context) {
2525 coap_lock_lock(return);
2526 }
2528 if (context) {
2530 }
2531 }
2532}
2533
2534void
2536 if (ep) {
2537 coap_session_t *session, *rtmp;
2538
2539 if (ep->context) {
2540 /* If fully allocated and inserted */
2542 SESSIONS_ITER_SAFE(ep->sessions, session, rtmp) {
2543 assert(session->ref == 0);
2544 if (session->ref == 0) {
2546 coap_session_free(session);
2547 }
2548 }
2549 if (coap_netif_available_ep(ep)) {
2550 /*
2551 * ep->sock.endpoint is set in coap_new_endpoint().
2552 * ep->sock.session is never set.
2553 *
2554 * session->sock.session is set for both clients and servers (when a
2555 * new session is accepted), but does not affect the endpoint.
2556 *
2557 * So, it is safe to call coap_netif_close_ep() after all the sessions
2558 * have been freed above as we are only working with the endpoint sock.
2559 */
2560#ifdef COAP_EPOLL_SUPPORT
2561 assert(ep->sock.session == NULL);
2562#endif /* COAP_EPOLL_SUPPORT */
2564 }
2565
2566 if (ep->context->endpoint) {
2567 LL_DELETE(ep->context->endpoint, ep);
2568 }
2569 }
2570
2571 if (ep->app_cb) {
2572 ep->app_cb(ep->app_data);
2573 }
2574
2576 }
2577}
2578
2579void *
2581 assert(endpoint);
2582 return endpoint->app_data;
2583}
2584
2585COAP_API void *
2586coap_endpoint_set_app_data(coap_endpoint_t *endpoint, void *app_data,
2588 void *old_data;
2589
2590 coap_lock_lock(return NULL);
2591 old_data = coap_endpoint_set_app_data_lkd(endpoint, app_data, callback);
2593 return old_data;
2594}
2595
2596void *
2597coap_endpoint_set_app_data_lkd(coap_endpoint_t *endpoint, void *app_data,
2599 void *old_data = endpoint->app_data;
2600
2601 endpoint->app_data = app_data;
2602 endpoint->app_cb = app_data ? callback : NULL;
2603 return old_data;
2604}
2605
2606#endif /* COAP_SERVER_SUPPORT */
2607
2610 const coap_address_t *remote_addr,
2611 int ifindex) {
2612 coap_session_t *s, *rtmp;
2613#if COAP_CLIENT_SUPPORT
2614 SESSIONS_ITER(ctx->sessions, s, rtmp) {
2615 if (s->ifindex == ifindex) {
2616 if (s->sock.flags & COAP_SOCKET_MULTICAST) {
2617 if (coap_address_equals(&s->sock.mcast_addr, remote_addr))
2618 return s;
2619 } else if (coap_address_equals(&s->addr_info.remote, remote_addr))
2620 return s;
2621 }
2622 }
2623#endif /* COAP_CLIENT_SUPPORT */
2624#if COAP_SERVER_SUPPORT
2625 coap_endpoint_t *ep;
2626
2627 LL_FOREACH(ctx->endpoint, ep) {
2628 SESSIONS_ITER(ep->sessions, s, rtmp) {
2629 if (s->ifindex == ifindex && coap_address_equals(&s->addr_info.remote,
2630 remote_addr))
2631 return s;
2632 }
2633 }
2634#endif /* COAP_SERVER_SUPPORT */
2635 return NULL;
2636}
2637
2638#ifndef INET6_ADDRSTRLEN
2639#define INET6_ADDRSTRLEN 46
2640#endif
2641const char *
2643 static char szSession[2 * (INET6_ADDRSTRLEN + 8) + 24];
2644 char *p = szSession, *end = szSession + sizeof(szSession);
2645 if (coap_print_addr(&session->addr_info.local,
2646 (unsigned char *)p, end - p) > 0)
2647 p += strlen(p);
2648 if (p + 6 < end) {
2649 strcpy(p, " <-> ");
2650 p += 5;
2651 }
2652 if (p + 1 < end) {
2653 if (coap_print_addr(&session->addr_info.remote,
2654 (unsigned char *)p, end - p) > 0)
2655 p += strlen(p);
2656 }
2657 if (session->ifindex > 0 && p + 1 < end)
2658 p += snprintf(p, end - p, " (if%d)", session->ifindex);
2659 if (p + 6 < end) {
2660 strcpy(p, " ");
2661 p++;
2662 strcpy(p, coap_proto_name(session->proto));
2663 }
2664
2665 return szSession;
2666}
2667
2668#if COAP_SERVER_SUPPORT
2669const char *
2670coap_endpoint_str(const coap_endpoint_t *endpoint) {
2671 static char szEndpoint[128];
2672 char *p = szEndpoint, *end = szEndpoint + sizeof(szEndpoint);
2673 if (coap_print_addr(&endpoint->bind_addr, (unsigned char *)p, end - p) > 0)
2674 p += strlen(p);
2675 if (p + 6 < end) {
2676 if (endpoint->proto == COAP_PROTO_UDP) {
2677 strcpy(p, " UDP");
2678 } else if (endpoint->proto == COAP_PROTO_DTLS) {
2679 strcpy(p, " DTLS");
2680 } else {
2681 strcpy(p, " NONE");
2682 }
2683 }
2684
2685 return szEndpoint;
2686}
2687#endif /* COAP_SERVER_SUPPORT */
2688#if COAP_CLIENT_SUPPORT
2689void
2691 session->no_observe_cancel = 1;
2692}
2693#endif /* COAP_CLIENT_SUPPORT */
2694#endif /* COAP_SESSION_C_ */
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.
uint16_t coap_address_get_port(const coap_address_t *addr)
Returns the port from addr in host byte order.
void coap_address_copy(coap_address_t *dst, const coap_address_t *src)
int coap_address_equals(const coap_address_t *a, const coap_address_t *b)
Compares given address objects a and b.
#define PRIu32
coap_nack_reason_t
Definition coap_io.h:62
@ COAP_NACK_NOT_DELIVERABLE
Definition coap_io.h:64
@ COAP_NACK_WS_FAILED
Definition coap_io.h:71
@ COAP_NACK_TOO_MANY_RETRIES
Definition coap_io.h:63
@ COAP_NACK_TLS_FAILED
Definition coap_io.h:66
@ COAP_NACK_TLS_LAYER_FAILED
Definition coap_io.h:69
@ COAP_NACK_ICMP_ISSUE
Definition coap_io.h:67
@ COAP_NACK_WS_LAYER_FAILED
Definition coap_io.h:70
@ COAP_NACK_RST
Definition coap_io.h:65
@ COAP_NACK_BAD_RESPONSE
Definition coap_io.h:68
#define COAP_SOCKET_MULTICAST
socket is used for multicast communication
void coap_epoll_ctl_add(coap_socket_t *sock, uint32_t events, const char *func)
Epoll specific function to add the state of events that epoll is to track for the appropriate file de...
#define COAP_SOCKET_NOT_EMPTY
the socket is not empty
#define COAP_SOCKET_BOUND
the socket is bound
#define COAP_SOCKET_SLAVE
socket is a slave socket - do not close
#define COAP_SOCKET_WANT_READ
non blocking socket is waiting for reading
coap_endpoint_t * coap_malloc_endpoint(void)
#define COAP_SOCKET_WANT_CONNECT
non blocking client socket is waiting for connect
void coap_mfree_endpoint(coap_endpoint_t *ep)
coap_layer_func_t coap_layers_coap[COAP_PROTO_LAST][COAP_LAYER_LAST]
Definition coap_layers.c:39
@ COAP_LAYER_SESSION
Library specific build wrapper for coap_internal.h.
#define COAP_API
@ COAP_SESSION
Definition coap_mem.h:51
@ COAP_STRING
Definition coap_mem.h:39
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().
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)
Definition coap_notls.c:108
void * coap_dtls_get_tls(const coap_session_t *c_session COAP_UNUSED, coap_tls_library_t *tls_lib)
Definition coap_notls.c:158
unsigned int coap_dtls_get_overhead(coap_session_t *session COAP_UNUSED)
Definition coap_notls.c:261
int coap_dtls_context_check_keys_enabled(coap_context_t *ctx COAP_UNUSED)
Definition coap_notls.c:147
static const char * coap_proto_name(coap_proto_t proto)
COAP_API coap_mid_t coap_session_send_ping(coap_session_t *session)
Send a ping message for the session.
static const char * coap_nack_name(coap_nack_reason_t reason)
static coap_session_t * coap_make_session(coap_proto_t proto, coap_session_type_t type, const coap_addr_hash_t *addr_hash, const coap_address_t *local_addr, const coap_address_t *remote_addr, int ifindex, coap_context_t *context, coap_endpoint_t *endpoint)
static size_t coap_session_max_pdu_size_internal(const coap_session_t *session, size_t max_with_header)
#define INET6_ADDRSTRLEN
void coap_session_set_no_observe_cancel(coap_session_t *session)
Disable client automatically sending observe cancel on session close.
#define SESSIONS_ADD(e, obj)
#define SESSIONS_ITER_SAFE(e, el, rtmp)
#define COAP_PARTIAL_SESSION_TIMEOUT_TICKS
#define SESSIONS_DELETE(e, obj)
#define COAP_DEFAULT_MAX_HANDSHAKE_SESSIONS
#define SESSIONS_ITER(e, el, rtmp)
#define SESSIONS_FIND(e, k, res)
coap_mid_t coap_send_lkd(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
Definition coap_net.c:1478
void coap_block_delete_lg_srcv(coap_session_t *session, coap_lg_srcv_t *lg_srcv)
void coap_block_delete_lg_crcv(coap_session_t *session, coap_lg_crcv_t *lg_crcv)
void coap_check_update_token(coap_session_t *session, coap_pdu_t *pdu)
The function checks if the token needs to be updated before PDU is presented to the application (only...
void coap_block_delete_lg_xmit(coap_session_t *session, coap_lg_xmit_t *lg_xmit)
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...
#define COAP_DEFAULT_NON_MAX_RETRANSMIT
The number of times for requests for re-transmission of missing Q-Block1 when no response has been re...
uint16_t coap_session_get_non_max_retransmit(const coap_session_t *session)
Get the CoAP NON maximum retransmit count of missing Q-Block1 or Q-Block2 requested before there is a...
coap_fixed_point_t coap_session_get_default_leisure(const coap_session_t *session)
Get the CoAP default leisure time RFC7252 DEFAULT_LEISURE.
void coap_session_set_max_retransmit(coap_session_t *session, uint16_t value)
Set the CoAP maximum retransmit count before failure.
#define COAP_DEFAULT_NON_TIMEOUT
The delay (+ ACK_RANDOM_FACTOR) to introduce once NON MAX_PAYLOADS Q-Block1 or Q-Block2 have been sen...
coap_fixed_point_t coap_session_get_non_timeout(const coap_session_t *session)
Get the CoAP MAX_PAYLOADS limit delay timeout.
void coap_session_set_ack_random_factor(coap_session_t *session, coap_fixed_point_t value)
Set the CoAP ack randomize factor.
#define COAP_DEFAULT_MAX_LATENCY
The MAX_LATENCY definition.
coap_fixed_point_t coap_session_get_ack_random_factor(const coap_session_t *session)
Get the CoAP ack randomize factor.
#define COAP_DEFAULT_ACK_RANDOM_FACTOR
A factor that is used to randomize the wait time before a message is retransmitted to prevent synchro...
uint16_t coap_session_get_max_retransmit(const coap_session_t *session)
Get the CoAP maximum retransmit before failure.
void coap_session_set_max_payloads(coap_session_t *session, uint16_t value)
Set the CoAP maximum payloads count of Q-Block1 or Q-Block2 before delay is introduced RFC9177 MAX_PA...
#define COAP_DEFAULT_MAX_RETRANSMIT
Number of message retransmissions before message sending is stopped.
uint32_t coap_session_get_probing_rate(const coap_session_t *session)
Get the CoAP probing rate when there is no response RFC7252 PROBING_RATE.
#define COAP_DEFAULT_ACK_TIMEOUT
Number of seconds when to expect an ACK or a response to an outstanding CON message.
#define COAP_DEFAULT_DEFAULT_LEISURE
The number of seconds to use as bounds for multicast traffic RFC 7252, Section 4.8 Default value of D...
void coap_session_set_ack_timeout(coap_session_t *session, coap_fixed_point_t value)
Set the CoAP initial ack response timeout before the next re-transmit.
#define COAP_DEFAULT_NSTART
The number of simultaneous outstanding interactions that a client maintains to a given server.
void coap_session_set_non_receive_timeout(coap_session_t *session, coap_fixed_point_t value)
Set the CoAP non receive timeout delay timeout.
void coap_session_set_nstart(coap_session_t *session, uint16_t value)
Set the CoAP maximum concurrent transmission count of Confirmable messages RFC7252 NSTART.
#define COAP_DEFAULT_PROBING_RATE
The number of bytes/second allowed when there is no response RFC 7252, Section 4.8 Default value of P...
void coap_session_set_non_max_retransmit(coap_session_t *session, uint16_t value)
Set the CoAP NON maximum retransmit count of missing Q-Block1 or Q-Block2 requested before there is a...
uint16_t coap_session_get_max_payloads(const coap_session_t *session)
Get the CoAP maximum payloads count of Q-Block1 or Q-Block2 before delay is introduced RFC9177 MAX_PA...
#define COAP_DEFAULT_NON_RECEIVE_TIMEOUT
The time to wait for any missing Q-Block1 or Q-Block2 packets before requesting re-transmission of mi...
void coap_session_set_probing_rate(coap_session_t *session, uint32_t value)
Set the CoAP probing rate when there is no response RFC7252 PROBING_RATE.
void coap_session_set_default_leisure(coap_session_t *session, coap_fixed_point_t value)
Set the CoAP default leisure time (for multicast) RFC7252 DEFAULT_LEISURE.
coap_fixed_point_t coap_session_get_non_receive_timeout(const coap_session_t *session)
Get the CoAP non receive timeout delay timeout.
uint16_t coap_session_get_nstart(const coap_session_t *session)
Get the CoAP maximum concurrent transmission count of Confirmable messages RFC7252 NSTART.
#define COAP_DEFAULT_MAX_PAYLOADS
Number of Q-Block1 or Q-Block2 payloads that can be sent in a burst before a delay has to kick in.
coap_fixed_point_t coap_session_get_ack_timeout(const coap_session_t *session)
Get the CoAP initial ack response timeout before the next re-transmit.
void coap_session_set_non_timeout(coap_session_t *session, coap_fixed_point_t value)
Set the CoAP non timeout delay timeout.
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
Definition coap_time.h:143
#define COAP_TICKS_PER_SECOND
Use ms resolution on POSIX systems.
Definition coap_time.h:158
int coap_prng_lkd(void *buf, size_t len)
Fills buf with len random bytes using the default pseudo random number generator.
Definition coap_prng.c:190
#define RESOURCES_ITER(r, tmp)
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.
Definition coap_net.c:4911
uint16_t coap_new_message_id_lkd(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
int coap_delete_node_lkd(coap_queue_t *node)
Destroys specified node.
Definition coap_net.c:230
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.
Definition coap_net.c:2942
int coap_client_delay_first(coap_session_t *session)
Delay the sending of the first client request until some other negotiation has completed.
Definition coap_net.c:1346
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',...
Definition coap_net.c:1230
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.
Definition coap_net.c:1844
coap_mid_t coap_wait_ack(coap_context_t *context, coap_session_t *session, coap_queue_t *node)
Definition coap_net.c:1256
coap_queue_t * coap_new_node(void)
Creates a new node suitable for adding to the CoAP sendqueue.
Definition coap_net.c:259
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.
Definition coap_net.c:3046
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.
Definition coap_net.c:3085
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
COAP_API uint16_t coap_new_message_id(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
@ COAP_RESPONSE_OK
Response is fine.
Definition coap_net.h:55
void coap_dtls_establish(coap_session_t *session)
Layer function interface for layer below DTLS connect being established.
Definition coap_dtls.c:266
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_context_set_cpsk(coap_context_t *coap_context, coap_dtls_cpsk_t *setup_data)
Set the DTLS context's default client PSK information.
#define COAP_DTLS_PKI_SETUP_VERSION
Latest PKI setup version.
Definition coap_dtls.h:307
#define COAP_DTLS_CPSK_SETUP_VERSION
Latest CPSK setup version.
Definition coap_dtls.h:405
coap_tls_library_t
Definition coap_dtls.h:70
@ COAP_DTLS_ROLE_CLIENT
Internal function invoked for client.
Definition coap_dtls.h:45
unsigned int coap_encode_var_safe(uint8_t *buf, size_t length, unsigned int val)
Encodes multiple-length byte sequences.
Definition coap_encode.c:47
uint64_t coap_decode_var_bytes8(const uint8_t *buf, size_t len)
Decodes multiple-length byte sequences.
Definition coap_encode.c:67
unsigned int coap_encode_var_safe8(uint8_t *buf, size_t length, uint64_t val)
Encodes multiple-length byte sequences.
Definition coap_encode.c:77
@ COAP_EVENT_SESSION_CONNECTED
Triggered when TCP layer completes exchange of CSM information.
Definition coap_event.h:61
@ COAP_EVENT_TCP_FAILED
Triggered when TCP layer fails for some reason.
Definition coap_event.h:55
@ COAP_EVENT_SESSION_FAILED
Triggered when TCP layer fails following exchange of CSM information.
Definition coap_event.h:65
@ COAP_EVENT_SERVER_SESSION_NEW
Called in the CoAP IO loop if a new server-side session is created due to an incoming connection.
Definition coap_event.h:85
@ COAP_EVENT_SESSION_CLOSED
Triggered when TCP layer closes following exchange of CSM information.
Definition coap_event.h:63
@ 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...
Definition coap_event.h:94
@ COAP_EVENT_TCP_CLOSED
Triggered when TCP layer is closed.
Definition coap_event.h:53
@ COAP_EVENT_TCP_CONNECTED
Triggered when TCP layer connects.
Definition coap_event.h:51
@ COAP_EVENT_KEEPALIVE_FAILURE
Triggered when no response to a keep alive (ping) packet.
Definition coap_event.h:138
#define coap_lock_callback(func)
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_lock(failed)
Dummy for no thread-safe code.
#define coap_log_debug(...)
Definition coap_debug.h:120
coap_log_t coap_get_log_level(void)
Get the current logging level.
Definition coap_debug.c:103
size_t coap_print_addr(const coap_address_t *addr, unsigned char *buf, size_t len)
Print the address into the defined buffer.
Definition coap_debug.c:241
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(...)
Definition coap_debug.h:108
#define coap_log_warn(...)
Definition coap_debug.h:102
#define coap_log_err(...)
Definition coap_debug.h:96
#define coap_log_crit(...)
Definition coap_debug.h:90
@ COAP_LOG_DEBUG
Definition coap_debug.h:58
int coap_netif_dgrm_listen(coap_endpoint_t *endpoint, const coap_address_t *listen_addr)
Layer function interface for Netif datagram listem (udp).
void coap_netif_close_ep(coap_endpoint_t *endpoint)
Layer function interface for Netif close for a endpoint.
int coap_netif_strm_connect1(coap_session_t *session, const coap_address_t *local_if, const coap_address_t *server, int default_port)
Layer function interface for Netif stream connect (tcp).
int coap_netif_strm_accept(coap_endpoint_t *endpoint, coap_session_t *session, void *extra)
Layer function interface for Netif stream accept.
int coap_netif_strm_listen(coap_endpoint_t *endpoint, const coap_address_t *listen_addr)
Layer function interface for Netif stream listem (tcp).
int coap_netif_dgrm_connect(coap_session_t *session, const coap_address_t *local_if, const coap_address_t *server, int default_port)
Layer function interface for Netif datagram connect (udp).
int coap_netif_available(coap_session_t *session)
Function interface to check whether netif for session is still available.
Definition coap_netif.c:25
int coap_netif_available_ep(coap_endpoint_t *endpoint)
Function interface to check whether netif for endpoint is still available.
void coap_delete_oscore_associations(coap_session_t *session)
Cleanup all allocated OSCORE association information.
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() ...
Definition coap_pdu.c:1655
void coap_delete_pdu_lkd(coap_pdu_t *pdu)
Dispose of an CoAP PDU and free off associated storage.
Definition coap_pdu.c:194
int coap_update_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Updates token in pdu with length len and data.
Definition coap_pdu.c:417
#define COAP_PDU_MAX_UDP_HEADER_SIZE
coap_pdu_t * coap_new_pdu_lkd(coap_pdu_type_t type, coap_pdu_code_t code, coap_session_t *session)
Creates a new CoAP PDU.
Definition coap_pdu.c:173
#define COAP_PDU_DELAYED
#define COAP_PDU_MAX_TCP_HEADER_SIZE
#define COAP_MAX_MESSAGE_SIZE_TCP8
#define COAP_MAX_MESSAGE_SIZE_TCP0
size_t coap_pdu_encode_header(coap_pdu_t *pdu, coap_proto_t proto)
Compose the protocol specific header for the specified PDU.
Definition coap_pdu.c:1517
#define COAP_MAX_MESSAGE_SIZE_TCP16
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.
Definition coap_pdu.c:783
#define COAP_DEFAULT_PORT
Definition coap_pdu.h:37
int coap_mid_t
coap_mid_t is used to store the CoAP Message ID of a CoAP PDU.
Definition coap_pdu.h:264
#define COAP_TOKEN_DEFAULT_MAX
Definition coap_pdu.h:56
#define COAP_SIGNALING_OPTION_EXTENDED_TOKEN_LENGTH
Definition coap_pdu.h:200
coap_proto_t
CoAP protocol types.
Definition coap_pdu.h:313
#define COAP_SIGNALING_OPTION_BLOCK_WISE_TRANSFER
Definition coap_pdu.h:199
#define COAPS_DEFAULT_PORT
Definition coap_pdu.h:38
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.
Definition coap_pdu.c:102
#define COAP_INVALID_MID
Indicates an invalid message id.
Definition coap_pdu.h:267
#define COAP_DEFAULT_MTU
Definition coap_pdu.h:41
#define COAP_BERT_BASE
Definition coap_pdu.h:44
#define COAP_SIGNALING_OPTION_MAX_MESSAGE_SIZE
Definition coap_pdu.h:198
@ COAP_PROTO_WS
Definition coap_pdu.h:319
@ COAP_PROTO_DTLS
Definition coap_pdu.h:316
@ COAP_PROTO_UDP
Definition coap_pdu.h:315
@ COAP_PROTO_NONE
Definition coap_pdu.h:314
@ COAP_PROTO_TLS
Definition coap_pdu.h:318
@ COAP_PROTO_WSS
Definition coap_pdu.h:320
@ COAP_PROTO_TCP
Definition coap_pdu.h:317
@ COAP_PROTO_LAST
Definition coap_pdu.h:321
@ COAP_SIGNALING_CODE_CSM
Definition coap_pdu.h:366
@ COAP_SIGNALING_CODE_PING
Definition coap_pdu.h:367
@ COAP_EMPTY_CODE
Definition coap_pdu.h:328
@ COAP_MESSAGE_NON
Definition coap_pdu.h:70
@ COAP_MESSAGE_CON
Definition coap_pdu.h:69
#define COAP_NON_PROBING_WAIT_BASE(s)
void coap_session_reestablished(coap_session_t *session)
Session has been re-connected to server.
ssize_t coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu, coap_queue_t *node)
int coap_session_refresh_psk_hint(coap_session_t *session, const coap_bin_const_t *psk_hint)
Refresh the session's current Identity Hint (PSK).
void coap_session_send_csm(coap_session_t *session)
Notify session transport has just connected and CSM exchange can now start.
coap_session_t * coap_new_client_session_psk2_lkd(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, coap_dtls_cpsk_t *setup_data)
Creates a new client session to the designated server with PSK credentials.
coap_fixed_point_t coap_add_fixed_uint(coap_fixed_point_t fp1, uint32_t u2)
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.
coap_fixed_point_t coap_sub_fixed_uint(coap_fixed_point_t fp1, uint32_t u2)
int coap_session_set_type_server_lkd(coap_session_t *session)
Set the session type to server.
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.
#define COAP_ACK_RANDOM_FACTOR(s)
void coap_free_endpoint_lkd(coap_endpoint_t *endpoint)
Release an endpoint and all the structures associated with it.
coap_session_t * coap_new_client_session_psk_lkd(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, const char *identity, const uint8_t *key, unsigned key_len)
Creates a new client session to the designated server with PSK credentials.
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.
void * coap_endpoint_set_app_data_lkd(coap_endpoint_t *endpoint, void *data, coap_app_data_free_callback_t callback)
Stores data with the given endpoint, returning the previously stored value or NULL.
void coap_session_establish(coap_session_t *session)
Layer function interface for layer below session accept/connect being established.
coap_session_t * coap_new_client_session_pki_lkd(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, coap_dtls_pki_t *setup_data)
Creates a new client session to the designated server with PKI credentials.
coap_session_t * coap_new_client_session_lkd(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto)
Creates a new client session to the designated server.
coap_fixed_point_t coap_add_fixed_fixed(coap_fixed_point_t fp1, coap_fixed_point_t fp2)
coap_tick_t coap_get_non_timeout_random_ticks(coap_session_t *session)
#define COAP_NSTART(s)
int coap_session_refresh_psk_key(coap_session_t *session, const coap_bin_const_t *psk_key)
Refresh the session's current pre-shared key (PSK).
void coap_session_connected(coap_session_t *session)
Notify session that it has just connected or reconnected.
void coap_session_failed(coap_session_t *session)
Session has failed due to a socket error.
coap_fixed_point_t coap_multi_fixed_fixed(coap_fixed_point_t fp1, coap_fixed_point_t fp2)
ssize_t coap_session_send_pdu(coap_session_t *session, coap_pdu_t *pdu)
Send a pdu according to the session's protocol.
Definition coap_net.c:1108
size_t coap_session_max_pdu_size_lkd(const coap_session_t *session)
Get maximum acceptable PDU size.
coap_mid_t coap_session_send_ping_lkd(coap_session_t *session)
Send a ping message for the session.
coap_fixed_point_t coap_div_fixed_uint(coap_fixed_point_t fp1, uint32_t u2)
void coap_session_free(coap_session_t *session)
void coap_session_mfree(coap_session_t *session)
void coap_session_release_lkd(coap_session_t *session)
Decrement reference counter on a session.
int coap_session_refresh_psk_identity(coap_session_t *session, const coap_bin_const_t *psk_identity)
Refresh the session's current pre-shared identity (PSK).
int coap_session_set_type_client_lkd(coap_session_t *session, int report_changed)
Set the session type to client.
coap_fixed_point_t coap_get_non_timeout_random(coap_session_t *session)
#define COAP_NON_MAX_RETRANSMIT(s)
coap_session_t * coap_session_reference_lkd(coap_session_t *session)
Increment reference counter on a session.
#define COAP_NON_TIMEOUT(s)
void * coap_session_set_app_data2_lkd(coap_session_t *session, void *app_data, coap_app_data_free_callback_t callback)
Stores data with the given session, returning the previously stored value or NULL.
coap_fixed_point_t coap_multi_fixed_uint(coap_fixed_point_t fp1, uint32_t u2)
#define COAP_NON_PARTIAL_TIMEOUT(s)
void coap_session_disconnected_lkd(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
coap_endpoint_t * coap_new_endpoint_lkd(coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto)
Create a new endpoint for communicating with peers.
coap_session_t * coap_new_server_session(coap_context_t *ctx, coap_endpoint_t *ep, void *extra)
Creates a new server session for the specified endpoint.
@ COAP_EXT_T_CHECKED
Token size valid.
COAP_API void coap_session_set_app_data(coap_session_t *session, void *app_data)
Stores data with the given session.
COAP_API coap_session_t * coap_session_reference(coap_session_t *session)
Increment reference counter on a session.
coap_session_type_t
coap_session_type_t values
COAP_API void coap_session_disconnected(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
COAP_API void * coap_endpoint_set_app_data(coap_endpoint_t *endpoint, void *data, coap_app_data_free_callback_t callback)
Stores data with the given endpoint, returning the previously stored value or NULL.
void coap_session_set_mtu(coap_session_t *session, unsigned mtu)
Set the session MTU.
coap_context_t * coap_session_get_context(const coap_session_t *session)
Get the session context.
const coap_address_t * coap_session_get_addr_local(const coap_session_t *session)
Get the local IP address and port from the session.
coap_proto_t coap_session_get_proto(const coap_session_t *session)
Get the session protocol type.
COAP_API int coap_session_set_type_client(coap_session_t *session)
Set the session type to client.
const coap_bin_const_t * coap_session_get_psk_key(const coap_session_t *session)
Get the session's current pre-shared key (PSK).
void * coap_session_get_tls(const coap_session_t *session, coap_tls_library_t *tls_lib)
Get the session TLS security ptr (TLS type dependent)
coap_session_state_t coap_session_get_state(const coap_session_t *session)
Get the session state.
coap_session_state_t
coap_session_state_t values
void * coap_endpoint_get_app_data(const coap_endpoint_t *endpoint)
Returns any application-specific data that has been stored with endpoint using the function coap_endp...
coap_endpoint_t * coap_session_get_endpoint(const coap_session_t *session)
Get the endpoint of a session.
#define COAP_PROTO_NOT_RELIABLE(p)
COAP_API coap_session_t * coap_new_client_session_pki(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, coap_dtls_pki_t *setup_data)
Creates a new client session to the designated server with PKI credentials.
void coap_session_init_token(coap_session_t *session, size_t len, const uint8_t *data)
Initializes the token value to use as a starting point.
#define COAP_PROTO_RELIABLE(p)
void coap_session_new_token(coap_session_t *session, size_t *len, uint8_t *data)
Creates a new token for use.
COAP_API coap_session_t * coap_new_client_session(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto)
Creates a new client session to the designated server.
const coap_bin_const_t * coap_session_get_psk_identity(const coap_session_t *session)
Get the server session's current PSK identity (PSK).
coap_session_t * coap_session_get_by_peer(const coap_context_t *ctx, const coap_address_t *remote_addr, int ifindex)
Get the session associated with the specified remote_addr and index.
void coap_endpoint_set_default_mtu(coap_endpoint_t *endpoint, unsigned mtu)
Set the endpoint's default MTU.
const coap_bin_const_t * coap_session_get_psk_hint(const coap_session_t *session)
Get the server session's current Identity Hint (PSK).
COAP_API 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.
const coap_address_t * coap_session_get_addr_remote(const coap_session_t *session)
Get the remote IP address and port from the session.
COAP_API void coap_free_endpoint(coap_endpoint_t *endpoint)
Release an endpoint and all the structures associated with it.
COAP_API void coap_session_release(coap_session_t *session)
Decrement reference counter on a session.
COAP_API coap_session_t * coap_new_client_session_psk2(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, coap_dtls_cpsk_t *setup_data)
Creates a new client session to the designated server with PSK credentials.
const coap_address_t * coap_session_get_addr_mcast(const coap_session_t *session)
Get the remote multicast IP address and port from the session if the original target IP was multicast...
COAP_API size_t coap_session_max_pdu_size(const coap_session_t *session)
Get maximum acceptable PDU size.
COAP_API int coap_session_set_type_server(coap_session_t *session)
Set the session type to server.
COAP_API coap_session_t * coap_new_client_session_psk(coap_context_t *ctx, const coap_address_t *local_if, const coap_address_t *server, coap_proto_t proto, const char *identity, const uint8_t *key, unsigned key_len)
Creates a new client session to the designated server with PSK credentials.
int coap_session_get_ifindex(const coap_session_t *session)
Get the session if index.
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_API void * coap_session_set_app_data2(coap_session_t *session, void *app_data, coap_app_data_free_callback_t callback)
Stores data with the given session, returning the previously stored value or NULL.
void * coap_session_get_app_data(const coap_session_t *session)
Returns any application-specific data that has been stored with session using the function coap_sessi...
coap_session_type_t coap_session_get_type(const coap_session_t *session)
Get the session type.
@ 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_HANDSHAKE
@ COAP_SESSION_STATE_CSM
@ 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.
Definition coap_str.c:120
void coap_delete_str_const(coap_str_const_t *s)
Deletes the given const string and releases any memory allocated.
Definition coap_str.c:61
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...
Definition coap_str.c:110
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
Definition coap_str.h:211
int coap_delete_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token)
Removes any subscription for session observer from resource and releases the allocated storage.
int coap_cancel_observe_lkd(coap_session_t *session, coap_binary_t *token, coap_pdu_type_t message_type)
Cancel an observe that is being tracked by the client large receive logic.
void coap_delete_observers(coap_context_t *context, coap_session_t *session)
Removes any subscription for session and releases the allocated storage.
int coap_tcp_is_supported(void)
Check whether TCP is available.
Definition coap_tcp.c:29
int coap_tls_is_supported(void)
Check whether TLS is available.
Definition coap_notls.c:41
int coap_ws_is_supported(void)
Check whether WebSockets is available.
Definition coap_ws.c:933
int coap_dtls_is_supported(void)
Check whether DTLS is available.
Definition coap_notls.c:36
int coap_wss_is_supported(void)
Check whether Secure WebSockets is available.
Definition coap_ws.c:938
Only used for servers for hashing incoming packets.
uint16_t lport
local port
coap_address_t remote
remote address and port
coap_proto_t proto
CoAP protocol.
coap_address_t remote
remote address and port
Definition coap_io.h:56
coap_address_t local
local address and port
Definition coap_io.h:57
Multi-purpose address abstraction.
CoAP binary data definition with const data.
Definition coap_str.h:64
size_t length
length of binary data
Definition coap_str.h:65
const uint8_t * s
read-only binary data
Definition coap_str.h:66
coap_session_t * session
The CoAP stack's global state is stored in a coap_context_t object.
unsigned int reconnect_time
Time to wait before reconnecting a failed client session.
coap_session_t * sessions
client sessions
coap_nack_handler_t nack_handler
Called when a response issue has occurred.
coap_resource_t * resources
hash table or list of known resources
uint32_t csm_max_message_size
Value for CSM Max-Message-Size.
unsigned int max_handshake_sessions
Maximum number of simultaneous negotating sessions per endpoint.
coap_queue_t * sendqueue
uint32_t max_token_size
Largest token size supported RFC8974.
coap_cache_entry_t * cache
CoAP cache-entry cache.
coap_endpoint_t * endpoint
the endpoints used for listening
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
coap_resource_t * proxy_uri_resource
can be used for handling proxy URI resources
coap_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 key
Definition coap_dtls.h:381
coap_bin_const_t identity
Definition coap_dtls.h:380
The structure used for defining the Client PSK setup data to be used.
Definition coap_dtls.h:410
char * client_sni
If not NULL, SNI to use in client TLS setup.
Definition coap_dtls.h:437
coap_dtls_cpsk_info_t psk_info
Client PSK definition.
Definition coap_dtls.h:443
The structure used for defining the PKI setup data to be used.
Definition coap_dtls.h:312
uint8_t version
Definition coap_dtls.h:313
char * client_sni
If not NULL, SNI to use in client TLS setup.
Definition coap_dtls.h:368
Abstraction of virtual endpoint that can be attached to coap_context_t.
void * app_data
application-specific data
coap_context_t * context
endpoint's context
uint16_t default_mtu
default mtu for this interface
coap_session_t * sessions
hash table or list of active sessions
coap_app_data_free_callback_t app_cb
call-back to release app_data
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
Abstraction of a fixed point number that can be used where necessary instead of a float.
uint16_t fractional_part
Fractional part of fixed point variable 1/1000 (3 points) precision.
uint16_t integer_part
Integer part of fixed point variable.
coap_layer_establish_t l_establish
coap_layer_close_t l_close
Structure to hold large body (many blocks) client receive information.
coap_binary_t * app_token
app requesting PDU token
coap_pdu_t * sent_pdu
The sent pdu with all the data.
uint8_t observe_set
Set if this is an observe receive PDU.
Structure to hold large body (many blocks) server receive information.
Structure to hold large body (many blocks) transmission information.
size_t length
length of payload
coap_addr_tuple_t addr_info
local and remote addresses
unsigned char * payload
payload
int ifindex
the interface index
structure for CoAP PDUs
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.
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
coap_session_t * session
Session responsible for PDU or NULL.
coap_pdu_type_t type
message type
Queue entry.
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
struct coap_queue_t * next
coap_mid_t id
CoAP message id.
coap_tick_t t
when to send PDU for the next time
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.
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
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
coap_app_data_free_callback_t app_cb
call-back to release app_data
uint8_t doing_first
Set if doing client's first request.
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.
uint16_t nstart
maximum concurrent confirmable xmits (default 1)
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
uint64_t tx_token
Next token number to use.
coap_bin_const_t * client_cid
Contains client CID or NULL.
coap_address_t local_reconnect
local address to initiate reconnect from
uint8_t csm_bert_loc_support
CSM TCP BERT blocks supported (local)
unsigned ref_proxy_subs
reference count of current proxy subscriptions
coap_addr_tuple_t addr_info
remote/local address info
coap_proto_t proto
protocol used
uint16_t tx_mid
the last message id that was used in this session
uint8_t is_dtls13
Set if session is DTLS1.3.
unsigned ref
reference count from queues
size_t csm_rcv_mtu
CSM mtu (rcv)
coap_response_t last_con_handler_res
The result of calling the response handler of the last CON.
coap_bin_const_t * psk_hint
If client, this field contains the server provided identity hint.
coap_bin_const_t * last_token
uint8_t doing_send_recv
Set if coap_send_recv() active.
coap_dtls_cpsk_t cpsk_setup_data
client provided PSK initial setup data
size_t mtu
path or CSM mtu (xmt)
uint8_t no_observe_cancel
Set if do not cancel observe on session close.
size_t partial_read
if > 0 indicates number of bytes already read for an incoming message
int dtls_event
Tracking any (D)TLS events on this session.
uint16_t max_retransmit
maximum re-transmit count (default 4)
coap_fixed_point_t ack_random_factor
ack random factor backoff (default 1.5)
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
size_t tls_overhead
overhead of TLS layer
void * app_data
application-specific data
uint32_t tx_rtag
Next Request-Tag number to use.
coap_mid_t last_ping_mid
the last keepalive message id that was used in this session
coap_lg_srcv_t * lg_srcv
Server list of expected large receives.
coap_bin_const_t * req_token
Token in request pdu of coap_send_recv()
coap_lg_crcv_t * lg_crcv
Client list of expected large receives.
coap_fixed_point_t ack_timeout
timeout waiting for ack (default 2.0 secs)
coap_fixed_point_t default_leisure
Mcast leisure time (default 5.0 secs)
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
uint32_t probing_rate
Max transfer wait when remote is not respoding (default 1 byte/sec)
coap_mid_t last_ack_mid
The last ACK mid that has been been processed.
coap_context_t * context
session's context
uint8_t session_failed
Set if session failed and can try re-connect.
size_t partial_write
if > 0 indicates number of bytes already written from the pdu at the head of sendqueue
coap_addr_hash_t addr_hash
Address hash for server incoming packets.
coap_pdu_t * cached_pdu
Cached copy of last ACK response PDU.
int ifindex
interface index
coap_bin_const_t * echo
last token used to make a request
coap_layer_func_t lfunc[COAP_LAYER_LAST]
Layer functions to use.
coap_session_t * session
Used to determine session owner.
coap_endpoint_t * endpoint
Used by the epoll logic for a listening endpoint.
coap_address_t mcast_addr
remote address and port (multicast track)
coap_socket_flags_t flags
1 or more of COAP_SOCKET* flag values