gcoap.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2017 Ken Bannister. All rights reserved.
 *               2017 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef NET_GCOAP_H
#define NET_GCOAP_H
 
#include <stdint.h>
 
#include "event/callback.h"
#include "event/timeout.h"
#include "net/ipv6/addr.h"
#include "net/sock/udp.h"
#include "net/nanocoap.h"
#include "xtimer.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_GCOAP_PORT
#define CONFIG_GCOAP_PORT              (5683)
#endif
 
#ifndef CONFIG_GCOAP_PDU_BUF_SIZE
#define CONFIG_GCOAP_PDU_BUF_SIZE      (128)
#endif
 
#ifndef CONFIG_GCOAP_REQ_WAITING_MAX
#define CONFIG_GCOAP_REQ_WAITING_MAX   (2)
#endif
 
#define GCOAP_TOKENLEN_MAX      (8)
 
#define GCOAP_HEADER_MAXLEN     (sizeof(coap_hdr_t) + GCOAP_TOKENLEN_MAX)
 
#ifndef CONFIG_GCOAP_TOKENLEN
#define CONFIG_GCOAP_TOKENLEN          (2)
#endif
 
#define GCOAP_PAYLOAD_MARKER    (0xFF)
 
#ifndef CONFIG_GCOAP_NO_AUTO_INIT
#define CONFIG_GCOAP_NO_AUTO_INIT      0
#endif
 
#define GCOAP_MEMO_UNUSED       (0)     
#define GCOAP_MEMO_RETRANSMIT   (1)     
#define GCOAP_MEMO_WAIT         (2)     
#define GCOAP_MEMO_RESP         (3)     
#define GCOAP_MEMO_TIMEOUT      (4)     
#define GCOAP_MEMO_ERR          (5)     
#define GCOAP_SEND_LIMIT_NON    (-1)
 
#ifdef DOXYGEN
 
#define CONFIG_GCOAP_NO_RETRANS_BACKOFF
#endif
 
#ifndef CONFIG_GCOAP_NON_TIMEOUT
#define CONFIG_GCOAP_NON_TIMEOUT       (5000000U)
#endif
 
#ifndef CONFIG_GCOAP_OBS_CLIENTS_MAX
#define CONFIG_GCOAP_OBS_CLIENTS_MAX   (2)
#endif
 
#ifndef CONFIG_GCOAP_OBS_REGISTRATIONS_MAX
#define CONFIG_GCOAP_OBS_REGISTRATIONS_MAX     (2)
#endif
 
#define GCOAP_OBS_MEMO_UNUSED   (0) 
#define GCOAP_OBS_MEMO_IDLE     (1) 
#define GCOAP_OBS_MEMO_PENDING  (2) 
#ifndef CONFIG_GCOAP_OBS_VALUE_WIDTH
#define CONFIG_GCOAP_OBS_VALUE_WIDTH   (3)
#endif
 
#if (CONFIG_GCOAP_OBS_VALUE_WIDTH == 3)
#define GCOAP_OBS_TICK_EXPONENT (5)
#elif (CONFIG_GCOAP_OBS_VALUE_WIDTH == 2)
#define GCOAP_OBS_TICK_EXPONENT (16)
#elif (CONFIG_GCOAP_OBS_VALUE_WIDTH == 1)
#define GCOAP_OBS_TICK_EXPONENT (24)
#endif
 
#define GCOAP_OBS_INIT_OK       (0)
#define GCOAP_OBS_INIT_ERR      (-1)
#define GCOAP_OBS_INIT_UNUSED   (-2)
 
#ifndef GCOAP_STACK_SIZE
#define GCOAP_STACK_SIZE (THREAD_STACKSIZE_DEFAULT + DEBUG_EXTRA_STACKSIZE \
                          + sizeof(coap_pkt_t))
#endif
 
#ifndef CONFIG_GCOAP_RESEND_BUFS_MAX
#define CONFIG_GCOAP_RESEND_BUFS_MAX      (1)
#endif
 
#define COAP_LINK_FLAG_INIT_RESLIST  (1)  
typedef struct {
    unsigned content_format;            
    size_t link_pos;                    
    uint16_t flags;                     
} coap_link_encoder_ctx_t;
 
typedef ssize_t (*gcoap_link_encoder_t)(const coap_resource_t *resource, char *buf,
                                        size_t maxlen, coap_link_encoder_ctx_t *context);
 
#define GCOAP_RESOURCE_FOUND        (0)
#define GCOAP_RESOURCE_WRONG_METHOD (1)
#define GCOAP_RESOURCE_NO_PATH      (2)
#define GCOAP_RESOURCE_ERROR        (3)
 
typedef struct gcoap_listener gcoap_listener_t;
 
typedef int (*gcoap_request_matcher_t)(gcoap_listener_t *listener,
                                       const coap_resource_t **resource,
                                       const coap_pkt_t *pdu);
 
struct gcoap_listener {
    const coap_resource_t *resources;   
    size_t resources_len;               
    gcoap_link_encoder_t link_encoder;  
    struct gcoap_listener *next;        
    gcoap_request_matcher_t request_matcher;
};
 
typedef struct gcoap_request_memo gcoap_request_memo_t;
 
typedef void (*gcoap_resp_handler_t)(const gcoap_request_memo_t *memo,
                                     coap_pkt_t* pdu,
                                     const sock_udp_ep_t *remote);
 
typedef struct {
    uint8_t *pdu_buf;                   
    size_t pdu_len;                     
} gcoap_resend_t;
 
struct gcoap_request_memo {
    unsigned state;                     
    int send_limit;                     
    union {
        uint8_t hdr_buf[GCOAP_HEADER_MAXLEN];
        gcoap_resend_t data;            
    } msg;                              
    sock_udp_ep_t remote_ep;            
    gcoap_resp_handler_t resp_handler;  
    void *context;                      
    event_timeout_t resp_evt_tmout;     
    event_callback_t resp_tmout_cb;     
};
 
typedef struct {
    sock_udp_ep_t *observer;            
    const coap_resource_t *resource;    
    uint8_t token[GCOAP_TOKENLEN_MAX];  
    unsigned token_len;                 
} gcoap_observe_memo_t;
 
kernel_pid_t gcoap_init(void);
 
void gcoap_register_listener(gcoap_listener_t *listener);
 
int gcoap_req_init(coap_pkt_t *pdu, uint8_t *buf, size_t len,
                   unsigned code, const char *path);
 
static inline ssize_t gcoap_request(coap_pkt_t *pdu, uint8_t *buf, size_t len,
                                    unsigned code, char *path)
{
    return (gcoap_req_init(pdu, buf, len, code, path) == 0)
                ? coap_opt_finish(pdu, COAP_OPT_FINISH_NONE)
                : -1;
}
 
size_t gcoap_req_send(const uint8_t *buf, size_t len,
                      const sock_udp_ep_t *remote,
                      gcoap_resp_handler_t resp_handler, void *context);
 
int gcoap_resp_init(coap_pkt_t *pdu, uint8_t *buf, size_t len, unsigned code);
 
static inline ssize_t gcoap_response(coap_pkt_t *pdu, uint8_t *buf,
                                     size_t len, unsigned code)
{
    return (gcoap_resp_init(pdu, buf, len, code) == 0)
                ? coap_opt_finish(pdu, COAP_OPT_FINISH_NONE)
                : -1;
}
 
int gcoap_obs_init(coap_pkt_t *pdu, uint8_t *buf, size_t len,
                   const coap_resource_t *resource);
 
size_t gcoap_obs_send(const uint8_t *buf, size_t len,
                      const coap_resource_t *resource);
 
uint8_t gcoap_op_state(void);
 
int gcoap_get_resource_list(void *buf, size_t maxlen, uint8_t cf);
 
ssize_t gcoap_encode_link(const coap_resource_t *resource, char *buf,
                          size_t maxlen, coap_link_encoder_ctx_t *context);
 
int gcoap_add_qstring(coap_pkt_t *pdu, const char *key, const char *val);
 
#ifdef __cplusplus
}
#endif
 
#endif /* NET_GCOAP_H */