net.h

Go to the documentation of this file.

/* net.h -- CoAP network interface
 *
 * Copyright (C) 2010,2011 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 "config.h"

#ifdef HAVE_ASSERT_H
#include <assert.h>
#else
#ifndef assert
#warning "assertions are disabled"
#  define assert(x)
#endif
#endif

#include <stdlib.h>
#include <string.h>
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_TIME_H
#include <time.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#include "option.h"
#include "address.h"
#include "prng.h"
#include "pdu.h"
#include "coap_time.h"

struct coap_queue_t;

typedef struct coap_queue_t {
  struct coap_queue_t *next;

  coap_tick_t t;            /* when to send PDU for the next time */
  unsigned char retransmit_cnt; /* retransmission counter, will be removed when zero */
  unsigned int timeout;     /* the randomized timeout value */

  coap_address_t local;     
  coap_address_t remote;    
  coap_tid_t id;        
  coap_pdu_t *pdu;      
} coap_queue_t;

/* adds node to given queue, ordered by specified order function */
int coap_insert_node(coap_queue_t **queue, coap_queue_t *node,
             int (*order)(coap_queue_t *, coap_queue_t *node));

/* destroys specified node */
int coap_delete_node(coap_queue_t *node);

/* removes all items from given queue and frees the allocated storage */
void coap_delete_all(coap_queue_t *queue);

/* creates a new node suitable for adding to the CoAP sendqueue */
coap_queue_t *coap_new_node();

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  *, 
                    const coap_address_t *remote,
                    coap_pdu_t *sent,
                    coap_pdu_t *received,
                    const coap_tid_t id);

#define COAP_MID_CACHE_SIZE 3
typedef struct {
  unsigned char flags[COAP_MID_CACHE_SIZE];
  coap_key_t item[COAP_MID_CACHE_SIZE];
} coap_mid_cache_t; 

typedef struct coap_context_t {
  coap_opt_filter_t known_options;
#ifndef WITH_CONTIKI
  struct coap_resource_t *resources; 
#endif /* WITH_CONTIKI */
#ifndef WITHOUT_ASYNC

  struct coap_async_state_t *async_state;
#endif /* WITHOUT_ASYNC */
  coap_queue_t *sendqueue, *recvqueue;
#ifndef WITH_CONTIKI
  int sockfd;           
#else /* WITH_CONTIKI */
  struct uip_udp_conn *conn;    
  struct etimer retransmit_timer; 
  struct etimer notify_timer;     
#endif /* WITH_CONTIKI */

  unsigned short message_id;

  unsigned int observe;

  coap_response_handler_t response_handler;
} coap_context_t;

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

inline static void 
coap_register_option(coap_context_t *ctx, unsigned char type) {
  coap_option_setb(ctx->known_options, type);
}

/* Returns the next pdu to send without removing from sendqeue. */
coap_queue_t *coap_peek_next( coap_context_t *context );

/* Returns the next pdu to send and removes it from the sendqeue. */
coap_queue_t *coap_pop_next( coap_context_t *context );

/* Creates a new coap_context_t object that will hold the CoAP stack status.  */
coap_context_t *coap_new_context(const coap_address_t *listen_addr);

static inline unsigned short 
coap_new_message_id(coap_context_t *context) {
#ifndef WITH_CONTIKI
  return htons(++(context->message_id));
#else /* WITH_CONTIKI */
  return uip_htons(++context->message_id);
#endif
}

/* CoAP stack context must be released with coap_free_context() */
void coap_free_context( coap_context_t *context );


coap_tid_t coap_send_confirmed(coap_context_t *context, 
                   const coap_address_t *dst,
                   coap_pdu_t *pdu);

coap_pdu_t *coap_new_error_response(coap_pdu_t *request, 
                    unsigned char code, 
                    coap_opt_filter_t opts);
coap_tid_t coap_send(coap_context_t *context, 
             const coap_address_t *dst, 
             coap_pdu_t *pdu);

coap_tid_t coap_send_error(coap_context_t *context, 
               coap_pdu_t *request,
               const coap_address_t *dst,
               unsigned char code,
               coap_opt_filter_t opts);

coap_tid_t
coap_send_message_type(coap_context_t *context, 
               const coap_address_t *dst, 
               coap_pdu_t *request,
               unsigned char type);
coap_tid_t coap_send_ack(coap_context_t *context, 
             const coap_address_t *dst, 
             coap_pdu_t *request);

static inline coap_tid_t
coap_send_rst(coap_context_t *context, 
          const coap_address_t *dst, 
          coap_pdu_t *request) {
  return coap_send_message_type(context, dst, request, COAP_MESSAGE_RST);
}

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

int coap_read( coap_context_t *context );

void coap_transaction_id(const coap_address_t *peer, const coap_pdu_t *pdu, 
             coap_tid_t *id);

int coap_remove_from_queue(coap_queue_t **queue, 
               coap_tid_t id, 
               coap_queue_t **node);

inline static int
coap_remove_transaction(coap_queue_t **queue, coap_tid_t id) {
  coap_queue_t *node;
  if (!coap_remove_from_queue(queue, id, &node)) 
    return 0;

  coap_delete_node(node);
  return 1;
}

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

void coap_cancel_all_messages(coap_context_t *context, 
                  const coap_address_t *dst,
                  const unsigned char *token,
                  size_t token_length);

void coap_dispatch( coap_context_t *context );

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);

#endif /* _COAP_NET_H_ */