net.h

Go to the documentation of this file.

/*
 * net.h -- CoAP network interface
 *
 * Copyright (C) 2010-2015 Olaf Bergmann <bergmann@tzi.org>
 *
 * This file is part of the CoAP library libcoap. Please see README for terms
 * of use.
 */

#ifndef COAP_NET_H_
#define COAP_NET_H_

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <sys/time.h>
#endif
#include <time.h>

#ifdef WITH_LWIP
#include <lwip/ip_addr.h>
#endif

#include "coap_io.h"
#include "coap_dtls.h"
#include "coap_event.h"
#include "coap_time.h"
#include "option.h"
#include "pdu.h"
#include "prng.h"
#include "coap_session.h"

struct coap_queue_t;

typedef struct coap_queue_t {
  struct coap_queue_t *next;
  coap_tick_t t;                
  unsigned char retransmit_cnt; 
  unsigned int timeout;         
  coap_session_t *session;      
  coap_tid_t id;                
  coap_pdu_t *pdu;              
} coap_queue_t;

int coap_insert_node(coap_queue_t **queue, coap_queue_t *node);

int coap_delete_node(coap_queue_t *node);

void coap_delete_all(coap_queue_t *queue);

coap_queue_t *coap_new_node(void);

struct coap_resource_t;
struct coap_context_t;
#ifndef WITHOUT_ASYNC
struct coap_async_state_t;
#endif

typedef void (*coap_response_handler_t)(struct coap_context_t *context,
                                        coap_session_t *session,
                                        coap_pdu_t *sent,
                                        coap_pdu_t *received,
                                        const coap_tid_t id);

typedef void (*coap_nack_handler_t)(struct coap_context_t *context,
                                    coap_session_t *session,
                                    coap_pdu_t *sent,
                                    coap_nack_reason_t reason,
                                    const coap_tid_t id);

typedef void (*coap_ping_handler_t)(struct coap_context_t *context,
                                    coap_session_t *session,
                                    coap_pdu_t *received,
                                    const coap_tid_t id);

typedef void (*coap_pong_handler_t)(struct coap_context_t *context,
                                    coap_session_t *session,
                                    coap_pdu_t *received,
                                    const coap_tid_t id);

typedef struct coap_context_t {
  coap_opt_filter_t known_options;
  struct coap_resource_t *resources; 
  struct coap_resource_t *unknown_resource; 
#ifndef WITHOUT_ASYNC

  struct coap_async_state_t *async_state;
#endif /* WITHOUT_ASYNC */

  coap_tick_t sendqueue_basetime;
  coap_queue_t *sendqueue;
  coap_endpoint_t *endpoint;      
  coap_session_t *sessions;       
#ifdef WITH_CONTIKI
  struct uip_udp_conn *conn;      
  struct etimer retransmit_timer; 
  struct etimer notify_timer;     
#endif /* WITH_CONTIKI */

#ifdef WITH_LWIP
  uint8_t timer_configured;       
#endif /* WITH_LWIP */

  uint16_t message_id;

  coap_response_handler_t response_handler;
  coap_nack_handler_t nack_handler;
  coap_ping_handler_t ping_handler;
  coap_pong_handler_t pong_handler;

  coap_event_handler_t handle_event;

  ssize_t (*network_send)(coap_socket_t *sock, const coap_session_t *session, const uint8_t *data, size_t datalen);

  ssize_t (*network_read)(coap_socket_t *sock, struct coap_packet_t *packet);

  size_t(*get_client_psk)(const coap_session_t *session, const uint8_t *hint, size_t hint_len, uint8_t *identity, size_t *identity_len, size_t max_identity_len, uint8_t *psk, size_t max_psk_len);
  size_t(*get_server_psk)(const coap_session_t *session, const uint8_t *identity, size_t identity_len, uint8_t *psk, size_t max_psk_len);
  size_t(*get_server_hint)(const coap_session_t *session, uint8_t *hint, size_t max_hint_len);

  void *dtls_context;
  uint8_t *psk_hint;
  size_t psk_hint_len;
  uint8_t *psk_key;
  size_t psk_key_len;

  unsigned int session_timeout;    
  unsigned int max_idle_sessions;  
  unsigned int max_handshake_sessions; 
  unsigned int ping_timeout;           
  unsigned int csm_timeout;           
  void *app;                       
} coap_context_t;

COAP_STATIC_INLINE void
coap_register_response_handler(coap_context_t *context,
                               coap_response_handler_t handler) {
  context->response_handler = handler;
}

COAP_STATIC_INLINE void
coap_register_nack_handler(coap_context_t *context,
                           coap_nack_handler_t handler) {
  context->nack_handler = handler;
}

COAP_STATIC_INLINE void
coap_register_ping_handler(coap_context_t *context,
                           coap_ping_handler_t handler) {
  context->ping_handler = handler;
}

COAP_STATIC_INLINE void
coap_register_pong_handler(coap_context_t *context,
                           coap_pong_handler_t handler) {
  context->pong_handler = handler;
}

COAP_STATIC_INLINE void
coap_register_option(coap_context_t *ctx, uint16_t type) {
  coap_option_setb(ctx->known_options, type);
}

unsigned int coap_adjust_basetime(coap_context_t *ctx, coap_tick_t now);

coap_queue_t *coap_peek_next( coap_context_t *context );

coap_queue_t *coap_pop_next( coap_context_t *context );

coap_context_t *coap_new_context(const coap_address_t *listen_addr);

int coap_context_set_psk( coap_context_t *context, const char *hint,
                           const uint8_t *key, size_t key_len );

int
coap_context_set_pki(coap_context_t *context,
                     coap_dtls_pki_t *setup_data);

int
coap_context_set_pki_root_cas(coap_context_t *context,
                              const char *ca_file,
                              const char *ca_dir);

void coap_context_set_keepalive(coap_context_t *context, unsigned int seconds);

COAP_STATIC_INLINE uint16_t
coap_new_message_id(coap_session_t *session) {
  return ++session->tx_mid;
}

void coap_free_context(coap_context_t *context);

void coap_set_app_data(coap_context_t *context, void *data);

void *coap_get_app_data(const coap_context_t *context);

coap_pdu_t *coap_new_error_response(coap_pdu_t *request,
                                    unsigned char code,
                                    coap_opt_filter_t opts);

coap_tid_t coap_send_error(coap_session_t *session,
                           coap_pdu_t *request,
                           unsigned char code,
                           coap_opt_filter_t opts);

coap_tid_t
coap_send_message_type(coap_session_t *session, coap_pdu_t *request, unsigned char type);

coap_tid_t coap_send_ack(coap_session_t *session, coap_pdu_t *request);

COAP_STATIC_INLINE coap_tid_t
coap_send_rst(coap_session_t *session, coap_pdu_t *request) {
  return coap_send_message_type(session, request, COAP_MESSAGE_RST);
}

coap_tid_t coap_send( coap_session_t *session, coap_pdu_t *pdu );

coap_tid_t coap_retransmit(coap_context_t *context, coap_queue_t *node);

unsigned int
coap_write(coap_context_t *ctx,
  coap_socket_t *sockets[],
  unsigned int max_sockets,
  unsigned int *num_sockets,
  coap_tick_t now
);

void coap_read(coap_context_t *ctx, coap_tick_t now);

int coap_run_once( coap_context_t *ctx, unsigned int timeout_ms );

int coap_handle_dgram(coap_context_t *ctx, coap_session_t *session, uint8_t *data, size_t data_len);

int coap_handle_event(coap_context_t *context,
                      coap_event_t event,
                      coap_session_t *session);
int coap_remove_from_queue(coap_queue_t **queue,
                           coap_session_t *session,
                           coap_tid_t id,
                           coap_queue_t **node);

coap_tid_t
coap_wait_ack( coap_context_t *context, coap_session_t *session,
               coap_queue_t *node);

coap_queue_t *coap_find_transaction(coap_queue_t *queue, coap_session_t *session, coap_tid_t id);

void coap_cancel_all_messages(coap_context_t *context,
                              coap_session_t *session,
                              const uint8_t *token,
                              size_t token_length);

void
coap_cancel_session_messages(coap_context_t *context,
                             coap_session_t *session,
                             coap_nack_reason_t reason);

void coap_dispatch(coap_context_t *context, coap_session_t *session,
                   coap_pdu_t *pdu);

int coap_can_exit(coap_context_t *context);

void coap_ticks(coap_tick_t *);

int coap_option_check_critical(coap_context_t *ctx,
                               coap_pdu_t *pdu,
                               coap_opt_filter_t unknown);

coap_pdu_t *coap_wellknown_response(coap_context_t *context,
                                    coap_session_t *session,
                                    coap_pdu_t *request);

unsigned int coap_calc_timeout(coap_session_t *session, unsigned char r);

#endif /* COAP_NET_H_ */