picocoap.h

Go to the documentation of this file.

 
#ifndef _COAP_H_
#define _COAP_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#include <stdint.h>
#include <stddef.h>
#include <stdint.h>
 
 
#define COAP_ACK_TIMEOUT          2
#define COAP_ACK_RANDOM_FACTOR    1.5
#define COAP_MAX_RETRANSMIT       4
#define COAP_NSTART               1
#define COAP_DEFAULT_LEISURE      5
#define COAP_PROBING_RATE         1
 
#define COAP_MAX_TRANSMIT_SPAN   45
#define COAP_MAX_TRANSMIT_WAIT   93
#define COAP_MAX_LATENCY        100
#define COAP_PROCESSING_DELAY     2
#define COAP_MAX_RTT            202
#define COAP_EXCHANGE_LIFETIME  247
#define COAP_NON_LIFETIME       145
 
// total number of CoAP options available
#define COAP_OPTIONS_LENGTH     16
 
/*
 * this struct and the corresponding names are added
 * so we can check the fields in the SCHC header
 */
struct pcoap_option_names {
    uint16_t id;
    char name[16];
};
 
static struct pcoap_option_names coap_options[COAP_OPTIONS_LENGTH] = {
        { 1, "if-match" },
        { 3, "uri-host" },
        { 4, "etag" },
        { 5, "if-none-match" },
        { 7, "uri-port" },
        { 8, "location-path" },
        { 11, "uri-path"} ,
        { 12, "content-format" },
        { 14, "max-age" },
        { 15, "uri-query" },
        { 17, "accept" },
        { 20, "location-query" },
        { 35, "proxy-uri" },
        { 39, "proxy-scheme" },
        { 60, "size1" },
        { 258, "no-response"}
};
 
typedef enum coap_error {
    CE_NONE = 0,
    CE_INVALID_PACKET,
    CE_BAD_VERSION,
    CE_TOKEN_LENGTH_OUT_OF_RANGE,
    CE_UNKNOWN_CODE,
    CE_TOO_MANY_OPTIONS,
    CE_OUT_OF_ORDER_OPTIONS_LIST,
    CE_INSUFFICIENT_BUFFER,
    CE_FOUND_PAYLOAD_MARKER,
    CE_END_OF_PACKET
} pcoap_error;
 
typedef enum coap_version {
    COAP_V1 = 1
} pcoap_version;
 
typedef enum coap_type {
    CT_CON = 0,
    CT_NON = 1,
    CT_ACK = 2,
    CT_RST = 3
} pcoap_type;
 
typedef enum pcoap_code {
    /* CoAP method codes */
    CC_EMPTY = 0,
    CC_GET = 1,
    CC_POST = 2,
    CC_PUT = 3,
    CC_DELETE = 4,
    /* CoAP response codes */
    CC_CREATED = 65,
    CC_DELETED = 66,
    CC_VALID = 67,
    CC_CHANGED = 68,
    CC_CONTENT = 69,
    CC_CONTINUE = 95,
    CC_BAD_REQUEST = 128,
    CC_UNAUTHORIZED = 129,
    CC_BAD_OPTION = 130,
    CC_FORBIDDEN = 131,
    CC_NOT_FOUND = 132,
    CC_METHOD_NOT_ALLOWED = 133,
    CC_NOT_ACCEPTABLE = 134,
    CC_REQUEST_ENTITY_INCOMPLETE = 136,
    CC_PRECONDITION_FAILED = 140,
    CC_REQUEST_ENTITY_TOO_LARGE = 141,
    CC_UNSUPPORTED_CONTENT  = 143,
    CC_INTERNAL_SERVER_ERROR = 160,
    CC_NOT_IMPLEMENTED = 161,
    CC_BAD_GATEWAY = 162,
    CC_SERVICE_UNAVAILABLE = 163,
    CC_GATEWAY_TIMEOUT = 164,
    CC_PROXYING_NOT_SUPPORTED = 165
} pcoap_code;
 
typedef enum pcoap_option_number {
    CON_IF_MATCH = 1,
    CON_URI_HOST = 3,
    CON_ETAG = 4,
    CON_IF_NONE_MATCH = 5,
    CON_OBSERVE = 6,
    CON_URI_PORT = 7,
    CON_LOCATION_PATH = 8,
    CON_URI_PATH = 11,
    CON_CONTENT_FORMAT = 12,
    CON_MAX_AGE = 14,
    CON_URI_QUERY = 15,
    CON_ACCEPT = 17,
    CON_LOCATION_QUERY = 20,
    CON_PROXY_URI = 35,
    CON_PROXY_SCHEME = 39,
    CON_SIZE1 = 60,
    CON_NO_RESPONSE = 258
} pcoap_option_number;
 
typedef struct pcoap_pdu {
    uint8_t *buf;  
    size_t len;    
    size_t max;    
} pcoap_pdu;
 
typedef struct pcoap_option {
    uint16_t num;   
    size_t len; 
    uint8_t *val;   
} pcoap_option;
 
typedef struct pcoap_payload {
    size_t len; 
    uint8_t *val;   
} pcoap_payload;
 
// Finds the length of the CoAP header
// And consequently the length of the payload
uint8_t pcoap_get_coap_offset(pcoap_pdu *pdu);
 
pcoap_error pcoap_validate_pkt(pcoap_pdu *pdu);
 
//
// Getters
//
 
static inline pcoap_version pcoap_get_version(pcoap_pdu *pdu) { return (pcoap_version) (pdu->buf[0] >> 6); }
 
static inline pcoap_type pcoap_get_type(pcoap_pdu *pdu) { return (pcoap_type) ((pdu->buf[0] >> 4) & 0x03); }
 
static inline uint8_t pcoap_get_tkl(pcoap_pdu *pdu) { return pdu->buf[0] & 0x0F; }
 
static inline pcoap_code pcoap_get_code(pcoap_pdu *pdu) { return (pcoap_code) (pdu->buf[1]); }
 
static inline uint8_t pcoap_get_code_class(pcoap_pdu *pdu) { return pcoap_get_code(pdu) >> 5; }
 
static inline uint8_t pcoap_get_code_detail(pcoap_pdu *pdu) { return pcoap_get_code(pdu) & 0x1F; }
 
static inline uint16_t pcoap_get_mid(pcoap_pdu *pdu) { return (pdu->buf[2] << 8) | pdu->buf[3]; }
 
uint8_t pcoap_get_token(pcoap_pdu *pdu, uint8_t* ptr);
 
pcoap_option pcoap_get_option(pcoap_pdu *pdu, pcoap_option *last);
 
pcoap_option pcoap_get_option_by_num(pcoap_pdu *pdu, pcoap_option_number num, uint8_t occ);
 
pcoap_payload pcoap_get_payload(pcoap_pdu *pdu);
 
pcoap_error pcoap_decode_option(uint8_t *pkt_ptr, size_t pkt_len,
                              uint16_t *option_number, size_t *option_length, uint8_t **value);
 
//
// Setters
//
 
pcoap_error pcoap_init_pdu(pcoap_pdu *pdu);
 
pcoap_error pcoap_set_version(pcoap_pdu *pdu, pcoap_version ver);
 
pcoap_error pcoap_set_type(pcoap_pdu *pdu, pcoap_type mtype);
 
pcoap_error pcoap_set_code(pcoap_pdu *pdu, pcoap_code code);
 
pcoap_error pcoap_set_mid(pcoap_pdu *pdu, uint16_t mid);
 
pcoap_error pcoap_set_token(pcoap_pdu *pdu, uint8_t* token, uint8_t tkl);
 
pcoap_error pcoap_add_option(pcoap_pdu *pdu, int32_t opt_num, uint8_t* value, uint16_t opt_len);
 
pcoap_error pcoap_set_payload(pcoap_pdu *pdu, uint8_t *payload, size_t payload_len);
 
static inline uint8_t pcoap_build_code(uint8_t _class, uint8_t detail) { return (_class << 5) | detail; }
 
//
// Internal
//
 
pcoap_error pcoap_adjust_option_deltas(uint8_t *opts, size_t *opts_len, size_t max_len, int32_t offset);
 
int8_t pcoap_build_option_header(uint8_t *buf, size_t max_len, int32_t opt_delta, int32_t opt_len);
 
int8_t pcoap_compute_option_header_len(int32_t opt_delta, int32_t opt_len);
 
#ifdef __cplusplus
}
#endif
 
#endif /*_COAP_H_*/