coap_session.h

Go to the documentation of this file.

/* coap_session.h -- Session management for libcoap
*
* Copyright (C) 2017 Jean-Claue Michelou <jcm@spinetix.com>
*
* This file is part of the CoAP library libcoap. Please see
* README for terms of use.
*/
 
#ifndef COAP_SESSION_H_
#define COAP_SESSION_H_
 
 
#include "coap_forward_decls.h"
#include "coap_io.h"
#include "coap_time.h"
#include "pdu.h"
#include "uthash.h"
#include "coap_dtls.h"
 
typedef struct coap_fixed_point_t {
  uint16_t integer_part;    
  uint16_t fractional_part; 
} coap_fixed_point_t;
 
#define COAP_DEFAULT_SESSION_TIMEOUT 300
#define COAP_PARTIAL_SESSION_TIMEOUT_TICKS (30 * COAP_TICKS_PER_SECOND)
#define COAP_DEFAULT_MAX_HANDSHAKE_SESSIONS 100
 
#define COAP_PROTO_NOT_RELIABLE(p) ((p)==COAP_PROTO_UDP || (p)==COAP_PROTO_DTLS)
#define COAP_PROTO_RELIABLE(p) ((p)==COAP_PROTO_TCP || (p)==COAP_PROTO_TLS)
 
typedef uint8_t coap_session_type_t;
#define COAP_SESSION_TYPE_CLIENT 1  
#define COAP_SESSION_TYPE_SERVER 2  
#define COAP_SESSION_TYPE_HELLO  3  
typedef uint8_t coap_session_state_t;
#define COAP_SESSION_STATE_NONE                0
#define COAP_SESSION_STATE_CONNECTING          1
#define COAP_SESSION_STATE_HANDSHAKE           2
#define COAP_SESSION_STATE_CSM                 3
#define COAP_SESSION_STATE_ESTABLISHED         4
 
typedef struct coap_session_t {
  coap_proto_t proto;               
  coap_session_type_t type;         
  coap_session_state_t state;       
  unsigned ref;                     
  unsigned tls_overhead;            
  uint64_t mtu;                     
  coap_address_t local_if;          
  UT_hash_handle hh;
  coap_addr_tuple_t addr_info;      
  int ifindex;                      
  coap_socket_t sock;               
  coap_endpoint_t *endpoint;        
  struct coap_context_t *context;   
  void *tls;                        
  uint16_t tx_mid;                  
  uint8_t con_active;               
  uint8_t csm_block_supported;      
  coap_tid_t last_ping_mid;         
  struct coap_queue_t *delayqueue;  
  size_t partial_write;             
  uint8_t read_header[8];           
  size_t partial_read;              
  coap_pdu_t *partial_pdu;          
  coap_tick_t last_rx_tx;
  coap_tick_t last_tx_rst;
  coap_tick_t last_ping;
  coap_tick_t last_pong;
  coap_tick_t csm_tx;
  coap_dtls_cpsk_t cpsk_setup_data; 
  coap_bin_const_t *psk_identity;   
  coap_bin_const_t *psk_key;        
  coap_bin_const_t *psk_hint;       
  void *app;                        
  unsigned int max_retransmit;      
  coap_fixed_point_t ack_timeout;   
  coap_fixed_point_t ack_random_factor; 
  unsigned int dtls_timeout_count;      
  int dtls_event;                       
} coap_session_t;
 
coap_session_t *coap_session_reference(coap_session_t *session);
 
void coap_session_release(coap_session_t *session);
 
void coap_session_set_app_data(coap_session_t *session, void *data);
 
void *coap_session_get_app_data(const coap_session_t *session);
 
void coap_session_disconnected(coap_session_t *session, coap_nack_reason_t reason);
 
void coap_session_send_csm(coap_session_t *session);
 
void coap_session_connected(coap_session_t *session);
 
void coap_session_set_mtu(coap_session_t *session, unsigned mtu);
 
size_t coap_session_max_pdu_size(const coap_session_t *session);
 
coap_session_t *coap_new_client_session(
  struct coap_context_t *ctx,
  const coap_address_t *local_if,
  const coap_address_t *server,
  coap_proto_t proto
);
 
coap_session_t *coap_new_client_session_psk(
  struct 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
);
 
coap_session_t *coap_new_client_session_psk2(
  struct coap_context_t *ctx,
  const coap_address_t *local_if,
  const coap_address_t *server,
  coap_proto_t proto,
  struct coap_dtls_cpsk_t *setup_data
);
 
int coap_session_refresh_psk_hint(coap_session_t *session,
                                 const struct coap_bin_const_t *psk_hint);
 
int coap_session_refresh_psk_key(coap_session_t *session,
                                 const struct coap_bin_const_t *psk_key);
 
coap_session_t *coap_new_client_session_pki(
  struct coap_context_t *ctx,
  const coap_address_t *local_if,
  const coap_address_t *server,
  coap_proto_t proto,
  struct coap_dtls_pki_t *setup_data
);
 
coap_session_t *coap_new_server_session(
  struct coap_context_t *ctx,
  coap_endpoint_t *ep
);
 
ssize_t coap_session_send(coap_session_t *session,
  const uint8_t *data, size_t datalen);
 
ssize_t coap_session_write(coap_session_t *session,
  const uint8_t *data, size_t datalen);
 
ssize_t coap_session_send_pdu(coap_session_t *session, coap_pdu_t *pdu);
 
 
const char *coap_session_str(const coap_session_t *session);
 
ssize_t
coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu,
                       struct coap_queue_t *node);
 
coap_endpoint_t *coap_new_endpoint(struct coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto);
 
void coap_endpoint_set_default_mtu(coap_endpoint_t *endpoint, unsigned mtu);
 
void coap_free_endpoint(coap_endpoint_t *ep);
 
 
const char *coap_endpoint_str(const coap_endpoint_t *endpoint);
 
coap_session_t *coap_endpoint_get_session(coap_endpoint_t *endpoint,
  const struct coap_packet_t *packet, coap_tick_t now);
 
coap_session_t *coap_session_new_dtls_session(coap_session_t *session,
  coap_tick_t now);
 
coap_session_t *coap_session_get_by_peer(struct coap_context_t *ctx,
  const struct coap_address_t *remote_addr, int ifindex);
 
void coap_session_free(coap_session_t *session);
void coap_session_mfree(coap_session_t *session);
 
#define COAP_DEFAULT_ACK_TIMEOUT ((coap_fixed_point_t){2,0})
 
#define COAP_DEFAULT_ACK_RANDOM_FACTOR ((coap_fixed_point_t){1,500})
 
#define COAP_DEFAULT_MAX_RETRANSMIT  4
 
#define COAP_DEFAULT_NSTART 1
 
#define COAP_MAX_TRANSMIT_SPAN(s) \
 ((s->ack_timeout.integer_part * 1000 + s->ack_timeout.fractional_part) * \
  ((1 << (s->max_retransmit)) -1) * \
  (s->ack_random_factor.integer_part * 1000 + \
   s->ack_random_factor.fractional_part) \
  / 1000000)
 
#define COAP_MAX_TRANSMIT_WAIT(s) \
 ((s->ack_timeout.integer_part * 1000 + s->ack_timeout.fractional_part) * \
  ((1 << (s->max_retransmit + 1)) -1) * \
  (s->ack_random_factor.integer_part * 1000 + \
   s->ack_random_factor.fractional_part) \
  / 1000000)
 
#define COAP_MAX_LATENCY 100
 
#define COAP_PROCESSING_DELAY(s) \
 ((s->ack_timeout.integer_part * 1000 + s->ack_timeout.fractional_part + 500) \
  / 1000)
 
#define COAP_MAX_RTT(s) \
 ((2 * COAP_MAX_LATENCY) + COAP_PROCESSING_DELAY(s))
 
#define COAP_EXCHANGE_LIFETIME(s) \
 (COAP_MAX_TRANSMIT_SPAN(s) + (2 * COAP_MAX_LATENCY) + COAP_PROCESSING_DELAY(s))
 
#define COAP_NON_LIFETIME(s) \
 (COAP_MAX_TRANSMIT_SPAN(s) + COAP_MAX_LATENCY)
 
void coap_session_set_max_retransmit(coap_session_t *session,
                                     unsigned int value);
 
void coap_session_set_ack_timeout(coap_session_t *session,
                                  coap_fixed_point_t value);
 
void coap_session_set_ack_random_factor(coap_session_t *session,
                                        coap_fixed_point_t value);
 
unsigned int coap_session_get_max_transmit(coap_session_t *session);
 
coap_fixed_point_t coap_session_get_ack_timeout(coap_session_t *session);
 
coap_fixed_point_t coap_session_get_ack_random_factor(coap_session_t *session);
 
coap_tid_t coap_session_send_ping(coap_session_t *session);
 
#define SESSIONS_ADD(e, obj) \
  HASH_ADD(hh, (e), addr_info, sizeof((obj)->addr_info), (obj))
 
#define SESSIONS_DELETE(e, obj) \
  HASH_DELETE(hh, (e), (obj))
 
#define SESSIONS_ITER(e, el, rtmp)  \
  HASH_ITER(hh, (e), el, rtmp)
 
#define SESSIONS_ITER_SAFE(e, el, rtmp) \
for ((el) = (e); (el) && ((rtmp) = (el)->hh.next, 1); (el) = (rtmp))
 
#define SESSIONS_FIND(e, k, res) {                     \
    HASH_FIND(hh, (e), &(k), sizeof(k), (res)); \
  }
 
#endif  /* COAP_SESSION_H */