Lines Matching refs:session
218 coap_get_non_timeout_random(coap_session_t *session) {
223 res = coap_sub_fixed_uint(COAP_ACK_RANDOM_FACTOR(session), 1);
226 res = coap_add_fixed_fixed(COAP_NON_TIMEOUT(session), res);
231 coap_get_non_timeout_random_ticks(coap_session_t *session) {
232 coap_fixed_point_t res = coap_get_non_timeout_random(session);
279 coap_session_set_ack_timeout(coap_session_t *session, coap_fixed_point_t value) {
281 session->ack_timeout = value;
282 coap_log_debug("***%s: session ack_timeout set to %u.%03u\n",
283 coap_session_str(session), session->ack_timeout.integer_part,
284 session->ack_timeout.fractional_part);
289 coap_session_set_ack_random_factor(coap_session_t *session,
292 session->ack_random_factor = value;
293 coap_log_debug("***%s: session ack_random_factor set to %u.%03u\n",
294 coap_session_str(session), session->ack_random_factor.integer_part,
295 session->ack_random_factor.fractional_part);
297 coap_session_fix_non_probing_wait_base(session);
298 coap_session_fix_non_partial_timeout(session);
305 coap_session_set_max_retransmit(coap_session_t *session, uint16_t value) {
307 session->max_retransmit = value;
308 coap_log_debug("***%s: session max_retransmit set to %u\n",
309 coap_session_str(session), session->max_retransmit);
314 coap_session_set_nstart(coap_session_t *session, uint16_t value) {
316 session->nstart = value;
317 coap_log_debug("***%s: session nstart set to %u\n",
318 coap_session_str(session), session->nstart);
323 coap_session_set_default_leisure(coap_session_t *session,
326 session->default_leisure = value;
327 coap_log_debug("***%s: session default_leisure set to %u.%03u\n",
328 coap_session_str(session), session->default_leisure.integer_part,
329 session->default_leisure.fractional_part);
334 coap_session_set_probing_rate(coap_session_t *session, uint32_t value) {
336 session->probing_rate = value;
337 coap_log_debug("***%s: session probing_rate set to %" PRIu32 "\n",
338 coap_session_str(session), session->probing_rate);
343 coap_session_set_max_payloads(coap_session_t *session, uint16_t value) {
346 session->max_payloads = value;
347 coap_log_debug("***%s: session max_payloads set to %u\n",
348 coap_session_str(session), session->max_payloads);
349 coap_session_fix_non_probing_wait_base(session);
350 coap_session_fix_non_partial_timeout(session);
353 (void)session;
359 coap_session_set_non_max_retransmit(coap_session_t *session, uint16_t value) {
362 session->non_max_retransmit = value;
363 coap_log_debug("***%s: session non_max_retransmit set to %u\n",
364 coap_session_str(session), session->non_max_retransmit);
365 coap_session_fix_non_probing_wait_base(session);
366 coap_session_fix_non_partial_timeout(session);
369 (void)session;
375 coap_session_set_non_timeout(coap_session_t *session,
379 session->non_timeout = value;
380 coap_log_debug("***%s: session non_timeout set to %u.%03u\n",
381 coap_session_str(session), session->non_timeout.integer_part,
382 session->non_timeout.fractional_part);
383 coap_session_fix_non_probing_wait_base(session);
384 coap_session_fix_non_partial_timeout(session);
387 (void)session;
393 coap_session_set_non_receive_timeout(coap_session_t *session,
397 session->non_receive_timeout = value;
398 coap_log_debug("***%s: session non_receive_timeout set to %u.%03u\n",
399 coap_session_str(session),
400 session->non_receive_timeout.integer_part,
401 session->non_receive_timeout.fractional_part);
403 (void)session;
409 coap_session_get_ack_timeout(const coap_session_t *session) {
410 return session->ack_timeout;
414 coap_session_get_ack_random_factor(const coap_session_t *session) {
415 return session->ack_random_factor;
419 coap_session_get_max_retransmit(const coap_session_t *session) {
420 return session->max_retransmit;
424 coap_session_get_nstart(const coap_session_t *session) {
425 return session->nstart;
429 coap_session_get_default_leisure(const coap_session_t *session) {
430 return session->default_leisure;
434 coap_session_get_probing_rate(const coap_session_t *session) {
435 return session->probing_rate;
439 coap_session_get_max_payloads(const coap_session_t *session) {
441 return session->max_payloads;
443 (void)session;
449 coap_session_get_non_max_retransmit(const coap_session_t *session) {
451 return session->non_max_retransmit;
453 (void)session;
459 coap_session_get_non_timeout(const coap_session_t *session) {
461 return session->non_timeout;
463 (void)session;
469 coap_session_get_non_receive_timeout(const coap_session_t *session) {
471 return session->non_receive_timeout;
473 (void)session;
479 coap_session_reference(coap_session_t *session) {
480 ++session->ref;
481 return session;
485 coap_session_release(coap_session_t *session) {
486 if (session) {
488 assert(session->ref > 0);
489 if (session->ref > 0)
490 --session->ref;
491 if (session->ref == 0 && session->type == COAP_SESSION_TYPE_CLIENT)
492 coap_session_free(session);
496 --session->ref;
497 __coverity_negative_sink__(session->ref);
499 if (session->ref == 0 && session->type == COAP_SESSION_TYPE_CLIENT) {
500 __coverity_free__(session);
507 coap_session_set_app_data(coap_session_t *session, void *app_data) {
508 assert(session);
509 session->app = app_data;
513 coap_session_get_app_data(const coap_session_t *session) {
514 assert(session);
515 return session->app;
524 coap_session_t *session = (coap_session_t *)coap_malloc_type(COAP_SESSION,
529 if (!session)
531 memset(session, 0, sizeof(*session));
532 session->proto = proto;
533 session->type = type;
535 memcpy(&session->addr_hash, addr_hash, sizeof(session->addr_hash));
537 memset(&session->addr_hash, 0, sizeof(session->addr_hash));
539 coap_address_copy(&session->addr_info.local, local_addr);
541 coap_address_init(&session->addr_info.local);
543 coap_address_copy(&session->addr_info.remote, remote_addr);
545 coap_address_init(&session->addr_info.remote);
546 session->ifindex = ifindex;
547 session->context = context;
549 session->endpoint = endpoint;
551 session->mtu = endpoint->default_mtu;
554 session->mtu = COAP_DEFAULT_MTU;
555 session->block_mode = context->block_mode;
557 session->tls_overhead = 29;
558 if (session->tls_overhead >= session->mtu) {
559 session->tls_overhead = session->mtu;
563 session->ack_timeout = COAP_DEFAULT_ACK_TIMEOUT;
564 session->ack_random_factor = COAP_DEFAULT_ACK_RANDOM_FACTOR;
565 session->max_retransmit = COAP_DEFAULT_MAX_RETRANSMIT;
566 session->nstart = COAP_DEFAULT_NSTART;
567 session->default_leisure = COAP_DEFAULT_DEFAULT_LEISURE;
568 session->probing_rate = COAP_DEFAULT_PROBING_RATE;
570 session->max_payloads = COAP_DEFAULT_MAX_PAYLOADS;
571 session->non_max_retransmit = COAP_DEFAULT_NON_MAX_RETRANSMIT;
572 session->non_timeout = COAP_DEFAULT_NON_TIMEOUT;
573 session->non_receive_timeout = COAP_DEFAULT_NON_RECEIVE_TIMEOUT;
574 coap_session_fix_non_probing_wait_base(session);
575 coap_session_fix_non_partial_timeout(session);
577 session->dtls_event = -1;
578 session->last_ping_mid = COAP_INVALID_MID;
579 session->last_ack_mid = COAP_INVALID_MID;
580 session->last_con_mid = COAP_INVALID_MID;
581 session->max_token_size = context->max_token_size; /* RFC8974 */
582 if (session->type != COAP_SESSION_TYPE_CLIENT)
583 session->max_token_checked = COAP_EXT_T_CHECKED;
587 if (COAP_PROTO_NOT_RELIABLE(session->proto))
588 coap_prng((unsigned char *)&session->tx_mid, sizeof(session->tx_mid));
589 coap_prng((unsigned char *)&session->tx_rtag, sizeof(session->tx_rtag));
591 return session;
595 coap_session_mfree(coap_session_t *session) {
603 LL_FOREACH_SAFE(session->lg_crcv, lg_crcv, etmp) {
604 if (lg_crcv->observe_set && session->no_observe_cancel == 0) {
606 if (coap_cancel_observe(session, lg_crcv->app_token, COAP_MESSAGE_NON)) {
608 coap_queue_t *queue = session->context->sendqueue;
611 if (queue->session == session) {
619 LL_DELETE(session->lg_crcv, lg_crcv);
620 coap_block_delete_lg_crcv(session, lg_crcv);
624 if (session->partial_pdu)
625 coap_delete_pdu(session->partial_pdu);
626 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
627 if (session->psk_identity)
628 coap_delete_bin_const(session->psk_identity);
629 if (session->psk_key)
630 coap_delete_bin_const(session->psk_key);
631 if (session->psk_hint)
632 coap_delete_bin_const(session->psk_hint);
636 HASH_ITER(hh, session->context->cache, cp, ctmp) {
637 /* cp->session is NULL if not session based */
638 if (cp->session == session) {
639 coap_delete_cache_entry(session->context, cp);
643 LL_FOREACH_SAFE(session->delayqueue, q, tmp) {
644 if (q->pdu->type==COAP_MESSAGE_CON && session->context &&
645 session->context->nack_handler) {
646 coap_check_update_token(session, q->pdu);
647 session->context->nack_handler(session, q->pdu,
648 session->proto == COAP_PROTO_DTLS ?
654 LL_FOREACH_SAFE(session->lg_xmit, lq, ltmp) {
655 LL_DELETE(session->lg_xmit, lq);
656 coap_block_delete_lg_xmit(session, lq);
661 LL_FOREACH_SAFE(session->lg_srcv, sq, stmp) {
662 LL_DELETE(session->lg_srcv, sq);
663 coap_block_delete_lg_srcv(session, sq);
667 coap_delete_oscore_associations(session);
670 coap_free_type(COAP_STRING, session->ws);
671 coap_delete_str_const(session->ws_host);
676 coap_session_free(coap_session_t *session) {
677 if (!session)
679 assert(session->ref == 0);
680 if (session->ref)
683 coap_session_reference(session);
684 coap_session_mfree(session);
686 if (session->endpoint) {
687 if (session->endpoint->sessions)
688 SESSIONS_DELETE(session->endpoint->sessions, session);
692 if (session->context) {
693 if (session->context->sessions)
694 SESSIONS_DELETE(session->context->sessions, session);
697 coap_delete_bin_const(session->last_token);
698 coap_log_debug("***%s: session %p: closed\n", coap_session_str(session),
699 (void *)session);
701 assert(session->ref == 1);
702 coap_free_type(COAP_SESSION, session);
706 coap_session_max_pdu_size_internal(const coap_session_t *session,
709 (void)session;
712 if (COAP_PROTO_NOT_RELIABLE(session->proto))
729 coap_session_max_pdu_rcv_size(const coap_session_t *session) {
730 if (session->csm_rcv_mtu)
731 return coap_session_max_pdu_size_internal(session,
732 (size_t)(session->csm_rcv_mtu));
734 return coap_session_max_pdu_size_internal(session,
735 (size_t)(session->mtu - session->tls_overhead));
739 coap_session_max_pdu_size(const coap_session_t *session) {
744 * Delay if session->doing_first is set.
753 memcpy(&session_rw, &session, sizeof(session_rw));
760 max_with_header = (size_t)(session->mtu - session->tls_overhead);
762 return coap_session_max_pdu_size_internal(session, max_with_header);
766 coap_session_set_mtu(coap_session_t *session, unsigned mtu) {
773 session->mtu = mtu;
774 if (session->tls_overhead >= session->mtu) {
775 session->tls_overhead = session->mtu;
781 coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu,
785 coap_remove_from_queue(&session->context->sendqueue, session, node->id, &removed);
787 coap_session_release(node->session);
788 node->session = NULL;
791 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
794 LL_FOREACH(session->delayqueue, q) {
797 coap_session_str(session), pdu->mid);
807 if (pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
811 node->timeout = coap_calc_timeout(session, r);
814 LL_APPEND(session->delayqueue, node);
816 coap_session_str(session), node->id);
822 coap_session_send_csm(coap_session_t *session) {
825 assert(COAP_PROTO_RELIABLE(session->proto));
826 coap_log_debug("***%s: sending CSM\n", coap_session_str(session));
827 session->state = COAP_SESSION_STATE_CSM;
828 session->partial_write = 0;
829 if (session->mtu == 0)
830 session->mtu = COAP_DEFAULT_MTU; /* base value */
835 session->context->csm_max_message_size), buf) == 0
839 || (session->max_token_size > COAP_TOKEN_DEFAULT_MAX &&
843 session->max_token_size),
845 || coap_pdu_encode_header(pdu, session->proto) == 0
847 coap_session_disconnected(session, COAP_NACK_NOT_DELIVERABLE);
851 pdu->session = session;
852 bytes_written = coap_session_send_pdu(session, pdu);
854 coap_session_disconnected(session, COAP_NACK_NOT_DELIVERABLE);
856 session->csm_rcv_mtu = session->context->csm_max_message_size;
857 if (session->csm_rcv_mtu > COAP_BERT_BASE)
858 session->csm_bert_loc_support = 1;
860 session->csm_bert_loc_support = 0;
869 coap_session_send_ping(coap_session_t *session) {
872 if (session->state != COAP_SESSION_STATE_ESTABLISHED ||
873 session->con_active)
875 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
876 uint16_t mid = coap_new_message_id(session);
886 return coap_send_internal(session, ping);
890 coap_session_connected(coap_session_t *session) {
891 if (session->state != COAP_SESSION_STATE_ESTABLISHED) {
892 coap_log_debug("***%s: session connected\n",
893 coap_session_str(session));
894 if (session->state == COAP_SESSION_STATE_CSM) {
895 coap_handle_event(session->context, COAP_EVENT_SESSION_CONNECTED, session);
896 if (session->doing_first)
897 session->doing_first = 0;
901 session->state = COAP_SESSION_STATE_ESTABLISHED;
902 session->partial_write = 0;
904 if (session->proto==COAP_PROTO_DTLS) {
905 session->tls_overhead = coap_dtls_get_overhead(session);
906 if (session->tls_overhead >= session->mtu) {
907 session->tls_overhead = session->mtu;
912 while (session->delayqueue && session->state == COAP_SESSION_STATE_ESTABLISHED) {
914 coap_queue_t *q = session->delayqueue;
915 if (q->pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
916 if (session->con_active >= COAP_NSTART(session))
918 session->con_active++;
921 session->delayqueue = q->next;
925 coap_session_str(session), (int)q->pdu->mid);
926 bytes_written = coap_session_send_pdu(session, q->pdu);
927 if (q->pdu->type == COAP_MESSAGE_CON && COAP_PROTO_NOT_RELIABLE(session->proto)) {
928 if (coap_wait_ack(session->context, session, q) >= 0)
931 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
938 q->next = session->delayqueue;
939 session->delayqueue = q;
941 session->partial_write = (size_t)bytes_written;
979 coap_session_disconnected(coap_session_t *session, coap_nack_reason_t reason) {
981 coap_session_state_t state = session->state;
992 if (session->context->nack_handler) {
994 coap_queue_t *q = session->context->sendqueue;
996 if (q->session == session) {
1000 coap_check_update_token(session, q->pdu);
1001 session->context->nack_handler(session, q->pdu, reason, q->id);
1009 if (!sent_nack && session->lg_crcv) {
1011 session->context->nack_handler(session, &session->lg_crcv->pdu, reason,
1012 session->lg_crcv->pdu.mid);
1018 session->context->nack_handler(session, NULL, reason, 0);
1021 coap_log_debug("***%s: session issue (%s)\n",
1022 coap_session_str(session), coap_nack_name(reason));
1025 coap_log_debug("***%s: session disconnected (%s)\n",
1026 coap_session_str(session), coap_nack_name(reason));
1028 coap_delete_observers(session->context, session);
1031 if (session->proto == COAP_PROTO_UDP)
1032 session->state = COAP_SESSION_STATE_ESTABLISHED;
1034 session->state = COAP_SESSION_STATE_NONE;
1036 session->con_active = 0;
1038 if (session->partial_pdu) {
1039 coap_delete_pdu(session->partial_pdu);
1040 session->partial_pdu = NULL;
1042 session->partial_read = 0;
1044 while (session->delayqueue) {
1045 coap_queue_t *q = session->delayqueue;
1046 session->delayqueue = q->next;
1049 coap_session_str(session), q->id);
1051 && session->context->nack_handler) {
1052 coap_check_update_token(session, q->pdu);
1053 session->context->nack_handler(session, q->pdu, reason, q->id);
1061 LL_FOREACH_SAFE(session->lg_crcv, cq, etmp) {
1062 LL_DELETE(session->lg_crcv, cq);
1063 coap_block_delete_lg_crcv(session, cq);
1066 LL_FOREACH_SAFE(session->lg_xmit, lq, ltmp) {
1067 LL_DELETE(session->lg_xmit, lq);
1068 coap_block_delete_lg_xmit(session, lq);
1071 LL_FOREACH_SAFE(session->lg_srcv, sq, stmp) {
1072 LL_DELETE(session->lg_srcv, sq);
1073 coap_block_delete_lg_srcv(session, sq);
1076 coap_cancel_session_messages(session->context, session, reason);
1079 if (COAP_PROTO_RELIABLE(session->proto)) {
1080 if (coap_netif_available(session)) {
1081 coap_handle_event(session->context,
1083 COAP_EVENT_TCP_FAILED : COAP_EVENT_TCP_CLOSED, session);
1086 coap_handle_event(session->context,
1088 COAP_EVENT_SESSION_CLOSED : COAP_EVENT_SESSION_FAILED, session);
1090 if (session->doing_first)
1091 session->doing_first = 0;
1094 session->sock.lfunc[COAP_LAYER_SESSION].l_close(session);
1110 coap_session_t *session;
1124 SESSIONS_FIND(endpoint->sessions, addr_hash, session);
1125 if (session) {
1127 coap_address_copy(&session->addr_info.local, &packet->addr_info.local);
1128 session->ifindex = packet->ifindex;
1129 session->last_rx_tx = now;
1130 return session;
1133 SESSIONS_ITER(endpoint->sessions, session, rtmp) {
1134 if (session->ref == 0 && session->delayqueue == NULL) {
1135 if (session->type == COAP_SESSION_TYPE_SERVER) {
1137 if (oldest==NULL || session->last_rx_tx < oldest->last_rx_tx)
1138 oldest = session;
1140 if (session->state == COAP_SESSION_STATE_HANDSHAKE) {
1142 /* See if this is a partial (D)TLS session set up
1144 if ((session->last_rx_tx + COAP_PARTIAL_SESSION_TIMEOUT_TICKS) < now) {
1146 session->last_rx_tx < oldest_hs->last_rx_tx)
1147 oldest_hs = session;
1150 } else if (session->type == COAP_SESSION_TYPE_HELLO) {
1152 /* See if this is a partial (D)TLS session set up for Client Hello
1154 if ((session->last_rx_tx + COAP_PARTIAL_SESSION_TIMEOUT_TICKS) < now) {
1156 session->last_rx_tx < oldest_hs->last_rx_tx)
1157 oldest_hs = session;
1168 coap_log_warn("***%s: Incomplete session timed out\n",
1186 * time allocating and then freeing off session.
1224 session = coap_make_session(endpoint->proto, COAP_SESSION_TYPE_SERVER,
1228 if (session) {
1229 session->last_rx_tx = now;
1230 memcpy(session->sock.lfunc, endpoint->sock.lfunc,
1231 sizeof(session->sock.lfunc));
1233 session->state = COAP_SESSION_STATE_ESTABLISHED;
1235 session->type = COAP_SESSION_TYPE_HELLO;
1237 SESSIONS_ADD(endpoint->sessions, session);
1238 coap_log_debug("***%s: session %p: new incoming session\n",
1239 coap_session_str(session), (void *)session);
1240 coap_handle_event(session->context, COAP_EVENT_SERVER_SESSION_NEW, session);
1242 return session;
1246 coap_session_new_dtls_session(coap_session_t *session,
1248 if (session) {
1249 session->last_rx_tx = now;
1250 session->type = COAP_SESSION_TYPE_SERVER;
1251 coap_dtls_establish(session);
1253 return session;
1263 coap_session_t *session = NULL;
1313 session = coap_make_session(proto, COAP_SESSION_TYPE_CLIENT, NULL,
1315 if (!session)
1318 coap_session_reference(session);
1319 session->sock.session = session;
1320 memcpy(&session->sock.lfunc, coap_layers_coap[proto],
1321 sizeof(session->sock.lfunc));
1325 if (!coap_netif_dgrm_connect(session, local_if, server, default_port)) {
1331 coap_address_equals(&session->addr_info.local,
1333 coap_address_equals(&session->addr_info.remote,
1335 coap_log_warn("***%s: session %p: duplicate - already exists\n",
1336 coap_session_str(session), (void *)session);
1341 session->sock.context = ctx;
1345 if (!coap_netif_strm_connect1(session, local_if, server, default_port)) {
1352 session->sock.session = session;
1353 coap_epoll_ctl_add(&session->sock,
1355 ((session->sock.flags & COAP_SOCKET_WANT_CONNECT) ?
1360 session->sock.flags |= COAP_SOCKET_NOT_EMPTY | COAP_SOCKET_WANT_READ;
1362 session->sock.flags |= COAP_SOCKET_BOUND;
1365 session->proxy_session = 1;
1367 SESSIONS_ADD(ctx->sessions, session);
1368 return session;
1372 * Need to add in the session as coap_session_release()
1375 if (session)
1376 SESSIONS_ADD(ctx->sessions, session);
1377 coap_session_release(session);
1382 coap_session_check_connect(coap_session_t *session) {
1383 if (COAP_PROTO_NOT_RELIABLE(session->proto)) {
1384 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
1387 if (COAP_PROTO_RELIABLE(session->proto)) {
1388 if (session->sock.flags & COAP_SOCKET_WANT_CONNECT) {
1389 session->state = COAP_SESSION_STATE_CONNECTING;
1390 if (session->state != COAP_SESSION_STATE_ESTABLISHED &&
1391 session->state != COAP_SESSION_STATE_NONE &&
1392 session->type == COAP_SESSION_TYPE_CLIENT) {
1393 session->doing_first = 1;
1397 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
1401 coap_ticks(&session->last_rx_tx);
1406 coap_session_establish(coap_session_t *session) {
1407 if (COAP_PROTO_NOT_RELIABLE(session->proto))
1408 coap_session_connected(session);
1410 if (COAP_PROTO_RELIABLE(session->proto))
1411 coap_session_send_csm(session);
1421 coap_session_t *session = coap_session_create_client(ctx, local_if, server,
1423 if (session) {
1424 coap_log_debug("***%s: session %p: created outgoing session\n",
1425 coap_session_str(session), (void *)session);
1426 coap_session_check_connect(session);
1428 return session;
1462 coap_session_t *session = coap_session_create_client(ctx, local_if,
1465 if (!session)
1468 session->cpsk_setup_data = *setup_data;
1470 session->psk_identity =
1473 if (!session->psk_identity) {
1474 coap_log_warn("Cannot store session Identity (PSK)\n");
1475 coap_session_release(session);
1480 coap_session_release(session);
1485 session->psk_key = coap_new_bin_const(setup_data->psk_info.key.s,
1487 if (!session->psk_key) {
1488 coap_log_warn("Cannot store session pre-shared key (PSK)\n");
1489 coap_session_release(session);
1494 coap_session_release(session);
1500 coap_session_release(session);
1504 coap_log_debug("***%s: new outgoing session\n",
1505 coap_session_str(session));
1506 coap_session_check_connect(session);
1507 return session;
1512 coap_session_refresh_psk_hint(coap_session_t *session,
1516 coap_bin_const_t *old_psk_hint = session->psk_hint;
1519 if (session->psk_hint) {
1520 if (coap_binary_equal(session->psk_hint, psk_hint))
1523 session->psk_hint = coap_new_bin_const(psk_hint->s,
1525 if (!session->psk_hint) {
1532 session->psk_hint = NULL;
1541 coap_session_refresh_psk_key(coap_session_t *session,
1545 coap_bin_const_t *old_psk_key = session->psk_key;
1548 if (session->psk_key) {
1549 if (coap_binary_equal(session->psk_key, psk_key))
1552 session->psk_key = coap_new_bin_const(psk_key->s, psk_key->length);
1553 if (!session->psk_key) {
1560 session->psk_key = NULL;
1569 coap_session_refresh_psk_identity(coap_session_t *session,
1573 coap_bin_const_t *old_psk_identity = session->psk_identity;
1576 if (session->psk_identity) {
1577 if (coap_binary_equal(session->psk_identity, psk_identity))
1580 session->psk_identity = coap_new_bin_const(psk_identity->s,
1582 if (!session->psk_identity) {
1589 session->psk_identity = NULL;
1599 coap_session_get_psk_hint(const coap_session_t *session) {
1600 if (session)
1601 return session->psk_hint;
1607 coap_session_get_psk_identity(const coap_session_t *session) {
1609 if (session) {
1610 psk_identity = session->psk_identity;
1612 psk_identity = &session->cpsk_setup_data.psk_info.identity;
1619 coap_session_get_psk_key(const coap_session_t *session) {
1620 if (session)
1621 return session->psk_key;
1632 coap_session_t *session;
1645 session = coap_session_create_client(ctx, local_if, server, proto);
1647 if (!session) {
1654 coap_session_release(session);
1658 coap_log_debug("***%s: new outgoing session\n",
1659 coap_session_str(session));
1660 coap_session_check_connect(session);
1661 return session;
1669 coap_session_t *session;
1670 session = coap_make_session(ep->proto, COAP_SESSION_TYPE_SERVER,
1672 if (!session)
1675 memcpy(session->sock.lfunc, ep->sock.lfunc, sizeof(session->sock.lfunc));
1676 if (!coap_netif_strm_accept(ep, session))
1679 coap_make_addr_hash(&session->addr_hash, session->proto, &session->addr_info);
1682 session->sock.session = session;
1683 coap_epoll_ctl_add(&session->sock,
1687 SESSIONS_ADD(ep->sessions, session);
1688 if (session) {
1689 coap_log_debug("***%s: session %p: new incoming session\n",
1690 coap_session_str(session), (void *)session);
1691 coap_handle_event(session->context, COAP_EVENT_TCP_CONNECTED, session);
1692 coap_handle_event(session->context, COAP_EVENT_SERVER_SESSION_NEW, session);
1693 session->state = COAP_SESSION_STATE_CONNECTING;
1694 session->sock.lfunc[COAP_LAYER_SESSION].l_establish(session);
1696 return session;
1700 * Need to add in the session as coap_session_release()
1703 if (session) {
1704 SESSIONS_ADD(ep->sessions, session);
1705 coap_session_free(session);
1713 coap_session_init_token(coap_session_t *session, size_t len,
1715 session->tx_token = coap_decode_var_bytes8(data, len);
1719 coap_session_new_token(coap_session_t *session, size_t *len,
1722 sizeof(session->tx_token), ++session->tx_token);
1726 coap_new_message_id(coap_session_t *session) {
1727 if (COAP_PROTO_NOT_RELIABLE(session->proto))
1728 return ++session->tx_mid;
1734 coap_session_get_addr_remote(const coap_session_t *session) {
1735 if (session)
1736 return &session->addr_info.remote;
1741 coap_session_get_addr_local(const coap_session_t *session) {
1742 if (session)
1743 return &session->addr_info.local;
1748 coap_session_get_addr_mcast(const coap_session_t *session) {
1750 if (session && session->type == COAP_SESSION_TYPE_CLIENT &&
1751 session->sock.flags & COAP_SOCKET_MULTICAST)
1752 return &session->sock.mcast_addr;
1754 (void)session;
1760 coap_session_get_context(const coap_session_t *session) {
1761 if (session)
1762 return session->context;
1767 coap_session_get_proto(const coap_session_t *session) {
1768 if (session)
1769 return session->proto;
1774 coap_session_get_type(const coap_session_t *session) {
1775 if (session)
1776 return session->type;
1782 coap_session_set_type_client(coap_session_t *session) {
1784 if (session && session->type == COAP_SESSION_TYPE_SERVER) {
1785 coap_session_reference(session);
1786 session->type = COAP_SESSION_TYPE_CLIENT;
1790 (void)session;
1797 coap_session_get_state(const coap_session_t *session) {
1798 if (session)
1799 return session->state;
1804 coap_session_get_ifindex(const coap_session_t *session) {
1805 if (session)
1806 return session->ifindex;
1811 coap_session_get_tls(const coap_session_t *session,
1813 if (session)
1814 return coap_dtls_get_tls(session, tls_lib);
1951 coap_session_t *session, *rtmp;
1953 SESSIONS_ITER_SAFE(ep->sessions, session, rtmp) {
1954 assert(session->ref == 0);
1955 if (session->ref == 0) {
1956 coap_session_free(session);
1962 * ep->sock.session is never set.
1964 * session->sock.session is set for both clients and servers (when a
1965 * new session is accepted), but does not affect the endpoint.
1971 assert(ep->sock.session == NULL);
2018 coap_session_str(const coap_session_t *session) {
2021 if (coap_print_addr(&session->addr_info.local,
2029 if (coap_print_addr(&session->addr_info.remote,
2033 if (session->ifindex > 0 && p + 1 < end)
2034 p += snprintf(p, end - p, " (if%d)", session->ifindex);
2038 strcpy(p, coap_proto_name(session->proto));
2069 coap_session_set_no_observe_cancel(coap_session_t *session) {
2070 session->no_observe_cancel = 1;